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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
5,800 | skip | eloqsql/libmariadb/unittest/mytap/tap.c | void
skip(int how_many, char const *const fmt, ...)
{
char reason[80];
if (fmt && *fmt)
{
va_list ap;
va_start(ap, fmt);
vsnprintf(reason, sizeof(reason), fmt, ap);
va_end(ap);
}
else
reason[0] = '\0';
while (how_many-- > 0)
{
va_list ap;
memset((char*) &ap, 0, sizeof(ap)); /* Keep compiler happy */
vemit_tap(1, NULL, ap);
emit_dir("skip", reason);
emit_endl();
}
} | O0 | c | skip:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
testb %al, %al
je 0x1d7e7
movaps %xmm0, -0x130(%rbp)
movaps %xmm1, -0x120(%rbp)
movaps %xmm2, -0x110(%rbp)
movaps %xmm3, -0x100(%rbp)
movaps %xmm4, -0xf0(%rbp)
movaps %xmm5, -0xe0(%rbp)
movaps %xmm6, -0xd0(%rbp)
movaps %xmm7, -0xc0(%rbp)
movq %r9, -0x138(%rbp)
movq %r8, -0x140(%rbp)
movq %rcx, -0x148(%rbp)
movq %rdx, -0x150(%rbp)
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movl %edi, -0x64(%rbp)
movq %rsi, -0x70(%rbp)
cmpq $0x0, -0x70(%rbp)
je 0x1d873
movq -0x70(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1d873
leaq -0x90(%rbp), %rax
leaq -0x160(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
leaq -0x60(%rbp), %rdi
movq -0x70(%rbp), %rdx
leaq -0x90(%rbp), %rcx
movl $0x50, %esi
callq 0x132a0
leaq -0x90(%rbp), %rax
jmp 0x1d877
movb $0x0, -0x60(%rbp)
jmp 0x1d879
movl -0x64(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x64(%rbp)
cmpl $0x0, %eax
jle 0x1d8c8
leaq -0xb0(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x13250
leaq -0xb0(%rbp), %rdx
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x1d690
leaq -0x60(%rbp), %rsi
leaq 0x382af(%rip), %rdi # 0x55b6b
callq 0x1d760
callq 0x1da50
jmp 0x1d879
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x1d8e3
addq $0x160, %rsp # imm = 0x160
popq %rbp
retq
callq 0x134b0
nopl (%rax,%rax)
| skip:
push rbp
mov rbp, rsp
sub rsp, 160h
test al, al
jz short loc_1D7E7
movaps [rbp+var_130], xmm0
movaps [rbp+var_120], xmm1
movaps [rbp+var_110], xmm2
movaps [rbp+var_100], xmm3
movaps [rbp+var_F0], xmm4
movaps [rbp+var_E0], xmm5
movaps [rbp+var_D0], xmm6
movaps [rbp+var_C0], xmm7
loc_1D7E7:
mov [rbp+var_138], r9
mov [rbp+var_140], r8
mov [rbp+var_148], rcx
mov [rbp+var_150], rdx
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_64], edi
mov [rbp+var_70], rsi
cmp [rbp+var_70], 0
jz short loc_1D873
mov rax, [rbp+var_70]
movsx eax, byte ptr [rax]
cmp eax, 0
jz short loc_1D873
lea rax, [rbp+var_90]
lea rcx, [rbp+var_160]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 10h
lea rdi, [rbp+var_60]
mov rdx, [rbp+var_70]
lea rcx, [rbp+var_90]
mov esi, 50h ; 'P'
call _vsnprintf
lea rax, [rbp+var_90]
jmp short loc_1D877
loc_1D873:
mov [rbp+var_60], 0
loc_1D877:
jmp short $+2
loc_1D879:
mov eax, [rbp+var_64]
mov ecx, eax
add ecx, 0FFFFFFFFh
mov [rbp+var_64], ecx
cmp eax, 0
jle short loc_1D8C8
lea rdi, [rbp+var_B0]
xor esi, esi
mov edx, 18h
call _memset
lea rdx, [rbp+var_B0]
mov edi, 1
xor eax, eax
mov esi, eax
call vemit_tap
lea rsi, [rbp+var_60]
lea rdi, aSkip; "skip"
call emit_dir
call emit_endl
jmp short loc_1D879
loc_1D8C8:
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_1D8E3
add rsp, 160h
pop rbp
retn
loc_1D8E3:
call ___stack_chk_fail
| unsigned long long skip(int a1, _BYTE *a2, ...)
{
int v2; // eax
_BYTE v4[32]; // [rsp+B0h] [rbp-B0h] BYREF
va_list va; // [rsp+D0h] [rbp-90h] BYREF
_BYTE *v6; // [rsp+F0h] [rbp-70h]
int v7; // [rsp+FCh] [rbp-64h]
char v8[88]; // [rsp+100h] [rbp-60h] BYREF
unsigned long long v9; // [rsp+158h] [rbp-8h]
v9 = __readfsqword(0x28u);
v7 = a1;
v6 = a2;
if ( a2 && *v6 )
{
va_start(va, a2);
vsnprintf(v8, 80LL, v6, va);
}
else
{
v8[0] = 0;
}
while ( 1 )
{
v2 = v7--;
if ( v2 <= 0 )
break;
memset(v4, 0LL, 24LL);
vemit_tap(1, 0LL, (long long)v4);
emit_dir("skip", v8);
emit_endl();
}
return __readfsqword(0x28u);
}
| skip:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x160
TEST AL,AL
JZ 0x0011d7e7
MOVAPS xmmword ptr [RBP + -0x130],XMM0
MOVAPS xmmword ptr [RBP + -0x120],XMM1
MOVAPS xmmword ptr [RBP + -0x110],XMM2
MOVAPS xmmword ptr [RBP + -0x100],XMM3
MOVAPS xmmword ptr [RBP + -0xf0],XMM4
MOVAPS xmmword ptr [RBP + -0xe0],XMM5
MOVAPS xmmword ptr [RBP + -0xd0],XMM6
MOVAPS xmmword ptr [RBP + -0xc0],XMM7
LAB_0011d7e7:
MOV qword ptr [RBP + -0x138],R9
MOV qword ptr [RBP + -0x140],R8
MOV qword ptr [RBP + -0x148],RCX
MOV qword ptr [RBP + -0x150],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x64],EDI
MOV qword ptr [RBP + -0x70],RSI
CMP qword ptr [RBP + -0x70],0x0
JZ 0x0011d873
MOV RAX,qword ptr [RBP + -0x70]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JZ 0x0011d873
LEA RAX,[RBP + -0x90]
LEA RCX,[RBP + -0x160]
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x10
LEA RDI,[RBP + -0x60]
MOV RDX,qword ptr [RBP + -0x70]
LEA RCX,[RBP + -0x90]
MOV ESI,0x50
CALL 0x001132a0
LEA RAX,[RBP + -0x90]
JMP 0x0011d877
LAB_0011d873:
MOV byte ptr [RBP + -0x60],0x0
LAB_0011d877:
JMP 0x0011d879
LAB_0011d879:
MOV EAX,dword ptr [RBP + -0x64]
MOV ECX,EAX
ADD ECX,-0x1
MOV dword ptr [RBP + -0x64],ECX
CMP EAX,0x0
JLE 0x0011d8c8
LEA RDI,[RBP + -0xb0]
XOR ESI,ESI
MOV EDX,0x18
CALL 0x00113250
LEA RDX,[RBP + -0xb0]
MOV EDI,0x1
XOR EAX,EAX
MOV ESI,EAX
CALL 0x0011d690
LEA RSI,[RBP + -0x60]
LEA RDI,[0x155b6b]
CALL 0x0011d760
CALL 0x0011da50
JMP 0x0011d879
LAB_0011d8c8:
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0011d8e3
ADD RSP,0x160
POP RBP
RET
LAB_0011d8e3:
CALL 0x001134b0
|
void skip(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,int param_9,
char *param_10,int8 param_11,int8 param_12,int8 param_13,
int8 param_14)
{
char in_AL;
long in_FS_OFFSET;
int1 local_168 [16];
int8 local_158;
int8 local_150;
int8 local_148;
int8 local_140;
int8 local_138;
int8 local_128;
int8 local_118;
int8 local_108;
int8 local_f8;
int8 local_e8;
int8 local_d8;
int8 local_c8;
int1 local_b8 [32];
int4 local_98;
int4 local_94;
int1 *local_90;
int1 *local_88;
char *local_78;
int local_6c;
char local_68 [88];
long local_10;
if (in_AL != '\0') {
local_138 = param_1;
local_128 = param_2;
local_118 = param_3;
local_108 = param_4;
local_f8 = param_5;
local_e8 = param_6;
local_d8 = param_7;
local_c8 = param_8;
}
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_158 = param_11;
local_150 = param_12;
local_148 = param_13;
local_140 = param_14;
local_78 = param_10;
local_6c = param_9;
if ((param_10 == (char *)0x0) || (*param_10 == '\0')) {
local_68[0] = '\0';
}
else {
local_88 = local_168;
local_90 = &stack0x00000008;
local_94 = 0x30;
local_98 = 0x10;
vsnprintf(local_68,0x50,param_10,&local_98);
}
while (0 < local_6c) {
local_6c = local_6c + -1;
memset(local_b8,0,0x18);
vemit_tap(1,0,local_b8);
emit_dir(&DAT_00155b6b);
emit_endl();
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
local_6c = local_6c + -1;
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
}
|
|
5,801 | uf_endspace | eloqsql/storage/myisam/mi_packrec.c | static void uf_endspace(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff, uchar *to,
uchar *end)
{
uint spaces;
if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
{
bit_buff->error=1;
return;
}
if (to+spaces != end)
decode_bytes(rec,bit_buff,to,end-spaces);
bfill((uchar*) end-spaces,spaces,' ');
} | O0 | c | uf_endspace:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jb 0xbd3db
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x1c(%rcx), %esi
movq -0x10(%rbp), %rdx
movl 0x4(%rdx), %ecx
subl %esi, %ecx
movl %ecx, 0x4(%rdx)
shrl %cl, %eax
movq -0x8(%rbp), %rcx
movl 0x1c(%rcx), %ecx
movl %ecx, %edx
leaq 0x20226d(%rip), %rcx # 0x2bf640
andl (%rcx,%rdx,4), %eax
movl %eax, -0x28(%rbp)
jmp 0xbd3ee
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %esi
callq 0xbab20
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
cmpq -0x20(%rbp), %rax
jbe 0xbd410
movq -0x10(%rbp), %rax
movl $0x1, 0x28(%rax)
jmp 0xbd463
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
addq %rcx, %rax
cmpq -0x20(%rbp), %rax
je 0xbd443
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %eax
movl %eax, %r8d
xorl %eax, %eax
subq %r8, %rax
addq %rax, %rcx
callq 0xbca80
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rdi
movl -0x24(%rbp), %eax
movl %eax, %edx
movl $0x20, %esi
callq 0x2a2c0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| uf_endspace_0:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov rax, [rbp+var_10]
mov eax, [rax+4]
mov rcx, [rbp+var_8]
cmp eax, [rcx+1Ch]
jb short loc_BD3DB
mov rax, [rbp+var_10]
mov eax, [rax]
mov rcx, [rbp+var_8]
mov esi, [rcx+1Ch]
mov rdx, [rbp+var_10]
mov ecx, [rdx+4]
sub ecx, esi
mov [rdx+4], ecx
shr eax, cl
mov rcx, [rbp+var_8]
mov ecx, [rcx+1Ch]
mov edx, ecx
lea rcx, mask_0
and eax, [rcx+rdx*4]
mov [rbp+var_28], eax
jmp short loc_BD3EE
loc_BD3DB:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_8]
mov esi, [rax+1Ch]
call fill_and_get_bits_0
mov [rbp+var_28], eax
loc_BD3EE:
mov ecx, [rbp+var_28]
mov [rbp+var_24], ecx
mov rax, [rbp+var_18]
mov ecx, ecx
add rax, rcx
cmp rax, [rbp+var_20]
jbe short loc_BD410
mov rax, [rbp+var_10]
mov dword ptr [rax+28h], 1
jmp short loc_BD463
loc_BD410:
mov rax, [rbp+var_18]
mov ecx, [rbp+var_24]
add rax, rcx
cmp rax, [rbp+var_20]
jz short loc_BD443
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
mov eax, [rbp+var_24]
mov r8d, eax
xor eax, eax
sub rax, r8
add rcx, rax
call decode_bytes_0
loc_BD443:
mov rdi, [rbp+var_20]
mov eax, [rbp+var_24]
mov ecx, eax
xor eax, eax
sub rax, rcx
add rdi, rax
mov eax, [rbp+var_24]
mov edx, eax
mov esi, 20h ; ' '
call _memset
loc_BD463:
add rsp, 30h
pop rbp
retn
| long long uf_endspace_0(long long a1, unsigned int *a2, _BYTE *a3, _BYTE *a4)
{
unsigned int v4; // eax
int v5; // ecx
long long result; // rax
unsigned int bits_0; // [rsp+8h] [rbp-28h]
if ( a2[1] < *(_DWORD *)(a1 + 28) )
{
bits_0 = fill_and_get_bits_0(a2, *(_DWORD *)(a1 + 28));
}
else
{
v4 = *a2;
v5 = a2[1] - *(_DWORD *)(a1 + 28);
a2[1] = v5;
bits_0 = mask_0[*(unsigned int *)(a1 + 28)] & (v4 >> v5);
}
if ( &a3[bits_0] <= a4 )
{
if ( &a3[bits_0] != a4 )
decode_bytes_0(a1, (long long)a2, a3, &a4[-bits_0]);
return memset(&a4[-bits_0], 32LL, bits_0);
}
else
{
result = (long long)a2;
a2[10] = 1;
}
return result;
}
| uf_endspace:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x4]
MOV RCX,qword ptr [RBP + -0x8]
CMP EAX,dword ptr [RCX + 0x1c]
JC 0x001bd3db
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RCX + 0x1c]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RDX + 0x4]
SUB ECX,ESI
MOV dword ptr [RDX + 0x4],ECX
SHR EAX,CL
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX + 0x1c]
MOV EDX,ECX
LEA RCX,[0x3bf640]
AND EAX,dword ptr [RCX + RDX*0x4]
MOV dword ptr [RBP + -0x28],EAX
JMP 0x001bd3ee
LAB_001bd3db:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RAX + 0x1c]
CALL 0x001bab20
MOV dword ptr [RBP + -0x28],EAX
LAB_001bd3ee:
MOV ECX,dword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x24],ECX
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,ECX
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x001bd410
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x28],0x1
JMP 0x001bd463
LAB_001bd410:
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x24]
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x20]
JZ 0x001bd443
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RBP + -0x24]
MOV R8D,EAX
XOR EAX,EAX
SUB RAX,R8
ADD RCX,RAX
CALL 0x001bca80
LAB_001bd443:
MOV RDI,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RBP + -0x24]
MOV ECX,EAX
XOR EAX,EAX
SUB RAX,RCX
ADD RDI,RAX
MOV EAX,dword ptr [RBP + -0x24]
MOV EDX,EAX
MOV ESI,0x20
CALL 0x0012a2c0
LAB_001bd463:
ADD RSP,0x30
POP RBP
RET
|
void uf_endspace(long param_1,uint *param_2,long param_3,ulong param_4)
{
uint uVar1;
uint local_30;
if (param_2[1] < *(uint *)(param_1 + 0x1c)) {
local_30 = fill_and_get_bits(param_2,*(int4 *)(param_1 + 0x1c));
}
else {
uVar1 = param_2[1] - *(int *)(param_1 + 0x1c);
param_2[1] = uVar1;
local_30 = *param_2 >> ((byte)uVar1 & 0x1f) &
*(uint *)(mask + (ulong)*(uint *)(param_1 + 0x1c) * 4);
}
if (param_4 < param_3 + (ulong)local_30) {
param_2[10] = 1;
}
else {
if (param_3 + (ulong)local_30 != param_4) {
decode_bytes(param_1,param_2,param_3,param_4 - local_30);
}
memset((void *)(param_4 - local_30),0x20,(ulong)local_30);
}
return;
}
|
|
5,802 | inline_mysql_file_seek | eloqsql/include/mysql/psi/mysql_file.h | static inline my_off_t
inline_mysql_file_seek(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, my_off_t pos, int whence, myf flags)
{
my_off_t result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, file, PSI_FILE_SEEK);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, (size_t) 0, src_file, src_line);
result= my_seek(file, pos, whence, flags);
PSI_FILE_CALL(end_file_wait)(locker, (size_t) 0);
return result;
}
#endif
result= my_seek(file, pos, whence, flags);
return result;
} | O0 | c | inline_mysql_file_seek:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
leaq 0x213758(%rip), %rax # 0x2cb450
movq (%rax), %rax
movq 0x158(%rax), %rax
movl -0x18(%rbp), %esi
leaq -0x88(%rbp), %rdi
movl $0x8, %edx
callq *%rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xb7d93
leaq 0x213712(%rip), %rax # 0x2cb450
movq (%rax), %rax
movq 0x210(%rax), %rax
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
xorl %esi, %esi
callq *%rax
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
movq -0x30(%rbp), %rcx
callq 0xfb570
movq %rax, -0x38(%rbp)
leaq 0x2136db(%rip), %rax # 0x2cb450
movq (%rax), %rax
movq 0x218(%rax), %rax
movq -0x40(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
callq *%rax
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb7db2
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
movq -0x30(%rbp), %rcx
callq 0xfb570
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nop
| inline_mysql_file_seek_4:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_20], rcx
mov [rbp+var_24], r8d
mov [rbp+var_30], r9
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+158h]
mov esi, [rbp+var_18]
lea rdi, [rbp+var_88]
mov edx, 8
call rax
mov [rbp+var_40], rax
cmp [rbp+var_40], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_B7D93
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+210h]
mov rdi, [rbp+var_40]
mov rdx, [rbp+var_10]
mov ecx, [rbp+var_14]
xor esi, esi
call rax
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov edx, [rbp+var_24]
mov rcx, [rbp+var_30]
call my_seek
mov [rbp+var_38], rax
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+218h]
mov rdi, [rbp+var_40]
xor ecx, ecx
mov esi, ecx
call rax
mov rax, [rbp+var_38]
mov [rbp+var_8], rax
jmp short loc_B7DB2
loc_B7D93:
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov edx, [rbp+var_24]
mov rcx, [rbp+var_30]
call my_seek
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov [rbp+var_8], rax
loc_B7DB2:
mov rax, [rbp+var_8]
add rsp, 90h
pop rbp
retn
| long long inline_mysql_file_seek_4(
long long a1,
unsigned int a2,
unsigned int a3,
long long a4,
unsigned int a5,
long long a6)
{
_BYTE v7[72]; // [rsp+8h] [rbp-88h] BYREF
long long v8; // [rsp+50h] [rbp-40h]
long long v9; // [rsp+58h] [rbp-38h]
long long v10; // [rsp+60h] [rbp-30h]
unsigned int v11; // [rsp+6Ch] [rbp-24h]
long long v12; // [rsp+70h] [rbp-20h]
unsigned int v13; // [rsp+78h] [rbp-18h]
unsigned int v14; // [rsp+7Ch] [rbp-14h]
long long v15; // [rsp+80h] [rbp-10h]
v15 = a1;
v14 = a2;
v13 = a3;
v12 = a4;
v11 = a5;
v10 = a6;
v8 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v7, a3, 8LL);
if ( !v8 )
return my_seek(v13, v12, v11, v10);
((void ( *)(long long, _QWORD, long long, _QWORD))PSI_server[66])(v8, 0LL, v15, v14);
v9 = my_seek(v13, v12, v11, v10);
((void ( *)(long long, _QWORD))PSI_server[67])(v8, 0LL);
return v9;
}
| inline_mysql_file_seek:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV dword ptr [RBP + -0x24],R8D
MOV qword ptr [RBP + -0x30],R9
LEA RAX,[0x3cb450]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x158]
MOV ESI,dword ptr [RBP + -0x18]
LEA RDI,[RBP + -0x88]
MOV EDX,0x8
CALL RAX
MOV qword ptr [RBP + -0x40],RAX
CMP qword ptr [RBP + -0x40],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001b7d93
LEA RAX,[0x3cb450]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x210]
MOV RDI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x14]
XOR ESI,ESI
CALL RAX
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x24]
MOV RCX,qword ptr [RBP + -0x30]
CALL 0x001fb570
MOV qword ptr [RBP + -0x38],RAX
LEA RAX,[0x3cb450]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV RDI,qword ptr [RBP + -0x40]
XOR ECX,ECX
MOV ESI,ECX
CALL RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001b7db2
LAB_001b7d93:
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x24]
MOV RCX,qword ptr [RBP + -0x30]
CALL 0x001fb570
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
LAB_001b7db2:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x90
POP RBP
RET
|
int8
inline_mysql_file_seek
(int8 param_1,int4 param_2,int4 param_3,int8 param_4,
int4 param_5,int8 param_6)
{
int1 local_90 [72];
long local_48;
int8 local_40;
int8 local_38;
int4 local_2c;
int8 local_28;
int4 local_20;
int4 local_1c;
int8 local_18;
int8 local_10;
local_38 = param_6;
local_2c = param_5;
local_28 = param_4;
local_20 = param_3;
local_1c = param_2;
local_18 = param_1;
local_48 = (**(code **)(PSI_server + 0x158))(local_90,param_3,8);
if (local_48 == 0) {
local_10 = my_seek(local_20,local_28,local_2c,local_38);
}
else {
(**(code **)(PSI_server + 0x210))(local_48,0,local_18,local_1c);
local_40 = my_seek(local_20,local_28,local_2c,local_38);
(**(code **)(PSI_server + 0x218))(local_48,0);
local_10 = local_40;
}
return local_10;
}
|
|
5,803 | PFS_account::aggregate_status(PFS_user*, PFS_host*) | eloqsql/storage/perfschema/pfs_account.cc | void PFS_account::aggregate_status(PFS_user *safe_user, PFS_host *safe_host)
{
/*
Never aggregate to global_status_var,
because of the parallel THD -> global_status_var flow.
*/
if (safe_user != NULL)
{
/*
Aggregate STATUS_BY_ACCOUNT to:
- STATUS_BY_USER
*/
safe_user->m_status_stats.aggregate(& m_status_stats);
}
if (safe_host != NULL)
{
/*
Aggregate STATUS_BY_ACCOUNT to:
- STATUS_BY_HOST
*/
safe_host->m_status_stats.aggregate(& m_status_stats);
}
m_status_stats.reset();
return;
} | O3 | cpp | PFS_account::aggregate_status(PFS_user*, PFS_host*):
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x41beb
addq $0x30, %rsi
leaq 0x30(%rbx), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x3ce9c
testq %r14, %r14
je 0x41c00
addq $0x30, %r14
leaq 0x30(%rbx), %rsi
movq %r14, %rdi
callq 0x3ce9c
addq $0x30, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3ce84
| _ZN11PFS_account16aggregate_statusEP8PFS_userP8PFS_host:
push rbp
mov rbp, rsp
push r14
push rbx
mov r14, rdx
mov rbx, rdi
test rsi, rsi
jz short loc_41BEB
add rsi, 30h ; '0'
lea rax, [rbx+30h]
mov rdi, rsi
mov rsi, rax
call _ZN16PFS_status_stats9aggregateEPKS_; PFS_status_stats::aggregate(PFS_status_stats const*)
loc_41BEB:
test r14, r14
jz short loc_41C00
add r14, 30h ; '0'
lea rsi, [rbx+30h]
mov rdi, r14
call _ZN16PFS_status_stats9aggregateEPKS_; PFS_status_stats::aggregate(PFS_status_stats const*)
loc_41C00:
add rbx, 30h ; '0'
mov rdi, rbx; this
pop rbx
pop r14
pop rbp
jmp _ZN16PFS_status_stats5resetEv; PFS_status_stats::reset(void)
| long long PFS_account::aggregate_status(PFS_account *this, PFS_user *a2, PFS_host *a3)
{
if ( a2 )
PFS_status_stats::aggregate((PFS_user *)((char *)a2 + 48), (PFS_account *)((char *)this + 48));
if ( a3 )
PFS_status_stats::aggregate((PFS_host *)((char *)a3 + 48), (PFS_account *)((char *)this + 48));
return PFS_status_stats::reset((PFS_account *)((char *)this + 48));
}
| aggregate_status:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV R14,RDX
MOV RBX,RDI
TEST RSI,RSI
JZ 0x00141beb
ADD RSI,0x30
LEA RAX,[RBX + 0x30]
MOV RDI,RSI
MOV RSI,RAX
CALL 0x0013ce9c
LAB_00141beb:
TEST R14,R14
JZ 0x00141c00
ADD R14,0x30
LEA RSI,[RBX + 0x30]
MOV RDI,R14
CALL 0x0013ce9c
LAB_00141c00:
ADD RBX,0x30
MOV RDI,RBX
POP RBX
POP R14
POP RBP
JMP 0x0013ce84
|
/* PFS_account::aggregate_status(PFS_user*, PFS_host*) */
void __thiscall PFS_account::aggregate_status(PFS_account *this,PFS_user *param_1,PFS_host *param_2)
{
if (param_1 != (PFS_user *)0x0) {
PFS_status_stats::aggregate
((PFS_status_stats *)(param_1 + 0x30),(PFS_status_stats *)(this + 0x30));
}
if (param_2 != (PFS_host *)0x0) {
PFS_status_stats::aggregate
((PFS_status_stats *)(param_2 + 0x30),(PFS_status_stats *)(this + 0x30));
}
PFS_status_stats::reset((PFS_status_stats *)(this + 0x30));
return;
}
|
|
5,804 | js_object_hasOwn | bluesky950520[P]quickjs/quickjs.c | static JSValue js_object_hasOwn(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue obj;
JSAtom atom;
JSObject *p;
BOOL ret;
obj = JS_ToObject(ctx, argv[0]);
if (JS_IsException(obj))
return obj;
atom = JS_ValueToAtom(ctx, argv[1]);
if (unlikely(atom == JS_ATOM_NULL)) {
JS_FreeValue(ctx, obj);
return JS_EXCEPTION;
}
p = JS_VALUE_GET_OBJ(obj);
ret = JS_GetOwnPropertyInternal(ctx, NULL, p, atom);
JS_FreeAtom(ctx, atom);
JS_FreeValue(ctx, obj);
if (ret < 0)
return JS_EXCEPTION;
else
return js_bool(ret);
} | O1 | c | js_object_hasOwn:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rdi, %r15
movq (%r8), %rsi
movq 0x8(%r8), %rdx
callq 0x26ddd
movq %rax, %rbx
movq %rdx, %r14
movq %rax, (%rsp)
cmpl $0x6, %r14d
je 0x710c3
movq 0x10(%r12), %rsi
movq 0x18(%r12), %rdx
movq %r15, %rdi
callq 0x24093
testl %eax, %eax
je 0x710d8
movl %eax, %ebp
movq (%rsp), %r12
xorl %ebx, %ebx
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
movl %eax, %ecx
callq 0x23bd9
movl %eax, %r13d
movq %r15, %rdi
movl %ebp, %esi
callq 0x207d8
movq 0x18(%r15), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x1d8c6
testl %r13d, %r13d
js 0x710bd
setne %al
movzbl %al, %ebx
movl $0x1, %r14d
jmp 0x710c3
movl $0x6, %r14d
movq %rbx, %rax
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1d8c6
movl $0x6, %r14d
xorl %ebx, %ebx
jmp 0x710c3
| js_object_hasOwn:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r12, r8
mov r15, rdi
mov rsi, [r8]
mov rdx, [r8+8]
call JS_ToObject
mov rbx, rax
mov r14, rdx
mov [rsp+38h+var_38], rax
cmp r14d, 6
jz short loc_710C3
mov rsi, [r12+10h]
mov rdx, [r12+18h]
mov rdi, r15
call JS_ValueToAtom
test eax, eax
jz short loc_710D8
mov ebp, eax
mov r12, [rsp+38h+var_38]
xor ebx, ebx
mov rdi, r15
xor esi, esi
mov rdx, r12
mov ecx, eax
call JS_GetOwnPropertyInternal
mov r13d, eax
mov rdi, r15
mov esi, ebp
call JS_FreeAtom
mov rdi, [r15+18h]
mov rsi, r12
mov rdx, r14
call JS_FreeValueRT
test r13d, r13d
js short loc_710BD
setnz al
movzx ebx, al
mov r14d, 1
jmp short loc_710C3
loc_710BD:
mov r14d, 6
loc_710C3:
mov rax, rbx
mov rdx, r14
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_710D8:
mov rdi, [r15+18h]
mov rsi, rbx
mov rdx, r14
call JS_FreeValueRT
mov r14d, 6
xor ebx, ebx
jmp short loc_710C3
| _BOOL8 js_object_hasOwn(
long long a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
long long a12,
long long *a13,
long long a14)
{
_DWORD *v15; // rbx
long long v16; // rdx
long long v17; // r14
int v18; // eax
int v19; // ebp
int OwnPropertyInternal; // r13d
_DWORD *v22; // [rsp+0h] [rbp-38h]
v15 = JS_ToObject(a1, *a13, a13[1], a12, (long long)a13, a14, a2, a3, a4, a5, a6, a7, a8, a9);
v17 = v16;
v22 = v15;
if ( (_DWORD)v16 != 6 )
{
v18 = JS_ValueToAtom(a1, a13[2], a13[3]);
if ( v18 )
{
v19 = v18;
v15 = 0LL;
OwnPropertyInternal = JS_GetOwnPropertyInternal(a1, 0LL, (long long)v22, v18);
JS_FreeAtom(a1, v19);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v22, v17);
if ( OwnPropertyInternal >= 0 )
return OwnPropertyInternal != 0;
}
else
{
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v15, v17);
return 0LL;
}
}
return (_BOOL8)v15;
}
| js_object_hasOwn:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R12,R8
MOV R15,RDI
MOV RSI,qword ptr [R8]
MOV RDX,qword ptr [R8 + 0x8]
CALL 0x00126ddd
MOV RBX,RAX
MOV R14,RDX
MOV qword ptr [RSP],RAX
CMP R14D,0x6
JZ 0x001710c3
MOV RSI,qword ptr [R12 + 0x10]
MOV RDX,qword ptr [R12 + 0x18]
MOV RDI,R15
CALL 0x00124093
TEST EAX,EAX
JZ 0x001710d8
MOV EBP,EAX
MOV R12,qword ptr [RSP]
XOR EBX,EBX
MOV RDI,R15
XOR ESI,ESI
MOV RDX,R12
MOV ECX,EAX
CALL 0x00123bd9
MOV R13D,EAX
MOV RDI,R15
MOV ESI,EBP
CALL 0x001207d8
MOV RDI,qword ptr [R15 + 0x18]
MOV RSI,R12
MOV RDX,R14
CALL 0x0011d8c6
TEST R13D,R13D
JS 0x001710bd
SETNZ AL
MOVZX EBX,AL
MOV R14D,0x1
JMP 0x001710c3
LAB_001710bd:
MOV R14D,0x6
LAB_001710c3:
MOV RAX,RBX
MOV RDX,R14
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001710d8:
MOV RDI,qword ptr [R15 + 0x18]
MOV RSI,RBX
MOV RDX,R14
CALL 0x0011d8c6
MOV R14D,0x6
XOR EBX,EBX
JMP 0x001710c3
|
int1 [16] js_object_hasOwn(long param_1)
{
int iVar1;
int iVar2;
int8 *in_R8;
int1 auVar3 [16];
auVar3 = JS_ToObject(param_1,*in_R8,in_R8[1]);
auVar3._0_8_ = auVar3._0_8_;
if (auVar3._8_4_ != 6) {
iVar1 = JS_ValueToAtom(param_1,in_R8[2],in_R8[3]);
if (iVar1 == 0) {
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),auVar3._0_8_,auVar3._8_8_);
auVar3 = ZEXT816(6) << 0x40;
}
else {
iVar2 = JS_GetOwnPropertyInternal(param_1,0,auVar3._0_8_,iVar1);
JS_FreeAtom(param_1,iVar1);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),auVar3._0_8_,auVar3._8_8_);
if (iVar2 < 0) {
auVar3 = ZEXT816(6) << 0x40;
}
else {
auVar3._1_7_ = 0;
auVar3[0] = iVar2 != 0;
auVar3._8_8_ = 1;
}
}
}
return auVar3;
}
|
|
5,805 | evmone::advanced::get_op_table(evmc_revision) | corpus-core[P]colibri-stateless/build_O1/_deps/evmone_external-src/lib/evmone/advanced_instructions.cpp | EVMC_EXPORT const OpTable& get_op_table(evmc_revision rev) noexcept
{
static constexpr auto op_tables = []() noexcept {
std::array<OpTable, EVMC_MAX_REVISION + 1> tables{};
for (size_t r = EVMC_FRONTIER; r <= EVMC_MAX_REVISION; ++r)
{
auto& table = tables[r];
for (size_t i = 0; i < table.size(); ++i)
{
auto& t = table[i];
const auto gas_cost = instr::gas_costs[r][i];
if (gas_cost == instr::undefined)
{
t.fn = op_undefined;
t.gas_cost = 0;
}
else
{
t.fn = instruction_implementations[i];
t.gas_cost = gas_cost;
t.stack_req = instr::traits[i].stack_height_required;
t.stack_change = instr::traits[i].stack_height_change;
}
}
}
return tables;
}();
return op_tables[rev];
} | O1 | cpp | evmone::advanced::get_op_table(evmc_revision):
movl %edi, %ecx
shlq $0xc, %rcx
leaq 0x62197(%rip), %rax # 0xb1b98
addq %rcx, %rax
retq
| _ZN6evmone8advanced12get_op_tableE13evmc_revision:
mov ecx, edi
shl rcx, 0Ch
lea rax, _ZZN6evmone8advanced12get_op_tableE13evmc_revisionE9op_tables; evmone::advanced::get_op_table(evmc_revision)::op_tables
add rax, rcx
retn
| long long ( ** evmone::advanced::get_op_table(unsigned int a1))()
{
return &evmone::advanced::get_op_table(evmc_revision)::op_tables + 512 * (unsigned long long)a1;
}
| get_op_table:
MOV ECX,EDI
SHL RCX,0xc
LEA RAX,[0x1b1b98]
ADD RAX,RCX
RET
|
/* evmone::advanced::get_op_table(evmc_revision) */
int1 * evmone::advanced::get_op_table(uint param_1)
{
return get_op_table(evmc_revision)::op_tables + (ulong)param_1 * 0x1000;
}
|
|
5,806 | skip_all | eloqsql/unittest/mytap/tap.c | void
skip_all(char const *reason, ...)
{
va_list ap;
va_start(ap, reason);
fprintf(tapout, "1..0 # skip ");
vfprintf(tapout, reason, ap);
fflush(tapout);
va_end(ap);
exit(0);
} | O0 | c | skip_all:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0xdb565
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x1e3a21(%rip), %rax # 0x2befd8
movq (%rax), %rdi
leaq 0x79d69(%rip), %rsi # 0x15532a
movb $0x0, %al
callq 0x2a160
movq 0x1e3a09(%rip), %rax # 0x2befd8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x2a7c0
movq 0x1e39f2(%rip), %rax # 0x2befd8
movq (%rax), %rdi
callq 0x2a3d0
leaq -0x20(%rbp), %rax
xorl %edi, %edi
callq 0x2a500
nopl (%rax)
| skip_all:
push rbp
mov rbp, rsp
sub rsp, 0D0h
test al, al
jz short loc_DB565
movaps [rbp+var_A0], xmm0
movaps [rbp+var_90], xmm1
movaps [rbp+var_80], xmm2
movaps [rbp+var_70], xmm3
movaps [rbp+var_60], xmm4
movaps [rbp+var_50], xmm5
movaps [rbp+var_40], xmm6
movaps [rbp+var_30], xmm7
loc_DB565:
mov [rbp+var_A8], r9
mov [rbp+var_B0], r8
mov [rbp+var_B8], rcx
mov [rbp+var_C0], rdx
mov [rbp+var_C8], rsi
mov [rbp+var_8], rdi
lea rax, [rbp+var_20]
lea rcx, [rbp+var_D0]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 8
mov rax, cs:stdout_ptr
mov rdi, [rax]
lea rsi, a10Skip; "1..0 # skip "
mov al, 0
call _fprintf
mov rax, cs:stdout_ptr
mov rdi, [rax]
mov rsi, [rbp+var_8]
lea rdx, [rbp+var_20]
call _vfprintf
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
lea rax, [rbp+var_20]
xor edi, edi
call _exit
| void __noreturn skip_all(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
char v15; // [rsp+0h] [rbp-D0h] BYREF
long long v16; // [rsp+8h] [rbp-C8h]
long long v17; // [rsp+10h] [rbp-C0h]
long long v18; // [rsp+18h] [rbp-B8h]
long long v19; // [rsp+20h] [rbp-B0h]
long long v20; // [rsp+28h] [rbp-A8h]
__m128 v21; // [rsp+30h] [rbp-A0h]
__m128 v22; // [rsp+40h] [rbp-90h]
__m128 v23; // [rsp+50h] [rbp-80h]
__m128 v24; // [rsp+60h] [rbp-70h]
__m128 v25; // [rsp+70h] [rbp-60h]
__m128 v26; // [rsp+80h] [rbp-50h]
__m128 v27; // [rsp+90h] [rbp-40h]
__m128 v28; // [rsp+A0h] [rbp-30h]
_DWORD v29[2]; // [rsp+B0h] [rbp-20h] BYREF
char *v30; // [rsp+B8h] [rbp-18h]
char *v31; // [rsp+C0h] [rbp-10h]
long long v32; // [rsp+C8h] [rbp-8h]
v21 = a7;
v22 = a8;
v23 = a9;
v24 = a10;
v25 = a11;
v26 = a12;
v27 = a13;
v28 = a14;
v20 = a6;
v19 = a5;
v18 = a4;
v17 = a3;
v16 = a2;
v32 = a1;
v31 = &v15;
v30 = &a15;
v29[1] = 48;
v29[0] = 8;
fprintf(stdout, "1..0 # skip ");
vfprintf(stdout, v32, v29);
fflush(stdout);
exit(0LL);
}
| skip_all:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xd0
TEST AL,AL
JZ 0x001db565
MOVAPS xmmword ptr [RBP + -0xa0],XMM0
MOVAPS xmmword ptr [RBP + -0x90],XMM1
MOVAPS xmmword ptr [RBP + -0x80],XMM2
MOVAPS xmmword ptr [RBP + -0x70],XMM3
MOVAPS xmmword ptr [RBP + -0x60],XMM4
MOVAPS xmmword ptr [RBP + -0x50],XMM5
MOVAPS xmmword ptr [RBP + -0x40],XMM6
MOVAPS xmmword ptr [RBP + -0x30],XMM7
LAB_001db565:
MOV qword ptr [RBP + -0xa8],R9
MOV qword ptr [RBP + -0xb0],R8
MOV qword ptr [RBP + -0xb8],RCX
MOV qword ptr [RBP + -0xc0],RDX
MOV qword ptr [RBP + -0xc8],RSI
MOV qword ptr [RBP + -0x8],RDI
LEA RAX,[RBP + -0x20]
LEA RCX,[RBP + -0xd0]
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x8
MOV RAX,qword ptr [0x003befd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x25532a]
MOV AL,0x0
CALL 0x0012a160
MOV RAX,qword ptr [0x003befd8]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x8]
LEA RDX,[RBP + -0x20]
CALL 0x0012a7c0
MOV RAX,qword ptr [0x003befd8]
MOV RDI,qword ptr [RAX]
CALL 0x0012a3d0
LEA RAX,[RBP + -0x20]
XOR EDI,EDI
CALL 0x0012a500
|
void skip_all(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
char *param_9,int8 param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
char in_AL;
int1 local_d8 [8];
int8 local_d0;
int8 local_c8;
int8 local_c0;
int8 local_b8;
int8 local_b0;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int8 local_48;
int8 local_38;
int4 local_28;
int4 local_24;
int1 *local_20;
int1 *local_18;
char *local_10;
if (in_AL != '\0') {
local_a8 = param_1;
local_98 = param_2;
local_88 = param_3;
local_78 = param_4;
local_68 = param_5;
local_58 = param_6;
local_48 = param_7;
local_38 = param_8;
}
local_18 = local_d8;
local_20 = &stack0x00000008;
local_24 = 0x30;
local_28 = 8;
local_d0 = param_10;
local_c8 = param_11;
local_c0 = param_12;
local_b8 = param_13;
local_b0 = param_14;
local_10 = param_9;
fprintf(*(FILE **)PTR_stdout_003befd8,"1..0 # skip ");
vfprintf(*(FILE **)PTR_stdout_003befd8,local_10,&local_28);
fflush(*(FILE **)PTR_stdout_003befd8);
/* WARNING: Subroutine does not return */
exit(0);
}
|
|
5,807 | my_mb_wc_sjis | eloqsql/strings/ctype-sjis.c | static int
my_mb_wc_sjis(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e){
int hi;
if (s >= e)
return MY_CS_TOOSMALL;
if ((hi= s[0]) < 0x80) /* ASCII: [00..7F] -> [U+0000..U+007F] */
{
*pwc= hi;
return 1;
}
/* JIS-X-0201 Half width Katakana: [A1..DF] -> [U+FF61..U+FF9F] */
if (hi >= 0xA1 && hi <= 0xDF)
{
*pwc= sjis_to_unicode[hi];
return 1;
}
if (s + 2 > e)
return MY_CS_TOOSMALL2;
/* JIS-X-0208 [81..9F,E0..FC][40..7E,80..FC] */
if (!(pwc[0]= sjis_to_unicode[(hi << 8) + s[1]]))
return (issjishead(hi) && issjistail(s[1])) ? -2 : MY_CS_ILSEQ;
return 2;
} | O0 | c | my_mb_wc_sjis:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x5224a
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x523a8
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x80, %eax
jge 0x52272
movslq -0x2c(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x523a8
cmpl $0xa1, -0x2c(%rbp)
jl 0x522a8
cmpl $0xdf, -0x2c(%rbp)
jg 0x522a8
movslq -0x2c(%rbp), %rcx
leaq 0x233521(%rip), %rax # 0x2857b0
movzwl (%rax,%rcx,2), %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x523a8
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0x522c2
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x523a8
movl -0x2c(%rbp), %eax
shll $0x8, %eax
movq -0x20(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x2334d4(%rip), %rax # 0x2857b0
movzwl (%rax,%rcx,2), %eax
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x523a1
movl -0x2c(%rbp), %eax
movzbl %al, %ecx
movl $0x81, %eax
cmpl %ecx, %eax
jg 0x5230d
movl -0x2c(%rbp), %eax
movzbl %al, %eax
cmpl $0x9f, %eax
jle 0x52334
movl -0x2c(%rbp), %eax
movzbl %al, %edx
xorl %eax, %eax
movl $0xe0, %ecx
cmpl %edx, %ecx
movb %al, -0x2d(%rbp)
jg 0x5238c
movl -0x2c(%rbp), %eax
movzbl %al, %ecx
xorl %eax, %eax
cmpl $0xfc, %ecx
movb %al, -0x2d(%rbp)
jg 0x5238c
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %ecx
movl $0x40, %eax
cmpl %ecx, %eax
jg 0x52357
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %ecx
movb $0x1, %al
cmpl $0x7e, %ecx
movb %al, -0x2e(%rbp)
jle 0x52386
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %edx
xorl %eax, %eax
movl $0x80, %ecx
cmpl %edx, %ecx
movb %al, -0x2f(%rbp)
jg 0x52380
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xfc, %eax
setle %al
movb %al, -0x2f(%rbp)
movb -0x2f(%rbp), %al
movb %al, -0x2e(%rbp)
movb -0x2e(%rbp), %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %dl
xorl %eax, %eax
movl $0xfffffffe, %ecx # imm = 0xFFFFFFFE
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x523a8
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
| my_mb_wc_sjis:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jb short loc_5224A
mov [rbp+var_4], 0FFFFFF9Bh
jmp loc_523A8
loc_5224A:
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
mov [rbp+var_2C], eax
cmp eax, 80h
jge short loc_52272
movsxd rcx, [rbp+var_2C]
mov rax, [rbp+var_18]
mov [rax], rcx
mov [rbp+var_4], 1
jmp loc_523A8
loc_52272:
cmp [rbp+var_2C], 0A1h
jl short loc_522A8
cmp [rbp+var_2C], 0DFh
jg short loc_522A8
movsxd rcx, [rbp+var_2C]
lea rax, sjis_to_unicode
movzx eax, word ptr [rax+rcx*2]
mov ecx, eax
mov rax, [rbp+var_18]
mov [rax], rcx
mov [rbp+var_4], 1
jmp loc_523A8
loc_522A8:
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_522C2
mov [rbp+var_4], 0FFFFFF9Ah
jmp loc_523A8
loc_522C2:
mov eax, [rbp+var_2C]
shl eax, 8
mov rcx, [rbp+var_20]
movzx ecx, byte ptr [rcx+1]
add eax, ecx
movsxd rcx, eax
lea rax, sjis_to_unicode
movzx eax, word ptr [rax+rcx*2]
mov rcx, [rbp+var_18]
mov [rcx], rax
cmp rax, 0
jnz loc_523A1
mov eax, [rbp+var_2C]
movzx ecx, al
mov eax, 81h
cmp eax, ecx
jg short loc_5230D
mov eax, [rbp+var_2C]
movzx eax, al
cmp eax, 9Fh
jle short loc_52334
loc_5230D:
mov eax, [rbp+var_2C]
movzx edx, al
xor eax, eax
mov ecx, 0E0h
cmp ecx, edx
mov [rbp+var_2D], al
jg short loc_5238C
mov eax, [rbp+var_2C]
movzx ecx, al
xor eax, eax
cmp ecx, 0FCh
mov [rbp+var_2D], al
jg short loc_5238C
loc_52334:
mov rax, [rbp+var_20]
movzx ecx, byte ptr [rax+1]
mov eax, 40h ; '@'
cmp eax, ecx
jg short loc_52357
mov rax, [rbp+var_20]
movzx ecx, byte ptr [rax+1]
mov al, 1
cmp ecx, 7Eh ; '~'
mov [rbp+var_2E], al
jle short loc_52386
loc_52357:
mov rax, [rbp+var_20]
movzx edx, byte ptr [rax+1]
xor eax, eax
mov ecx, 80h
cmp ecx, edx
mov [rbp+var_2F], al
jg short loc_52380
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
cmp eax, 0FCh
setle al
mov [rbp+var_2F], al
loc_52380:
mov al, [rbp+var_2F]
mov [rbp+var_2E], al
loc_52386:
mov al, [rbp+var_2E]
mov [rbp+var_2D], al
loc_5238C:
mov dl, [rbp+var_2D]
xor eax, eax
mov ecx, 0FFFFFFFEh
test dl, 1
cmovnz eax, ecx
mov [rbp+var_4], eax
jmp short loc_523A8
loc_523A1:
mov [rbp+var_4], 2
loc_523A8:
mov eax, [rbp+var_4]
pop rbp
retn
| long long my_mb_wc_sjis(long long a1, _QWORD *a2, unsigned __int8 *a3, unsigned long long a4)
{
long long v4; // rax
unsigned int v5; // eax
bool v7; // [rsp+1h] [rbp-2Fh]
char v8; // [rsp+2h] [rbp-2Eh]
char v9; // [rsp+3h] [rbp-2Dh]
unsigned int v10; // [rsp+4h] [rbp-2Ch]
if ( (unsigned long long)a3 < a4 )
{
v10 = *a3;
if ( v10 >= 0x80 )
{
if ( *a3 < 0xA1u || *a3 > 0xDFu )
{
if ( (unsigned long long)(a3 + 2) <= a4 )
{
v4 = sjis_to_unicode[a3[1] + (v10 << 8)];
*a2 = v4;
if ( v4 )
{
return 2;
}
else
{
if ( (unsigned __int8)v10 >= 0x81u && (unsigned __int8)v10 <= 0x9Fu
|| (v9 = 0, (unsigned __int8)v10 >= 0xE0u) && (v9 = 0, (unsigned __int8)v10 <= 0xFCu) )
{
if ( a3[1] < 0x40u || (v8 = 1, a3[1] > 0x7Eu) )
{
v7 = 0;
if ( a3[1] >= 0x80u )
v7 = a3[1] <= 0xFCu;
v8 = v7;
}
v9 = v8;
}
v5 = 0;
if ( (v9 & 1) != 0 )
return (unsigned int)-2;
return v5;
}
}
else
{
return (unsigned int)-102;
}
}
else
{
*a2 = sjis_to_unicode[*a3];
return 1;
}
}
else
{
*a2 = *a3;
return 1;
}
}
else
{
return (unsigned int)-101;
}
}
| my_mb_wc_sjis:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x0015224a
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x001523a8
LAB_0015224a:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x80
JGE 0x00152272
MOVSXD RCX,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001523a8
LAB_00152272:
CMP dword ptr [RBP + -0x2c],0xa1
JL 0x001522a8
CMP dword ptr [RBP + -0x2c],0xdf
JG 0x001522a8
MOVSXD RCX,dword ptr [RBP + -0x2c]
LEA RAX,[0x3857b0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001523a8
LAB_001522a8:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x001522c2
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x001523a8
LAB_001522c2:
MOV EAX,dword ptr [RBP + -0x2c]
SHL EAX,0x8
MOV RCX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RCX + 0x1]
ADD EAX,ECX
MOVSXD RCX,EAX
LEA RAX,[0x3857b0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV RCX,qword ptr [RBP + -0x18]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JNZ 0x001523a1
MOV EAX,dword ptr [RBP + -0x2c]
MOVZX ECX,AL
MOV EAX,0x81
CMP EAX,ECX
JG 0x0015230d
MOV EAX,dword ptr [RBP + -0x2c]
MOVZX EAX,AL
CMP EAX,0x9f
JLE 0x00152334
LAB_0015230d:
MOV EAX,dword ptr [RBP + -0x2c]
MOVZX EDX,AL
XOR EAX,EAX
MOV ECX,0xe0
CMP ECX,EDX
MOV byte ptr [RBP + -0x2d],AL
JG 0x0015238c
MOV EAX,dword ptr [RBP + -0x2c]
MOVZX ECX,AL
XOR EAX,EAX
CMP ECX,0xfc
MOV byte ptr [RBP + -0x2d],AL
JG 0x0015238c
LAB_00152334:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RAX + 0x1]
MOV EAX,0x40
CMP EAX,ECX
JG 0x00152357
MOV RAX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RAX + 0x1]
MOV AL,0x1
CMP ECX,0x7e
MOV byte ptr [RBP + -0x2e],AL
JLE 0x00152386
LAB_00152357:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EDX,byte ptr [RAX + 0x1]
XOR EAX,EAX
MOV ECX,0x80
CMP ECX,EDX
MOV byte ptr [RBP + -0x2f],AL
JG 0x00152380
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0xfc
SETLE AL
MOV byte ptr [RBP + -0x2f],AL
LAB_00152380:
MOV AL,byte ptr [RBP + -0x2f]
MOV byte ptr [RBP + -0x2e],AL
LAB_00152386:
MOV AL,byte ptr [RBP + -0x2e]
MOV byte ptr [RBP + -0x2d],AL
LAB_0015238c:
MOV DL,byte ptr [RBP + -0x2d]
XOR EAX,EAX
MOV ECX,0xfffffffe
TEST DL,0x1
CMOVNZ EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001523a8
LAB_001523a1:
MOV dword ptr [RBP + -0x4],0x2
LAB_001523a8:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_mb_wc_sjis(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
ushort uVar1;
bool bVar2;
uint uVar3;
int4 local_c;
if (param_3 < param_4) {
uVar3 = (uint)*param_3;
if (uVar3 < 0x80) {
*param_2 = (long)(int)uVar3;
local_c = 1;
}
else if ((uVar3 < 0xa1) || (0xdf < uVar3)) {
if (param_4 < param_3 + 2) {
local_c = 0xffffff9a;
}
else {
uVar1 = *(ushort *)(sjis_to_unicode + (long)(int)(uVar3 * 0x100 + (uint)param_3[1]) * 2);
*param_2 = (ulong)uVar1;
if ((ulong)uVar1 == 0) {
if ((((0x80 < uVar3) && (uVar3 < 0xa0)) ||
((bVar2 = false, 0xdf < uVar3 && (bVar2 = false, uVar3 < 0xfd)))) &&
(((param_3[1] < 0x40 || (bVar2 = true, 0x7e < param_3[1])) &&
(bVar2 = false, 0x7f < param_3[1])))) {
bVar2 = param_3[1] < 0xfd;
}
local_c = 0;
if (bVar2) {
local_c = 0xfffffffe;
}
}
else {
local_c = 2;
}
}
}
else {
*param_2 = (ulong)*(ushort *)(sjis_to_unicode + (long)(int)uVar3 * 2);
local_c = 1;
}
}
else {
local_c = 0xffffff9b;
}
return local_c;
}
|
|
5,808 | final_exp | corpus-core[P]colibri-stateless/build_O2/_deps/blst-src/src/pairing.c | static void final_exp(vec384fp12 ret, const vec384fp12 f)
{
vec384fp12 y0, y1, y2, y3;
vec_copy(y1, f, sizeof(y1));
conjugate_fp12(y1);
inverse_fp12(y2, f);
mul_fp12(ret, y1, y2);
frobenius_map_fp12(y2, ret, 2);
mul_fp12(ret, ret, y2);
cyclotomic_sqr_fp12(y0, ret);
raise_to_z(y1, y0);
raise_to_z_div_by_2(y2, y1);
vec_copy(y3, ret, sizeof(y3));
conjugate_fp12(y3);
mul_fp12(y1, y1, y3);
conjugate_fp12(y1);
mul_fp12(y1, y1, y2);
raise_to_z(y2, y1);
raise_to_z(y3, y2);
conjugate_fp12(y1);
mul_fp12(y3, y3, y1);
conjugate_fp12(y1);
frobenius_map_fp12(y1, y1, 3);
frobenius_map_fp12(y2, y2, 2);
mul_fp12(y1, y1, y2);
raise_to_z(y2, y3);
mul_fp12(y2, y2, y0);
mul_fp12(y2, y2, ret);
mul_fp12(y1, y1, y2);
frobenius_map_fp12(y2, y3, 1);
mul_fp12(ret, y1, y2);
} | O2 | c | final_exp:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x908, %rsp # imm = 0x908
movq %rsi, %r12
movq %rdi, %rbx
leaq -0x6f0(%rbp), %r14
movl $0x240, %edx # imm = 0x240
movq %r14, %rdi
callq 0x51055
movq %r14, %rdi
callq 0x561f3
leaq -0x4b0(%rbp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x56211
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x55f2f
pushq $0x2
popq %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x56457
movq %rbx, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x55f2f
leaq -0x930(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x55d42
movq %r14, %rdi
movq %r12, %rsi
callq 0x570fc
movq %r14, %rdi
movq %r14, %rsi
callq 0x55d42
movq %r15, %rdi
movq %r14, %rsi
callq 0x570fc
leaq -0x270(%rbp), %r13
movl $0x240, %edx # imm = 0x240
movq %r13, %rdi
movq %rbx, %rsi
callq 0x51055
movq %r13, %rdi
callq 0x561f3
movq %r14, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x55f2f
movq %r14, %rdi
callq 0x561f3
movq %r14, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x55f2f
movq %r15, %rdi
movq %r14, %rsi
callq 0x570fc
movq %r15, %rdi
movq %r15, %rsi
callq 0x55d42
movq %r13, %rdi
movq %r15, %rsi
callq 0x570fc
movq %r13, %rdi
movq %r13, %rsi
callq 0x55d42
movq %r14, %rdi
callq 0x561f3
movq %r13, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x55f2f
movq %r14, %rdi
callq 0x561f3
pushq $0x3
popq %rdx
movq %r14, %rdi
movq %r14, %rsi
callq 0x56457
movq %r15, %rdi
movq %r15, %rsi
pushq $0x2
popq %rdx
callq 0x56457
movq %r14, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x55f2f
movq %r15, %rdi
movq %r13, %rsi
callq 0x570fc
movq %r15, %rdi
movq %r15, %rsi
callq 0x55d42
movq %r15, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x55f2f
movq %r15, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x55f2f
movq %r14, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x55f2f
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r13, %rsi
callq 0x56457
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x55f2f
addq $0x908, %rsp # imm = 0x908
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| final_exp:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 908h
mov r12, rsi
mov rbx, rdi
lea r14, [rbp+var_6F0]
mov edx, 240h
mov rdi, r14
call vec_copy
mov rdi, r14
call conjugate_fp12
lea r15, [rbp+var_4B0]
mov rdi, r15
mov rsi, r12
call inverse_fp12
mov rdi, rbx
mov rsi, r14
mov rdx, r15
call mul_fp12
push 2
pop rdx
mov rdi, r15
mov rsi, rbx
call frobenius_map_fp12
mov rdi, rbx
mov rsi, rbx
mov rdx, r15
call mul_fp12
lea r12, [rbp+var_930]
mov rdi, r12
mov rsi, rbx
call cyclotomic_sqr_fp12
mov rdi, r14
mov rsi, r12
call raise_to_z_div_by_2
mov rdi, r14
mov rsi, r14
call cyclotomic_sqr_fp12
mov rdi, r15
mov rsi, r14
call raise_to_z_div_by_2
lea r13, [rbp+var_270]
mov edx, 240h
mov rdi, r13
mov rsi, rbx
call vec_copy
mov rdi, r13
call conjugate_fp12
mov rdi, r14
mov rsi, r14
mov rdx, r13
call mul_fp12
mov rdi, r14
call conjugate_fp12
mov rdi, r14
mov rsi, r14
mov rdx, r15
call mul_fp12
mov rdi, r15
mov rsi, r14
call raise_to_z_div_by_2
mov rdi, r15
mov rsi, r15
call cyclotomic_sqr_fp12
mov rdi, r13
mov rsi, r15
call raise_to_z_div_by_2
mov rdi, r13
mov rsi, r13
call cyclotomic_sqr_fp12
mov rdi, r14
call conjugate_fp12
mov rdi, r13
mov rsi, r13
mov rdx, r14
call mul_fp12
mov rdi, r14
call conjugate_fp12
push 3
pop rdx
mov rdi, r14
mov rsi, r14
call frobenius_map_fp12
mov rdi, r15
mov rsi, r15
push 2
pop rdx
call frobenius_map_fp12
mov rdi, r14
mov rsi, r14
mov rdx, r15
call mul_fp12
mov rdi, r15
mov rsi, r13
call raise_to_z_div_by_2
mov rdi, r15
mov rsi, r15
call cyclotomic_sqr_fp12
mov rdi, r15
mov rsi, r15
mov rdx, r12
call mul_fp12
mov rdi, r15
mov rsi, r15
mov rdx, rbx
call mul_fp12
mov rdi, r14
mov rsi, r14
mov rdx, r15
call mul_fp12
push 1
pop rdx
mov rdi, r15
mov rsi, r13
call frobenius_map_fp12
mov rdi, rbx
mov rsi, r14
mov rdx, r15
call mul_fp12
add rsp, 908h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long final_exp(long long a1, long long a2)
{
_BYTE v3[576]; // [rsp+0h] [rbp-930h] BYREF
_BYTE v4[576]; // [rsp+240h] [rbp-6F0h] BYREF
_BYTE v5[576]; // [rsp+480h] [rbp-4B0h] BYREF
_BYTE v6[624]; // [rsp+6C0h] [rbp-270h] BYREF
vec_copy((long long)v4, a2, 0x240uLL);
conjugate_fp12((long long)v4);
inverse_fp12((long long)v5, a2);
mul_fp12(a1, (long long)v4, (long long)v5);
frobenius_map_fp12((long long)v5, a1, 2LL);
mul_fp12(a1, a1, (long long)v5);
cyclotomic_sqr_fp12((long long)v3, a1);
raise_to_z_div_by_2(v4, v3);
cyclotomic_sqr_fp12((long long)v4, (long long)v4);
raise_to_z_div_by_2(v5, v4);
vec_copy((long long)v6, a1, 0x240uLL);
conjugate_fp12((long long)v6);
mul_fp12((long long)v4, (long long)v4, (long long)v6);
conjugate_fp12((long long)v4);
mul_fp12((long long)v4, (long long)v4, (long long)v5);
raise_to_z_div_by_2(v5, v4);
cyclotomic_sqr_fp12((long long)v5, (long long)v5);
raise_to_z_div_by_2(v6, v5);
cyclotomic_sqr_fp12((long long)v6, (long long)v6);
conjugate_fp12((long long)v4);
mul_fp12((long long)v6, (long long)v6, (long long)v4);
conjugate_fp12((long long)v4);
frobenius_map_fp12((long long)v4, (long long)v4, 3LL);
frobenius_map_fp12((long long)v5, (long long)v5, 2LL);
mul_fp12((long long)v4, (long long)v4, (long long)v5);
raise_to_z_div_by_2(v5, v6);
cyclotomic_sqr_fp12((long long)v5, (long long)v5);
mul_fp12((long long)v5, (long long)v5, (long long)v3);
mul_fp12((long long)v5, (long long)v5, a1);
mul_fp12((long long)v4, (long long)v4, (long long)v5);
frobenius_map_fp12((long long)v5, (long long)v6, 1LL);
return mul_fp12(a1, (long long)v4, (long long)v5);
}
| final_exp:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x908
MOV R12,RSI
MOV RBX,RDI
LEA R14,[RBP + -0x6f0]
MOV EDX,0x240
MOV RDI,R14
CALL 0x00151055
MOV RDI,R14
CALL 0x001561f3
LEA R15,[RBP + -0x4b0]
MOV RDI,R15
MOV RSI,R12
CALL 0x00156211
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
CALL 0x00155f2f
PUSH 0x2
POP RDX
MOV RDI,R15
MOV RSI,RBX
CALL 0x00156457
MOV RDI,RBX
MOV RSI,RBX
MOV RDX,R15
CALL 0x00155f2f
LEA R12,[RBP + -0x930]
MOV RDI,R12
MOV RSI,RBX
CALL 0x00155d42
MOV RDI,R14
MOV RSI,R12
CALL 0x001570fc
MOV RDI,R14
MOV RSI,R14
CALL 0x00155d42
MOV RDI,R15
MOV RSI,R14
CALL 0x001570fc
LEA R13,[RBP + -0x270]
MOV EDX,0x240
MOV RDI,R13
MOV RSI,RBX
CALL 0x00151055
MOV RDI,R13
CALL 0x001561f3
MOV RDI,R14
MOV RSI,R14
MOV RDX,R13
CALL 0x00155f2f
MOV RDI,R14
CALL 0x001561f3
MOV RDI,R14
MOV RSI,R14
MOV RDX,R15
CALL 0x00155f2f
MOV RDI,R15
MOV RSI,R14
CALL 0x001570fc
MOV RDI,R15
MOV RSI,R15
CALL 0x00155d42
MOV RDI,R13
MOV RSI,R15
CALL 0x001570fc
MOV RDI,R13
MOV RSI,R13
CALL 0x00155d42
MOV RDI,R14
CALL 0x001561f3
MOV RDI,R13
MOV RSI,R13
MOV RDX,R14
CALL 0x00155f2f
MOV RDI,R14
CALL 0x001561f3
PUSH 0x3
POP RDX
MOV RDI,R14
MOV RSI,R14
CALL 0x00156457
MOV RDI,R15
MOV RSI,R15
PUSH 0x2
POP RDX
CALL 0x00156457
MOV RDI,R14
MOV RSI,R14
MOV RDX,R15
CALL 0x00155f2f
MOV RDI,R15
MOV RSI,R13
CALL 0x001570fc
MOV RDI,R15
MOV RSI,R15
CALL 0x00155d42
MOV RDI,R15
MOV RSI,R15
MOV RDX,R12
CALL 0x00155f2f
MOV RDI,R15
MOV RSI,R15
MOV RDX,RBX
CALL 0x00155f2f
MOV RDI,R14
MOV RSI,R14
MOV RDX,R15
CALL 0x00155f2f
PUSH 0x1
POP RDX
MOV RDI,R15
MOV RSI,R13
CALL 0x00156457
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
CALL 0x00155f2f
ADD RSP,0x908
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void final_exp(int8 param_1,int8 param_2)
{
int1 local_938 [576];
int1 local_6f8 [576];
int1 local_4b8 [576];
int1 local_278 [584];
vec_copy(local_6f8,param_2,0x240);
conjugate_fp12(local_6f8);
inverse_fp12(local_4b8,param_2);
mul_fp12(param_1,local_6f8,local_4b8);
frobenius_map_fp12(local_4b8,param_1,2);
mul_fp12(param_1,param_1,local_4b8);
cyclotomic_sqr_fp12(local_938,param_1);
raise_to_z_div_by_2(local_6f8,local_938);
cyclotomic_sqr_fp12(local_6f8,local_6f8);
raise_to_z_div_by_2(local_4b8,local_6f8);
vec_copy(local_278,param_1,0x240);
conjugate_fp12(local_278);
mul_fp12(local_6f8,local_6f8,local_278);
conjugate_fp12(local_6f8);
mul_fp12(local_6f8,local_6f8,local_4b8);
raise_to_z_div_by_2(local_4b8,local_6f8);
cyclotomic_sqr_fp12(local_4b8,local_4b8);
raise_to_z_div_by_2(local_278,local_4b8);
cyclotomic_sqr_fp12(local_278,local_278);
conjugate_fp12(local_6f8);
mul_fp12(local_278,local_278,local_6f8);
conjugate_fp12(local_6f8);
frobenius_map_fp12(local_6f8,local_6f8,3);
frobenius_map_fp12(local_4b8,local_4b8,2);
mul_fp12(local_6f8,local_6f8,local_4b8);
raise_to_z_div_by_2(local_4b8,local_278);
cyclotomic_sqr_fp12(local_4b8,local_4b8);
mul_fp12(local_4b8,local_4b8,local_938);
mul_fp12(local_4b8,local_4b8,param_1);
mul_fp12(local_6f8,local_6f8,local_4b8);
frobenius_map_fp12(local_4b8,local_278,1);
mul_fp12(param_1,local_6f8,local_4b8);
return;
}
|
|
5,809 | LefDefParser::lefwArraySite(char const*, double, double, int, double, double, double, double) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp | int
lefwArraySite(const char *name,
double origX,
double origY,
int orient,
double numX,
double numY,
double spaceX,
double spaceY)
{
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (lefwState != LEFW_ARRAY_START &&
lefwState != LEFW_ARRAY)
return LEFW_BAD_ORDER;
if (!name || name == 0 || *name == 0)
return LEFW_BAD_DATA;
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*)
" SITE %s %.11g %.11g %s DO %.11g BY %.11g STEP %.11g %.11g ;\n",
name, origX, origY, lefwOrient(orient), numX, numY, spaceX, spaceY);
else
fprintf(lefwFile,
" SITE %s %.11g %.11g %s DO %.11g BY %.11g STEP %.11g %.11g ;\n",
name, origX, origY, lefwOrient(orient), numX, numY, spaceX, spaceY);
lefwLines++;
lefwHasArrayReq = 1;
lefwState = LEFW_ARRAY;
return LEFW_OK;
} | O3 | cpp | LefDefParser::lefwArraySite(char const*, double, double, int, double, double, double, double):
pushq %rbx
movq %rdi, %rdx
leaq 0x13866(%rip), %rax # 0x24e00
movq (%rax), %rdi
testq %rdi, %rdi
je 0x115f2
leaq 0x13aa7(%rip), %rbx # 0x25050
movl (%rbx), %ecx
cmpl $0x13, %ecx
je 0x115be
movl $0x2, %eax
cmpl $0x2, %ecx
jne 0x11657
movl $0x3, %eax
testq %rdx, %rdx
je 0x11657
cmpb $0x0, (%rdx)
je 0x11657
cmpb $0x1, 0x13b10(%rip) # 0x250ec
jne 0x115f9
cmpl $0x7, %esi
ja 0x1160d
movl %esi, %eax
leaq 0x10724(%rip), %rcx # 0x21d10
movq (%rcx,%rax,8), %rcx
jmp 0x11614
movl $0x1, %eax
jmp 0x11657
cmpl $0x7, %esi
ja 0x11624
movl %esi, %eax
leaq 0x10709(%rip), %rcx # 0x21d10
movq (%rcx,%rax,8), %rcx
jmp 0x1162b
leaq 0x8a0b(%rip), %rcx # 0x1a01f
leaq 0xa09f(%rip), %rsi # 0x1b6ba
movb $0x6, %al
callq 0x18c35
jmp 0x11639
leaq 0x89f4(%rip), %rcx # 0x1a01f
leaq 0xa088(%rip), %rsi # 0x1b6ba
movb $0x6, %al
callq 0x10f0
leaq 0x13a0c(%rip), %rax # 0x2504c
incl (%rax)
leaq 0x13a2b(%rip), %rax # 0x25074
movl $0x1, (%rax)
movl $0x13, (%rbx)
xorl %eax, %eax
popq %rbx
retq
| _ZN12LefDefParser13lefwArraySiteEPKcddidddd:
push rbx
mov rdx, rdi
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
test rdi, rdi
jz short loc_115F2
lea rbx, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
mov ecx, [rbx]
cmp ecx, 13h
jz short loc_115BE
mov eax, 2
cmp ecx, 2
jnz loc_11657
loc_115BE:
mov eax, 3
test rdx, rdx
jz loc_11657
cmp byte ptr [rdx], 0
jz loc_11657
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 1; LefDefParser::lefwWriteEncrypt
jnz short loc_115F9
cmp esi, 7
ja short loc_1160D
mov eax, esi
lea rcx, off_21D10; "N"
mov rcx, [rcx+rax*8]
jmp short loc_11614
loc_115F2:
mov eax, 1
jmp short loc_11657
loc_115F9:
cmp esi, 7
ja short loc_11624
mov eax, esi
lea rcx, off_21D10; "N"
mov rcx, [rcx+rax*8]
jmp short loc_1162B
loc_1160D:
lea rcx, aBogus; "BOGUS"
loc_11614:
lea rsi, aSiteS11g11gSDo; " SITE %s %.11g %.11g %s DO %.11g BY %"...
mov al, 6
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_11639
loc_11624:
lea rcx, aBogus; "BOGUS"
loc_1162B:
lea rsi, aSiteS11g11gSDo; " SITE %s %.11g %.11g %s DO %.11g BY %"...
mov al, 6
call _fprintf
loc_11639:
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
inc dword ptr [rax]
lea rax, _ZN12LefDefParser15lefwHasArrayReqE; LefDefParser::lefwHasArrayReq
mov dword ptr [rax], 1
mov dword ptr [rbx], 13h
xor eax, eax
loc_11657:
pop rbx
retn
| long long LefDefParser::lefwArraySite(
LefDefParser *this,
const char *a2,
double a3,
double a4,
int a5,
double a6,
double a7,
double a8,
double a9,
long long a10,
int a11,
int a12)
{
long long result; // rax
const char *v13; // rcx
const char *v14; // rcx
if ( !*(_QWORD *)&LefDefParser::lefwFile )
return 1LL;
if ( LefDefParser::lefwState == 19 || (result = 2LL, LefDefParser::lefwState == 2) )
{
result = 3LL;
if ( this )
{
if ( *(_BYTE *)this )
{
if ( LefDefParser::lefwWriteEncrypt == 1 )
{
if ( (unsigned int)a2 > 7 )
v13 = "BOGUS";
else
v13 = (const char *)*(&off_21D10 + (unsigned int)a2);
LefDefParser::encPrint(
LefDefParser::lefwFile,
(unsigned int)" SITE %s %.11g %.11g %s DO %.11g BY %.11g STEP %.11g %.11g ;\n",
(_DWORD)this,
(_DWORD)v13,
a11,
a12);
}
else
{
if ( (unsigned int)a2 > 7 )
v14 = "BOGUS";
else
v14 = (const char *)*(&off_21D10 + (unsigned int)a2);
fprintf(
*(_QWORD *)&LefDefParser::lefwFile,
" SITE %s %.11g %.11g %s DO %.11g BY %.11g STEP %.11g %.11g ;\n",
(const char *)this,
a3,
a4,
v14,
a6,
a7,
a8,
a9);
}
++LefDefParser::lefwLines;
LefDefParser::lefwHasArrayReq = 1;
LefDefParser::lefwState = 19;
return 0LL;
}
}
}
return result;
}
| lefwArraySite:
PUSH RBX
MOV RDX,RDI
LEA RAX,[0x124e00]
MOV RDI,qword ptr [RAX]
TEST RDI,RDI
JZ 0x001115f2
LEA RBX,[0x125050]
MOV ECX,dword ptr [RBX]
CMP ECX,0x13
JZ 0x001115be
MOV EAX,0x2
CMP ECX,0x2
JNZ 0x00111657
LAB_001115be:
MOV EAX,0x3
TEST RDX,RDX
JZ 0x00111657
CMP byte ptr [RDX],0x0
JZ 0x00111657
CMP byte ptr [0x001250ec],0x1
JNZ 0x001115f9
CMP ESI,0x7
JA 0x0011160d
MOV EAX,ESI
LEA RCX,[0x121d10]
MOV RCX,qword ptr [RCX + RAX*0x8]
JMP 0x00111614
LAB_001115f2:
MOV EAX,0x1
JMP 0x00111657
LAB_001115f9:
CMP ESI,0x7
JA 0x00111624
MOV EAX,ESI
LEA RCX,[0x121d10]
MOV RCX,qword ptr [RCX + RAX*0x8]
JMP 0x0011162b
LAB_0011160d:
LEA RCX,[0x11a01f]
LAB_00111614:
LEA RSI,[0x11b6ba]
MOV AL,0x6
CALL 0x00118c35
JMP 0x00111639
LAB_00111624:
LEA RCX,[0x11a01f]
LAB_0011162b:
LEA RSI,[0x11b6ba]
MOV AL,0x6
CALL 0x001010f0
LAB_00111639:
LEA RAX,[0x12504c]
INC dword ptr [RAX]
LEA RAX,[0x125074]
MOV dword ptr [RAX],0x1
MOV dword ptr [RBX],0x13
XOR EAX,EAX
LAB_00111657:
POP RBX
RET
|
/* LefDefParser::lefwArraySite(char const*, double, double, int, double, double, double, double) */
int8
LefDefParser::lefwArraySite
(char *param_1,double param_2,double param_3,int param_4,double param_5,double param_6,
double param_7,double param_8)
{
int8 uVar1;
char *pcVar2;
if (lefwFile == (_IO_FILE *)0x0) {
uVar1 = 1;
}
else if ((((lefwState == 0x13) || (uVar1 = 2, lefwState == 2)) &&
(uVar1 = 3, param_1 != (char *)0x0)) && (*param_1 != '\0')) {
if (lefwWriteEncrypt == '\x01') {
if ((uint)param_4 < 8) {
pcVar2 = (&PTR_s_N_00121d10)[(uint)param_4];
}
else {
pcVar2 = "BOGUS";
}
encPrint(lefwFile," SITE %s %.11g %.11g %s DO %.11g BY %.11g STEP %.11g %.11g ;\n",param_1,
pcVar2);
}
else {
if ((uint)param_4 < 8) {
pcVar2 = (&PTR_s_N_00121d10)[(uint)param_4];
}
else {
pcVar2 = "BOGUS";
}
fprintf(lefwFile," SITE %s %.11g %.11g %s DO %.11g BY %.11g STEP %.11g %.11g ;\n",param_1,
pcVar2);
}
lefwLines = lefwLines + 1;
lefwHasArrayReq = 1;
lefwState = 0x13;
uVar1 = 0;
}
return uVar1;
}
|
|
5,810 | google::protobuf::RepeatedPtrField<aimrt::protocols::sensor::JointState>::TypeHandler::Type* google::protobuf::internal::RepeatedPtrFieldBase::Add<google::protobuf::RepeatedPtrField<aimrt::protocols::sensor::JointState>::TypeHandler>(google::protobuf::RepeatedPtrField<aimrt::protocols::sensor::JointState>::TypeHandler::Type const*) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/repeated_ptr_field.h | typename TypeHandler::Type* Add(
const typename TypeHandler::Type* prototype = nullptr) {
if (rep_ != nullptr && current_size_ < rep_->allocated_size) {
return cast<TypeHandler>(rep_->elements[current_size_++]);
}
typename TypeHandler::Type* result =
TypeHandler::NewFromPrototype(prototype, arena_);
return reinterpret_cast<typename TypeHandler::Type*>(
AddOutOfLineHelper(result));
} | O0 | c | google::protobuf::RepeatedPtrField<aimrt::protocols::sensor::JointState>::TypeHandler::Type* google::protobuf::internal::RepeatedPtrFieldBase::Add<google::protobuf::RepeatedPtrField<aimrt::protocols::sensor::JointState>::TypeHandler>(google::protobuf::RepeatedPtrField<aimrt::protocols::sensor::JointState>::TypeHandler::Type const*):
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x10(%rax)
je 0x2e6f94
movq (%rsp), %rcx
movl 0x8(%rcx), %eax
movq 0x10(%rcx), %rcx
cmpl (%rcx), %eax
jge 0x2e6f94
movq (%rsp), %rdx
movq 0x10(%rdx), %rax
movl 0x8(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x8(%rdx)
movslq %ecx, %rcx
movq 0x8(%rax,%rcx,8), %rdi
callq 0x2971e0
movq %rax, 0x20(%rsp)
jmp 0x2e6fbd
movq (%rsp), %rax
movq 0x10(%rsp), %rdi
movq (%rax), %rsi
callq 0x2e6fd0
movq (%rsp), %rdi
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rsi
callq 0x1995b0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
| _ZN6google8protobuf8internal20RepeatedPtrFieldBase3AddINS0_16RepeatedPtrFieldINS0_28UninterpretedOption_NamePartEE11TypeHandlerEEEPNT_4TypeEPKS9_:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov [rsp+28h+var_18], rsi
mov rax, [rsp+28h+var_10]
mov [rsp+28h+var_28], rax
cmp qword ptr [rax+10h], 0
jz short loc_2E6F94
mov rcx, [rsp+28h+var_28]
mov eax, [rcx+8]
mov rcx, [rcx+10h]
cmp eax, [rcx]
jge short loc_2E6F94
mov rdx, [rsp+28h+var_28]
mov rax, [rdx+10h]
mov ecx, [rdx+8]
mov esi, ecx
add esi, 1
mov [rdx+8], esi
movsxd rcx, ecx
mov rdi, [rax+rcx*8+8]
call _ZN6google8protobuf8internal20RepeatedPtrFieldBase4castINS0_16RepeatedPtrFieldINS0_28UninterpretedOption_NamePartEE11TypeHandlerEEEPNT_4TypeEPv; google::protobuf::internal::RepeatedPtrFieldBase::cast<google::protobuf::RepeatedPtrField<google::protobuf::UninterpretedOption_NamePart>::TypeHandler>(void *)
mov [rsp+28h+var_8], rax
jmp short loc_2E6FBD
loc_2E6F94:
mov rax, [rsp+28h+var_28]
mov rdi, [rsp+28h+var_18]
mov rsi, [rax]
call _ZN6google8protobuf8internal18GenericTypeHandlerINS0_28UninterpretedOption_NamePartEE16NewFromPrototypeEPKS3_PNS0_5ArenaE; google::protobuf::internal::GenericTypeHandler<google::protobuf::UninterpretedOption_NamePart>::NewFromPrototype(google::protobuf::UninterpretedOption_NamePart const*,google::protobuf::Arena *)
mov rdi, [rsp+28h+var_28]; this
mov [rsp+28h+var_20], rax
mov rsi, [rsp+28h+var_20]; void *
call _ZN6google8protobuf8internal20RepeatedPtrFieldBase18AddOutOfLineHelperEPv; google::protobuf::internal::RepeatedPtrFieldBase::AddOutOfLineHelper(void *)
mov [rsp+28h+var_8], rax
loc_2E6FBD:
mov rax, [rsp+28h+var_8]
add rsp, 28h
retn
| void * google::protobuf::internal::RepeatedPtrFieldBase::Add<google::protobuf::RepeatedPtrField<google::protobuf::UninterpretedOption_NamePart>::TypeHandler>(
long long a1,
long long a2)
{
long long v2; // rax
int v3; // ecx
void *v5; // [rsp+8h] [rbp-20h]
if ( *(_QWORD *)(a1 + 16) && *(_DWORD *)(a1 + 8) < **(_DWORD **)(a1 + 16) )
{
v2 = *(_QWORD *)(a1 + 16);
v3 = *(_DWORD *)(a1 + 8);
*(_DWORD *)(a1 + 8) = v3 + 1;
return (void *)google::protobuf::internal::RepeatedPtrFieldBase::cast<google::protobuf::RepeatedPtrField<google::protobuf::UninterpretedOption_NamePart>::TypeHandler>(*(_QWORD *)(v2 + 8LL * v3 + 8));
}
else
{
v5 = (void *)google::protobuf::internal::GenericTypeHandler<google::protobuf::UninterpretedOption_NamePart>::NewFromPrototype(
a2,
*(_QWORD *)a1);
return google::protobuf::internal::RepeatedPtrFieldBase::AddOutOfLineHelper((google::protobuf::internal **)a1, v5);
}
}
| |||
5,811 | google::protobuf::RepeatedPtrField<aimrt::protocols::sensor::JointState>::TypeHandler::Type* google::protobuf::internal::RepeatedPtrFieldBase::Add<google::protobuf::RepeatedPtrField<aimrt::protocols::sensor::JointState>::TypeHandler>(google::protobuf::RepeatedPtrField<aimrt::protocols::sensor::JointState>::TypeHandler::Type const*) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/repeated_ptr_field.h | typename TypeHandler::Type* Add(
const typename TypeHandler::Type* prototype = nullptr) {
if (rep_ != nullptr && current_size_ < rep_->allocated_size) {
return cast<TypeHandler>(rep_->elements[current_size_++]);
}
typename TypeHandler::Type* result =
TypeHandler::NewFromPrototype(prototype, arena_);
return reinterpret_cast<typename TypeHandler::Type*>(
AddOutOfLineHelper(result));
} | O3 | c | google::protobuf::RepeatedPtrField<aimrt::protocols::sensor::JointState>::TypeHandler::Type* google::protobuf::internal::RepeatedPtrFieldBase::Add<google::protobuf::RepeatedPtrField<aimrt::protocols::sensor::JointState>::TypeHandler>(google::protobuf::RepeatedPtrField<aimrt::protocols::sensor::JointState>::TypeHandler::Type const*):
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0xfb392
movslq 0x8(%rbx), %rcx
cmpl (%rax), %ecx
jge 0xfb392
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rbx)
movq 0x8(%rax,%rcx,8), %rax
popq %rbx
retq
movq (%rbx), %rdi
callq 0xfac54
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x84e0c
| _ZN6google8protobuf8internal20RepeatedPtrFieldBase3AddINS0_16RepeatedPtrFieldINS0_28GeneratedCodeInfo_AnnotationEE11TypeHandlerEEEPNT_4TypeEPKS9_:
push rbx
mov rbx, rdi
mov rax, [rdi+10h]
test rax, rax
jz short loc_FB392
movsxd rcx, dword ptr [rbx+8]
cmp ecx, [rax]
jge short loc_FB392
lea edx, [rcx+1]
mov [rbx+8], edx
mov rax, [rax+rcx*8+8]
pop rbx
retn
loc_FB392:
mov rdi, [rbx]
call _ZN6google8protobuf5Arena18CreateMaybeMessageINS0_28GeneratedCodeInfo_AnnotationEJEEEPT_PS1_DpOT0_; google::protobuf::Arena::CreateMaybeMessage<google::protobuf::GeneratedCodeInfo_Annotation>(google::protobuf::Arena*)
mov rdi, rbx; this
mov rsi, rax; void *
pop rbx
jmp _ZN6google8protobuf8internal20RepeatedPtrFieldBase18AddOutOfLineHelperEPv; google::protobuf::internal::RepeatedPtrFieldBase::AddOutOfLineHelper(void *)
| void * google::protobuf::internal::RepeatedPtrFieldBase::Add<google::protobuf::RepeatedPtrField<google::protobuf::GeneratedCodeInfo_Annotation>::TypeHandler>(
google::protobuf::internal::RepeatedPtrFieldBase *this)
{
_DWORD *v1; // rax
long long v2; // rcx
void *v4; // rax
v1 = (_DWORD *)*((_QWORD *)this + 2);
if ( v1 && (v2 = *((int *)this + 2), (int)v2 < *v1) )
{
*((_DWORD *)this + 2) = v2 + 1;
return *(void **)&v1[2 * v2 + 2];
}
else
{
v4 = (void *)google::protobuf::Arena::CreateMaybeMessage<google::protobuf::GeneratedCodeInfo_Annotation>(*(google::protobuf::Arena **)this);
return google::protobuf::internal::RepeatedPtrFieldBase::AddOutOfLineHelper(this, v4);
}
}
| Add<google::protobuf::RepeatedPtrField<google::protobuf::GeneratedCodeInfo_Annotation>::TypeHandler>:
PUSH RBX
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x10]
TEST RAX,RAX
JZ 0x001fb392
MOVSXD RCX,dword ptr [RBX + 0x8]
CMP ECX,dword ptr [RAX]
JGE 0x001fb392
LEA EDX,[RCX + 0x1]
MOV dword ptr [RBX + 0x8],EDX
MOV RAX,qword ptr [RAX + RCX*0x8 + 0x8]
POP RBX
RET
LAB_001fb392:
MOV RDI,qword ptr [RBX]
CALL 0x001fac54
MOV RDI,RBX
MOV RSI,RAX
POP RBX
JMP 0x00184e0c
|
/* google::protobuf::RepeatedPtrField<google::protobuf::GeneratedCodeInfo_Annotation>::TypeHandler::Type*
google::protobuf::internal::RepeatedPtrFieldBase::Add<google::protobuf::RepeatedPtrField<google::protobuf::GeneratedCodeInfo_Annotation>::TypeHandler>(google::protobuf::RepeatedPtrField<google::protobuf::GeneratedCodeInfo_Annotation>::TypeHandler::Type
const*) */
Type * google::protobuf::internal::RepeatedPtrFieldBase::
Add<google::protobuf::RepeatedPtrField<google::protobuf::GeneratedCodeInfo_Annotation>::TypeHandler>
(Type *param_1)
{
int iVar1;
int *piVar2;
GeneratedCodeInfo_Annotation *pGVar3;
Type *pTVar4;
piVar2 = *(int **)(param_1 + 0x10);
if (piVar2 != (int *)0x0) {
iVar1 = *(int *)(param_1 + 8);
if (iVar1 < *piVar2) {
*(int *)(param_1 + 8) = iVar1 + 1;
return *(Type **)(piVar2 + (long)iVar1 * 2 + 2);
}
}
pGVar3 = Arena::CreateMaybeMessage<google::protobuf::GeneratedCodeInfo_Annotation>
(*(Arena **)param_1);
pTVar4 = (Type *)AddOutOfLineHelper((RepeatedPtrFieldBase *)param_1,pGVar3);
return pTVar4;
}
|
|
5,812 | ggml_map_custom3_impl | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | static struct ggml_tensor * ggml_map_custom3_impl(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b,
struct ggml_tensor * c,
const ggml_custom3_op_t fun,
int n_tasks,
void * userdata,
bool inplace) {
GGML_ASSERT(n_tasks == GGML_N_TASKS_MAX || n_tasks > 0);
bool is_node = false;
if (!inplace && (a->grad || b->grad || c->grad)) {
is_node = true;
}
struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);
struct ggml_map_custom3_op_params params = {
/*.fun =*/ fun,
/*.n_tasks =*/ n_tasks,
/*.userdata =*/ userdata
};
ggml_set_op_params(result, (const void *) ¶ms, sizeof(params));
result->op = GGML_OP_MAP_CUSTOM3;
result->grad = is_node ? ggml_dup_tensor(ctx, result) : NULL;
result->src[0] = a;
result->src[1] = b;
result->src[2] = c;
return result;
} | O1 | c | ggml_map_custom3_impl:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
cmpl $-0x1, %r9d
sete %al
testl %r9d, %r9d
setg %sil
orb %al, %sil
je 0x95c2c
movl %r9d, %ebp
movq %rdi, %r12
movb 0x68(%rsp), %al
testb %al, %al
je 0x95b50
xorl %r14d, %r14d
jmp 0x95b71
cmpq $0x0, 0x98(%r15)
jne 0x95b6e
cmpq $0x0, 0x98(%rdx)
jne 0x95b6e
cmpq $0x0, 0x98(%rcx)
je 0x95b4b
movb $0x1, %r14b
movq %r8, %r13
movq %rdx, 0x8(%rsp)
movq %rcx, (%rsp)
testb %al, %al
je 0x95b8e
movq %r12, %rdi
movq %r15, %rsi
callq 0x90b1a
jmp 0x95ba8
movl (%r15), %esi
leaq 0x10(%r15), %rcx
movq %r12, %rdi
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x8e8b7
movq %rax, %rbx
leaq 0x10(%rsp), %rsi
movq %r13, (%rsi)
movl %ebp, 0x8(%rsi)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsi)
movl $0x18, %edx
movq %rbx, %rdi
callq 0x91e91
movl $0x45, 0x50(%rbx)
testb %r14b, %r14b
je 0x95bf3
movl (%rbx), %esi
leaq 0x10(%rbx), %rcx
movq %r12, %rdi
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x8e8b7
jmp 0x95bf5
xorl %eax, %eax
movq (%rsp), %r13
movq 0x8(%rsp), %rcx
movq %rax, 0x98(%rbx)
movq %r15, 0xa0(%rbx)
movq %rcx, 0xa8(%rbx)
movq %r13, 0xb0(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xef27
| ggml_map_custom3_impl:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r15, rsi
cmp r9d, 0FFFFFFFFh
setz al
test r9d, r9d
setnle sil
or sil, al
jz loc_95C2C
mov ebp, r9d
mov r12, rdi
mov al, [rsp+58h+arg_8]
test al, al
jz short loc_95B50
loc_95B4B:
xor r14d, r14d
jmp short loc_95B71
loc_95B50:
cmp qword ptr [r15+98h], 0
jnz short loc_95B6E
cmp qword ptr [rdx+98h], 0
jnz short loc_95B6E
cmp qword ptr [rcx+98h], 0
jz short loc_95B4B
loc_95B6E:
mov r14b, 1
loc_95B71:
mov r13, r8
mov [rsp+58h+var_50], rdx
mov [rsp+58h+var_58], rcx
test al, al
jz short loc_95B8E
mov rdi, r12
mov rsi, r15
call ggml_view_tensor
jmp short loc_95BA8
loc_95B8E:
mov esi, [r15]
lea rcx, [r15+10h]
mov rdi, r12
mov edx, 4
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
loc_95BA8:
mov rbx, rax
lea rsi, [rsp+58h+var_48]
mov [rsi], r13
mov [rsi+8], ebp
mov rax, [rsp+58h+arg_0]
mov [rsi+10h], rax
mov edx, 18h
mov rdi, rbx
call ggml_set_op_params
mov dword ptr [rbx+50h], 45h ; 'E'
test r14b, r14b
jz short loc_95BF3
mov esi, [rbx]
lea rcx, [rbx+10h]
mov rdi, r12
mov edx, 4
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
jmp short loc_95BF5
loc_95BF3:
xor eax, eax
loc_95BF5:
mov r13, [rsp+58h+var_58]
mov rcx, [rsp+58h+var_50]
mov [rbx+98h], rax
mov [rbx+0A0h], r15
mov [rbx+0A8h], rcx
mov [rbx+0B0h], r13
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_95C2C:
call ggml_map_custom3_impl_cold_1
| long long ggml_map_custom3_impl(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
int a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14,
long long a15,
char a16)
{
bool v17; // r14
long long v19; // rax
long long v20; // rbx
long long v21; // rax
long long v25; // [rsp+10h] [rbp-48h] BYREF
int v26; // [rsp+18h] [rbp-40h]
long long v27; // [rsp+20h] [rbp-38h]
if ( a6 != -1 && a6 <= 0 )
ggml_map_custom3_impl_cold_1();
v17 = !a16 && (*(_QWORD *)(a2 + 152) || *(_QWORD *)(a3 + 152) || *(_QWORD *)(a4 + 152));
if ( a16 )
v19 = ggml_view_tensor(a1, a2, a7, a8, a9, a10, a11, a12, a13, a14);
else
v19 = ggml_new_tensor_impl(a1, *(_DWORD *)a2, 4, (_QWORD *)(a2 + 16), 0LL, 0LL, a7, a8);
v20 = v19;
v25 = a5;
v26 = a6;
v27 = a15;
ggml_set_op_params(v19, (long long)&v25, 24LL);
*(_DWORD *)(v20 + 80) = 69;
if ( v17 )
v21 = ggml_new_tensor_impl(a1, *(_DWORD *)v20, 4, (_QWORD *)(v20 + 16), 0LL, 0LL, a7, a8);
else
v21 = 0LL;
*(_QWORD *)(v20 + 152) = v21;
*(_QWORD *)(v20 + 160) = a2;
*(_QWORD *)(v20 + 168) = a3;
*(_QWORD *)(v20 + 176) = a4;
return v20;
}
| |||
5,813 | ggml_map_custom3_impl | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | static struct ggml_tensor * ggml_map_custom3_impl(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b,
struct ggml_tensor * c,
const ggml_custom3_op_t fun,
int n_tasks,
void * userdata,
bool inplace) {
GGML_ASSERT(n_tasks == GGML_N_TASKS_MAX || n_tasks > 0);
bool is_node = false;
if (!inplace && (a->grad || b->grad || c->grad)) {
is_node = true;
}
struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);
struct ggml_map_custom3_op_params params = {
/*.fun =*/ fun,
/*.n_tasks =*/ n_tasks,
/*.userdata =*/ userdata
};
ggml_set_op_params(result, (const void *) ¶ms, sizeof(params));
result->op = GGML_OP_MAP_CUSTOM3;
result->grad = is_node ? ggml_dup_tensor(ctx, result) : NULL;
result->src[0] = a;
result->src[1] = b;
result->src[2] = c;
return result;
} | O2 | c | ggml_map_custom3_impl:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
cmpl $-0x1, %r9d
sete %al
testl %r9d, %r9d
setg %sil
orb %al, %sil
je 0x6f5d1
movl %r9d, %ebp
movq %rdi, %r12
cmpb $0x0, 0x68(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, (%rsp)
je 0x6f51f
movq %r8, %r13
movq %r12, %rdi
movq %r15, %rsi
callq 0x69922
movq %rax, %rbx
xorl %r14d, %r14d
jmp 0x6f555
cmpq $0x0, 0x98(%r15)
jne 0x6f541
cmpq $0x0, 0x98(%rdx)
jne 0x6f541
cmpq $0x0, 0x98(%rcx)
je 0x6f5c6
movq %r8, %r13
movb $0x1, %r14b
movq %r12, %rdi
movq %r15, %rsi
callq 0x68a65
movq %rax, %rbx
leaq 0x10(%rsp), %rsi
movq %r13, (%rsi)
movl %ebp, 0x8(%rsi)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsi)
pushq $0x18
popq %rdx
movq %rbx, %rdi
callq 0x6ab3d
movl $0x45, 0x50(%rbx)
testb %r14b, %r14b
je 0x6f58d
movq %r12, %rdi
movq %rbx, %rsi
callq 0x68a65
jmp 0x6f58f
xorl %eax, %eax
movq (%rsp), %r13
movq 0x8(%rsp), %rcx
movq %rax, 0x98(%rbx)
movq %r15, 0xa0(%rbx)
movq %rcx, 0xa8(%rbx)
movq %r13, 0xb0(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r8, %r13
xorl %r14d, %r14d
jmp 0x6f547
movq 0x66970(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x669c1(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0x2ac2d(%rip), %rsi # 0x9a21e
leaq 0x32286(%rip), %rdx # 0xa187e
leaq 0x340cb(%rip), %r8 # 0xa36ca
movl $0x188e, %ecx # imm = 0x188E
xorl %eax, %eax
callq 0xa8b0
callq 0x67550
callq 0xa300
| ggml_map_custom3_impl:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r15, rsi
cmp r9d, 0FFFFFFFFh
setz al
test r9d, r9d
setnle sil
or sil, al
jz loc_6F5D1
mov ebp, r9d
mov r12, rdi
cmp [rsp+58h+arg_8], 0
mov [rsp+58h+var_50], rdx
mov [rsp+58h+var_58], rcx
jz short loc_6F51F
mov r13, r8
mov rdi, r12
mov rsi, r15
call ggml_view_tensor
mov rbx, rax
xor r14d, r14d
jmp short loc_6F555
loc_6F51F:
cmp qword ptr [r15+98h], 0
jnz short loc_6F541
cmp qword ptr [rdx+98h], 0
jnz short loc_6F541
cmp qword ptr [rcx+98h], 0
jz loc_6F5C6
loc_6F541:
mov r13, r8
mov r14b, 1
loc_6F547:
mov rdi, r12
mov rsi, r15
call ggml_dup_tensor
mov rbx, rax
loc_6F555:
lea rsi, [rsp+58h+var_48]
mov [rsi], r13
mov [rsi+8], ebp
mov rax, [rsp+58h+arg_0]
mov [rsi+10h], rax
push 18h
pop rdx
mov rdi, rbx
call ggml_set_op_params
mov dword ptr [rbx+50h], 45h ; 'E'
test r14b, r14b
jz short loc_6F58D
mov rdi, r12
mov rsi, rbx
call ggml_dup_tensor
jmp short loc_6F58F
loc_6F58D:
xor eax, eax
loc_6F58F:
mov r13, [rsp+58h+var_58]
mov rcx, [rsp+58h+var_50]
mov [rbx+98h], rax
mov [rbx+0A0h], r15
mov [rbx+0A8h], rcx
mov [rbx+0B0h], r13
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_6F5C6:
mov r13, r8
xor r14d, r14d
jmp loc_6F547
loc_6F5D1:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea r8, aNTasksGgmlNTas; "n_tasks == GGML_N_TASKS_MAX || n_tasks "...
mov ecx, 188Eh
xor eax, eax
call _fprintf
call ggml_print_backtrace
call _abort
| long long ggml_map_custom3_impl(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
int a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14,
long long a15,
char a16)
{
long long v17; // r13
long long v18; // rbx
char v19; // r14
long long v20; // rax
long long v22; // rdi
long long v25; // [rsp+10h] [rbp-48h] BYREF
int v26; // [rsp+18h] [rbp-40h]
long long v27; // [rsp+20h] [rbp-38h]
if ( a6 != -1 && a6 <= 0 )
{
fflush(stdout);
v22 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
6286,
"n_tasks == GGML_N_TASKS_MAX || n_tasks > 0");
ggml_print_backtrace();
abort(v22);
}
if ( a16 )
{
v17 = a5;
v18 = ggml_view_tensor(a1, a2, a7, a8, a9, a10, a11, a12, a13, a14);
v19 = 0;
}
else
{
if ( *(_QWORD *)(a2 + 152) || *(_QWORD *)(a3 + 152) || *(_QWORD *)(a4 + 152) )
{
v17 = a5;
v19 = 1;
}
else
{
v17 = a5;
v19 = 0;
}
v18 = ggml_dup_tensor(a1, (unsigned int *)a2);
}
v25 = v17;
v26 = a6;
v27 = a15;
ggml_set_op_params(v18, (long long)&v25, 24LL);
*(_DWORD *)(v18 + 80) = 69;
if ( v19 )
v20 = ggml_dup_tensor(a1, (unsigned int *)v18);
else
v20 = 0LL;
*(_QWORD *)(v18 + 152) = v20;
*(_QWORD *)(v18 + 160) = a2;
*(_QWORD *)(v18 + 168) = a3;
*(_QWORD *)(v18 + 176) = a4;
return v18;
}
| ggml_map_custom3_impl:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R15,RSI
CMP R9D,-0x1
SETZ AL
TEST R9D,R9D
SETG SIL
OR SIL,AL
JZ 0x0016f5d1
MOV EBP,R9D
MOV R12,RDI
CMP byte ptr [RSP + 0x68],0x0
MOV qword ptr [RSP + 0x8],RDX
MOV qword ptr [RSP],RCX
JZ 0x0016f51f
MOV R13,R8
MOV RDI,R12
MOV RSI,R15
CALL 0x00169922
MOV RBX,RAX
XOR R14D,R14D
JMP 0x0016f555
LAB_0016f51f:
CMP qword ptr [R15 + 0x98],0x0
JNZ 0x0016f541
CMP qword ptr [RDX + 0x98],0x0
JNZ 0x0016f541
CMP qword ptr [RCX + 0x98],0x0
JZ 0x0016f5c6
LAB_0016f541:
MOV R13,R8
MOV R14B,0x1
LAB_0016f547:
MOV RDI,R12
MOV RSI,R15
CALL 0x00168a65
MOV RBX,RAX
LAB_0016f555:
LEA RSI,[RSP + 0x10]
MOV qword ptr [RSI],R13
MOV dword ptr [RSI + 0x8],EBP
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSI + 0x10],RAX
PUSH 0x18
POP RDX
MOV RDI,RBX
CALL 0x0016ab3d
MOV dword ptr [RBX + 0x50],0x45
TEST R14B,R14B
JZ 0x0016f58d
MOV RDI,R12
MOV RSI,RBX
CALL 0x00168a65
JMP 0x0016f58f
LAB_0016f58d:
XOR EAX,EAX
LAB_0016f58f:
MOV R13,qword ptr [RSP]
MOV RCX,qword ptr [RSP + 0x8]
MOV qword ptr [RBX + 0x98],RAX
MOV qword ptr [RBX + 0xa0],R15
MOV qword ptr [RBX + 0xa8],RCX
MOV qword ptr [RBX + 0xb0],R13
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0016f5c6:
MOV R13,R8
XOR R14D,R14D
JMP 0x0016f547
LAB_0016f5d1:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a187e]
LEA R8,[0x1a36ca]
MOV ECX,0x188e
XOR EAX,EAX
CALL 0x0010a8b0
CALL 0x00167550
CALL 0x0010a300
|
long ggml_map_custom3_impl
(int8 param_1,long param_2,long param_3,long param_4,int8 param_5,
int param_6,int8 param_7,char param_8)
{
bool bVar1;
long lVar2;
int8 uVar3;
int8 local_48;
int local_40;
int8 local_38;
if (0 < param_6 || param_6 == -1) {
if (param_8 == '\0') {
if (((*(long *)(param_2 + 0x98) == 0) && (*(long *)(param_3 + 0x98) == 0)) &&
(*(long *)(param_4 + 0x98) == 0)) {
bVar1 = false;
}
else {
bVar1 = true;
}
lVar2 = ggml_dup_tensor(param_1,param_2);
}
else {
lVar2 = ggml_view_tensor(param_1,param_2);
bVar1 = false;
}
local_38 = param_7;
local_48 = param_5;
local_40 = param_6;
ggml_set_op_params(lVar2,&local_48,0x18);
*(int4 *)(lVar2 + 0x50) = 0x45;
if (bVar1) {
uVar3 = ggml_dup_tensor(param_1,lVar2);
}
else {
uVar3 = 0;
}
*(int8 *)(lVar2 + 0x98) = uVar3;
*(long *)(lVar2 + 0xa0) = param_2;
*(long *)(lVar2 + 0xa8) = param_3;
*(long *)(lVar2 + 0xb0) = param_4;
return lVar2;
}
fflush(*(FILE **)PTR_stdout_001d5f48);
fprintf(*(FILE **)PTR_stderr_001d5fa8,"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
0x188e,"n_tasks == GGML_N_TASKS_MAX || n_tasks > 0");
ggml_print_backtrace();
/* WARNING: Subroutine does not return */
abort();
}
|
|
5,814 | js_create_iterator_helper | bluesky950520[P]quickjs/quickjs.c | static JSValue js_create_iterator_helper(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int magic)
{
JSValue func, obj, method;
int64_t count;
JSIteratorHelperData *it;
if (check_iterator(ctx, this_val) < 0)
return JS_EXCEPTION;
func = JS_UNDEFINED;
count = 0;
switch(magic) {
case JS_ITERATOR_HELPER_KIND_DROP:
case JS_ITERATOR_HELPER_KIND_TAKE:
{
JSValue v;
double dlimit;
v = JS_ToNumber(ctx, argv[0]);
if (JS_IsException(v))
return JS_EXCEPTION;
// Check for Infinity.
if (JS_ToFloat64(ctx, &dlimit, v)) {
JS_FreeValue(ctx, v);
return JS_EXCEPTION;
}
if (isnan(dlimit)) {
JS_FreeValue(ctx, v);
goto fail;
}
if (!isfinite(dlimit)) {
JS_FreeValue(ctx, v);
if (dlimit < 0)
goto fail;
else
count = MAX_SAFE_INTEGER;
} else {
v = JS_ToIntegerFree(ctx, v);
if (JS_IsException(v))
return JS_EXCEPTION;
if (JS_ToInt64Free(ctx, &count, v))
return JS_EXCEPTION;
}
if (count < 0) {
fail:
return JS_ThrowRangeError(ctx, "must be positive");
}
}
break;
case JS_ITERATOR_HELPER_KIND_FILTER:
case JS_ITERATOR_HELPER_KIND_FLAT_MAP:
case JS_ITERATOR_HELPER_KIND_MAP:
{
func = argv[0];
if (check_function(ctx, func))
return JS_EXCEPTION;
}
break;
default:
abort();
break;
}
method = JS_GetProperty(ctx, this_val, JS_ATOM_next);
if (JS_IsException(method))
return JS_EXCEPTION;
obj = JS_NewObjectClass(ctx, JS_CLASS_ITERATOR_HELPER);
if (JS_IsException(obj)) {
JS_FreeValue(ctx, method);
return JS_EXCEPTION;
}
it = js_malloc(ctx, sizeof(*it));
if (!it) {
JS_FreeValue(ctx, obj);
JS_FreeValue(ctx, method);
return JS_EXCEPTION;
}
it->kind = magic;
it->obj = js_dup(this_val);
it->func = js_dup(func);
it->next = method;
it->inner = JS_UNDEFINED;
it->count = count;
it->executing = 0;
it->done = 0;
JS_SetOpaqueInternal(obj, it);
return obj;
} | O1 | c | js_create_iterator_helper:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rdi, %rbx
cmpl $-0x1, %r14d
jne 0x71fc8
movl %r9d, %ebp
movq $0x0, 0x10(%rsp)
cmpl $0x8, %r9d
ja 0x721d6
movq %rsi, %r15
movl $0x54, %eax
btl %ebp, %eax
jae 0x71fe4
movq (%r8), %r12
movq 0x8(%r8), %r13
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x415b1
testl %eax, %eax
jne 0x72046
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
andq %r12, %rax
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0x6b, %ecx
movq %r15, %r8
movq %r14, %r9
pushq $0x0
pushq $0x0
callq 0x22fa3
addq $0x10, %rsp
cmpl $0x6, %edx
je 0x71fb8
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq %r13, 0x38(%rsp)
movq 0x40(%rbx), %rax
movq 0x280(%rax), %rsi
movq 0x288(%rax), %rdx
movq %rbx, %rdi
movl $0x28, %ecx
callq 0x20f05
movq %rdx, %r13
cmpl $0x6, %r13d
jne 0x7211d
movq 0x18(%rbx), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x1d8c6
xorl %r14d, %r14d
xorl %eax, %eax
movl $0x6, %r13d
jmp 0x72051
leaq 0x2d056(%rip), %rsi # 0x9f025
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22567
movl $0x6, %r13d
jmp 0x7204f
movl $0x101, %eax # imm = 0x101
btl %ebp, %eax
jae 0x721d6
movq (%r8), %rsi
movq 0x8(%r8), %rdx
movq %rsi, 0x28(%rsp)
cmpl $-0x9, %edx
jb 0x7200a
movq 0x28(%rsp), %rax
incl (%rax)
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x42b20
movq %rdx, %r12
cmpl $0x6, %r12d
je 0x72046
movq %rax, %r13
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
movq %rax, %rdx
movq %r12, %rcx
callq 0x27681
testl %eax, %eax
je 0x72069
movq 0x18(%rbx), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1d8c6
movl $0x6, %r13d
xorl %r14d, %r14d
xorl %eax, %eax
orq %rax, %r14
movq %r14, %rax
movq %r13, %rdx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movsd 0x40(%rsp), %xmm0
ucomisd %xmm0, %xmm0
jp 0x721db
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jl 0x720c8
movq 0x18(%rbx), %rdi
movq %r13, %rsi
movq %r12, %rdx
movsd %xmm0, 0x8(%rsp)
callq 0x1d8c6
xorpd %xmm0, %xmm0
ucomisd 0x8(%rsp), %xmm0
ja 0x721ea
movabsq $0x1fffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFF
movq %rax, 0x10(%rsp)
jmp 0x720fa
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x731de
movq %rdx, %rcx
cmpl $0x6, %ecx
je 0x72046
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x278c7
testl %eax, %eax
jne 0x72046
cmpq $0x0, 0x10(%rsp)
js 0x721ea
movl $0x3, %r13d
xorl %r12d, %r12d
movq $0x0, 0x8(%rsp)
jmp 0x71f44
movq %rax, 0x30(%rsp)
movl $0x50, %esi
movq %rbx, %rdi
callq 0xede6
testq %rax, %rax
je 0x721c0
movb %bpl, 0x48(%rax)
incl (%r15)
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movl %r12d, %ecx
movq 0x8(%rsp), %rdx
orq %rcx, %rdx
movq %rdx, 0x28(%rsp)
cmpl $-0x9, 0x38(%rsp)
jb 0x72164
movq 0x28(%rsp), %rcx
incl (%rcx)
movq %rdx, 0x20(%rax)
movq 0x38(%rsp), %rcx
movq %rcx, 0x28(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x18(%rax)
movl $0x0, 0x30(%rax)
movq $0x3, 0x38(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x40(%rax)
andb $-0x4, 0x49(%rax)
movq 0x30(%rsp), %rdx
movq %rax, 0x30(%rdx)
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
movq %rdx, %rax
andq %rcx, %rax
movl %edx, %r14d
jmp 0x72051
movq 0x18(%rbx), %rdi
movq 0x30(%rsp), %rsi
movq %r13, %rdx
callq 0x1d8c6
jmp 0x71fa5
callq 0xe090
movq 0x18(%rbx), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1d8c6
leaq 0x2fa0b(%rip), %rsi # 0xa1bfc
movq %rbx, %rdi
xorl %eax, %eax
callq 0x20add
jmp 0x72046
| js_create_iterator_helper:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r14, rdx
mov rbx, rdi
cmp r14d, 0FFFFFFFFh
jnz loc_71FC8
mov ebp, r9d
mov [rsp+78h+var_68], 0
cmp r9d, 8
ja loc_721D6
mov r15, rsi
mov eax, 54h ; 'T'
bt eax, ebp
jnb loc_71FE4
mov r12, [r8]
mov r13, [r8+8]
mov rdi, rbx
mov rsi, r12
mov rdx, r13
call check_function
test eax, eax
jnz loc_72046
mov rax, 0FFFFFFFF00000000h
and rax, r12
mov [rsp+78h+var_70], rax
loc_71F44:
mov rdi, rbx
mov rsi, r15
mov rdx, r14
mov ecx, 6Bh ; 'k'
mov r8, r15
mov r9, r14
push 0
push 0
call JS_GetPropertyInternal2
add rsp, 10h
cmp edx, 6
jz short loc_71FB8
mov [rsp+78h+var_60], rax
mov [rsp+78h+var_58], rdx
mov [rsp+78h+var_40], r13
mov rax, [rbx+40h]
mov rsi, [rax+280h]
mov rdx, [rax+288h]
mov rdi, rbx
mov ecx, 28h ; '('
call JS_NewObjectProtoClass
mov r13, rdx
cmp r13d, 6
jnz loc_7211D
loc_71FA5:
mov rdi, [rbx+18h]
mov rsi, [rsp+78h+var_60]
mov rdx, [rsp+78h+var_58]
call JS_FreeValueRT
loc_71FB8:
xor r14d, r14d
xor eax, eax
mov r13d, 6
jmp loc_72051
loc_71FC8:
lea rsi, aOperandPrototy+20h; "not an object"
xor r14d, r14d
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
mov r13d, 6
jmp short loc_7204F
loc_71FE4:
mov eax, 101h
bt eax, ebp
jnb loc_721D6
mov rsi, [r8]
mov rdx, [r8+8]
mov [rsp+78h+var_50], rsi
cmp edx, 0FFFFFFF7h
jb short loc_7200A
mov rax, [rsp+78h+var_50]
inc dword ptr [rax]
loc_7200A:
mov rdi, rbx
xor ecx, ecx
call JS_ToNumberHintFree
mov r12, rdx
cmp r12d, 6
jz short loc_72046
mov r13, rax
lea rsi, [rsp+78h+var_38]
mov rdi, rbx
mov rdx, rax
mov rcx, r12
call JS_ToFloat64
test eax, eax
jz short loc_72069
mov rdi, [rbx+18h]
mov rsi, r13
mov rdx, r12
call JS_FreeValueRT
loc_72046:
mov r13d, 6
xor r14d, r14d
loc_7204F:
xor eax, eax
loc_72051:
or r14, rax
mov rax, r14
mov rdx, r13
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_72069:
movsd xmm0, [rsp+78h+var_38]
ucomisd xmm0, xmm0
jp loc_721DB
movq rax, xmm0
btr rax, 3Fh ; '?'
mov rcx, 7FF0000000000000h
cmp rax, rcx
jl short loc_720C8
mov rdi, [rbx+18h]
mov rsi, r13
mov rdx, r12
movsd [rsp+78h+var_70], xmm0
call JS_FreeValueRT
xorpd xmm0, xmm0
ucomisd xmm0, [rsp+78h+var_70]
ja loc_721EA
mov rax, 1FFFFFFFFFFFFFh
mov [rsp+78h+var_68], rax
jmp short loc_720FA
loc_720C8:
mov rdi, rbx
mov rsi, r13
mov rdx, r12
call JS_ToIntegerFree
mov rcx, rdx
cmp ecx, 6
jz loc_72046
lea rsi, [rsp+78h+var_68]
mov rdi, rbx
mov rdx, rax
call JS_ToInt64Free
test eax, eax
jnz loc_72046
loc_720FA:
cmp [rsp+78h+var_68], 0
js loc_721EA
mov r13d, 3
xor r12d, r12d
mov [rsp+78h+var_70], 0
jmp loc_71F44
loc_7211D:
mov [rsp+78h+var_48], rax
mov esi, 50h ; 'P'
mov rdi, rbx
call js_malloc
test rax, rax
jz loc_721C0
mov [rax+48h], bpl
inc dword ptr [r15]
mov [rax], r15
mov [rax+8], r14
mov ecx, r12d
mov rdx, [rsp+78h+var_70]
or rdx, rcx
mov [rsp+78h+var_50], rdx
cmp dword ptr [rsp+78h+var_40], 0FFFFFFF7h
jb short loc_72164
mov rcx, [rsp+78h+var_50]
inc dword ptr [rcx]
loc_72164:
mov [rax+20h], rdx
mov rcx, [rsp+78h+var_40]
mov [rax+28h], rcx
mov rcx, [rsp+78h+var_60]
mov [rax+10h], rcx
mov rcx, [rsp+78h+var_58]
mov [rax+18h], rcx
mov dword ptr [rax+30h], 0
mov qword ptr [rax+38h], 3
mov rcx, [rsp+78h+var_68]
mov [rax+40h], rcx
and byte ptr [rax+49h], 0FCh
mov rdx, [rsp+78h+var_48]
mov [rdx+30h], rax
mov rcx, 0FFFFFFFF00000000h
mov rax, rdx
and rax, rcx
mov r14d, edx
jmp loc_72051
loc_721C0:
mov rdi, [rbx+18h]
mov rsi, [rsp+78h+var_48]
mov rdx, r13
call JS_FreeValueRT
jmp loc_71FA5
loc_721D6:
call _abort
loc_721DB:
mov rdi, [rbx+18h]
mov rsi, r13
mov rdx, r12
call JS_FreeValueRT
loc_721EA:
lea rsi, aMustBePositive; "must be positive"
mov rdi, rbx
xor eax, eax
call JS_ThrowRangeError
jmp loc_72046
| unsigned long long js_create_iterator_helper(
long long a1,
_DWORD *a2,
long long a3,
long long a4,
long long *a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
char v15; // bp
int v17; // eax
long long v18; // r12
long long v19; // r13
_DWORD *PropertyInternal2; // rax
long long v21; // rdx
_DWORD *v22; // rax
long long v23; // rdx
long long v24; // r13
long long v25; // r14
unsigned long long v26; // rax
int v27; // eax
unsigned long long v28; // rsi
long long v29; // rdx
_DWORD *v30; // rax
long long v31; // rdx
long long v32; // r12
_DWORD *v33; // r13
__m128 v35; // xmm0
long long v36; // rdx
long long v37; // rcx
long long v38; // r8
long long v39; // r9
__m128 v40; // xmm4
__m128 v41; // xmm5
long long v42; // rax
long long v43; // rdx
long long v44; // rax
unsigned long long v45; // rdx
char v46; // [rsp+0h] [rbp-78h]
unsigned long long v47; // [rsp+8h] [rbp-70h]
double v48; // [rsp+8h] [rbp-70h]
long long v49; // [rsp+10h] [rbp-68h] BYREF
_DWORD *v50; // [rsp+18h] [rbp-60h]
long long v51; // [rsp+20h] [rbp-58h]
_DWORD *v52; // [rsp+28h] [rbp-50h]
_DWORD *v53; // [rsp+30h] [rbp-48h]
long long v54; // [rsp+38h] [rbp-40h]
unsigned long long v55[7]; // [rsp+40h] [rbp-38h] BYREF
if ( (_DWORD)a3 != -1 )
{
v25 = 0LL;
JS_ThrowTypeError(a1, (long long)"not an object", a3, a4, (long long)a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v46);
LABEL_18:
v26 = 0LL;
return v26 | v25;
}
v15 = a6;
v49 = 0LL;
if ( (unsigned int)a6 > 8 )
goto LABEL_32;
v17 = 84;
if ( _bittest(&v17, a6) )
{
v18 = *a5;
v19 = a5[1];
if ( !(unsigned int)check_function(
a1,
*a5,
v19,
a7,
a8,
a9,
a10,
*(double *)a11.m128_u64,
*(double *)a12.m128_u64,
a13,
a14) )
{
v47 = v18 & 0xFFFFFFFF00000000LL;
goto LABEL_6;
}
goto LABEL_17;
}
v27 = 257;
if ( !_bittest(&v27, a6) )
LABEL_32:
abort((const char *)a1);
v28 = *a5;
v29 = a5[1];
v52 = (_DWORD *)*a5;
if ( (unsigned int)v29 >= 0xFFFFFFF7 )
++*v52;
v30 = (_DWORD *)JS_ToNumberHintFree(
a1,
v28,
v29,
0,
a7,
a8,
a9,
a10,
*(double *)a11.m128_u64,
*(double *)a12.m128_u64,
a13,
a14);
v32 = v31;
if ( (_DWORD)v31 == 6 )
{
LABEL_17:
v25 = 0LL;
goto LABEL_18;
}
v33 = v30;
if ( (unsigned int)JS_ToFloat64(a1, (double *)v55, v30, v31) )
{
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v33, v32);
goto LABEL_17;
}
v35 = (__m128)v55[0];
if ( (v55[0] & 0x7FFFFFFFFFFFFFFFLL) < 0x7FF0000000000000LL )
{
v42 = JS_ToIntegerFree(a1, v33, v32);
if ( (_DWORD)v43 == 6 || (unsigned int)JS_ToInt64Free(a1, &v49, v42, v43) )
goto LABEL_17;
}
else
{
v48 = *(double *)v55;
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v33, v32);
v35 = 0LL;
if ( v48 < 0.0 )
{
LABEL_33:
JS_ThrowRangeError(a1, (long long)"must be positive", v36, v37, v38, v39, v35, a8, a9, a10, v40, v41, a13, a14, v46);
goto LABEL_17;
}
v49 = 0x1FFFFFFFFFFFFFLL;
}
if ( v49 < 0 )
goto LABEL_33;
v19 = 3LL;
LODWORD(v18) = 0;
v47 = 0LL;
LABEL_6:
PropertyInternal2 = (_DWORD *)JS_GetPropertyInternal2(a1, (long long)a2, a3, 0x6Bu, (long long)a2, a3, 0LL, 0);
if ( (_DWORD)v21 == 6 )
{
LABEL_9:
v25 = 0LL;
v26 = 0LL;
return v26 | v25;
}
v50 = PropertyInternal2;
v51 = v21;
v54 = v19;
v22 = (_DWORD *)JS_NewObjectProtoClass(
a1,
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 640LL),
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 648LL),
0x28u);
v24 = v23;
if ( (_DWORD)v23 == 6 )
{
LABEL_8:
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v50, v51);
goto LABEL_9;
}
v53 = v22;
v44 = js_malloc(a1, 80LL);
if ( !v44 )
{
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v53, v24);
goto LABEL_8;
}
*(_BYTE *)(v44 + 72) = v15;
++*a2;
*(_QWORD *)v44 = a2;
*(_QWORD *)(v44 + 8) = a3;
v52 = (_DWORD *)((unsigned int)v18 | v47);
if ( (unsigned int)v54 >= 0xFFFFFFF7 )
++*v52;
*(_QWORD *)(v44 + 32) = (unsigned int)v18 | v47;
*(_QWORD *)(v44 + 40) = v54;
*(_QWORD *)(v44 + 16) = v50;
*(_QWORD *)(v44 + 24) = v51;
*(_DWORD *)(v44 + 48) = 0;
*(_QWORD *)(v44 + 56) = 3LL;
*(_QWORD *)(v44 + 64) = v49;
*(_BYTE *)(v44 + 73) &= 0xFCu;
v45 = (unsigned long long)v53;
*((_QWORD *)v53 + 6) = v44;
v26 = v45 & 0xFFFFFFFF00000000LL;
v25 = (unsigned int)v45;
return v26 | v25;
}
| |||
5,815 | js_create_iterator_helper | bluesky950520[P]quickjs/quickjs.c | static JSValue js_create_iterator_helper(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int magic)
{
JSValue func, obj, method;
int64_t count;
JSIteratorHelperData *it;
if (check_iterator(ctx, this_val) < 0)
return JS_EXCEPTION;
func = JS_UNDEFINED;
count = 0;
switch(magic) {
case JS_ITERATOR_HELPER_KIND_DROP:
case JS_ITERATOR_HELPER_KIND_TAKE:
{
JSValue v;
double dlimit;
v = JS_ToNumber(ctx, argv[0]);
if (JS_IsException(v))
return JS_EXCEPTION;
// Check for Infinity.
if (JS_ToFloat64(ctx, &dlimit, v)) {
JS_FreeValue(ctx, v);
return JS_EXCEPTION;
}
if (isnan(dlimit)) {
JS_FreeValue(ctx, v);
goto fail;
}
if (!isfinite(dlimit)) {
JS_FreeValue(ctx, v);
if (dlimit < 0)
goto fail;
else
count = MAX_SAFE_INTEGER;
} else {
v = JS_ToIntegerFree(ctx, v);
if (JS_IsException(v))
return JS_EXCEPTION;
if (JS_ToInt64Free(ctx, &count, v))
return JS_EXCEPTION;
}
if (count < 0) {
fail:
return JS_ThrowRangeError(ctx, "must be positive");
}
}
break;
case JS_ITERATOR_HELPER_KIND_FILTER:
case JS_ITERATOR_HELPER_KIND_FLAT_MAP:
case JS_ITERATOR_HELPER_KIND_MAP:
{
func = argv[0];
if (check_function(ctx, func))
return JS_EXCEPTION;
}
break;
default:
abort();
break;
}
method = JS_GetProperty(ctx, this_val, JS_ATOM_next);
if (JS_IsException(method))
return JS_EXCEPTION;
obj = JS_NewObjectClass(ctx, JS_CLASS_ITERATOR_HELPER);
if (JS_IsException(obj)) {
JS_FreeValue(ctx, method);
return JS_EXCEPTION;
}
it = js_malloc(ctx, sizeof(*it));
if (!it) {
JS_FreeValue(ctx, obj);
JS_FreeValue(ctx, method);
return JS_EXCEPTION;
}
it->kind = magic;
it->obj = js_dup(this_val);
it->func = js_dup(func);
it->next = method;
it->inner = JS_UNDEFINED;
it->count = count;
it->executing = 0;
it->done = 0;
JS_SetOpaqueInternal(obj, it);
return obj;
} | O2 | c | js_create_iterator_helper:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, %ebp
movq %r8, %r13
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq %rdx, %rsi
callq 0x60e07
pushq $0x6
popq %rbx
testl %eax, %eax
js 0x601c6
andq $0x0, 0x38(%rsp)
cmpl $0x8, %ebp
ja 0x602c1
pushq $0x54
popq %rax
btl %ebp, %eax
movq %r12, 0x20(%rsp)
jae 0x60177
movq (%r13), %r12
movq 0x8(%r13), %rbx
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x3949a
xorl %r13d, %r13d
testl %eax, %eax
jne 0x60288
movq %rbx, 0x8(%rsp)
movq %r12, %rbx
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
andq %rax, %rbx
pushq $0x6b
popq %rcx
movq %r14, %rdi
movq 0x20(%rsp), %rsi
movq %r15, %rdx
callq 0x1b043
cmpl $0x6, %edx
je 0x60285
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0x1b297
cmpl $0x6, %edx
je 0x60273
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
pushq $0x50
popq %rsi
movq %r14, %rdi
callq 0x17214
testq %rax, %rax
je 0x60261
movzbl 0x49(%rax), %ecx
shll $0x8, %ecx
orl %ebp, %ecx
movw %cx, 0x48(%rax)
cmpl $-0x9, %r15d
jb 0x60102
movq 0x20(%rsp), %rcx
incl (%rcx)
movq 0x20(%rsp), %rcx
movq %rcx, (%rax)
movq %r15, 0x8(%rax)
movl %r12d, %ecx
movq %rbx, %rdx
orq %rcx, %rdx
movq 0x8(%rsp), %rbx
cmpl $-0x9, %ebx
jb 0x60123
incl (%rdx)
movq %rdx, 0x20(%rax)
movq %rbx, 0x28(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x18(%rax)
andl $0x0, 0x30(%rax)
movq $0x3, 0x38(%rax)
movq %r13, 0x40(%rax)
andb $-0x4, 0x49(%rax)
movq 0x28(%rsp), %rdx
movq %rax, 0x30(%rdx)
movq %rdx, %rax
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rcx, %rax
movl %edx, %r13d
movq 0x30(%rsp), %rbx
jmp 0x6028d
movl $0x101, %eax # imm = 0x101
btl %ebp, %eax
jae 0x602c1
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r14, %rdi
callq 0x366a6
movq %rdx, %r12
cmpl $0x6, %r12d
je 0x601c6
movq %rax, %r13
leaq 0x40(%rsp), %rsi
movq %r14, %rdi
movq %rax, %rdx
movq %r12, %rcx
callq 0x2127f
testl %eax, %eax
je 0x601d0
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1801e
xorl %r13d, %r13d
xorl %eax, %eax
jmp 0x6028d
movsd 0x40(%rsp), %xmm0
ucomisd %xmm0, %xmm0
jp 0x602c6
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
cmpq %rcx, %rax
jl 0x60230
movsd %xmm0, 0x8(%rsp)
callq 0x1801e
xorpd %xmm0, %xmm0
ucomisd 0x8(%rsp), %xmm0
jbe 0x602a5
leaq 0x28912(%rip), %rsi # 0x88b36
movq %r14, %rdi
xorl %eax, %eax
callq 0x1acb3
jmp 0x601c6
callq 0x60e1c
movq %rdx, %rcx
cmpl $0x6, %ecx
je 0x601c6
leaq 0x38(%rsp), %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x21507
testl %eax, %eax
jne 0x601c6
movq 0x38(%rsp), %r13
testq %r13, %r13
jns 0x602af
jmp 0x6021d
movq %r14, %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x1801e
movq %r14, %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x1801e
xorl %r13d, %r13d
xorl %eax, %eax
pushq $0x6
popq %rbx
orq %rax, %r13
movq %r13, %rax
movq %rbx, %rdx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movabsq $0x1fffffffffffff, %r13 # imm = 0x1FFFFFFFFFFFFF
pushq $0x3
popq %rax
movq %rax, 0x8(%rsp)
xorl %r12d, %r12d
xorl %ebx, %ebx
jmp 0x60090
callq 0xe090
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1801e
jmp 0x6021d
| js_create_iterator_helper:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov ebp, r9d
mov r13, r8
mov r15, rdx
mov r12, rsi
mov r14, rdi
mov rsi, rdx
call check_iterator
push 6
pop rbx
test eax, eax
js loc_601C6
and [rsp+78h+var_40], 0
cmp ebp, 8
ja loc_602C1
push 54h ; 'T'
pop rax
bt eax, ebp
mov [rsp+78h+var_58], r12
jnb loc_60177
mov r12, [r13+0]
mov rbx, [r13+8]
mov rdi, r14
mov rsi, r12
mov rdx, rbx
call check_function
xor r13d, r13d
test eax, eax
jnz loc_60288
mov [rsp+78h+var_70], rbx
mov rbx, r12
mov rax, 0FFFFFFFF00000000h
and rbx, rax
loc_60090:
push 6Bh ; 'k'
pop rcx
mov rdi, r14
mov rsi, [rsp+78h+var_58]
mov rdx, r15
call JS_GetProperty
cmp edx, 6
jz loc_60285
mov [rsp+78h+var_68], rax
mov [rsp+78h+var_60], rdx
push 28h ; '('
pop rsi
mov rdi, r14
call JS_NewObjectClass
cmp edx, 6
jz loc_60273
mov [rsp+78h+var_50], rax
mov [rsp+78h+var_48], rdx
push 50h ; 'P'
pop rsi
mov rdi, r14
call js_malloc
test rax, rax
jz loc_60261
movzx ecx, byte ptr [rax+49h]
shl ecx, 8
or ecx, ebp
mov [rax+48h], cx
cmp r15d, 0FFFFFFF7h
jb short loc_60102
mov rcx, [rsp+78h+var_58]
inc dword ptr [rcx]
loc_60102:
mov rcx, [rsp+78h+var_58]
mov [rax], rcx
mov [rax+8], r15
mov ecx, r12d
mov rdx, rbx
or rdx, rcx
mov rbx, [rsp+78h+var_70]
cmp ebx, 0FFFFFFF7h
jb short loc_60123
inc dword ptr [rdx]
loc_60123:
mov [rax+20h], rdx
mov [rax+28h], rbx
mov rcx, [rsp+78h+var_68]
mov [rax+10h], rcx
mov rcx, [rsp+78h+var_60]
mov [rax+18h], rcx
and dword ptr [rax+30h], 0
mov qword ptr [rax+38h], 3
mov [rax+40h], r13
and byte ptr [rax+49h], 0FCh
mov rdx, [rsp+78h+var_50]
mov [rdx+30h], rax
mov rax, rdx
mov rcx, 0FFFFFFFF00000000h
and rax, rcx
mov r13d, edx
mov rbx, [rsp+78h+var_48]
jmp loc_6028D
loc_60177:
mov eax, 101h
bt eax, ebp
jnb loc_602C1
mov rsi, [r13+0]
mov rdx, [r13+8]
mov rdi, r14
call JS_ToNumber
mov r12, rdx
cmp r12d, 6
jz short loc_601C6
mov r13, rax
lea rsi, [rsp+78h+var_38]
mov rdi, r14
mov rdx, rax
mov rcx, r12
call JS_ToFloat64
test eax, eax
jz short loc_601D0
mov rdi, r14
mov rsi, r13
mov rdx, r12
call JS_FreeValue
loc_601C6:
xor r13d, r13d
xor eax, eax
jmp loc_6028D
loc_601D0:
movsd xmm0, [rsp+78h+var_38]
ucomisd xmm0, xmm0
jp loc_602C6
movq rax, xmm0
btr rax, 3Fh ; '?'
mov rcx, 7FF0000000000000h
mov rdi, r14
mov rsi, r13
mov rdx, r12
cmp rax, rcx
jl short loc_60230
movsd [rsp+78h+var_70], xmm0
call JS_FreeValue
xorpd xmm0, xmm0
ucomisd xmm0, [rsp+78h+var_70]
jbe loc_602A5
loc_6021D:
lea rsi, aMustBePositive; "must be positive"
mov rdi, r14
xor eax, eax
call JS_ThrowRangeError
jmp short loc_601C6
loc_60230:
call JS_ToIntegerFree
mov rcx, rdx
cmp ecx, 6
jz short loc_601C6
lea rsi, [rsp+78h+var_40]
mov rdi, r14
mov rdx, rax
call JS_ToInt64Free
test eax, eax
jnz loc_601C6
mov r13, [rsp+78h+var_40]
test r13, r13
jns short loc_602AF
jmp short loc_6021D
loc_60261:
mov rdi, r14
mov rsi, [rsp+78h+var_50]
mov rdx, [rsp+78h+var_48]
call JS_FreeValue
loc_60273:
mov rdi, r14
mov rsi, [rsp+78h+var_68]
mov rdx, [rsp+78h+var_60]
call JS_FreeValue
loc_60285:
xor r13d, r13d
loc_60288:
xor eax, eax
push 6
pop rbx
loc_6028D:
or r13, rax
mov rax, r13
mov rdx, rbx
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_602A5:
mov r13, 1FFFFFFFFFFFFFh
loc_602AF:
push 3
pop rax
mov [rsp+78h+var_70], rax
xor r12d, r12d
xor ebx, ebx
jmp loc_60090
loc_602C1:
call _abort
loc_602C6:
mov rdi, r14
mov rsi, r13
mov rdx, r12
call JS_FreeValue
jmp loc_6021D
| unsigned long long js_create_iterator_helper(
const char *a1,
_DWORD *a2,
long long a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11,
long long a12,
long long *a13,
unsigned int a14)
{
double v17; // xmm4_8
double v18; // xmm5_8
int v19; // eax
long long v20; // r12
long long v21; // rbx
int v22; // eax
long long v23; // r13
unsigned long long v24; // rbx
long long Property; // rax
long long v26; // rdx
long long v27; // rax
long long v28; // rdx
long long v29; // rax
_DWORD *v30; // rdx
unsigned long long v31; // rax
int v32; // eax
_DWORD *v33; // rax
long long v34; // rdx
long long v35; // r12
long long v36; // r13
__m128 v37; // xmm0
long long v38; // rdx
long long v39; // rcx
long long v40; // r8
long long v41; // r9
__m128 v42; // xmm4
__m128 v43; // xmm5
long long v44; // rax
long long v45; // rdx
char v47; // [rsp+0h] [rbp-78h]
long long v48; // [rsp+8h] [rbp-70h]
double v49; // [rsp+8h] [rbp-70h]
long long v50; // [rsp+10h] [rbp-68h]
long long v51; // [rsp+18h] [rbp-60h]
long long v52; // [rsp+28h] [rbp-50h]
long long v53; // [rsp+30h] [rbp-48h]
long long v54; // [rsp+38h] [rbp-40h] BYREF
unsigned long long v55[7]; // [rsp+40h] [rbp-38h] BYREF
if ( (int)check_iterator(a1, a3) < 0 )
goto LABEL_18;
v54 = 0LL;
if ( a14 > 8 )
goto LABEL_33;
v19 = 84;
if ( !_bittest(&v19, a14) )
{
v32 = 257;
if ( _bittest(&v32, a14) )
{
v33 = (_DWORD *)JS_ToNumber((long long)a1, *a13, a13[1]);
v35 = v34;
if ( (_DWORD)v34 == 6 )
{
LABEL_18:
v23 = 0LL;
v31 = 0LL;
return v31 | v23;
}
v36 = (long long)v33;
if ( (unsigned int)JS_ToFloat64((long long)a1, (long long)v55, v33, v34) )
{
JS_FreeValue((long long)a1, v36, v35);
goto LABEL_18;
}
v37 = (__m128)v55[0];
if ( (v55[0] & 0x7FFFFFFFFFFFFFFFLL) < 0x7FF0000000000000LL )
{
v44 = JS_ToIntegerFree(a1, v36, v35);
if ( (_DWORD)v45 == 6 || (unsigned int)JS_ToInt64Free((long long)a1, &v54, v44, v45) )
goto LABEL_18;
v23 = v54;
if ( v54 < 0 )
goto LABEL_21;
}
else
{
v49 = *(double *)v55;
JS_FreeValue((long long)a1, v36, v35);
v37 = 0LL;
if ( v49 < 0.0 )
{
LABEL_21:
JS_ThrowRangeError(
(long long)a1,
(long long)"must be positive",
v38,
v39,
v40,
v41,
v37,
a5,
a6,
a7,
v42,
v43,
a10,
a11,
v47);
goto LABEL_18;
}
v23 = 0x1FFFFFFFFFFFFFLL;
}
v48 = 3LL;
LODWORD(v20) = 0;
v24 = 0LL;
goto LABEL_6;
}
LABEL_33:
abort(a1);
}
v20 = *a13;
v21 = a13[1];
v22 = check_function((long long)a1, *a13, v21, a4, a5, a6, a7, v17, v18, a10, a11);
v23 = 0LL;
if ( v22 )
{
LABEL_29:
v31 = 0LL;
return v31 | v23;
}
v48 = v21;
v24 = v20 & 0xFFFFFFFF00000000LL;
LABEL_6:
Property = JS_GetProperty((int)a1, (int)a2, a3, 107);
if ( (_DWORD)v26 == 6 )
{
LABEL_28:
v23 = 0LL;
goto LABEL_29;
}
v50 = Property;
v51 = v26;
v27 = JS_NewObjectClass((long long)a1, 40);
if ( (_DWORD)v28 == 6 )
{
LABEL_27:
JS_FreeValue((long long)a1, v50, v51);
goto LABEL_28;
}
v52 = v27;
v53 = v28;
v29 = js_malloc((long long)a1, 80LL);
if ( !v29 )
{
JS_FreeValue((long long)a1, v52, v53);
goto LABEL_27;
}
*(_WORD *)(v29 + 72) = a14 | (*(unsigned __int8 *)(v29 + 73) << 8);
if ( (unsigned int)a3 >= 0xFFFFFFF7 )
++*a2;
*(_QWORD *)v29 = a2;
*(_QWORD *)(v29 + 8) = a3;
v30 = (_DWORD *)((unsigned int)v20 | v24);
if ( (unsigned int)v48 >= 0xFFFFFFF7 )
++*v30;
*(_QWORD *)(v29 + 32) = v30;
*(_QWORD *)(v29 + 40) = v48;
*(_QWORD *)(v29 + 16) = v50;
*(_QWORD *)(v29 + 24) = v51;
*(_DWORD *)(v29 + 48) = 0;
*(_QWORD *)(v29 + 56) = 3LL;
*(_QWORD *)(v29 + 64) = v23;
*(_BYTE *)(v29 + 73) &= 0xFCu;
*(_QWORD *)(v52 + 48) = v29;
v31 = v52 & 0xFFFFFFFF00000000LL;
v23 = (unsigned int)v52;
return v31 | v23;
}
| js_create_iterator_helper:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV EBP,R9D
MOV R13,R8
MOV R15,RDX
MOV R12,RSI
MOV R14,RDI
MOV RSI,RDX
CALL 0x00160e07
PUSH 0x6
POP RBX
TEST EAX,EAX
JS 0x001601c6
AND qword ptr [RSP + 0x38],0x0
CMP EBP,0x8
JA 0x001602c1
PUSH 0x54
POP RAX
BT EAX,EBP
MOV qword ptr [RSP + 0x20],R12
JNC 0x00160177
MOV R12,qword ptr [R13]
MOV RBX,qword ptr [R13 + 0x8]
MOV RDI,R14
MOV RSI,R12
MOV RDX,RBX
CALL 0x0013949a
XOR R13D,R13D
TEST EAX,EAX
JNZ 0x00160288
MOV qword ptr [RSP + 0x8],RBX
MOV RBX,R12
MOV RAX,-0x100000000
AND RBX,RAX
LAB_00160090:
PUSH 0x6b
POP RCX
MOV RDI,R14
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,R15
CALL 0x0011b043
CMP EDX,0x6
JZ 0x00160285
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x18],RDX
PUSH 0x28
POP RSI
MOV RDI,R14
CALL 0x0011b297
CMP EDX,0x6
JZ 0x00160273
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x30],RDX
PUSH 0x50
POP RSI
MOV RDI,R14
CALL 0x00117214
TEST RAX,RAX
JZ 0x00160261
MOVZX ECX,byte ptr [RAX + 0x49]
SHL ECX,0x8
OR ECX,EBP
MOV word ptr [RAX + 0x48],CX
CMP R15D,-0x9
JC 0x00160102
MOV RCX,qword ptr [RSP + 0x20]
INC dword ptr [RCX]
LAB_00160102:
MOV RCX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],R15
MOV ECX,R12D
MOV RDX,RBX
OR RDX,RCX
MOV RBX,qword ptr [RSP + 0x8]
CMP EBX,-0x9
JC 0x00160123
INC dword ptr [RDX]
LAB_00160123:
MOV qword ptr [RAX + 0x20],RDX
MOV qword ptr [RAX + 0x28],RBX
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX + 0x18],RCX
AND dword ptr [RAX + 0x30],0x0
MOV qword ptr [RAX + 0x38],0x3
MOV qword ptr [RAX + 0x40],R13
AND byte ptr [RAX + 0x49],0xfc
MOV RDX,qword ptr [RSP + 0x28]
MOV qword ptr [RDX + 0x30],RAX
MOV RAX,RDX
MOV RCX,-0x100000000
AND RAX,RCX
MOV R13D,EDX
MOV RBX,qword ptr [RSP + 0x30]
JMP 0x0016028d
LAB_00160177:
MOV EAX,0x101
BT EAX,EBP
JNC 0x001602c1
MOV RSI,qword ptr [R13]
MOV RDX,qword ptr [R13 + 0x8]
MOV RDI,R14
CALL 0x001366a6
MOV R12,RDX
CMP R12D,0x6
JZ 0x001601c6
MOV R13,RAX
LEA RSI,[RSP + 0x40]
MOV RDI,R14
MOV RDX,RAX
MOV RCX,R12
CALL 0x0012127f
TEST EAX,EAX
JZ 0x001601d0
MOV RDI,R14
MOV RSI,R13
MOV RDX,R12
CALL 0x0011801e
LAB_001601c6:
XOR R13D,R13D
XOR EAX,EAX
JMP 0x0016028d
LAB_001601d0:
MOVSD XMM0,qword ptr [RSP + 0x40]
UCOMISD XMM0,XMM0
JP 0x001602c6
MOVQ RAX,XMM0
BTR RAX,0x3f
MOV RCX,0x7ff0000000000000
MOV RDI,R14
MOV RSI,R13
MOV RDX,R12
CMP RAX,RCX
JL 0x00160230
MOVSD qword ptr [RSP + 0x8],XMM0
CALL 0x0011801e
XORPD XMM0,XMM0
UCOMISD XMM0,qword ptr [RSP + 0x8]
JBE 0x001602a5
LAB_0016021d:
LEA RSI,[0x188b36]
MOV RDI,R14
XOR EAX,EAX
CALL 0x0011acb3
JMP 0x001601c6
LAB_00160230:
CALL 0x00160e1c
MOV RCX,RDX
CMP ECX,0x6
JZ 0x001601c6
LEA RSI,[RSP + 0x38]
MOV RDI,R14
MOV RDX,RAX
CALL 0x00121507
TEST EAX,EAX
JNZ 0x001601c6
MOV R13,qword ptr [RSP + 0x38]
TEST R13,R13
JNS 0x001602af
JMP 0x0016021d
LAB_00160261:
MOV RDI,R14
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
CALL 0x0011801e
LAB_00160273:
MOV RDI,R14
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x18]
CALL 0x0011801e
LAB_00160285:
XOR R13D,R13D
LAB_00160288:
XOR EAX,EAX
PUSH 0x6
POP RBX
LAB_0016028d:
OR R13,RAX
MOV RAX,R13
MOV RDX,RBX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001602a5:
MOV R13,0x1fffffffffffff
LAB_001602af:
PUSH 0x3
POP RAX
MOV qword ptr [RSP + 0x8],RAX
XOR R12D,R12D
XOR EBX,EBX
JMP 0x00160090
LAB_001602c1:
CALL 0x0010e090
LAB_001602c6:
MOV RDI,R14
MOV RSI,R13
MOV RDX,R12
CALL 0x0011801e
JMP 0x0016021d
|
int1 [16]
js_create_iterator_helper
(int8 param_1,int *param_2,int8 param_3,int8 param_4,ulong *param_5,
uint param_6)
{
int iVar1;
int8 *puVar2;
ulong uVar3;
int8 uVar4;
int *piVar5;
int8 uVar6;
ulong uVar7;
int8 uVar8;
long lVar9;
ulong uVar10;
int1 auVar11 [16];
int1 auVar12 [16];
int1 auVar13 [12];
ulong local_70;
long local_40;
double local_38;
iVar1 = check_iterator(param_1,param_3);
uVar8 = 6;
if (iVar1 < 0) goto LAB_001601c6;
local_40 = 0;
if (8 < param_6) {
LAB_001602c1:
/* WARNING: Subroutine does not return */
abort();
}
if ((0x54U >> (param_6 & 0x1f) & 1) != 0) {
uVar3 = *param_5;
local_70 = param_5[1];
iVar1 = check_function(param_1,uVar3,local_70);
lVar9 = 0;
if (iVar1 == 0) {
uVar7 = uVar3 & 0xffffffff00000000;
LAB_00160090:
auVar11 = JS_GetProperty(param_1,param_2,param_3,0x6b);
if (auVar11._8_4_ != 6) {
auVar12 = JS_NewObjectClass(param_1,0x28);
uVar8 = auVar12._8_8_;
uVar10 = auVar12._0_8_;
if (auVar12._8_4_ != 6) {
puVar2 = (int8 *)js_malloc(param_1,0x50);
if (puVar2 != (int8 *)0x0) {
*(ushort *)(puVar2 + 9) = (ushort)*(byte *)((long)puVar2 + 0x49) << 8 | (ushort)param_6;
if (0xfffffff6 < (uint)param_3) {
*param_2 = *param_2 + 1;
}
*puVar2 = param_2;
puVar2[1] = param_3;
piVar5 = (int *)(uVar7 | uVar3 & 0xffffffff);
if (0xfffffff6 < (uint)local_70) {
*piVar5 = *piVar5 + 1;
}
puVar2[4] = piVar5;
puVar2[5] = local_70;
*(int1 (*) [16])(puVar2 + 2) = auVar11;
*(int4 *)(puVar2 + 6) = 0;
puVar2[7] = 3;
puVar2[8] = lVar9;
*(byte *)((long)puVar2 + 0x49) = *(byte *)((long)puVar2 + 0x49) & 0xfc;
*(int8 **)(uVar10 + 0x30) = puVar2;
uVar3 = uVar10 & 0xffffffff00000000;
uVar10 = uVar10 & 0xffffffff;
goto LAB_0016028d;
}
JS_FreeValue(param_1,uVar10,uVar8);
}
JS_FreeValue(param_1,auVar11._0_8_,auVar11._8_8_);
}
}
uVar10 = 0;
uVar3 = 0;
uVar8 = 6;
goto LAB_0016028d;
}
if ((0x101U >> (param_6 & 0x1f) & 1) == 0) goto LAB_001602c1;
auVar11 = JS_ToNumber(param_1,*param_5,param_5[1]);
uVar6 = auVar11._8_8_;
uVar4 = auVar11._0_8_;
if (auVar11._8_4_ != 6) {
iVar1 = JS_ToFloat64(param_1,&local_38,uVar4,uVar6);
if (iVar1 == 0) {
if (NAN(local_38)) {
JS_FreeValue(param_1,uVar4,uVar6);
}
else if ((ulong)ABS(local_38) < 0x7ff0000000000000) {
auVar13 = JS_ToIntegerFree(param_1,uVar4,uVar6);
if ((auVar13._8_4_ == 6) ||
(iVar1 = JS_ToInt64Free(param_1,&local_40,auVar13._0_8_), iVar1 != 0)) goto LAB_001601c6;
lVar9 = local_40;
if (-1 < local_40) goto LAB_001602af;
}
else {
JS_FreeValue();
if (0.0 <= local_38) {
lVar9 = 0x1fffffffffffff;
LAB_001602af:
local_70 = 3;
uVar3 = 0;
uVar7 = 0;
goto LAB_00160090;
}
}
JS_ThrowRangeError(param_1,"must be positive");
}
else {
JS_FreeValue(param_1,uVar4,uVar6);
}
}
LAB_001601c6:
uVar10 = 0;
uVar3 = 0;
LAB_0016028d:
auVar11._8_8_ = uVar8;
auVar11._0_8_ = uVar10 | uVar3;
return auVar11;
}
|
|
5,816 | maria_rtree_rect_volume | eloqsql/storage/maria/ma_rt_mbr.c | double maria_rtree_rect_volume(HA_KEYSEG *keyseg, uchar *a, uint key_length)
{
double res= 1;
for (; (int)key_length > 0; keyseg += 2)
{
uint32 keyseg_length;
switch ((enum ha_base_keytype) keyseg->type) {
case HA_KEYTYPE_INT8:
RT_VOL_KORR(int8, mi_sint1korr, 1, (double));
break;
case HA_KEYTYPE_BINARY:
RT_VOL_KORR(uint8, mi_uint1korr, 1, (double));
break;
case HA_KEYTYPE_SHORT_INT:
RT_VOL_KORR(int16, mi_sint2korr, 2, (double));
break;
case HA_KEYTYPE_USHORT_INT:
RT_VOL_KORR(uint16, mi_uint2korr, 2, (double));
break;
case HA_KEYTYPE_INT24:
RT_VOL_KORR(int32, mi_sint3korr, 3, (double));
break;
case HA_KEYTYPE_UINT24:
RT_VOL_KORR(uint32, mi_uint3korr, 3, (double));
break;
case HA_KEYTYPE_LONG_INT:
RT_VOL_KORR(int32, mi_sint4korr, 4, (double));
break;
case HA_KEYTYPE_ULONG_INT:
RT_VOL_KORR(uint32, mi_uint4korr, 4, (double));
break;
#ifdef HAVE_LONG_LONG
case HA_KEYTYPE_LONGLONG:
RT_VOL_KORR(longlong, mi_sint8korr, 8, (double));
break;
case HA_KEYTYPE_ULONGLONG:
RT_VOL_KORR(longlong, mi_sint8korr, 8, ulonglong2double);
break;
#endif
case HA_KEYTYPE_FLOAT:
RT_VOL_GET(float, mi_float4get, 4, (double));
break;
case HA_KEYTYPE_DOUBLE:
RT_VOL_GET(double, mi_float8get, 8, (double));
break;
case HA_KEYTYPE_END:
key_length= 0;
break;
default:
return -1;
}
keyseg_length= keyseg->length * 2;
key_length-= keyseg_length;
a+= keyseg_length;
}
return res;
} | O3 | c | maria_rtree_rect_volume:
pushq %rbp
movq %rsp, %rbp
testl %edx, %edx
jle 0x6158b
addq $0x18, %rdi
movsd 0x81d94(%rip), %xmm0 # 0xe30c8
movsd 0x81d84(%rip), %xmm1 # 0xe30c0
leaq 0x82139(%rip), %rax # 0xe347c
movq 0x81a85(%rip), %xmm2 # 0xe2dd0
movapd 0x81a8d(%rip), %xmm3 # 0xe2de0
movzbl (%rdi), %ecx
cmpq $0xe, %rcx
ja 0x61595
movslq (%rax,%rcx,4), %r8
addq %rax, %r8
jmpq *%r8
movl %ecx, %edx
jmp 0x614ff
movq (%rsi), %rcx
movq 0x8(%rsi), %r8
bswapq %rcx
bswapq %r8
movq %rcx, %xmm4
movq %r8, %xmm5
jmp 0x61471
movzbl (%rsi), %ecx
leal 0x1(%rcx), %r8d
movzbl %r8b, %r8d
jmp 0x614cb
movl (%rsi), %ecx
movl 0x4(%rsi), %r8d
bswapl %ecx
bswapl %r8d
xorps %xmm4, %xmm4
cvtsi2sd %r8d, %xmm4
jmp 0x61449
movq (%rsi), %rcx
movq 0x8(%rsi), %r8
bswapq %rcx
bswapq %r8
jmp 0x614e7
movzwl (%rsi), %ecx
movzwl 0x2(%rsi), %r8d
rolw $0x8, %cx
rolw $0x8, %r8w
movswl %r8w, %r8d
xorps %xmm4, %xmm4
cvtsi2sd %r8d, %xmm4
movswl %cx, %ecx
jmp 0x61449
movzwl 0x1(%rsi), %ecx
movzwl 0x4(%rsi), %r8d
rolw $0x8, %cx
movzwl %cx, %ecx
movzbl (%rsi), %r9d
shll $0x10, %r9d
orl %ecx, %r9d
rolw $0x8, %r8w
movzwl %r8w, %ecx
movzbl 0x3(%rsi), %r8d
shll $0x10, %r8d
orl %ecx, %r8d
subl %r9d, %r8d
xorps %xmm4, %xmm4
cvtsi2sd %r8d, %xmm4
jmp 0x614fb
movzwl (%rsi), %ecx
movzwl 0x2(%rsi), %r8d
rolw $0x8, %cx
rolw $0x8, %r8w
movzwl %r8w, %r8d
xorps %xmm4, %xmm4
cvtsi2sd %r8d, %xmm4
movzwl %cx, %ecx
xorps %xmm5, %xmm5
cvtsi2sd %ecx, %xmm5
jmp 0x614f7
movl (%rsi), %ecx
movl 0x4(%rsi), %r8d
bswapl %ecx
movd %ecx, %xmm4
bswapl %r8d
movd %r8d, %xmm5
cvtss2sd %xmm5, %xmm5
cvtss2sd %xmm4, %xmm4
subsd %xmm4, %xmm5
jmp 0x614ba
movq (%rsi), %rcx
movq 0x8(%rsi), %r8
bswapq %rcx
bswapq %r8
movq %r8, %xmm4
punpckldq %xmm2, %xmm4 # xmm4 = xmm4[0],xmm2[0],xmm4[1],xmm2[1]
subpd %xmm3, %xmm4
movapd %xmm4, %xmm5
unpckhpd %xmm4, %xmm5 # xmm5 = xmm5[1],xmm4[1]
addsd %xmm4, %xmm5
movq %rcx, %xmm4
punpckldq %xmm2, %xmm4 # xmm4 = xmm4[0],xmm2[0],xmm4[1],xmm2[1]
subpd %xmm3, %xmm4
movapd %xmm4, %xmm6
unpckhpd %xmm4, %xmm6 # xmm6 = xmm6[1],xmm4[1]
addsd %xmm4, %xmm6
subsd %xmm6, %xmm5
mulsd %xmm5, %xmm0
jmp 0x614ff
movsbl (%rsi), %ecx
leal 0x1(%rcx), %r8d
movsbl %r8b, %r8d
xorps %xmm4, %xmm4
cvtsi2sd %r8d, %xmm4
xorps %xmm5, %xmm5
cvtsi2sd %ecx, %xmm5
jmp 0x614f7
movl (%rsi), %ecx
movl 0x4(%rsi), %r8d
bswapl %ecx
bswapl %r8d
xorps %xmm4, %xmm4
cvtsi2sd %r8, %xmm4
xorps %xmm5, %xmm5
cvtsi2sd %rcx, %xmm5
subsd %xmm5, %xmm4
mulsd %xmm4, %xmm0
movzwl -0x4(%rdi), %ecx
addl %ecx, %ecx
addq %rcx, %rsi
addq $0x40, %rdi
subl %ecx, %edx
jg 0x61353
jmp 0x61593
movzbl (%rsi), %r10d
movl %r10d, %ecx
shll $0x10, %ecx
movzbl 0x1(%rsi), %r8d
shll $0x8, %r8d
movzbl 0x2(%rsi), %r9d
testb %r10b, %r10b
js 0x6153b
orl %r9d, %ecx
orl %r8d, %ecx
jmp 0x61547
orl %r9d, %r8d
addl %r8d, %ecx
addl $0xff000000, %ecx # imm = 0xFF000000
movzbl 0x3(%rsi), %r11d
movl %r11d, %r8d
shll $0x10, %r8d
movzbl 0x4(%rsi), %r9d
shll $0x8, %r9d
movzbl 0x5(%rsi), %r10d
testb %r11b, %r11b
js 0x6156e
orl %r10d, %r8d
orl %r9d, %r8d
jmp 0x6157b
orl %r10d, %r9d
addl %r9d, %r8d
addl $0xff000000, %r8d # imm = 0xFF000000
subl %ecx, %r8d
xorps %xmm4, %xmm4
cvtsi2sd %r8d, %xmm4
jmp 0x614fb
movsd 0x81b35(%rip), %xmm0 # 0xe30c8
popq %rbp
retq
movapd %xmm1, %xmm0
jmp 0x61593
| maria_rtree_rect_volume:
push rbp
mov rbp, rsp
test edx, edx
jle loc_6158B
add rdi, 18h
movsd xmm0, cs:qword_E30C8
movsd xmm1, cs:qword_E30C0
lea rax, jpt_61367
movq xmm2, qword ptr cs:xmmword_E2DD0
movapd xmm3, cs:xmmword_E2DE0
loc_61353:
movzx ecx, byte ptr [rdi]
cmp rcx, 0Eh; switch 15 cases
ja def_61367; jumptable 0000000000061367 default case, cases 1,7
movsxd r8, ds:(jpt_61367 - 0E347Ch)[rax+rcx*4]
add r8, rax
jmp r8; switch jump
loc_6136A:
mov edx, ecx; jumptable 0000000000061367 case 0
jmp loc_614FF
loc_61371:
mov rcx, [rsi]; jumptable 0000000000061367 case 6
mov r8, [rsi+8]
bswap rcx
bswap r8
movq xmm4, rcx
movq xmm5, r8
jmp loc_61471
loc_6138D:
movzx ecx, byte ptr [rsi]; jumptable 0000000000061367 case 2
lea r8d, [rcx+1]
movzx r8d, r8b
jmp loc_614CB
loc_6139D:
mov ecx, [rsi]; jumptable 0000000000061367 case 4
mov r8d, [rsi+4]
bswap ecx
bswap r8d
xorps xmm4, xmm4
cvtsi2sd xmm4, r8d
jmp loc_61449
loc_613B5:
mov rcx, [rsi]; jumptable 0000000000061367 case 10
mov r8, [rsi+8]
bswap rcx
bswap r8
jmp loc_614E7
loc_613C7:
movzx ecx, word ptr [rsi]; jumptable 0000000000061367 case 3
movzx r8d, word ptr [rsi+2]
rol cx, 8
rol r8w, 8
movsx r8d, r8w
xorps xmm4, xmm4
cvtsi2sd xmm4, r8d
movsx ecx, cx
jmp short loc_61449
loc_613E9:
movzx ecx, word ptr [rsi+1]; jumptable 0000000000061367 case 13
movzx r8d, word ptr [rsi+4]
rol cx, 8
movzx ecx, cx
movzx r9d, byte ptr [rsi]
shl r9d, 10h
or r9d, ecx
rol r8w, 8
movzx ecx, r8w
movzx r8d, byte ptr [rsi+3]
shl r8d, 10h
or r8d, ecx
sub r8d, r9d
xorps xmm4, xmm4
cvtsi2sd xmm4, r8d
jmp loc_614FB
loc_61429:
movzx ecx, word ptr [rsi]; jumptable 0000000000061367 case 8
movzx r8d, word ptr [rsi+2]
rol cx, 8
rol r8w, 8
movzx r8d, r8w
xorps xmm4, xmm4
cvtsi2sd xmm4, r8d
movzx ecx, cx
loc_61449:
xorps xmm5, xmm5
cvtsi2sd xmm5, ecx
jmp loc_614F7
loc_61455:
mov ecx, [rsi]; jumptable 0000000000061367 case 5
mov r8d, [rsi+4]
bswap ecx
movd xmm4, ecx
bswap r8d
movd xmm5, r8d
cvtss2sd xmm5, xmm5
cvtss2sd xmm4, xmm4
loc_61471:
subsd xmm5, xmm4
jmp short loc_614BA
loc_61477:
mov rcx, [rsi]; jumptable 0000000000061367 case 11
mov r8, [rsi+8]
bswap rcx
bswap r8
movq xmm4, r8
punpckldq xmm4, xmm2
subpd xmm4, xmm3
movapd xmm5, xmm4
unpckhpd xmm5, xmm4
addsd xmm5, xmm4
movq xmm4, rcx
punpckldq xmm4, xmm2
subpd xmm4, xmm3
movapd xmm6, xmm4
unpckhpd xmm6, xmm4
addsd xmm6, xmm4
subsd xmm5, xmm6
loc_614BA:
mulsd xmm0, xmm5
jmp short loc_614FF
loc_614C0:
movsx ecx, byte ptr [rsi]; jumptable 0000000000061367 case 14
lea r8d, [rcx+1]
movsx r8d, r8b
loc_614CB:
xorps xmm4, xmm4
cvtsi2sd xmm4, r8d
xorps xmm5, xmm5
cvtsi2sd xmm5, ecx
jmp short loc_614F7
loc_614DC:
mov ecx, [rsi]; jumptable 0000000000061367 case 9
mov r8d, [rsi+4]
bswap ecx
bswap r8d
loc_614E7:
xorps xmm4, xmm4
cvtsi2sd xmm4, r8
xorps xmm5, xmm5
cvtsi2sd xmm5, rcx
loc_614F7:
subsd xmm4, xmm5
loc_614FB:
mulsd xmm0, xmm4
loc_614FF:
movzx ecx, word ptr [rdi-4]
add ecx, ecx
add rsi, rcx
add rdi, 40h ; '@'
sub edx, ecx
jg loc_61353
jmp short loc_61593
loc_61516:
movzx r10d, byte ptr [rsi]; jumptable 0000000000061367 case 12
mov ecx, r10d
shl ecx, 10h
movzx r8d, byte ptr [rsi+1]
shl r8d, 8
movzx r9d, byte ptr [rsi+2]
test r10b, r10b
js short loc_6153B
or ecx, r9d
or ecx, r8d
jmp short loc_61547
loc_6153B:
or r8d, r9d
add ecx, r8d
add ecx, 0FF000000h
loc_61547:
movzx r11d, byte ptr [rsi+3]
mov r8d, r11d
shl r8d, 10h
movzx r9d, byte ptr [rsi+4]
shl r9d, 8
movzx r10d, byte ptr [rsi+5]
test r11b, r11b
js short loc_6156E
or r8d, r10d
or r8d, r9d
jmp short loc_6157B
loc_6156E:
or r9d, r10d
add r8d, r9d
add r8d, 0FF000000h
loc_6157B:
sub r8d, ecx
xorps xmm4, xmm4
cvtsi2sd xmm4, r8d
jmp loc_614FB
loc_6158B:
movsd xmm0, cs:qword_E30C8
loc_61593:
pop rbp
retn
def_61367:
movapd xmm0, xmm1; jumptable 0000000000061367 default case, cases 1,7
jmp short loc_61593
| double maria_rtree_rect_volume(long long a1, _WORD *a2, int a3)
{
_BYTE *v3; // rdi
double result; // xmm0_8
__m128i v5; // xmm2
double v6; // xmm4_8
double v7; // xmm5_8
int v8; // ecx
int v9; // r8d
int v10; // ecx
double v11; // xmm4_8
int v12; // ecx
int v13; // r8d
double v14; // xmm4_8
double v15; // xmm5_8
double v16; // xmm5_8
__m128d v17; // xmm4
double v18; // xmm5_8
__m128d v19; // xmm4
long long v20; // rcx
bool v21; // cc
int v22; // ecx
int v23; // r8d
int v24; // r9d
int v25; // ecx
int v26; // r8d
int v27; // r9d
int v28; // r10d
int v29; // r8d
if ( a3 > 0 )
{
v3 = (_BYTE *)(a1 + 24);
result = 1.0;
v5 = _mm_loadl_epi64((const __m128i *)&xmmword_E2DD0);
while ( 2 )
{
switch ( *v3 )
{
case 0:
a3 = (unsigned __int8)*v3;
goto LABEL_23;
case 2:
v8 = *(unsigned __int8 *)a2;
v9 = (unsigned __int8)(v8 + 1);
goto LABEL_18;
case 3:
v11 = (double)(__int16)__ROL2__(a2[1], 8);
v10 = (__int16)__ROL2__(*a2, 8);
goto LABEL_12;
case 4:
v10 = _byteswap_ulong(*(_DWORD *)a2);
v11 = (double)(int)_byteswap_ulong(*((_DWORD *)a2 + 1));
goto LABEL_12;
case 5:
v7 = COERCE_FLOAT(_byteswap_ulong(*((_DWORD *)a2 + 1)));
v6 = COERCE_FLOAT(_byteswap_ulong(*(_DWORD *)a2));
goto LABEL_14;
case 6:
v6 = COERCE_DOUBLE(_byteswap_uint64(*(_QWORD *)a2));
v7 = COERCE_DOUBLE(_byteswap_uint64(*((_QWORD *)a2 + 1)));
LABEL_14:
v16 = v7 - v6;
goto LABEL_16;
case 8:
v11 = (double)(unsigned __int16)__ROL2__(a2[1], 8);
v10 = (unsigned __int16)__ROL2__(*a2, 8);
LABEL_12:
v15 = (double)v10;
goto LABEL_21;
case 9:
v12 = _byteswap_ulong(*(_DWORD *)a2);
v13 = _byteswap_ulong(*((_DWORD *)a2 + 1));
goto LABEL_20;
case 0xA:
v12 = _byteswap_uint64(*(_QWORD *)a2);
v13 = _byteswap_uint64(*((_QWORD *)a2 + 1));
LABEL_20:
v11 = (double)v13;
v15 = (double)v12;
goto LABEL_21;
case 0xB:
v17 = _mm_sub_pd(
(__m128d)_mm_unpacklo_epi32((__m128i)_byteswap_uint64(*((_QWORD *)a2 + 1)), v5),
(__m128d)xmmword_E2DE0);
v18 = _mm_unpackhi_pd(v17, v17).m128d_f64[0] + v17.m128d_f64[0];
v19 = _mm_sub_pd(
(__m128d)_mm_unpacklo_epi32((__m128i)_byteswap_uint64(*(_QWORD *)a2), v5),
(__m128d)xmmword_E2DE0);
v16 = v18 - (_mm_unpackhi_pd(v19, v19).m128d_f64[0] + v19.m128d_f64[0]);
LABEL_16:
result = result * v16;
goto LABEL_23;
case 0xC:
v22 = *(unsigned __int8 *)a2 << 16;
v23 = *((unsigned __int8 *)a2 + 1) << 8;
v24 = *((unsigned __int8 *)a2 + 2);
if ( *(char *)a2 < 0 )
v25 = (v24 | v23) + v22 - 0x1000000;
else
v25 = v23 | v24 | v22;
v26 = *((unsigned __int8 *)a2 + 3) << 16;
v27 = *((unsigned __int8 *)a2 + 4) << 8;
v28 = *((unsigned __int8 *)a2 + 5);
if ( *((char *)a2 + 3) < 0 )
v29 = (v28 | v27) + v26 - 0x1000000;
else
v29 = v27 | v28 | v26;
v14 = (double)(v29 - v25);
goto LABEL_22;
case 0xD:
v14 = (double)(((unsigned __int16)__ROL2__(a2[2], 8) | (*((unsigned __int8 *)a2 + 3) << 16))
- ((unsigned __int16)__ROL2__(*(_WORD *)((char *)a2 + 1), 8) | (*(unsigned __int8 *)a2 << 16)));
goto LABEL_22;
case 0xE:
v8 = *(char *)a2;
v9 = (char)(*(_BYTE *)a2 + 1);
LABEL_18:
v11 = (double)v9;
v15 = (double)v8;
LABEL_21:
v14 = v11 - v15;
LABEL_22:
result = result * v14;
LABEL_23:
v20 = 2 * (unsigned int)*((unsigned __int16 *)v3 - 2);
a2 = (_WORD *)((char *)a2 + v20);
v3 += 64;
v21 = a3 <= (int)v20;
a3 -= v20;
if ( v21 )
return result;
continue;
default:
return -1.0;
}
}
}
return 1.0;
}
| maria_rtree_rect_volume:
PUSH RBP
MOV RBP,RSP
TEST EDX,EDX
JLE 0x0016158b
ADD RDI,0x18
MOVSD XMM0,qword ptr [0x001e30c8]
MOVSD XMM1,qword ptr [0x001e30c0]
LEA RAX,[0x1e347c]
MOVQ XMM2,qword ptr [0x001e2dd0]
MOVAPD XMM3,xmmword ptr [0x001e2de0]
LAB_00161353:
MOVZX ECX,byte ptr [RDI]
CMP RCX,0xe
JA 0x00161595
MOVSXD R8,dword ptr [RAX + RCX*0x4]
ADD R8,RAX
switchD:
JMP R8
caseD_0:
MOV EDX,ECX
JMP 0x001614ff
caseD_6:
MOV RCX,qword ptr [RSI]
MOV R8,qword ptr [RSI + 0x8]
BSWAP RCX
BSWAP R8
MOVQ XMM4,RCX
MOVQ XMM5,R8
JMP 0x00161471
caseD_2:
MOVZX ECX,byte ptr [RSI]
LEA R8D,[RCX + 0x1]
MOVZX R8D,R8B
JMP 0x001614cb
caseD_4:
MOV ECX,dword ptr [RSI]
MOV R8D,dword ptr [RSI + 0x4]
BSWAP ECX
BSWAP R8D
XORPS XMM4,XMM4
CVTSI2SD XMM4,R8D
JMP 0x00161449
caseD_a:
MOV RCX,qword ptr [RSI]
MOV R8,qword ptr [RSI + 0x8]
BSWAP RCX
BSWAP R8
JMP 0x001614e7
caseD_3:
MOVZX ECX,word ptr [RSI]
MOVZX R8D,word ptr [RSI + 0x2]
ROL CX,0x8
ROL R8W,0x8
MOVSX R8D,R8W
XORPS XMM4,XMM4
CVTSI2SD XMM4,R8D
MOVSX ECX,CX
JMP 0x00161449
caseD_d:
MOVZX ECX,word ptr [RSI + 0x1]
MOVZX R8D,word ptr [RSI + 0x4]
ROL CX,0x8
MOVZX ECX,CX
MOVZX R9D,byte ptr [RSI]
SHL R9D,0x10
OR R9D,ECX
ROL R8W,0x8
MOVZX ECX,R8W
MOVZX R8D,byte ptr [RSI + 0x3]
SHL R8D,0x10
OR R8D,ECX
SUB R8D,R9D
XORPS XMM4,XMM4
CVTSI2SD XMM4,R8D
JMP 0x001614fb
caseD_8:
MOVZX ECX,word ptr [RSI]
MOVZX R8D,word ptr [RSI + 0x2]
ROL CX,0x8
ROL R8W,0x8
MOVZX R8D,R8W
XORPS XMM4,XMM4
CVTSI2SD XMM4,R8D
MOVZX ECX,CX
LAB_00161449:
XORPS XMM5,XMM5
CVTSI2SD XMM5,ECX
JMP 0x001614f7
caseD_5:
MOV ECX,dword ptr [RSI]
MOV R8D,dword ptr [RSI + 0x4]
BSWAP ECX
MOVD XMM4,ECX
BSWAP R8D
MOVD XMM5,R8D
CVTSS2SD XMM5,XMM5
CVTSS2SD XMM4,XMM4
LAB_00161471:
SUBSD XMM5,XMM4
JMP 0x001614ba
caseD_b:
MOV RCX,qword ptr [RSI]
MOV R8,qword ptr [RSI + 0x8]
BSWAP RCX
BSWAP R8
MOVQ XMM4,R8
PUNPCKLDQ XMM4,XMM2
SUBPD XMM4,XMM3
MOVAPD XMM5,XMM4
UNPCKHPD XMM5,XMM4
ADDSD XMM5,XMM4
MOVQ XMM4,RCX
PUNPCKLDQ XMM4,XMM2
SUBPD XMM4,XMM3
MOVAPD XMM6,XMM4
UNPCKHPD XMM6,XMM4
ADDSD XMM6,XMM4
SUBSD XMM5,XMM6
LAB_001614ba:
MULSD XMM0,XMM5
JMP 0x001614ff
caseD_e:
MOVSX ECX,byte ptr [RSI]
LEA R8D,[RCX + 0x1]
MOVSX R8D,R8B
LAB_001614cb:
XORPS XMM4,XMM4
CVTSI2SD XMM4,R8D
XORPS XMM5,XMM5
CVTSI2SD XMM5,ECX
JMP 0x001614f7
caseD_9:
MOV ECX,dword ptr [RSI]
MOV R8D,dword ptr [RSI + 0x4]
BSWAP ECX
BSWAP R8D
LAB_001614e7:
XORPS XMM4,XMM4
CVTSI2SD XMM4,R8
XORPS XMM5,XMM5
CVTSI2SD XMM5,RCX
LAB_001614f7:
SUBSD XMM4,XMM5
LAB_001614fb:
MULSD XMM0,XMM4
LAB_001614ff:
MOVZX ECX,word ptr [RDI + -0x4]
ADD ECX,ECX
ADD RSI,RCX
ADD RDI,0x40
SUB EDX,ECX
JG 0x00161353
JMP 0x00161593
caseD_c:
MOVZX R10D,byte ptr [RSI]
MOV ECX,R10D
SHL ECX,0x10
MOVZX R8D,byte ptr [RSI + 0x1]
SHL R8D,0x8
MOVZX R9D,byte ptr [RSI + 0x2]
TEST R10B,R10B
JS 0x0016153b
OR ECX,R9D
OR ECX,R8D
JMP 0x00161547
LAB_0016153b:
OR R8D,R9D
ADD ECX,R8D
ADD ECX,0xff000000
LAB_00161547:
MOVZX R11D,byte ptr [RSI + 0x3]
MOV R8D,R11D
SHL R8D,0x10
MOVZX R9D,byte ptr [RSI + 0x4]
SHL R9D,0x8
MOVZX R10D,byte ptr [RSI + 0x5]
TEST R11B,R11B
JS 0x0016156e
OR R8D,R10D
OR R8D,R9D
JMP 0x0016157b
LAB_0016156e:
OR R9D,R10D
ADD R8D,R9D
ADD R8D,0xff000000
LAB_0016157b:
SUB R8D,ECX
XORPS XMM4,XMM4
CVTSI2SD XMM4,R8D
JMP 0x001614fb
LAB_0016158b:
MOVSD XMM0,qword ptr [0x001e30c8]
LAB_00161593:
POP RBP
RET
caseD_1:
MOVAPD XMM0,XMM1
JMP 0x00161593
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double maria_rtree_rect_volume(long param_1,ulong *param_2,uint param_3)
{
ushort *puVar1;
uint uVar2;
ulong uVar3;
ulong uVar4;
byte *pbVar5;
uint uVar6;
ulong uVar7;
ulong uVar8;
bool bVar9;
double dVar10;
double dVar11;
int1 auVar12 [16];
int1 auVar13 [16];
double dVar14;
dVar10 = DAT_001e30c8;
if (0 < (int)param_3) {
pbVar5 = (byte *)(param_1 + 0x18);
do {
switch(*pbVar5) {
case 0:
param_3 = (uint)*pbVar5;
goto LAB_001614ff;
default:
return DAT_001e30c0;
case 2:
uVar2 = (uint)(byte)*param_2;
uVar6 = (byte)*param_2 + 1 & 0xff;
goto LAB_001614cb;
case 3:
dVar11 = (double)(int)(short)(*(ushort *)((long)param_2 + 2) << 8 |
*(ushort *)((long)param_2 + 2) >> 8);
uVar2 = (uint)(short)((ushort)*param_2 << 8 | (ushort)*param_2 >> 8);
break;
case 4:
uVar2 = (uint)*param_2;
uVar6 = *(uint *)((long)param_2 + 4);
uVar2 = uVar2 >> 0x18 | (uVar2 & 0xff0000) >> 8 | (uVar2 & 0xff00) << 8 | uVar2 << 0x18;
dVar11 = (double)(int)(uVar6 >> 0x18 | (uVar6 & 0xff0000) >> 8 | (uVar6 & 0xff00) << 8 |
uVar6 << 0x18);
break;
case 5:
uVar2 = (uint)*param_2;
uVar6 = *(uint *)((long)param_2 + 4);
dVar11 = (double)(float)(uVar6 >> 0x18 | (uVar6 & 0xff0000) >> 8 | (uVar6 & 0xff00) << 8 |
uVar6 << 0x18);
dVar14 = (double)(float)(uVar2 >> 0x18 | (uVar2 & 0xff0000) >> 8 | (uVar2 & 0xff00) << 8 |
uVar2 << 0x18);
goto LAB_00161471;
case 6:
uVar3 = *param_2;
uVar7 = param_2[1];
dVar14 = (double)(uVar3 >> 0x38 | (uVar3 & 0xff000000000000) >> 0x28 |
(uVar3 & 0xff0000000000) >> 0x18 | (uVar3 & 0xff00000000) >> 8 |
(uVar3 & 0xff000000) << 8 | (uVar3 & 0xff0000) << 0x18 |
(uVar3 & 0xff00) << 0x28 | uVar3 << 0x38);
dVar11 = (double)(uVar7 >> 0x38 | (uVar7 & 0xff000000000000) >> 0x28 |
(uVar7 & 0xff0000000000) >> 0x18 | (uVar7 & 0xff00000000) >> 8 |
(uVar7 & 0xff000000) << 8 | (uVar7 & 0xff0000) << 0x18 |
(uVar7 & 0xff00) << 0x28 | uVar7 << 0x38);
LAB_00161471:
dVar11 = dVar11 - dVar14;
LAB_001614ba:
dVar10 = dVar10 * dVar11;
goto LAB_001614ff;
case 8:
dVar11 = (double)(ushort)(*(ushort *)((long)param_2 + 2) << 8 |
*(ushort *)((long)param_2 + 2) >> 8);
uVar2 = (uint)(ushort)((ushort)*param_2 << 8 | (ushort)*param_2 >> 8);
break;
case 9:
uVar2 = (uint)*param_2;
uVar6 = *(uint *)((long)param_2 + 4);
uVar3 = (ulong)(uVar2 >> 0x18 | (uVar2 & 0xff0000) >> 8 | (uVar2 & 0xff00) << 8 |
uVar2 << 0x18);
uVar7 = (ulong)(uVar6 >> 0x18 | (uVar6 & 0xff0000) >> 8 | (uVar6 & 0xff00) << 8 |
uVar6 << 0x18);
goto LAB_001614e7;
case 10:
uVar3 = *param_2;
uVar7 = param_2[1];
uVar3 = uVar3 >> 0x38 | (uVar3 & 0xff000000000000) >> 0x28 |
(uVar3 & 0xff0000000000) >> 0x18 | (uVar3 & 0xff00000000) >> 8 |
(uVar3 & 0xff000000) << 8 | (uVar3 & 0xff0000) << 0x18 | (uVar3 & 0xff00) << 0x28 |
uVar3 << 0x38;
uVar7 = uVar7 >> 0x38 | (uVar7 & 0xff000000000000) >> 0x28 |
(uVar7 & 0xff0000000000) >> 0x18 | (uVar7 & 0xff00000000) >> 8 |
(uVar7 & 0xff000000) << 8 | (uVar7 & 0xff0000) << 0x18 | (uVar7 & 0xff00) << 0x28 |
uVar7 << 0x38;
LAB_001614e7:
dVar11 = (double)(long)uVar7;
dVar14 = (double)(long)uVar3;
goto LAB_001614f7;
case 0xb:
uVar3 = *param_2;
uVar7 = param_2[1];
uVar4 = (uVar3 & 0xff000000) << 8 | (uVar3 & 0xff0000) << 0x18 | (uVar3 & 0xff00) << 0x28 |
uVar3 << 0x38;
uVar8 = (uVar7 & 0xff000000) << 8 | (uVar7 & 0xff0000) << 0x18 | (uVar7 & 0xff00) << 0x28 |
uVar7 << 0x38;
auVar12._8_4_ = (int)(uVar8 >> 0x20);
auVar12._0_8_ = uVar8;
auVar12._12_4_ = DAT_001e2dd0._4_4_;
auVar13._8_4_ = (int)(uVar4 >> 0x20);
auVar13._0_8_ = uVar4;
auVar13._12_4_ = DAT_001e2dd0._4_4_;
dVar11 = ((auVar12._8_8_ - _UNK_001e2de8) +
((double)CONCAT44((int4)DAT_001e2dd0,
(uint)(byte)(uVar7 >> 0x38) |
((uint)(uVar7 >> 0x20) & 0xff0000) >> 8 |
(uint)(uVar7 >> 0x18) & 0xff0000 |
(uint)(uVar7 >> 8) & 0xff000000) - _DAT_001e2de0)) -
((auVar13._8_8_ - _UNK_001e2de8) +
((double)CONCAT44((int4)DAT_001e2dd0,
(uint)(byte)(uVar3 >> 0x38) |
((uint)(uVar3 >> 0x20) & 0xff0000) >> 8 |
(uint)(uVar3 >> 0x18) & 0xff0000 |
(uint)(uVar3 >> 8) & 0xff000000) - _DAT_001e2de0));
goto LAB_001614ba;
case 0xc:
uVar2 = (uint)(byte)*param_2 * 0x10000;
if ((char)(byte)*param_2 < '\0') {
uVar2 = (uVar2 + CONCAT11(*(byte *)((long)param_2 + 1),*(byte *)((long)param_2 + 2))) -
0x1000000;
}
else {
uVar2 = uVar2 | *(byte *)((long)param_2 + 2) | (uint)*(byte *)((long)param_2 + 1) << 8;
}
uVar6 = (uint)*(byte *)((long)param_2 + 3) * 0x10000;
if ((char)*(byte *)((long)param_2 + 3) < '\0') {
uVar6 = (uVar6 + CONCAT11(*(byte *)((long)param_2 + 4),*(byte *)((long)param_2 + 5))) -
0x1000000;
}
else {
uVar6 = uVar6 | *(byte *)((long)param_2 + 5) | (uint)*(byte *)((long)param_2 + 4) << 8;
}
dVar11 = (double)(int)(uVar6 - uVar2);
goto LAB_001614fb;
case 0xd:
dVar11 = (double)(int)((uint)CONCAT12(*(byte *)((long)param_2 + 3),
*(ushort *)((long)param_2 + 4) << 8 |
*(ushort *)((long)param_2 + 4) >> 8) -
(uint)CONCAT12((byte)*param_2,
*(ushort *)((long)param_2 + 1) << 8 |
*(ushort *)((long)param_2 + 1) >> 8));
goto LAB_001614fb;
case 0xe:
uVar2 = (uint)(char)(byte)*param_2;
uVar6 = (uint)(char)((byte)*param_2 + 1);
LAB_001614cb:
dVar11 = (double)(int)uVar6;
dVar14 = (double)(int)uVar2;
goto LAB_001614f7;
}
dVar14 = (double)(int)uVar2;
LAB_001614f7:
dVar11 = dVar11 - dVar14;
LAB_001614fb:
dVar10 = dVar10 * dVar11;
LAB_001614ff:
puVar1 = (ushort *)(pbVar5 + -4);
uVar2 = (uint)*puVar1 * 2;
param_2 = (ulong *)((long)param_2 + (ulong)uVar2);
pbVar5 = pbVar5 + 0x40;
bVar9 = SBORROW4(param_3,uVar2);
param_3 = param_3 + (uint)*puVar1 * -2;
} while (param_3 != 0 && bVar9 == (int)param_3 < 0);
}
return dVar10;
}
|
|
5,817 | MyCTX_gcm::finish(unsigned char*, unsigned int*) | eloqsql/mysys_ssl/my_crypt.cc | int finish(uchar *dst, uint *dlen)
{
int fin;
if (!EVP_CipherFinal_ex(ctx, dst, &fin))
return MY_AES_BAD_DATA;
DBUG_ASSERT(fin == 0);
if (EVP_CIPHER_CTX_encrypting(ctx))
{
if(!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_GET_TAG, MY_AES_BLOCK_SIZE, dst))
return MY_AES_OPENSSL_ERROR;
*dlen= MY_AES_BLOCK_SIZE;
}
else
*dlen= 0;
return MY_AES_OK;
} | O3 | cpp | MyCTX_gcm::finish(unsigned char*, unsigned int*):
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, %r12
movq 0xc8(%rdi), %rdi
leaq -0x2c(%rbp), %rdx
callq 0x29290
testl %eax, %eax
je 0xd93a6
movq 0xc8(%r12), %rdi
callq 0x29870
xorl %r15d, %r15d
movl $0x0, %r13d
testl %eax, %eax
je 0xd93a1
movq 0xc8(%r12), %rdi
movl $0x10, %r13d
movl $0x10, %esi
movl $0x10, %edx
movq %r14, %rcx
callq 0x292d0
testl %eax, %eax
je 0xd93ae
movl %r13d, (%rbx)
jmp 0xd93b4
movl $0xffffff9c, %r15d # imm = 0xFFFFFF9C
jmp 0xd93b4
movl $0xffffff9b, %r15d # imm = 0xFFFFFF9B
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN9MyCTX_gcm6finishEPhPj:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdx
mov r14, rsi
mov r12, rdi
mov rdi, [rdi+0C8h]
lea rdx, [rbp+var_2C]
call _EVP_CipherFinal_ex
test eax, eax
jz short loc_D93A6
mov rdi, [r12+0C8h]
call _EVP_CIPHER_CTX_is_encrypting
xor r15d, r15d
mov r13d, 0
test eax, eax
jz short loc_D93A1
mov rdi, [r12+0C8h]
mov r13d, 10h
mov esi, 10h
mov edx, 10h
mov rcx, r14
call _EVP_CIPHER_CTX_ctrl
test eax, eax
jz short loc_D93AE
loc_D93A1:
mov [rbx], r13d
jmp short loc_D93B4
loc_D93A6:
mov r15d, 0FFFFFF9Ch
jmp short loc_D93B4
loc_D93AE:
mov r15d, 0FFFFFF9Bh
loc_D93B4:
mov eax, r15d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long MyCTX_gcm::finish(MyCTX_gcm *this, unsigned __int8 *a2, unsigned int *a3)
{
long long v3; // rax
unsigned int v5; // r15d
unsigned int v6; // r13d
_DWORD v8[11]; // [rsp+0h] [rbp-2Ch] BYREF
v8[0] = HIDWORD(v3);
if ( (unsigned int)EVP_CipherFinal_ex(*((_QWORD *)this + 25), a2, v8) )
{
v5 = 0;
v6 = 0;
if ( (unsigned int)EVP_CIPHER_CTX_is_encrypting(*((_QWORD *)this + 25))
&& (v6 = 16, !(unsigned int)EVP_CIPHER_CTX_ctrl(*((_QWORD *)this + 25), 16LL, 16LL, a2)) )
{
return (unsigned int)-101;
}
else
{
*a3 = v6;
}
}
else
{
return (unsigned int)-100;
}
return v5;
}
| finish:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RSI
MOV R12,RDI
MOV RDI,qword ptr [RDI + 0xc8]
LEA RDX,[RBP + -0x2c]
CALL 0x00129290
TEST EAX,EAX
JZ 0x001d93a6
MOV RDI,qword ptr [R12 + 0xc8]
CALL 0x00129870
XOR R15D,R15D
MOV R13D,0x0
TEST EAX,EAX
JZ 0x001d93a1
MOV RDI,qword ptr [R12 + 0xc8]
MOV R13D,0x10
MOV ESI,0x10
MOV EDX,0x10
MOV RCX,R14
CALL 0x001292d0
TEST EAX,EAX
JZ 0x001d93ae
LAB_001d93a1:
MOV dword ptr [RBX],R13D
JMP 0x001d93b4
LAB_001d93a6:
MOV R15D,0xffffff9c
JMP 0x001d93b4
LAB_001d93ae:
MOV R15D,0xffffff9b
LAB_001d93b4:
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* MyCTX_gcm::finish(unsigned char*, unsigned int*) */
int8 __thiscall MyCTX_gcm::finish(MyCTX_gcm *this,uchar *param_1,uint *param_2)
{
int iVar1;
uint uVar2;
int8 uVar3;
int local_34;
iVar1 = EVP_CipherFinal_ex(*(EVP_CIPHER_CTX **)(this + 200),param_1,&local_34);
if (iVar1 == 0) {
uVar3 = 0xffffff9c;
}
else {
iVar1 = EVP_CIPHER_CTX_is_encrypting(*(int8 *)(this + 200));
uVar3 = 0;
uVar2 = 0;
if (iVar1 != 0) {
uVar2 = 0x10;
iVar1 = EVP_CIPHER_CTX_ctrl(*(EVP_CIPHER_CTX **)(this + 200),0x10,0x10,param_1);
if (iVar1 == 0) {
return 0xffffff9b;
}
}
*param_2 = uVar2;
}
return uVar3;
}
|
|
5,818 | mi_search_first | eloqsql/storage/myisam/mi_search.c | int _mi_search_first(register MI_INFO *info, register MI_KEYDEF *keyinfo,
register my_off_t pos)
{
uint nod_flag;
uchar *page;
DBUG_ENTER("_mi_search_first");
if (pos == HA_OFFSET_ERROR)
{
my_errno=HA_ERR_KEY_NOT_FOUND;
info->lastpos= HA_OFFSET_ERROR;
DBUG_RETURN(-1);
}
do
{
if (!_mi_fetch_keypage(info,keyinfo,pos,DFLT_INIT_HITS,info->buff,0))
{
info->lastpos= HA_OFFSET_ERROR;
DBUG_RETURN(-1);
}
nod_flag=mi_test_if_nod(info->buff);
page=info->buff+2+nod_flag;
} while ((pos=_mi_kpos(nod_flag,page)) != HA_OFFSET_ERROR);
if (!(info->lastkey_length=(*keyinfo->get_key)(keyinfo,nod_flag,&page,
info->lastkey)))
DBUG_RETURN(-1); /* Crashed */
info->int_keypos=page; info->int_maxpos=info->buff+mi_getint(info->buff)-1;
info->int_nod_flag=nod_flag;
info->int_keytree_version=keyinfo->version;
info->last_search_keypage=info->last_keypage;
info->page_changed=info->buff_used=0;
info->lastpos=_mi_dpos(info,0,info->lastkey+info->lastkey_length);
DBUG_PRINT("exit",("found key at %lu", (ulong) info->lastpos));
DBUG_RETURN(0);
} | O3 | c | mi_search_first:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpq $-0x1, %rdx
je 0x85f97
movq %rdx, %rax
movq %rsi, %r14
movq 0x100(%rbx), %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
movl $0x3, %ecx
movq %r12, %r8
xorl %r9d, %r9d
callq 0x83b38
testq %rax, %rax
je 0x85fa2
movq 0x100(%rbx), %r12
xorl %r15d, %r15d
cmpb $0x0, (%r12)
jns 0x85ee8
movq (%rbx), %rax
movl 0x17c(%rax), %r15d
movl %r15d, %eax
leaq (%r12,%rax), %rsi
addq $0x2, %rsi
movq %rsi, -0x28(%rbp)
movl %r15d, %edi
callq 0x844b2
cmpq $-0x1, %rax
jne 0x85eab
movq 0x108(%rbx), %rcx
leaq -0x28(%rbp), %rdx
movq %r14, %rdi
movl %r15d, %esi
callq *0x48(%r14)
movl %eax, 0x1d8(%rbx)
testl %eax, %eax
je 0x85fc6
movq -0x28(%rbp), %rcx
movq %rcx, 0x128(%rbx)
movq 0x100(%rbx), %rcx
movq 0x190(%rbx), %rdx
movzbl 0x1(%rcx), %esi
movzbl (%rcx), %edi
andl $0x7f, %edi
shll $0x8, %edi
orq %rsi, %rdi
addq %rdi, %rcx
decq %rcx
movq %rcx, 0x130(%rbx)
movl %r15d, 0x138(%rbx)
movl 0x1c(%r14), %ecx
movl %ecx, 0x13c(%rbx)
movq %rdx, 0x198(%rbx)
movw $0x0, 0x33c(%rbx)
movl %eax, %edx
addq 0x108(%rbx), %rdx
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x84591
jmp 0x85faf
callq 0xa1b26
movl $0x78, (%rax)
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
movq $-0x1, %rax
movq %rax, 0x170(%rbx)
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
jmp 0x85fb6
| _mi_search_first:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov rbx, rdi
cmp rdx, 0FFFFFFFFFFFFFFFFh
jz loc_85F97
mov rax, rdx
mov r14, rsi
mov r12, [rbx+100h]
loc_85EAB:
mov rdi, rbx
mov rsi, r14
mov rdx, rax
mov ecx, 3
mov r8, r12
xor r9d, r9d
call _mi_fetch_keypage
test rax, rax
jz loc_85FA2
mov r12, [rbx+100h]
xor r15d, r15d
cmp byte ptr [r12], 0
jns short loc_85EE8
mov rax, [rbx]
mov r15d, [rax+17Ch]
loc_85EE8:
mov eax, r15d
lea rsi, [r12+rax]
add rsi, 2
mov [rbp+var_28], rsi
mov edi, r15d
call _mi_kpos
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_85EAB
mov rcx, [rbx+108h]
lea rdx, [rbp+var_28]
mov rdi, r14
mov esi, r15d
call qword ptr [r14+48h]
mov [rbx+1D8h], eax
test eax, eax
jz loc_85FC6
mov rcx, [rbp+var_28]
mov [rbx+128h], rcx
mov rcx, [rbx+100h]
mov rdx, [rbx+190h]
movzx esi, byte ptr [rcx+1]
movzx edi, byte ptr [rcx]
and edi, 7Fh
shl edi, 8
or rdi, rsi
add rcx, rdi
dec rcx
mov [rbx+130h], rcx
mov [rbx+138h], r15d
mov ecx, [r14+1Ch]
mov [rbx+13Ch], ecx
mov [rbx+198h], rdx
mov word ptr [rbx+33Ch], 0
mov edx, eax
add rdx, [rbx+108h]
xor r14d, r14d
mov rdi, rbx
xor esi, esi
call _mi_dpos
jmp short loc_85FAF
loc_85F97:
call _my_thread_var
mov dword ptr [rax], 78h ; 'x'
loc_85FA2:
mov r14d, 0FFFFFFFFh
mov rax, 0FFFFFFFFFFFFFFFFh
loc_85FAF:
mov [rbx+170h], rax
loc_85FB6:
mov eax, r14d
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_85FC6:
mov r14d, 0FFFFFFFFh
jmp short loc_85FB6
| long long mi_search_first(long long *a1, long long a2, unsigned long long a3)
{
unsigned long long v3; // rax
char *v4; // r12
unsigned int v5; // r15d
unsigned int v6; // eax
long long v7; // rdx
unsigned int v8; // r14d
unsigned long long v9; // rax
char *v11; // [rsp+8h] [rbp-28h] BYREF
if ( a3 == -1LL )
{
*(_DWORD *)my_thread_var(a1) = 120;
}
else
{
v3 = a3;
while ( mi_fetch_keypage(a1, a2, v3) )
{
v4 = (char *)a1[32];
v5 = 0;
if ( *v4 < 0 )
v5 = *(_DWORD *)(*a1 + 380);
v11 = &v4[v5 + 2];
v3 = mi_kpos(v5, (long long)v11);
if ( v3 == -1LL )
{
v6 = (*(long long ( **)(long long, _QWORD, char **, long long))(a2 + 72))(a2, v5, &v11, a1[33]);
*((_DWORD *)a1 + 118) = v6;
if ( v6 )
{
a1[37] = (long long)v11;
v7 = a1[50];
a1[38] = (*(unsigned __int8 *)(a1[32] + 1) | (unsigned long long)((unsigned __int8)(*(_BYTE *)a1[32] & 0x7F) << 8))
+ a1[32]
- 1;
*((_DWORD *)a1 + 78) = v5;
*((_DWORD *)a1 + 79) = *(_DWORD *)(a2 + 28);
a1[51] = v7;
*((_WORD *)a1 + 414) = 0;
v8 = 0;
v9 = mi_dpos(a1, 0, a1[33] + v6);
goto LABEL_11;
}
return (unsigned int)-1;
}
}
}
v8 = -1;
v9 = -1LL;
LABEL_11:
a1[46] = v9;
return v8;
}
| _mi_search_first:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
CMP RDX,-0x1
JZ 0x00185f97
MOV RAX,RDX
MOV R14,RSI
MOV R12,qword ptr [RBX + 0x100]
LAB_00185eab:
MOV RDI,RBX
MOV RSI,R14
MOV RDX,RAX
MOV ECX,0x3
MOV R8,R12
XOR R9D,R9D
CALL 0x00183b38
TEST RAX,RAX
JZ 0x00185fa2
MOV R12,qword ptr [RBX + 0x100]
XOR R15D,R15D
CMP byte ptr [R12],0x0
JNS 0x00185ee8
MOV RAX,qword ptr [RBX]
MOV R15D,dword ptr [RAX + 0x17c]
LAB_00185ee8:
MOV EAX,R15D
LEA RSI,[R12 + RAX*0x1]
ADD RSI,0x2
MOV qword ptr [RBP + -0x28],RSI
MOV EDI,R15D
CALL 0x001844b2
CMP RAX,-0x1
JNZ 0x00185eab
MOV RCX,qword ptr [RBX + 0x108]
LEA RDX,[RBP + -0x28]
MOV RDI,R14
MOV ESI,R15D
CALL qword ptr [R14 + 0x48]
MOV dword ptr [RBX + 0x1d8],EAX
TEST EAX,EAX
JZ 0x00185fc6
MOV RCX,qword ptr [RBP + -0x28]
MOV qword ptr [RBX + 0x128],RCX
MOV RCX,qword ptr [RBX + 0x100]
MOV RDX,qword ptr [RBX + 0x190]
MOVZX ESI,byte ptr [RCX + 0x1]
MOVZX EDI,byte ptr [RCX]
AND EDI,0x7f
SHL EDI,0x8
OR RDI,RSI
ADD RCX,RDI
DEC RCX
MOV qword ptr [RBX + 0x130],RCX
MOV dword ptr [RBX + 0x138],R15D
MOV ECX,dword ptr [R14 + 0x1c]
MOV dword ptr [RBX + 0x13c],ECX
MOV qword ptr [RBX + 0x198],RDX
MOV word ptr [RBX + 0x33c],0x0
MOV EDX,EAX
ADD RDX,qword ptr [RBX + 0x108]
XOR R14D,R14D
MOV RDI,RBX
XOR ESI,ESI
CALL 0x00184591
JMP 0x00185faf
LAB_00185f97:
CALL 0x001a1b26
MOV dword ptr [RAX],0x78
LAB_00185fa2:
MOV R14D,0xffffffff
MOV RAX,-0x1
LAB_00185faf:
MOV qword ptr [RBX + 0x170],RAX
LAB_00185fb6:
MOV EAX,R14D
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00185fc6:
MOV R14D,0xffffffff
JMP 0x00185fb6
|
int8 _mi_search_first(long *param_1,long param_2,long param_3)
{
byte *pbVar1;
uint uVar2;
long lVar3;
int4 *puVar4;
char *pcVar5;
int8 uVar6;
ulong uVar7;
char *local_30;
if (param_3 == -1) {
puVar4 = (int4 *)_my_thread_var();
*puVar4 = 0x78;
LAB_00185fa2:
uVar6 = 0xffffffff;
lVar3 = -1;
}
else {
pcVar5 = (char *)param_1[0x20];
do {
lVar3 = _mi_fetch_keypage(param_1,param_2,param_3,3,pcVar5,0);
if (lVar3 == 0) goto LAB_00185fa2;
pcVar5 = (char *)param_1[0x20];
uVar7 = 0;
if (*pcVar5 < '\0') {
uVar7 = (ulong)*(uint *)(*param_1 + 0x17c);
}
local_30 = pcVar5 + uVar7 + 2;
param_3 = _mi_kpos(uVar7);
} while (param_3 != -1);
uVar2 = (**(code **)(param_2 + 0x48))(param_2,uVar7,&local_30,param_1[0x21]);
*(uint *)(param_1 + 0x3b) = uVar2;
if (uVar2 == 0) {
return 0xffffffff;
}
param_1[0x25] = (long)local_30;
pbVar1 = (byte *)param_1[0x20];
param_1[0x26] = (long)(pbVar1 + (((ulong)((*pbVar1 & 0x7f) << 8) | (ulong)pbVar1[1]) - 1));
*(int *)(param_1 + 0x27) = (int)uVar7;
*(int4 *)((long)param_1 + 0x13c) = *(int4 *)(param_2 + 0x1c);
param_1[0x33] = param_1[0x32];
*(int2 *)((long)param_1 + 0x33c) = 0;
uVar6 = 0;
lVar3 = _mi_dpos(param_1,0,(ulong)uVar2 + param_1[0x21]);
}
param_1[0x2e] = lVar3;
return uVar6;
}
|
|
5,819 | uf_intervall | eloqsql/storage/myisam/mi_packrec.c | static void uf_intervall(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff, uchar *to,
uchar *end)
{
reg1 uint field_length=(uint) (end-to);
memcpy(to,rec->huff_tree->intervalls+field_length*decode_pos(bit_buff,
rec->huff_tree),
(size_t) field_length);
} | O3 | c | uf_intervall:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r12
movq 0x28(%rdi), %rax
movq (%rax), %r13
movq 0x10(%rax), %r15
movl 0x4(%rsi), %eax
testl %eax, %eax
je 0x8385c
movl (%r12), %ecx
decl %eax
movl %eax, 0x4(%r12)
btl %eax, %ecx
jae 0x8384b
addq $0x2, %r13
movswq (%r13), %rcx
testq %rcx, %rcx
js 0x8387b
leaq (%r13,%rcx,2), %r13
jmp 0x83833
movq %r12, %rdi
callq 0x823a5
movl $0x1f, 0x4(%r12)
movl $0x1f, %eax
cmpl $0x0, (%r12)
jns 0x8384b
jmp 0x83847
subq %rbx, %r14
andl $0x7fff, %ecx # imm = 0x7FFF
imull %r14d, %ecx
addq %rcx, %r15
movl %r14d, %edx
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x29080
| uf_intervall_0:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rcx
mov rbx, rdx
mov r12, rsi
mov rax, [rdi+28h]
mov r13, [rax]
mov r15, [rax+10h]
mov eax, [rsi+4]
loc_83833:
test eax, eax
jz short loc_8385C
mov ecx, [r12]
dec eax
mov [r12+4], eax
bt ecx, eax
jnb short loc_8384B
loc_83847:
add r13, 2
loc_8384B:
movsx rcx, word ptr [r13+0]
test rcx, rcx
js short loc_8387B
lea r13, [r13+rcx*2+0]
jmp short loc_83833
loc_8385C:
mov rdi, r12
call fill_buffer_0
mov dword ptr [r12+4], 1Fh
mov eax, 1Fh
cmp dword ptr [r12], 0
jns short loc_8384B
jmp short loc_83847
loc_8387B:
sub r14, rbx
and ecx, 7FFFh
imul ecx, r14d
add r15, rcx
mov edx, r14d
mov rdi, rbx
mov rsi, r15
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _memcpy
| long long uf_intervall_0(long long a1, int *a2, long long a3, int a4)
{
__int16 **v6; // rax
__int16 *v7; // r13
__int16 *v8; // r15
unsigned int v9; // eax
int v10; // ecx
long long v11; // rcx
v6 = *(__int16 ***)(a1 + 40);
v7 = *v6;
v8 = v6[2];
v9 = a2[1];
while ( 1 )
{
if ( v9 )
{
v10 = *a2;
a2[1] = --v9;
if ( !_bittest(&v10, v9) )
goto LABEL_5;
LABEL_4:
++v7;
goto LABEL_5;
}
fill_buffer_0((long long)a2);
a2[1] = 31;
v9 = 31;
if ( *a2 < 0 )
goto LABEL_4;
LABEL_5:
v11 = *v7;
if ( v11 < 0 )
return memcpy(a3, (char *)v8 + (a4 - (_DWORD)a3) * (unsigned int)(v11 & 0x7FFF), (unsigned int)(a4 - a3));
v7 += v11;
}
}
| uf_intervall:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RCX
MOV RBX,RDX
MOV R12,RSI
MOV RAX,qword ptr [RDI + 0x28]
MOV R13,qword ptr [RAX]
MOV R15,qword ptr [RAX + 0x10]
MOV EAX,dword ptr [RSI + 0x4]
LAB_00183833:
TEST EAX,EAX
JZ 0x0018385c
MOV ECX,dword ptr [R12]
DEC EAX
MOV dword ptr [R12 + 0x4],EAX
BT ECX,EAX
JNC 0x0018384b
LAB_00183847:
ADD R13,0x2
LAB_0018384b:
MOVSX RCX,word ptr [R13]
TEST RCX,RCX
JS 0x0018387b
LEA R13,[R13 + RCX*0x2]
JMP 0x00183833
LAB_0018385c:
MOV RDI,R12
CALL 0x001823a5
MOV dword ptr [R12 + 0x4],0x1f
MOV EAX,0x1f
CMP dword ptr [R12],0x0
JNS 0x0018384b
JMP 0x00183847
LAB_0018387b:
SUB R14,RBX
AND ECX,0x7fff
IMUL ECX,R14D
ADD R15,RCX
MOV EDX,R14D
MOV RDI,RBX
MOV RSI,R15
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00129080
|
void uf_intervall(long param_1,uint *param_2,void *param_3,int param_4)
{
short sVar1;
long lVar2;
uint uVar3;
short *psVar4;
psVar4 = (short *)**(int8 **)(param_1 + 0x28);
lVar2 = (*(int8 **)(param_1 + 0x28))[2];
uVar3 = param_2[1];
do {
if (uVar3 == 0) {
fill_buffer(param_2);
param_2[1] = 0x1f;
uVar3 = 0x1f;
if ((int)*param_2 < 0) goto LAB_00183847;
}
else {
uVar3 = uVar3 - 1;
param_2[1] = uVar3;
if ((*param_2 >> (uVar3 & 0x1f) & 1) != 0) {
LAB_00183847:
psVar4 = psVar4 + 1;
}
}
sVar1 = *psVar4;
if ((long)sVar1 < 0) {
uVar3 = param_4 - (int)param_3;
memcpy(param_3,(void *)(lVar2 + (ulong)(((int)sVar1 & 0x7fffU) * uVar3)),(ulong)uVar3);
return;
}
psVar4 = psVar4 + sVar1;
} while( true );
}
|
|
5,820 | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::scan_number() | llama.cpp/common/./json.hpp | token_type scan_number() // lgtm [cpp/use-of-goto]
{
// reset token_buffer to store the number's bytes
reset();
// the type of the parsed number; initially set to unsigned; will be
// changed if minus sign, decimal point or exponent is read
token_type number_type = token_type::value_unsigned;
// state (init): we just found out we need to scan a number
switch (current)
{
case '-':
{
add(current);
goto scan_number_minus;
}
case '0':
{
add(current);
goto scan_number_zero;
}
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
{
add(current);
goto scan_number_any1;
}
// all other characters are rejected outside scan_number()
default: // LCOV_EXCL_LINE
JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
}
scan_number_minus:
// state: we just parsed a leading minus sign
number_type = token_type::value_integer;
switch (get())
{
case '0':
{
add(current);
goto scan_number_zero;
}
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
{
add(current);
goto scan_number_any1;
}
default:
{
error_message = "invalid number; expected digit after '-'";
return token_type::parse_error;
}
}
scan_number_zero:
// state: we just parse a zero (maybe with a leading minus sign)
switch (get())
{
case '.':
{
add(decimal_point_char);
goto scan_number_decimal1;
}
case 'e':
case 'E':
{
add(current);
goto scan_number_exponent;
}
default:
goto scan_number_done;
}
scan_number_any1:
// state: we just parsed a number 0-9 (maybe with a leading minus sign)
switch (get())
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
{
add(current);
goto scan_number_any1;
}
case '.':
{
add(decimal_point_char);
goto scan_number_decimal1;
}
case 'e':
case 'E':
{
add(current);
goto scan_number_exponent;
}
default:
goto scan_number_done;
}
scan_number_decimal1:
// state: we just parsed a decimal point
number_type = token_type::value_float;
switch (get())
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
{
add(current);
goto scan_number_decimal2;
}
default:
{
error_message = "invalid number; expected digit after '.'";
return token_type::parse_error;
}
}
scan_number_decimal2:
// we just parsed at least one number after a decimal point
switch (get())
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
{
add(current);
goto scan_number_decimal2;
}
case 'e':
case 'E':
{
add(current);
goto scan_number_exponent;
}
default:
goto scan_number_done;
}
scan_number_exponent:
// we just parsed an exponent
number_type = token_type::value_float;
switch (get())
{
case '+':
case '-':
{
add(current);
goto scan_number_sign;
}
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
{
add(current);
goto scan_number_any2;
}
default:
{
error_message =
"invalid number; expected '+', '-', or digit after exponent";
return token_type::parse_error;
}
}
scan_number_sign:
// we just parsed an exponent sign
switch (get())
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
{
add(current);
goto scan_number_any2;
}
default:
{
error_message = "invalid number; expected digit after exponent sign";
return token_type::parse_error;
}
}
scan_number_any2:
// we just parsed a number after the exponent or exponent sign
switch (get())
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
{
add(current);
goto scan_number_any2;
}
default:
goto scan_number_done;
}
scan_number_done:
// unget the character after the number (we only read it to know that
// we are done scanning a number)
unget();
char* endptr = nullptr; // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
errno = 0;
// try to parse integers first and fall back to floats
if (number_type == token_type::value_unsigned)
{
const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
// we checked the number format before
JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
if (errno == 0)
{
value_unsigned = static_cast<number_unsigned_t>(x);
if (value_unsigned == x)
{
return token_type::value_unsigned;
}
}
}
else if (number_type == token_type::value_integer)
{
const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
// we checked the number format before
JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
if (errno == 0)
{
value_integer = static_cast<number_integer_t>(x);
if (value_integer == x)
{
return token_type::value_integer;
}
}
}
// this code is reached if we parse a floating-point number or if an
// integer conversion above failed
strtof(value_float, token_buffer.data(), &endptr);
// we checked the number format before
JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
return token_type::value_float;
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::scan_number():
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x27e84
movl 0x14(%rbx), %eax
movl $0x5, %ebp
leal -0x31(%rax), %ecx
cmpl $0x9, %ecx
jae 0x27b34
leaq 0x50(%rbx), %r14
movsbl %al, %esi
movq %r14, %rdi
callq 0x1e070
movq %rbx, %rdi
callq 0x1e8a0
leal -0x30(%rax), %ecx
cmpl $0xa, %ecx
jae 0x27ae3
movsbl 0x14(%rbx), %esi
jmp 0x27ac5
cmpl $0x2e, %eax
je 0x27c10
cmpl $0x45, %eax
je 0x27afa
cmpl $0x65, %eax
jne 0x27c45
movsbl 0x14(%rbx), %esi
movq %r14, %rdi
callq 0x1e070
movq %rbx, %rdi
callq 0x1e8a0
leal -0x30(%rax), %ecx
cmpl $0xa, %ecx
jb 0x27b79
cmpl $0x2d, %eax
je 0x27ce0
cmpl $0x2b, %eax
je 0x27ce0
leaq 0xa2fd8(%rip), %rax # 0xcab07
jmp 0x27c3a
cmpl $0x30, %eax
je 0x27bda
cmpl $0x2d, %eax
jne 0x27b50
leaq 0x50(%rbx), %rdi
movl $0x2d, %esi
callq 0x1e070
movq %rbx, %rdi
callq 0x1e8a0
leal -0x31(%rax), %ecx
cmpl $0x9, %ecx
jb 0x27cbf
cmpl $0x30, %eax
je 0x27d47
leaq 0xa2f41(%rip), %rax # 0xcaab5
jmp 0x27c3a
leaq 0x50(%rbx), %r14
movsbl 0x14(%rbx), %esi
movq %r14, %rdi
callq 0x1e070
movq %rbx, %rdi
callq 0x1e8a0
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x27bb9
leaq 0x50(%rbx), %r14
movsbl 0x14(%rbx), %esi
movq %r14, %rdi
callq 0x1e070
movq %rbx, %rdi
callq 0x1e8a0
addl $-0x30, %eax
cmpl $0xa, %eax
jb 0x27b9d
movq %rbx, %rdi
callq 0x1e916
movq $0x0, 0x8(%rsp)
callq 0x1de40
movl $0x0, (%rax)
jmp 0x27c9b
leaq 0x50(%rbx), %rdi
movl $0x30, %esi
callq 0x1e070
movl $0x5, %ebp
movq %rbx, %rdi
callq 0x1e8a0
cmpl $0x65, %eax
je 0x27ccc
cmpl $0x45, %eax
je 0x27ccc
cmpl $0x2e, %eax
jne 0x27c45
leaq 0x50(%rbx), %r14
movsbl 0x90(%rbx), %esi
movq %r14, %rdi
callq 0x1e070
movq %rbx, %rdi
callq 0x1e8a0
addl $-0x30, %eax
cmpl $0x9, %eax
jbe 0x27d10
leaq 0xa2ea4(%rip), %rax # 0xcaade
movq %rax, 0x70(%rbx)
movl $0xe, %eax
jmp 0x27cb6
movq %rbx, %rdi
callq 0x1e916
movq $0x0, 0x8(%rsp)
callq 0x1de40
movq %rax, %r14
movl $0x0, (%rax)
movq 0x50(%rbx), %rdi
leaq 0x8(%rsp), %rsi
movl $0xa, %edx
cmpl $0x5, %ebp
jne 0x27c90
callq 0x1db60
cmpl $0x0, (%r14)
jne 0x27c9b
movq %rax, 0x80(%rbx)
movl $0x5, %eax
jmp 0x27cb6
callq 0x1dac0
cmpl $0x0, (%r14)
je 0x27cd5
movq 0x50(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1e0e0
movsd %xmm0, 0x88(%rbx)
movl $0x7, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl 0x14(%rbx), %eax
movl $0x6, %ebp
jmp 0x27abe
leaq 0x50(%rbx), %r14
jmp 0x27afa
movq %rax, 0x78(%rbx)
movl $0x6, %eax
jmp 0x27cb6
movsbl 0x14(%rbx), %esi
leaq 0x50(%rbx), %r14
movq %r14, %rdi
callq 0x1e070
movq %rbx, %rdi
callq 0x1e8a0
addl $-0x30, %eax
cmpl $0xa, %eax
jb 0x27b7d
leaq 0xa2e37(%rip), %rax # 0xcab42
jmp 0x27c3a
leaq 0x50(%rbx), %r14
movsbl 0x14(%rbx), %esi
movq %r14, %rdi
callq 0x1e070
movq %rbx, %rdi
callq 0x1e8a0
leal -0x30(%rax), %ecx
cmpl $0xa, %ecx
jb 0x27d14
cmpl $0x65, %eax
je 0x27afa
cmpl $0x45, %eax
je 0x27afa
jmp 0x27bb9
movsbl 0x14(%rbx), %esi
leaq 0x50(%rbx), %rdi
callq 0x1e070
movl $0x6, %ebp
jmp 0x27bed
| _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE11scan_numberEv:
push rbp
push r14
push rbx
sub rsp, 10h
mov rbx, rdi
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE5resetEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::reset(void)
mov eax, [rbx+14h]
mov ebp, 5
lea ecx, [rax-31h]
cmp ecx, 9
jnb short loc_27B34
loc_27ABE:
lea r14, [rbx+50h]
movsx esi, al
loc_27AC5:
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__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<std::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)
lea ecx, [rax-30h]
cmp ecx, 0Ah
jnb short loc_27AE3
movsx esi, byte ptr [rbx+14h]
jmp short loc_27AC5
loc_27AE3:
cmp eax, 2Eh ; '.'
jz loc_27C10
cmp eax, 45h ; 'E'
jz short loc_27AFA
cmp eax, 65h ; 'e'
jnz loc_27C45
loc_27AFA:
movsx esi, byte ptr [rbx+14h]
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__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<std::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)
lea ecx, [rax-30h]
cmp ecx, 0Ah
jb short loc_27B79
cmp eax, 2Dh ; '-'
jz loc_27CE0
cmp eax, 2Bh ; '+'
jz loc_27CE0
lea rax, aInvalidNumberE; "invalid number; expected '+', '-', or d"...
jmp loc_27C3A
loc_27B34:
cmp eax, 30h ; '0'
jz loc_27BDA
cmp eax, 2Dh ; '-'
jnz short loc_27B50
lea rdi, [rbx+50h]
mov esi, 2Dh ; '-'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
loc_27B50:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__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<std::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)
lea ecx, [rax-31h]
cmp ecx, 9
jb loc_27CBF
cmp eax, 30h ; '0'
jz loc_27D47
lea rax, aInvalidNumberE_0; "invalid number; expected digit after '-"...
jmp loc_27C3A
loc_27B79:
lea r14, [rbx+50h]
loc_27B7D:
movsx esi, byte ptr [rbx+14h]
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__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<std::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)
add eax, 0FFFFFFD0h
cmp eax, 9
ja short loc_27BB9
lea r14, [rbx+50h]
loc_27B9D:
movsx esi, byte ptr [rbx+14h]
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__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<std::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)
add eax, 0FFFFFFD0h
cmp eax, 0Ah
jb short loc_27B9D
loc_27BB9:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__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<std::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 [rsp+28h+var_20], 0
call ___errno_location
mov dword ptr [rax], 0
jmp loc_27C9B
loc_27BDA:
lea rdi, [rbx+50h]
mov esi, 30h ; '0'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov ebp, 5
loc_27BED:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__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<std::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, 65h ; 'e'
jz loc_27CCC
cmp eax, 45h ; 'E'
jz loc_27CCC
cmp eax, 2Eh ; '.'
jnz short loc_27C45
lea r14, [rbx+50h]
loc_27C10:
movsx esi, byte ptr [rbx+90h]
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__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<std::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)
add eax, 0FFFFFFD0h
cmp eax, 9
jbe loc_27D10
lea rax, aInvalidNumberE_1; "invalid number; expected digit after '."...
loc_27C3A:
mov [rbx+70h], rax
mov eax, 0Eh
jmp short loc_27CB6
loc_27C45:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__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<std::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 [rsp+28h+var_20], 0
call ___errno_location
mov r14, rax
mov dword ptr [rax], 0
mov rdi, [rbx+50h]
lea rsi, [rsp+28h+var_20]
mov edx, 0Ah
cmp ebp, 5
jnz short loc_27C90
call _strtoull
cmp dword ptr [r14], 0
jnz short loc_27C9B
mov [rbx+80h], rax
mov eax, 5
jmp short loc_27CB6
loc_27C90:
call _strtoll
cmp dword ptr [r14], 0
jz short loc_27CD5
loc_27C9B:
mov rdi, [rbx+50h]
lea rsi, [rsp+28h+var_20]
call _strtod
movsd qword ptr [rbx+88h], xmm0
mov eax, 7
loc_27CB6:
add rsp, 10h
pop rbx
pop r14
pop rbp
retn
loc_27CBF:
mov eax, [rbx+14h]
mov ebp, 6
jmp loc_27ABE
loc_27CCC:
lea r14, [rbx+50h]
jmp loc_27AFA
loc_27CD5:
mov [rbx+78h], rax
mov eax, 6
jmp short loc_27CB6
loc_27CE0:
movsx esi, byte ptr [rbx+14h]
lea r14, [rbx+50h]
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__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<std::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)
add eax, 0FFFFFFD0h
cmp eax, 0Ah
jb loc_27B7D
lea rax, aInvalidNumberE_2; "invalid number; expected digit after ex"...
jmp loc_27C3A
loc_27D10:
lea r14, [rbx+50h]
loc_27D14:
movsx esi, byte ptr [rbx+14h]
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__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<std::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)
lea ecx, [rax-30h]
cmp ecx, 0Ah
jb short loc_27D14
cmp eax, 65h ; 'e'
jz loc_27AFA
cmp eax, 45h ; 'E'
jz loc_27AFA
jmp loc_27BB9
loc_27D47:
movsx esi, byte ptr [rbx+14h]
lea rdi, [rbx+50h]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov ebp, 6
jmp loc_27BED
| long long nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::scan_number(
long long a1)
{
int v2; // eax
int v3; // ebp
long long v4; // r14
long long i; // rsi
int v6; // eax
int v7; // eax
const char *v8; // rax
int v9; // eax
long long v10; // r14
int v11; // eax
_DWORD *v13; // r14
long long v14; // rdi
long long v15; // rax
long long v16; // rax
int v17; // eax
_QWORD v18[4]; // [rsp+8h] [rbp-20h] BYREF
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::reset();
v2 = *(_DWORD *)(a1 + 20);
v3 = 5;
if ( (unsigned int)(v2 - 49) >= 9 )
{
if ( v2 == 48 )
{
std::string::push_back(a1 + 80, 48LL);
v3 = 5;
}
else
{
if ( v2 == 45 )
std::string::push_back(a1 + 80, 45LL);
v9 = nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get((__m128i *)a1);
if ( (unsigned int)(v9 - 49) < 9 )
{
v2 = *(_DWORD *)(a1 + 20);
v3 = 6;
goto LABEL_2;
}
if ( v9 != 48 )
{
v8 = "invalid number; expected digit after '-'";
goto LABEL_29;
}
std::string::push_back(a1 + 80, (unsigned int)*(char *)(a1 + 20));
v3 = 6;
}
v11 = nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get((__m128i *)a1);
if ( v11 == 101 || v11 == 69 )
{
v4 = a1 + 80;
goto LABEL_8;
}
if ( v11 != 46 )
goto LABEL_30;
v4 = a1 + 80;
LABEL_27:
std::string::push_back(v4, (unsigned int)*(char *)(a1 + 144));
if ( (unsigned int)nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get((__m128i *)a1)
- 48 > 9 )
{
v8 = "invalid number; expected digit after '.'";
goto LABEL_29;
}
v4 = a1 + 80;
do
{
std::string::push_back(a1 + 80, (unsigned int)*(char *)(a1 + 20));
v17 = nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get((__m128i *)a1);
}
while ( (unsigned int)(v17 - 48) < 0xA );
if ( v17 != 101 && v17 != 69 )
{
LABEL_21:
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::unget(a1);
v18[0] = 0LL;
*(_DWORD *)__errno_location() = 0;
goto LABEL_34;
}
LABEL_8:
std::string::push_back(v4, (unsigned int)*(char *)(a1 + 20));
v7 = nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get((__m128i *)a1);
if ( (unsigned int)(v7 - 48) < 0xA )
{
v10 = a1 + 80;
}
else
{
if ( v7 != 45 && v7 != 43 )
{
v8 = "invalid number; expected '+', '-', or digit after exponent";
LABEL_29:
*(_QWORD *)(a1 + 112) = v8;
return 14LL;
}
v10 = a1 + 80;
std::string::push_back(a1 + 80, (unsigned int)*(char *)(a1 + 20));
if ( (unsigned int)nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get((__m128i *)a1)
- 48 >= 0xA )
{
v8 = "invalid number; expected digit after exponent sign";
goto LABEL_29;
}
}
std::string::push_back(v10, (unsigned int)*(char *)(a1 + 20));
if ( (unsigned int)nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get((__m128i *)a1)
- 48 <= 9 )
{
do
std::string::push_back(a1 + 80, (unsigned int)*(char *)(a1 + 20));
while ( (unsigned int)nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get((__m128i *)a1)
- 48 < 0xA );
}
goto LABEL_21;
}
LABEL_2:
v4 = a1 + 80;
for ( i = (unsigned int)(char)v2; ; i = (unsigned int)*(char *)(a1 + 20) )
{
std::string::push_back(a1 + 80, i);
v6 = nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get((__m128i *)a1);
if ( (unsigned int)(v6 - 48) >= 0xA )
break;
}
if ( v6 == 46 )
goto LABEL_27;
if ( v6 == 69 || v6 == 101 )
goto LABEL_8;
LABEL_30:
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::unget(a1);
v18[0] = 0LL;
v13 = (_DWORD *)__errno_location();
*v13 = 0;
v14 = *(_QWORD *)(a1 + 80);
if ( v3 == 5 )
{
v15 = strtoull(v14, v18, 10LL);
if ( !*v13 )
{
*(_QWORD *)(a1 + 128) = v15;
return 5LL;
}
goto LABEL_34;
}
v16 = strtoll(v14, v18, 10LL);
if ( *v13 )
{
LABEL_34:
*(double *)(a1 + 136) = strtod(*(_QWORD *)(a1 + 80), v18);
return 7LL;
}
*(_QWORD *)(a1 + 120) = v16;
return 6LL;
}
| scan_number:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
CALL 0x00127e84
MOV EAX,dword ptr [RBX + 0x14]
MOV EBP,0x5
LEA ECX,[RAX + -0x31]
CMP ECX,0x9
JNC 0x00127b34
LAB_00127abe:
LEA R14,[RBX + 0x50]
MOVSX ESI,AL
LAB_00127ac5:
MOV RDI,R14
CALL 0x0011e070
MOV RDI,RBX
CALL 0x0011e8a0
LEA ECX,[RAX + -0x30]
CMP ECX,0xa
JNC 0x00127ae3
MOVSX ESI,byte ptr [RBX + 0x14]
JMP 0x00127ac5
LAB_00127ae3:
CMP EAX,0x2e
JZ 0x00127c10
CMP EAX,0x45
JZ 0x00127afa
CMP EAX,0x65
JNZ 0x00127c45
LAB_00127afa:
MOVSX ESI,byte ptr [RBX + 0x14]
MOV RDI,R14
CALL 0x0011e070
MOV RDI,RBX
CALL 0x0011e8a0
LEA ECX,[RAX + -0x30]
CMP ECX,0xa
JC 0x00127b79
CMP EAX,0x2d
JZ 0x00127ce0
CMP EAX,0x2b
JZ 0x00127ce0
LEA RAX,[0x1cab07]
JMP 0x00127c3a
LAB_00127b34:
CMP EAX,0x30
JZ 0x00127bda
CMP EAX,0x2d
JNZ 0x00127b50
LEA RDI,[RBX + 0x50]
MOV ESI,0x2d
CALL 0x0011e070
LAB_00127b50:
MOV RDI,RBX
CALL 0x0011e8a0
LEA ECX,[RAX + -0x31]
CMP ECX,0x9
JC 0x00127cbf
CMP EAX,0x30
JZ 0x00127d47
LEA RAX,[0x1caab5]
JMP 0x00127c3a
LAB_00127b79:
LEA R14,[RBX + 0x50]
LAB_00127b7d:
MOVSX ESI,byte ptr [RBX + 0x14]
MOV RDI,R14
CALL 0x0011e070
MOV RDI,RBX
CALL 0x0011e8a0
ADD EAX,-0x30
CMP EAX,0x9
JA 0x00127bb9
LEA R14,[RBX + 0x50]
LAB_00127b9d:
MOVSX ESI,byte ptr [RBX + 0x14]
MOV RDI,R14
CALL 0x0011e070
MOV RDI,RBX
CALL 0x0011e8a0
ADD EAX,-0x30
CMP EAX,0xa
JC 0x00127b9d
LAB_00127bb9:
MOV RDI,RBX
CALL 0x0011e916
MOV qword ptr [RSP + 0x8],0x0
CALL 0x0011de40
MOV dword ptr [RAX],0x0
JMP 0x00127c9b
LAB_00127bda:
LEA RDI,[RBX + 0x50]
MOV ESI,0x30
CALL 0x0011e070
MOV EBP,0x5
LAB_00127bed:
MOV RDI,RBX
CALL 0x0011e8a0
CMP EAX,0x65
JZ 0x00127ccc
CMP EAX,0x45
JZ 0x00127ccc
CMP EAX,0x2e
JNZ 0x00127c45
LEA R14,[RBX + 0x50]
LAB_00127c10:
MOVSX ESI,byte ptr [RBX + 0x90]
MOV RDI,R14
CALL 0x0011e070
MOV RDI,RBX
CALL 0x0011e8a0
ADD EAX,-0x30
CMP EAX,0x9
JBE 0x00127d10
LEA RAX,[0x1caade]
LAB_00127c3a:
MOV qword ptr [RBX + 0x70],RAX
MOV EAX,0xe
JMP 0x00127cb6
LAB_00127c45:
MOV RDI,RBX
CALL 0x0011e916
MOV qword ptr [RSP + 0x8],0x0
CALL 0x0011de40
MOV R14,RAX
MOV dword ptr [RAX],0x0
MOV RDI,qword ptr [RBX + 0x50]
LEA RSI,[RSP + 0x8]
MOV EDX,0xa
CMP EBP,0x5
JNZ 0x00127c90
CALL 0x0011db60
CMP dword ptr [R14],0x0
JNZ 0x00127c9b
MOV qword ptr [RBX + 0x80],RAX
MOV EAX,0x5
JMP 0x00127cb6
LAB_00127c90:
CALL 0x0011dac0
CMP dword ptr [R14],0x0
JZ 0x00127cd5
LAB_00127c9b:
MOV RDI,qword ptr [RBX + 0x50]
LEA RSI,[RSP + 0x8]
CALL 0x0011e0e0
MOVSD qword ptr [RBX + 0x88],XMM0
MOV EAX,0x7
LAB_00127cb6:
ADD RSP,0x10
POP RBX
POP R14
POP RBP
RET
LAB_00127cbf:
MOV EAX,dword ptr [RBX + 0x14]
MOV EBP,0x6
JMP 0x00127abe
LAB_00127ccc:
LEA R14,[RBX + 0x50]
JMP 0x00127afa
LAB_00127cd5:
MOV qword ptr [RBX + 0x78],RAX
MOV EAX,0x6
JMP 0x00127cb6
LAB_00127ce0:
MOVSX ESI,byte ptr [RBX + 0x14]
LEA R14,[RBX + 0x50]
MOV RDI,R14
CALL 0x0011e070
MOV RDI,RBX
CALL 0x0011e8a0
ADD EAX,-0x30
CMP EAX,0xa
JC 0x00127b7d
LEA RAX,[0x1cab42]
JMP 0x00127c3a
LAB_00127d10:
LEA R14,[RBX + 0x50]
LAB_00127d14:
MOVSX ESI,byte ptr [RBX + 0x14]
MOV RDI,R14
CALL 0x0011e070
MOV RDI,RBX
CALL 0x0011e8a0
LEA ECX,[RAX + -0x30]
CMP ECX,0xa
JC 0x00127d14
CMP EAX,0x65
JZ 0x00127afa
CMP EAX,0x45
JZ 0x00127afa
JMP 0x00127bb9
LAB_00127d47:
MOVSX ESI,byte ptr [RBX + 0x14]
LEA RDI,[RBX + 0x50]
CALL 0x0011e070
MOV EBP,0x6
JMP 0x00127bed
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > > >::scan_number() */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::scan_number(lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*this)
{
char cVar1;
int iVar2;
char *pcVar3;
int *piVar4;
ulonglong uVar5;
longlong lVar6;
int iVar7;
double dVar8;
char *local_20;
reset(this);
iVar2 = *(int *)(this + 0x14);
iVar7 = 5;
cVar1 = (char)this;
if (iVar2 - 0x31U < 9) {
LAB_00127abe:
do {
std::__cxx11::string::push_back(cVar1 + 'P');
iVar2 = get(this);
} while (iVar2 - 0x30U < 10);
if (iVar2 != 0x2e) {
if ((iVar2 != 0x45) && (iVar2 != 0x65)) {
LAB_00127c45:
unget(this);
local_20 = (char *)0x0;
piVar4 = __errno_location();
*piVar4 = 0;
if (iVar7 == 5) {
uVar5 = strtoull(*(char **)(this + 0x50),&local_20,10);
if (*piVar4 == 0) {
*(ulonglong *)(this + 0x80) = uVar5;
return 5;
}
}
else {
lVar6 = strtoll(*(char **)(this + 0x50),&local_20,10);
if (*piVar4 == 0) {
*(longlong *)(this + 0x78) = lVar6;
return 6;
}
}
goto LAB_00127c9b;
}
goto LAB_00127afa;
}
LAB_00127c10:
std::__cxx11::string::push_back(cVar1 + 'P');
iVar2 = get(this);
if (9 < iVar2 - 0x30U) {
pcVar3 = "invalid number; expected digit after \'.\'";
goto LAB_00127c3a;
}
do {
std::__cxx11::string::push_back(cVar1 + 'P');
iVar2 = get(this);
} while (iVar2 - 0x30U < 10);
if ((iVar2 == 0x65) || (iVar2 == 0x45)) goto LAB_00127afa;
}
else {
if (iVar2 == 0x30) {
std::__cxx11::string::push_back(cVar1 + 'P');
iVar7 = 5;
}
else {
if (iVar2 == 0x2d) {
std::__cxx11::string::push_back(cVar1 + 'P');
}
iVar2 = get(this);
if (iVar2 - 0x31U < 9) {
iVar7 = 6;
goto LAB_00127abe;
}
if (iVar2 != 0x30) {
pcVar3 = "invalid number; expected digit after \'-\'";
goto LAB_00127c3a;
}
std::__cxx11::string::push_back(cVar1 + 'P');
iVar7 = 6;
}
iVar2 = get(this);
if ((iVar2 != 0x65) && (iVar2 != 0x45)) {
if (iVar2 != 0x2e) goto LAB_00127c45;
goto LAB_00127c10;
}
LAB_00127afa:
std::__cxx11::string::push_back(cVar1 + 'P');
iVar2 = get(this);
if (9 < iVar2 - 0x30U) {
if ((iVar2 != 0x2d) && (iVar2 != 0x2b)) {
pcVar3 = "invalid number; expected \'+\', \'-\', or digit after exponent";
LAB_00127c3a:
*(char **)(this + 0x70) = pcVar3;
return 0xe;
}
std::__cxx11::string::push_back(cVar1 + 'P');
iVar2 = get(this);
if (9 < iVar2 - 0x30U) {
pcVar3 = "invalid number; expected digit after exponent sign";
goto LAB_00127c3a;
}
}
std::__cxx11::string::push_back(cVar1 + 'P');
iVar2 = get(this);
if (iVar2 - 0x30U < 10) {
do {
std::__cxx11::string::push_back(cVar1 + 'P');
iVar2 = get(this);
} while (iVar2 - 0x30U < 10);
}
}
unget(this);
local_20 = (char *)0x0;
piVar4 = __errno_location();
*piVar4 = 0;
LAB_00127c9b:
dVar8 = strtod(*(char **)(this + 0x50),&local_20);
*(double *)(this + 0x88) = dVar8;
return 7;
}
|
|
5,821 | func_uni_gbk_onechar | eloqsql/strings/ctype-gbk.c | static int func_uni_gbk_onechar(int code){
if ((code>=0x00A4)&&(code<=0x0451))
return(tab_uni_gbk0[code-0x00A4]);
if ((code>=0x2010)&&(code<=0x2312))
return(tab_uni_gbk1[code-0x2010]);
if ((code>=0x2460)&&(code<=0x2642))
return(tab_uni_gbk2[code-0x2460]);
if ((code>=0x3000)&&(code<=0x3129))
return(tab_uni_gbk3[code-0x3000]);
if ((code>=0x3220)&&(code<=0x32A3))
return(tab_uni_gbk4[code-0x3220]);
if ((code>=0x338E)&&(code<=0x33D5))
return(tab_uni_gbk5[code-0x338E]);
if ((code>=0x4E00)&&(code<=0x9FA5))
return(tab_uni_gbk6[code-0x4E00]);
if ((code>=0xF92C)&&(code<=0xFA29))
return(tab_uni_gbk7[code-0xF92C]);
if ((code>=0xFE30)&&(code<=0xFFE5))
return(tab_uni_gbk8[code-0xFE30]);
return(0);
} | O0 | c | func_uni_gbk_onechar:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0xa4, -0x8(%rbp)
jl 0xe1f87
cmpl $0x451, -0x8(%rbp) # imm = 0x451
jg 0xe1f87
movl -0x8(%rbp), %eax
subl $0xa4, %eax
movslq %eax, %rcx
leaq 0xef235(%rip), %rax # 0x1d11b0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0xe2105
cmpl $0x2010, -0x8(%rbp) # imm = 0x2010
jl 0xe1fb7
cmpl $0x2312, -0x8(%rbp) # imm = 0x2312
jg 0xe1fb7
movl -0x8(%rbp), %eax
subl $0x2010, %eax # imm = 0x2010
movslq %eax, %rcx
leaq 0xef965(%rip), %rax # 0x1d1910
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0xe2105
cmpl $0x2460, -0x8(%rbp) # imm = 0x2460
jl 0xe1fe7
cmpl $0x2642, -0x8(%rbp) # imm = 0x2642
jg 0xe1fe7
movl -0x8(%rbp), %eax
subl $0x2460, %eax # imm = 0x2460
movslq %eax, %rcx
leaq 0xeff45(%rip), %rax # 0x1d1f20
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0xe2105
cmpl $0x3000, -0x8(%rbp) # imm = 0x3000
jl 0xe2017
cmpl $0x3129, -0x8(%rbp) # imm = 0x3129
jg 0xe2017
movl -0x8(%rbp), %eax
subl $0x3000, %eax # imm = 0x3000
movslq %eax, %rcx
leaq 0xf02e5(%rip), %rax # 0x1d22f0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0xe2105
cmpl $0x3220, -0x8(%rbp) # imm = 0x3220
jl 0xe2047
cmpl $0x32a3, -0x8(%rbp) # imm = 0x32A3
jg 0xe2047
movl -0x8(%rbp), %eax
subl $0x3220, %eax # imm = 0x3220
movslq %eax, %rcx
leaq 0xf0515(%rip), %rax # 0x1d2550
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0xe2105
cmpl $0x338e, -0x8(%rbp) # imm = 0x338E
jl 0xe2077
cmpl $0x33d5, -0x8(%rbp) # imm = 0x33D5
jg 0xe2077
movl -0x8(%rbp), %eax
subl $0x338e, %eax # imm = 0x338E
movslq %eax, %rcx
leaq 0xf05f5(%rip), %rax # 0x1d2660
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0xe2105
cmpl $0x4e00, -0x8(%rbp) # imm = 0x4E00
jl 0xe20a4
cmpl $0x9fa5, -0x8(%rbp) # imm = 0x9FA5
jg 0xe20a4
movl -0x8(%rbp), %eax
subl $0x4e00, %eax # imm = 0x4E00
movslq %eax, %rcx
leaq 0xf0655(%rip), %rax # 0x1d26f0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0xe2105
cmpl $0xf92c, -0x8(%rbp) # imm = 0xF92C
jl 0xe20d1
cmpl $0xfa29, -0x8(%rbp) # imm = 0xFA29
jg 0xe20d1
movl -0x8(%rbp), %eax
subl $0xf92c, %eax # imm = 0xF92C
movslq %eax, %rcx
leaq 0xfa978(%rip), %rax # 0x1dca40
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0xe2105
cmpl $0xfe30, -0x8(%rbp) # imm = 0xFE30
jl 0xe20fe
cmpl $0xffe5, -0x8(%rbp) # imm = 0xFFE5
jg 0xe20fe
movl -0x8(%rbp), %eax
subl $0xfe30, %eax # imm = 0xFE30
movslq %eax, %rcx
leaq 0xfab4b(%rip), %rax # 0x1dcc40
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0xe2105
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
| func_uni_gbk_onechar:
push rbp
mov rbp, rsp
mov [rbp+var_8], edi
cmp [rbp+var_8], 0A4h
jl short loc_E1F87
cmp [rbp+var_8], 451h
jg short loc_E1F87
mov eax, [rbp+var_8]
sub eax, 0A4h
movsxd rcx, eax
lea rax, tab_uni_gbk0
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_E2105
loc_E1F87:
cmp [rbp+var_8], 2010h
jl short loc_E1FB7
cmp [rbp+var_8], 2312h
jg short loc_E1FB7
mov eax, [rbp+var_8]
sub eax, 2010h
movsxd rcx, eax
lea rax, tab_uni_gbk1
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_E2105
loc_E1FB7:
cmp [rbp+var_8], 2460h
jl short loc_E1FE7
cmp [rbp+var_8], 2642h
jg short loc_E1FE7
mov eax, [rbp+var_8]
sub eax, 2460h
movsxd rcx, eax
lea rax, tab_uni_gbk2
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_E2105
loc_E1FE7:
cmp [rbp+var_8], 3000h
jl short loc_E2017
cmp [rbp+var_8], 3129h
jg short loc_E2017
mov eax, [rbp+var_8]
sub eax, 3000h
movsxd rcx, eax
lea rax, tab_uni_gbk3
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_E2105
loc_E2017:
cmp [rbp+var_8], 3220h
jl short loc_E2047
cmp [rbp+var_8], 32A3h
jg short loc_E2047
mov eax, [rbp+var_8]
sub eax, 3220h
movsxd rcx, eax
lea rax, tab_uni_gbk4
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_E2105
loc_E2047:
cmp [rbp+var_8], 338Eh
jl short loc_E2077
cmp [rbp+var_8], 33D5h
jg short loc_E2077
mov eax, [rbp+var_8]
sub eax, 338Eh
movsxd rcx, eax
lea rax, tab_uni_gbk5
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_E2105
loc_E2077:
cmp [rbp+var_8], 4E00h
jl short loc_E20A4
cmp [rbp+var_8], 9FA5h
jg short loc_E20A4
mov eax, [rbp+var_8]
sub eax, 4E00h
movsxd rcx, eax
lea rax, tab_uni_gbk6
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_E2105
loc_E20A4:
cmp [rbp+var_8], 0F92Ch
jl short loc_E20D1
cmp [rbp+var_8], 0FA29h
jg short loc_E20D1
mov eax, [rbp+var_8]
sub eax, 0F92Ch
movsxd rcx, eax
lea rax, tab_uni_gbk7
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_E2105
loc_E20D1:
cmp [rbp+var_8], 0FE30h
jl short loc_E20FE
cmp [rbp+var_8], 0FFE5h
jg short loc_E20FE
mov eax, [rbp+var_8]
sub eax, 0FE30h
movsxd rcx, eax
lea rax, tab_uni_gbk8
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_E2105
loc_E20FE:
mov [rbp+var_4], 0
loc_E2105:
mov eax, [rbp+var_4]
pop rbp
retn
| long long func_uni_gbk_onechar(int a1)
{
if ( a1 < 164 || a1 > 1105 )
{
if ( a1 < 8208 || a1 > 8978 )
{
if ( a1 < 9312 || a1 > 9794 )
{
if ( a1 < 12288 || a1 > 12585 )
{
if ( a1 < 12832 || a1 > 12963 )
{
if ( a1 < 13198 || a1 > 13269 )
{
if ( a1 < 19968 || a1 > 40869 )
{
if ( a1 < 63788 || a1 > 64041 )
{
if ( a1 < 65072 || a1 > 65509 )
return 0;
else
return tab_uni_gbk8[a1 - 65072];
}
else
{
return tab_uni_gbk7[a1 - 63788];
}
}
else
{
return tab_uni_gbk6[a1 - 19968];
}
}
else
{
return tab_uni_gbk5[a1 - 13198];
}
}
else
{
return tab_uni_gbk4[a1 - 12832];
}
}
else
{
return tab_uni_gbk3[a1 - 12288];
}
}
else
{
return tab_uni_gbk2[a1 - 9312];
}
}
else
{
return tab_uni_gbk1[a1 - 8208];
}
}
else
{
return tab_uni_gbk0[a1 - 164];
}
}
| func_uni_gbk_onechar:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x8],EDI
CMP dword ptr [RBP + -0x8],0xa4
JL 0x001e1f87
CMP dword ptr [RBP + -0x8],0x451
JG 0x001e1f87
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xa4
MOVSXD RCX,EAX
LEA RAX,[0x2d11b0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001e2105
LAB_001e1f87:
CMP dword ptr [RBP + -0x8],0x2010
JL 0x001e1fb7
CMP dword ptr [RBP + -0x8],0x2312
JG 0x001e1fb7
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2010
MOVSXD RCX,EAX
LEA RAX,[0x2d1910]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001e2105
LAB_001e1fb7:
CMP dword ptr [RBP + -0x8],0x2460
JL 0x001e1fe7
CMP dword ptr [RBP + -0x8],0x2642
JG 0x001e1fe7
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2460
MOVSXD RCX,EAX
LEA RAX,[0x2d1f20]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001e2105
LAB_001e1fe7:
CMP dword ptr [RBP + -0x8],0x3000
JL 0x001e2017
CMP dword ptr [RBP + -0x8],0x3129
JG 0x001e2017
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x3000
MOVSXD RCX,EAX
LEA RAX,[0x2d22f0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001e2105
LAB_001e2017:
CMP dword ptr [RBP + -0x8],0x3220
JL 0x001e2047
CMP dword ptr [RBP + -0x8],0x32a3
JG 0x001e2047
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x3220
MOVSXD RCX,EAX
LEA RAX,[0x2d2550]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001e2105
LAB_001e2047:
CMP dword ptr [RBP + -0x8],0x338e
JL 0x001e2077
CMP dword ptr [RBP + -0x8],0x33d5
JG 0x001e2077
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x338e
MOVSXD RCX,EAX
LEA RAX,[0x2d2660]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001e2105
LAB_001e2077:
CMP dword ptr [RBP + -0x8],0x4e00
JL 0x001e20a4
CMP dword ptr [RBP + -0x8],0x9fa5
JG 0x001e20a4
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x4e00
MOVSXD RCX,EAX
LEA RAX,[0x2d26f0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001e2105
LAB_001e20a4:
CMP dword ptr [RBP + -0x8],0xf92c
JL 0x001e20d1
CMP dword ptr [RBP + -0x8],0xfa29
JG 0x001e20d1
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xf92c
MOVSXD RCX,EAX
LEA RAX,[0x2dca40]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001e2105
LAB_001e20d1:
CMP dword ptr [RBP + -0x8],0xfe30
JL 0x001e20fe
CMP dword ptr [RBP + -0x8],0xffe5
JG 0x001e20fe
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xfe30
MOVSXD RCX,EAX
LEA RAX,[0x2dcc40]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001e2105
LAB_001e20fe:
MOV dword ptr [RBP + -0x4],0x0
LAB_001e2105:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int2 func_uni_gbk_onechar(int param_1)
{
int2 uVar1;
if ((param_1 < 0xa4) || (0x451 < param_1)) {
if ((param_1 < 0x2010) || (0x2312 < param_1)) {
if ((param_1 < 0x2460) || (0x2642 < param_1)) {
if ((param_1 < 0x3000) || (0x3129 < param_1)) {
if ((param_1 < 0x3220) || (0x32a3 < param_1)) {
if ((param_1 < 0x338e) || (0x33d5 < param_1)) {
if ((param_1 < 0x4e00) || (0x9fa5 < param_1)) {
if ((param_1 < 0xf92c) || (0xfa29 < param_1)) {
if ((param_1 < 0xfe30) || (0xffe5 < param_1)) {
uVar1 = 0;
}
else {
uVar1 = *(int2 *)(tab_uni_gbk8 + (long)(param_1 + -0xfe30) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gbk7 + (long)(param_1 + -0xf92c) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gbk6 + (long)(param_1 + -0x4e00) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gbk5 + (long)(param_1 + -0x338e) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gbk4 + (long)(param_1 + -0x3220) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gbk3 + (long)(param_1 + -0x3000) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gbk2 + (long)(param_1 + -0x2460) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gbk1 + (long)(param_1 + -0x2010) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gbk0 + (long)(param_1 + -0xa4) * 2);
}
return uVar1;
}
|
|
5,822 | my_wc_mb_tis620 | eloqsql/strings/ctype-tis620.c | static
int my_wc_mb_tis620(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc,
uchar *str,
uchar *end __attribute__((unused)))
{
const uchar *pl;
if (str >= end)
return MY_CS_TOOSMALL;
pl= uni_to_cs[(wc>>8) & 0xFF];
str[0]= pl ? pl[wc & 0xFF] : '\0';
return (!str[0] && wc) ? MY_CS_ILUNI : 1;
} | O0 | c | my_wc_mb_tis620:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x7ed77
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x7edf2
movq -0x18(%rbp), %rcx
shrq $0x8, %rcx
andq $0xff, %rcx
leaq 0x1923e3(%rip), %rax # 0x211170
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x7edb4
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
andq $0xff, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x34(%rbp)
jmp 0x7edbb
xorl %eax, %eax
movl %eax, -0x34(%rbp)
jmp 0x7edbb
movl -0x34(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x35(%rbp)
jne 0x7eddf
cmpq $0x0, -0x18(%rbp)
setne %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %dl
movl $0x1, %eax
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
| my_wc_mb_tis620:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jb short loc_7ED77
mov [rbp+var_4], 0FFFFFF9Bh
jmp short loc_7EDF2
loc_7ED77:
mov rcx, [rbp+var_18]
shr rcx, 8
and rcx, 0FFh
lea rax, uni_to_cs_0
mov rax, [rax+rcx*8]
mov [rbp+var_30], rax
cmp [rbp+var_30], 0
jz short loc_7EDB4
mov rax, [rbp+var_30]
mov rcx, [rbp+var_18]
and rcx, 0FFh
movzx eax, byte ptr [rax+rcx]
mov [rbp+var_34], eax
jmp short loc_7EDBB
loc_7EDB4:
xor eax, eax
mov [rbp+var_34], eax
jmp short $+2
loc_7EDBB:
mov eax, [rbp+var_34]
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov rcx, [rbp+var_20]
xor eax, eax
cmp byte ptr [rcx], 0
mov [rbp+var_35], al
jnz short loc_7EDDF
cmp [rbp+var_18], 0
setnz al
mov [rbp+var_35], al
loc_7EDDF:
mov dl, [rbp+var_35]
mov eax, 1
xor ecx, ecx
test dl, 1
cmovnz eax, ecx
mov [rbp+var_4], eax
loc_7EDF2:
mov eax, [rbp+var_4]
pop rbp
retn
| long long my_wc_mb_tis620(long long a1, long long a2, _BYTE *a3, unsigned long long a4)
{
bool v5; // [rsp+1h] [rbp-35h]
char v6; // [rsp+2h] [rbp-34h]
long long v7; // [rsp+6h] [rbp-30h]
if ( (unsigned long long)a3 < a4 )
{
v7 = (long long)*(&uni_to_cs_0 + BYTE1(a2));
if ( v7 )
v6 = *(_BYTE *)(v7 + (unsigned __int8)a2);
else
v6 = 0;
*a3 = v6;
v5 = 0;
if ( !*a3 )
v5 = a2 != 0;
return !v5;
}
else
{
return (unsigned int)-101;
}
}
| my_wc_mb_tis620:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x0017ed77
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x0017edf2
LAB_0017ed77:
MOV RCX,qword ptr [RBP + -0x18]
SHR RCX,0x8
AND RCX,0xff
LEA RAX,[0x311170]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x30],0x0
JZ 0x0017edb4
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x18]
AND RCX,0xff
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV dword ptr [RBP + -0x34],EAX
JMP 0x0017edbb
LAB_0017edb4:
XOR EAX,EAX
MOV dword ptr [RBP + -0x34],EAX
JMP 0x0017edbb
LAB_0017edbb:
MOV EAX,dword ptr [RBP + -0x34]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV RCX,qword ptr [RBP + -0x20]
XOR EAX,EAX
CMP byte ptr [RCX],0x0
MOV byte ptr [RBP + -0x35],AL
JNZ 0x0017eddf
CMP qword ptr [RBP + -0x18],0x0
SETNZ AL
MOV byte ptr [RBP + -0x35],AL
LAB_0017eddf:
MOV DL,byte ptr [RBP + -0x35]
MOV EAX,0x1
XOR ECX,ECX
TEST DL,0x1
CMOVNZ EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
LAB_0017edf2:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
uint my_wc_mb_tis620(int8 param_1,ulong param_2,char *param_3,char *param_4)
{
char cVar1;
uint local_c;
if (param_3 < param_4) {
if (*(long *)(uni_to_cs + (param_2 >> 8 & 0xff) * 8) == 0) {
cVar1 = '\0';
}
else {
cVar1 = *(char *)(*(long *)(uni_to_cs + (param_2 >> 8 & 0xff) * 8) + (param_2 & 0xff));
}
*param_3 = cVar1;
local_c = (uint)(*param_3 != '\0' || param_2 == 0);
}
else {
local_c = 0xffffff9b;
}
return local_c;
}
|
|
5,823 | my_wc_mb_tis620 | eloqsql/strings/ctype-tis620.c | static
int my_wc_mb_tis620(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc,
uchar *str,
uchar *end __attribute__((unused)))
{
const uchar *pl;
if (str >= end)
return MY_CS_TOOSMALL;
pl= uni_to_cs[(wc>>8) & 0xFF];
str[0]= pl ? pl[wc & 0xFF] : '\0';
return (!str[0] && wc) ? MY_CS_ILUNI : 1;
} | O3 | c | my_wc_mb_tis620:
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x5c7da
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movq %rsi, %rbx
movzbl %bh, %eax
leaq 0x2b892d(%rip), %rcx # 0x3150e0
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0x5c7c4
movzbl %bl, %ecx
movb (%rax,%rcx), %al
jmp 0x5c7c6
xorl %eax, %eax
movb %al, (%rdx)
testb %al, %al
setne %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
movzbl %cl, %eax
popq %rbx
popq %rbp
retq
| my_wc_mb_tis620:
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short locret_5C7DA
push rbp
mov rbp, rsp
push rbx
mov rbx, rsi
movzx eax, bh
lea rcx, uni_to_cs_0
mov rax, [rcx+rax*8]
test rax, rax
jz short loc_5C7C4
movzx ecx, bl
mov al, [rax+rcx]
jmp short loc_5C7C6
loc_5C7C4:
xor eax, eax
loc_5C7C6:
mov [rdx], al
test al, al
setnz al
test rbx, rbx
setz cl
or cl, al
movzx eax, cl
pop rbx
pop rbp
locret_5C7DA:
retn
| long long my_wc_mb_tis620(long long a1, long long a2, _BYTE *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rax
char v6; // al
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
v5 = (long long)*(&uni_to_cs_0 + BYTE1(a2));
if ( v5 )
v6 = *(_BYTE *)(v5 + (unsigned __int8)a2);
else
v6 = 0;
*a3 = v6;
return (v6 != 0) | (unsigned __int8)(a2 == 0);
}
return result;
}
| my_wc_mb_tis620:
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x0015c7da
PUSH RBP
MOV RBP,RSP
PUSH RBX
MOV RBX,RSI
MOVZX EAX,BH
LEA RCX,[0x4150e0]
MOV RAX,qword ptr [RCX + RAX*0x8]
TEST RAX,RAX
JZ 0x0015c7c4
MOVZX ECX,BL
MOV AL,byte ptr [RAX + RCX*0x1]
JMP 0x0015c7c6
LAB_0015c7c4:
XOR EAX,EAX
LAB_0015c7c6:
MOV byte ptr [RDX],AL
TEST AL,AL
SETNZ AL
TEST RBX,RBX
SETZ CL
OR CL,AL
MOVZX EAX,CL
POP RBX
POP RBP
LAB_0015c7da:
RET
|
ulong my_wc_mb_tis620(int8 param_1,ulong param_2,char *param_3,char *param_4)
{
char cVar1;
ulong uVar2;
uVar2 = 0xffffff9b;
if (param_3 < param_4) {
if (*(long *)(uni_to_cs + (param_2 >> 8 & 0xff) * 8) == 0) {
cVar1 = '\0';
}
else {
cVar1 = *(char *)(*(long *)(uni_to_cs + (param_2 >> 8 & 0xff) * 8) + (param_2 & 0xff));
}
*param_3 = cVar1;
uVar2 = (ulong)(param_2 == 0 || cVar1 != '\0');
}
return uVar2;
}
|
|
5,824 | my_strerror | eloqsql/strings/my_vsnprintf.c | const char* my_strerror(char *buf, size_t len, int nr)
{
char *msg= NULL;
buf[0]= '\0'; /* failsafe */
if (nr <= 0)
{
strmake(buf, (nr == 0 ?
"Internal error/check (Not system error)" :
"Internal error < 0 (Not system error)"),
len-1);
return buf;
}
/*
These (handler-) error messages are shared by perror, as required
by the principle of least surprise.
*/
if ((nr >= HA_ERR_FIRST) && (nr <= HA_ERR_LAST))
{
msg= (char *) handler_error_messages[nr - HA_ERR_FIRST];
strmake(buf, msg, len - 1);
}
else
{
/*
On Windows, do things the Windows way. On a system that supports both
the GNU and the XSI variant, use whichever was configured (GNU); if
this choice is not advertised, use the default (POSIX/XSI). Testing
for __GNUC__ is not sufficient to determine whether this choice exists.
*/
#if defined(_WIN32)
strerror_s(buf, len, nr);
#elif ((defined _POSIX_C_SOURCE && (_POSIX_C_SOURCE >= 200112L)) || \
(defined _XOPEN_SOURCE && (_XOPEN_SOURCE >= 600))) && \
! defined _GNU_SOURCE
strerror_r(nr, buf, len); /* I can build with or without GNU */
#elif defined(__GLIBC__) && defined (_GNU_SOURCE)
char *r= strerror_r(nr, buf, len);
if (r != buf) /* Want to help, GNU? */
strmake(buf, r, len - 1); /* Then don't. */
#else
strerror_r(nr, buf, len);
#endif
}
/*
strerror() return values are implementation-dependent, so let's
be pragmatic.
*/
if (!buf[0])
strmake(buf, "unknown error", len - 1);
return buf;
} | O0 | c | my_strerror:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
cmpl $0x0, -0x1c(%rbp)
jg 0x787ce
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %ecx
leaq 0x6647(%rip), %rsi # 0x7eded
leaq 0x6618(%rip), %rax # 0x7edc5
cmpl $0x0, %ecx
cmoveq %rax, %rsi
movq -0x18(%rbp), %rdx
subq $0x1, %rdx
callq 0x793f0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7886a
cmpl $0x78, -0x1c(%rbp)
jl 0x7880c
cmpl $0xc6, -0x1c(%rbp)
jg 0x7880c
movl -0x1c(%rbp), %eax
subl $0x78, %eax
movslq %eax, %rcx
leaq 0x30ec63(%rip), %rax # 0x387450
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
subq $0x1, %rdx
callq 0x793f0
jmp 0x78841
movl -0x1c(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x240e0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x7883f
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
subq $0x1, %rdx
callq 0x793f0
jmp 0x78841
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x78862
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
subq $0x1, %rdx
leaq 0x65b6(%rip), %rsi # 0x7ee13
callq 0x793f0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_strerror:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_28], 0
mov rax, [rbp+var_10]
mov byte ptr [rax], 0
cmp [rbp+var_1C], 0
jg short loc_787CE
mov rdi, [rbp+var_10]
mov ecx, [rbp+var_1C]
lea rsi, aInternalError0; "Internal error < 0 (Not system error)"
lea rax, aInternalErrorC; "Internal error/check (Not system error)"
cmp ecx, 0
cmovz rsi, rax
mov rdx, [rbp+var_18]
sub rdx, 1
call strmake
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
jmp loc_7886A
loc_787CE:
cmp [rbp+var_1C], 78h ; 'x'
jl short loc_7880C
cmp [rbp+var_1C], 0C6h
jg short loc_7880C
mov eax, [rbp+var_1C]
sub eax, 78h ; 'x'
movsxd rcx, eax
lea rax, handler_error_messages
mov rax, [rax+rcx*8]
mov [rbp+var_28], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_18]
sub rdx, 1
call strmake
jmp short loc_78841
loc_7880C:
mov edi, [rbp+var_1C]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
call _strerror_r
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
cmp rax, [rbp+var_10]
jz short loc_7883F
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_18]
sub rdx, 1
call strmake
loc_7883F:
jmp short $+2
loc_78841:
mov rax, [rbp+var_10]
cmp byte ptr [rax], 0
jnz short loc_78862
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_18]
sub rdx, 1
lea rsi, aUnknownError; "unknown error"
call strmake
loc_78862:
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
loc_7886A:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
| _BYTE * my_strerror(_BYTE *a1, long long a2, int a3)
{
const char *v3; // rsi
long long v5; // [rsp+0h] [rbp-30h]
*a1 = 0;
if ( a3 > 0 )
{
if ( a3 < 120 || a3 > 198 )
{
v5 = strerror_r((unsigned int)a3, a1, a2);
if ( (_BYTE *)v5 != a1 )
strmake(a1, v5, a2 - 1);
}
else
{
strmake(a1, handler_error_messages[a3 - 120], a2 - 1);
}
if ( !*a1 )
strmake(a1, "unknown error", a2 - 1);
return a1;
}
else
{
v3 = "Internal error < 0 (Not system error)";
if ( !a3 )
v3 = "Internal error/check (Not system error)";
strmake(a1, v3, a2 - 1);
return a1;
}
}
| my_strerror:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV qword ptr [RBP + -0x28],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],0x0
CMP dword ptr [RBP + -0x1c],0x0
JG 0x001787ce
MOV RDI,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x1c]
LEA RSI,[0x17eded]
LEA RAX,[0x17edc5]
CMP ECX,0x0
CMOVZ RSI,RAX
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,0x1
CALL 0x001793f0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0017886a
LAB_001787ce:
CMP dword ptr [RBP + -0x1c],0x78
JL 0x0017880c
CMP dword ptr [RBP + -0x1c],0xc6
JG 0x0017880c
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x78
MOVSXD RCX,EAX
LEA RAX,[0x487450]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,0x1
CALL 0x001793f0
JMP 0x00178841
LAB_0017880c:
MOV EDI,dword ptr [RBP + -0x1c]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x001240e0
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x10]
JZ 0x0017883f
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,0x1
CALL 0x001793f0
LAB_0017883f:
JMP 0x00178841
LAB_00178841:
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX],0x0
JNZ 0x00178862
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,0x1
LEA RSI,[0x17ee13]
CALL 0x001793f0
LAB_00178862:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
LAB_0017886a:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
char * my_strerror(char *param_1,size_t param_2,int param_3)
{
char *pcVar1;
*param_1 = '\0';
if (param_3 < 1) {
pcVar1 = "Internal error < 0 (Not system error)";
if (param_3 == 0) {
pcVar1 = "Internal error/check (Not system error)";
}
strmake(param_1,pcVar1,param_2 - 1);
}
else {
if ((param_3 < 0x78) || (0xc6 < param_3)) {
pcVar1 = strerror_r(param_3,param_1,param_2);
if (pcVar1 != param_1) {
strmake(param_1,pcVar1,param_2 - 1);
}
}
else {
strmake(param_1,*(int8 *)(handler_error_messages + (long)(param_3 + -0x78) * 8),
param_2 - 1);
}
if (*param_1 == '\0') {
strmake(param_1,"unknown error",param_2 - 1);
}
}
return param_1;
}
|
|
5,825 | bitmap_is_prefix | eloqsql/mysys/my_bitmap.c | my_bool bitmap_is_prefix(const MY_BITMAP *map, uint prefix_size)
{
uint prefix_mask= last_byte_mask(prefix_size);
uchar *m= (uchar*) map->bitmap;
uchar *end_prefix= m+(prefix_size-1)/8;
uchar *end;
DBUG_ASSERT(m);
DBUG_ASSERT(prefix_size <= map->n_bits);
/* Empty prefix is always true */
if (!prefix_size)
return 1;
while (m < end_prefix)
if (*m++ != 0xff)
return 0;
end= ((uchar*) map->bitmap) + no_bytes_in_map(map) - 1;
if (m == end)
return ((*m & last_byte_mask(map->n_bits)) == prefix_mask);
if (*m != prefix_mask)
return 0;
while (++m < end)
if (*m != 0)
return 0;
return ((*m & last_byte_mask(map->n_bits)) == 0);
} | O0 | c | bitmap_is_prefix:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0xee6d0
movzbl %al, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
shrl $0x3, %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0xee5c0
jmp 0xee5c2
jmp 0xee5c4
cmpl $0x0, -0x14(%rbp)
jne 0xee5d3
movb $0x1, -0x1(%rbp)
jmp 0xee6c6
jmp 0xee5d5
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0xee603
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movzbl (%rax), %eax
cmpl $0xff, %eax
je 0xee601
movb $0x0, -0x1(%rbp)
jmp 0xee6c6
jmp 0xee5d5
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x1c(%rcx), %ecx
addl $0x7, %ecx
shrl $0x3, %ecx
movl %ecx, %ecx
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0xee65e
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %edi
callq 0xee6d0
movb %al, %cl
movl -0x34(%rbp), %eax
movzbl %cl, %ecx
andl %ecx, %eax
cmpl -0x18(%rbp), %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x1(%rbp)
jmp 0xee6c6
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl -0x18(%rbp), %eax
je 0xee670
movb $0x0, -0x1(%rbp)
jmp 0xee6c6
jmp 0xee672
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
cmpq -0x30(%rbp), %rax
jae 0xee698
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
je 0xee696
movb $0x0, -0x1(%rbp)
jmp 0xee6c6
jmp 0xee672
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %edi
callq 0xee6d0
movb %al, %cl
movl -0x38(%rbp), %eax
movzbl %cl, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nop
| bitmap_is_prefix:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov edi, [rbp+var_14]
call last_byte_mask
movzx eax, al
mov [rbp+var_18], eax
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov ecx, [rbp+var_14]
sub ecx, 1
shr ecx, 3
mov ecx, ecx
add rax, rcx
mov [rbp+var_28], rax
jmp short $+2
loc_EE5C0:
jmp short $+2
loc_EE5C2:
jmp short $+2
loc_EE5C4:
cmp [rbp+var_14], 0
jnz short loc_EE5D3
mov [rbp+var_1], 1
jmp loc_EE6C6
loc_EE5D3:
jmp short $+2
loc_EE5D5:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jnb short loc_EE603
mov rax, [rbp+var_20]
mov rcx, rax
add rcx, 1
mov [rbp+var_20], rcx
movzx eax, byte ptr [rax]
cmp eax, 0FFh
jz short loc_EE601
mov [rbp+var_1], 0
jmp loc_EE6C6
loc_EE601:
jmp short loc_EE5D5
loc_EE603:
mov rax, [rbp+var_10]
mov rax, [rax]
mov rcx, [rbp+var_10]
mov ecx, [rcx+1Ch]
add ecx, 7
shr ecx, 3
mov ecx, ecx
add rax, rcx
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_30], rax
mov rax, [rbp+var_20]
cmp rax, [rbp+var_30]
jnz short loc_EE65E
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
mov [rbp+var_34], eax
mov rax, [rbp+var_10]
mov edi, [rax+1Ch]
call last_byte_mask
mov cl, al
mov eax, [rbp+var_34]
movzx ecx, cl
and eax, ecx
cmp eax, [rbp+var_18]
setz al
and al, 1
movzx eax, al
mov [rbp+var_1], al
jmp short loc_EE6C6
loc_EE65E:
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
cmp eax, [rbp+var_18]
jz short loc_EE670
mov [rbp+var_1], 0
jmp short loc_EE6C6
loc_EE670:
jmp short $+2
loc_EE672:
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
cmp rax, [rbp+var_30]
jnb short loc_EE698
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
cmp eax, 0
jz short loc_EE696
mov [rbp+var_1], 0
jmp short loc_EE6C6
loc_EE696:
jmp short loc_EE672
loc_EE698:
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
mov [rbp+var_38], eax
mov rax, [rbp+var_10]
mov edi, [rax+1Ch]
call last_byte_mask
mov cl, al
mov eax, [rbp+var_38]
movzx ecx, cl
and eax, ecx
cmp eax, 0
setz al
and al, 1
movzx eax, al
mov [rbp+var_1], al
loc_EE6C6:
mov al, [rbp+var_1]
add rsp, 40h
pop rbp
retn
| char bitmap_is_prefix(unsigned __int8 **a1, unsigned int a2)
{
unsigned __int8 *v2; // rax
unsigned __int8 v4; // [rsp+8h] [rbp-38h]
unsigned __int8 v5; // [rsp+Ch] [rbp-34h]
unsigned long long v6; // [rsp+10h] [rbp-30h]
unsigned __int8 *v7; // [rsp+20h] [rbp-20h]
int byte_mask; // [rsp+28h] [rbp-18h]
byte_mask = (unsigned __int8)last_byte_mask(a2);
v7 = *a1;
if ( !a2 )
return 1;
while ( v7 < &(*a1)[(a2 - 1) >> 3] )
{
v2 = v7++;
if ( *v2 != 255 )
return 0;
}
v6 = (unsigned long long)&(*a1)[((unsigned int)(*((_DWORD *)a1 + 7) + 7) >> 3) - 1];
if ( v7 == (unsigned __int8 *)v6 )
{
v5 = *v7;
return (unsigned __int8)(last_byte_mask(*((unsigned int *)a1 + 7)) & v5) == byte_mask;
}
else if ( *v7 == byte_mask )
{
while ( (unsigned long long)++v7 < v6 )
{
if ( *v7 )
return 0;
}
v4 = *v7;
return (unsigned __int8)(last_byte_mask(*((unsigned int *)a1 + 7)) & v4) == 0;
}
else
{
return 0;
}
}
| bitmap_is_prefix:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV EDI,dword ptr [RBP + -0x14]
CALL 0x001ee6d0
MOVZX EAX,AL
MOV dword ptr [RBP + -0x18],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x14]
SUB ECX,0x1
SHR ECX,0x3
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001ee5c0
LAB_001ee5c0:
JMP 0x001ee5c2
LAB_001ee5c2:
JMP 0x001ee5c4
LAB_001ee5c4:
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x001ee5d3
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001ee6c6
LAB_001ee5d3:
JMP 0x001ee5d5
LAB_001ee5d5:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JNC 0x001ee603
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x20],RCX
MOVZX EAX,byte ptr [RAX]
CMP EAX,0xff
JZ 0x001ee601
MOV byte ptr [RBP + -0x1],0x0
JMP 0x001ee6c6
LAB_001ee601:
JMP 0x001ee5d5
LAB_001ee603:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0x1c]
ADD ECX,0x7
SHR ECX,0x3
MOV ECX,ECX
ADD RAX,RCX
ADD RAX,-0x1
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001ee65e
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x34],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EDI,dword ptr [RAX + 0x1c]
CALL 0x001ee6d0
MOV CL,AL
MOV EAX,dword ptr [RBP + -0x34]
MOVZX ECX,CL
AND EAX,ECX
CMP EAX,dword ptr [RBP + -0x18]
SETZ AL
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x1],AL
JMP 0x001ee6c6
LAB_001ee65e:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
CMP EAX,dword ptr [RBP + -0x18]
JZ 0x001ee670
MOV byte ptr [RBP + -0x1],0x0
JMP 0x001ee6c6
LAB_001ee670:
JMP 0x001ee672
LAB_001ee672:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x001ee698
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x0
JZ 0x001ee696
MOV byte ptr [RBP + -0x1],0x0
JMP 0x001ee6c6
LAB_001ee696:
JMP 0x001ee672
LAB_001ee698:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x38],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EDI,dword ptr [RAX + 0x1c]
CALL 0x001ee6d0
MOV CL,AL
MOV EAX,dword ptr [RBP + -0x38]
MOVZX ECX,CL
AND EAX,ECX
CMP EAX,0x0
SETZ AL
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x1],AL
LAB_001ee6c6:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x40
POP RBP
RET
|
int8 bitmap_is_prefix(long *param_1,int param_2)
{
byte bVar1;
byte bVar2;
byte bVar3;
byte *pbVar4;
byte *pbVar5;
byte *local_28;
bool local_9;
bVar1 = last_byte_mask(param_2);
pbVar4 = (byte *)*param_1 + (param_2 - 1U >> 3);
local_28 = (byte *)*param_1;
if (param_2 == 0) {
local_9 = true;
pbVar5 = pbVar4;
}
else {
do {
if (pbVar4 <= local_28) {
pbVar4 = (byte *)(*param_1 + (ulong)(*(int *)((long)param_1 + 0x1c) + 7U >> 3) + -1);
if (local_28 == pbVar4) {
bVar3 = *local_28;
bVar2 = last_byte_mask(*(int4 *)((long)param_1 + 0x1c));
local_9 = (bVar3 & bVar2) == bVar1;
pbVar5 = (byte *)0x0;
goto LAB_001ee6c6;
}
pbVar5 = (byte *)0x0;
if (*local_28 == bVar1) goto LAB_001ee672;
local_9 = false;
goto LAB_001ee6c6;
}
bVar3 = *local_28;
pbVar5 = (byte *)0x0;
local_28 = local_28 + 1;
} while (bVar3 == 0xff);
local_9 = false;
}
goto LAB_001ee6c6;
while (pbVar5 = (byte *)0x0, *local_28 == 0) {
LAB_001ee672:
local_28 = local_28 + 1;
if (pbVar4 <= local_28) {
bVar1 = *local_28;
bVar3 = last_byte_mask(*(int4 *)((long)param_1 + 0x1c));
local_9 = (bVar1 & bVar3) == 0;
pbVar5 = (byte *)0x0;
goto LAB_001ee6c6;
}
}
local_9 = false;
LAB_001ee6c6:
return CONCAT71((int7)((ulong)pbVar5 >> 8),local_9);
}
|
|
5,826 | my_strcasecmp_utf8mb3 | eloqsql/strings/ctype-utf8.c | static
int my_strcasecmp_utf8mb3(CHARSET_INFO *cs, const char *s, const char *t)
{
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
while (s[0] && t[0])
{
my_wc_t s_wc,t_wc;
if ((uchar) s[0] < 128)
{
/*
s[0] is between 0 and 127.
It represents a single byte character.
Convert it into weight according to collation.
*/
s_wc= my_unicase_default_page00[(uchar) s[0]].tolower;
s++;
}
else
{
int res;
/*
Scan a multibyte character.
In the future it is worth to write a special version of my_utf8mb3_uni()
for 0-terminated strings which will not take in account length. Now
we call the regular version of my_utf8mb3_uni() with s+3 in the
last argument. s+3 is enough to scan any multibyte sequence.
Calling the regular version of my_utf8mb3_uni is safe for 0-terminated
strings: we will never lose the end of the string:
If we have 0 character in the middle of a multibyte sequence,
then my_utf8mb3_uni will always return a negative number, so the
loop with finish.
*/
res= my_utf8mb3_uni(cs,&s_wc, (const uchar*)s, (const uchar*) s + 3);
/*
In the case of wrong multibyte sequence we will
call strcmp() for byte-to-byte comparison.
*/
if (res <= 0)
return strcmp(s, t);
s+= res;
/* Convert Unicode code into weight according to collation */
my_tolower_utf8mb3(uni_plane, &s_wc);
}
/* Do the same for the second string */
if ((uchar) t[0] < 128)
{
/* Convert single byte character into weight */
t_wc= my_unicase_default_page00[(uchar) t[0]].tolower;
t++;
}
else
{
int res=my_utf8mb3_uni(cs,&t_wc, (const uchar*)t, (const uchar*) t + 3);
if (res <= 0)
return strcmp(s, t);
t+= res;
/* Convert code into weight */
my_tolower_utf8mb3(uni_plane, &t_wc);
}
/* Now we have two weights, let's compare them */
if ( s_wc != t_wc )
return ((int) s_wc) - ((int) t_wc);
}
return ((int)(uchar)s[0]) - ((int) (uchar) t[0]);
} | O0 | c | my_strcasecmp_utf8mb3:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x41(%rbp)
je 0xc56b1
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0xc56bd
jmp 0xc57f6
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x80, %eax
jge 0xc56f7
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x306725(%rip), %rax # 0x3cbe00
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xc574c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x18(%rbp), %rcx
addq $0x3, %rcx
leaq -0x30(%rbp), %rsi
callq 0xc3d40
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jg 0xc572e
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x28490
movl %eax, -0x4(%rbp)
jmp 0xc5809
movl -0x3c(%rbp), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xc5010
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x80, %eax
jge 0xc5786
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x306696(%rip), %rax # 0x3cbe00
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xc57d8
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x20(%rbp), %rcx
addq $0x3, %rcx
leaq -0x38(%rbp), %rsi
callq 0xc3d40
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x40(%rbp)
jg 0xc57ba
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x28490
movl %eax, -0x4(%rbp)
jmp 0xc5809
movl -0x40(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xc5010
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0xc57f1
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xc5809
jmp 0xc5690
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movq -0x20(%rbp), %rcx
movzbl (%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_strcasecmp_utf8mb3:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
mov rax, [rax+78h]
mov [rbp+var_28], rax
loc_C5690:
mov rax, [rbp+var_18]
movsx ecx, byte ptr [rax]
xor eax, eax
cmp ecx, 0
mov [rbp+var_41], al
jz short loc_C56B1
mov rax, [rbp+var_20]
movsx eax, byte ptr [rax]
cmp eax, 0
setnz al
mov [rbp+var_41], al
loc_C56B1:
mov al, [rbp+var_41]
test al, 1
jnz short loc_C56BD
jmp loc_C57F6
loc_C56BD:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
cmp eax, 80h
jge short loc_C56F7
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
mov ecx, eax
lea rax, my_unicase_default_page00
imul rcx, 0Ch
add rax, rcx
mov eax, [rax+4]
mov [rbp+var_30], rax
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_C574C
loc_C56F7:
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_18]
add rcx, 3
lea rsi, [rbp+var_30]
call my_utf8mb3_uni
mov [rbp+var_3C], eax
cmp [rbp+var_3C], 0
jg short loc_C572E
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
call _strcmp
mov [rbp+var_4], eax
jmp loc_C5809
loc_C572E:
mov ecx, [rbp+var_3C]
mov rax, [rbp+var_18]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_18], rax
mov rdi, [rbp+var_28]
lea rsi, [rbp+var_30]
call my_tolower_utf8mb3
loc_C574C:
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
cmp eax, 80h
jge short loc_C5786
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
mov ecx, eax
lea rax, my_unicase_default_page00
imul rcx, 0Ch
add rax, rcx
mov eax, [rax+4]
mov [rbp+var_38], rax
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
jmp short loc_C57D8
loc_C5786:
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_20]
add rcx, 3
lea rsi, [rbp+var_38]
call my_utf8mb3_uni
mov [rbp+var_40], eax
cmp [rbp+var_40], 0
jg short loc_C57BA
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
call _strcmp
mov [rbp+var_4], eax
jmp short loc_C5809
loc_C57BA:
mov ecx, [rbp+var_40]
mov rax, [rbp+var_20]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_20], rax
mov rdi, [rbp+var_28]
lea rsi, [rbp+var_38]
call my_tolower_utf8mb3
loc_C57D8:
mov rax, [rbp+var_30]
cmp rax, [rbp+var_38]
jz short loc_C57F1
mov rax, [rbp+var_30]
mov rcx, [rbp+var_38]
sub eax, ecx
mov [rbp+var_4], eax
jmp short loc_C5809
loc_C57F1:
jmp loc_C5690
loc_C57F6:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_20]
movzx ecx, byte ptr [rcx]
sub eax, ecx
mov [rbp+var_4], eax
loc_C5809:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
| long long my_strcasecmp_utf8mb3(long long a1, _BYTE *a2, _BYTE *a3, long long a4, long long a5, long long a6)
{
bool v7; // [rsp+Fh] [rbp-41h]
int v8; // [rsp+10h] [rbp-40h]
int v9; // [rsp+14h] [rbp-3Ch]
long long v10; // [rsp+18h] [rbp-38h] BYREF
long long v11; // [rsp+20h] [rbp-30h] BYREF
long long v12; // [rsp+28h] [rbp-28h]
_BYTE *v13; // [rsp+30h] [rbp-20h]
_BYTE *v14; // [rsp+38h] [rbp-18h]
long long v15; // [rsp+40h] [rbp-10h]
v15 = a1;
v14 = a2;
v13 = a3;
v12 = *(_QWORD *)(a1 + 120);
while ( 1 )
{
v7 = 0;
if ( *v14 )
v7 = *v13 != 0;
if ( !v7 )
break;
if ( (unsigned __int8)*v14 >= 0x80u )
{
v9 = my_utf8mb3_uni(v15, (long long)&v11, (long long)v14, (long long)(v14 + 3), a5, a6);
if ( v9 <= 0 )
return (unsigned int)strcmp(v14, v13);
v14 += v9;
my_tolower_utf8mb3(v12, &v11);
}
else
{
v11 = my_unicase_default_page00[3 * (unsigned __int8)*v14++ + 1];
}
if ( (unsigned __int8)*v13 >= 0x80u )
{
v8 = my_utf8mb3_uni(v15, (long long)&v10, (long long)v13, (long long)(v13 + 3), a5, a6);
if ( v8 <= 0 )
return (unsigned int)strcmp(v14, v13);
v13 += v8;
my_tolower_utf8mb3(v12, &v10);
}
else
{
v10 = my_unicase_default_page00[3 * (unsigned __int8)*v13++ + 1];
}
if ( v11 != v10 )
return (unsigned int)(v11 - v10);
}
return (unsigned int)((unsigned __int8)*v14 - (unsigned __int8)*v13);
}
| my_strcasecmp_utf8mb3:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x78]
MOV qword ptr [RBP + -0x28],RAX
LAB_001c5690:
MOV RAX,qword ptr [RBP + -0x18]
MOVSX ECX,byte ptr [RAX]
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0x41],AL
JZ 0x001c56b1
MOV RAX,qword ptr [RBP + -0x20]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x41],AL
LAB_001c56b1:
MOV AL,byte ptr [RBP + -0x41]
TEST AL,0x1
JNZ 0x001c56bd
JMP 0x001c57f6
LAB_001c56bd:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x80
JGE 0x001c56f7
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
MOV ECX,EAX
LEA RAX,[0x4cbe00]
IMUL RCX,RCX,0xc
ADD RAX,RCX
MOV EAX,dword ptr [RAX + 0x4]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001c574c
LAB_001c56f7:
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x18]
ADD RCX,0x3
LEA RSI,[RBP + -0x30]
CALL 0x001c3d40
MOV dword ptr [RBP + -0x3c],EAX
CMP dword ptr [RBP + -0x3c],0x0
JG 0x001c572e
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00128490
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001c5809
LAB_001c572e:
MOV ECX,dword ptr [RBP + -0x3c]
MOV RAX,qword ptr [RBP + -0x18]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
MOV RDI,qword ptr [RBP + -0x28]
LEA RSI,[RBP + -0x30]
CALL 0x001c5010
LAB_001c574c:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x80
JGE 0x001c5786
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
MOV ECX,EAX
LEA RAX,[0x4cbe00]
IMUL RCX,RCX,0xc
ADD RAX,RCX
MOV EAX,dword ptr [RAX + 0x4]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001c57d8
LAB_001c5786:
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x20]
ADD RCX,0x3
LEA RSI,[RBP + -0x38]
CALL 0x001c3d40
MOV dword ptr [RBP + -0x40],EAX
CMP dword ptr [RBP + -0x40],0x0
JG 0x001c57ba
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00128490
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001c5809
LAB_001c57ba:
MOV ECX,dword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x28]
LEA RSI,[RBP + -0x38]
CALL 0x001c5010
LAB_001c57d8:
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x38]
JZ 0x001c57f1
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x38]
SUB EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001c5809
LAB_001c57f1:
JMP 0x001c5690
LAB_001c57f6:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RCX]
SUB EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
LAB_001c5809:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
int my_strcasecmp_utf8mb3(long param_1,byte *param_2,byte *param_3)
{
int iVar1;
bool bVar2;
ulong local_40;
ulong local_38;
int8 local_30;
byte *local_28;
byte *local_20;
long local_18;
local_30 = *(int8 *)(param_1 + 0x78);
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
do {
bVar2 = false;
if (*local_20 != 0) {
bVar2 = *local_28 != 0;
}
if (!bVar2) {
return (uint)*local_20 - (uint)*local_28;
}
if (*local_20 < 0x80) {
local_38 = (ulong)*(uint *)(my_unicase_default_page00 + (ulong)*local_20 * 0xc + 4);
local_20 = local_20 + 1;
}
else {
iVar1 = my_utf8mb3_uni(local_18,&local_38,local_20,local_20 + 3);
if (iVar1 < 1) {
iVar1 = strcmp((char *)local_20,(char *)local_28);
return iVar1;
}
local_20 = local_20 + iVar1;
my_tolower_utf8mb3(local_30,&local_38);
}
if (*local_28 < 0x80) {
local_40 = (ulong)*(uint *)(my_unicase_default_page00 + (ulong)*local_28 * 0xc + 4);
local_28 = local_28 + 1;
}
else {
iVar1 = my_utf8mb3_uni(local_18,&local_40,local_28,local_28 + 3);
if (iVar1 < 1) {
iVar1 = strcmp((char *)local_20,(char *)local_28);
return iVar1;
}
local_28 = local_28 + iVar1;
my_tolower_utf8mb3(local_30,&local_40);
}
} while (local_38 == local_40);
return (int)local_38 - (int)local_40;
}
|
|
5,827 | alloc_root | eloqsql/mysys/my_alloc.c | void *alloc_root(MEM_ROOT *mem_root, size_t length)
{
#if defined(HAVE_valgrind) && defined(EXTRA_DEBUG)
reg1 USED_MEM *next;
DBUG_ENTER("alloc_root");
DBUG_PRINT("enter",("root: %p", mem_root));
DBUG_ASSERT(alloc_root_inited(mem_root));
DBUG_EXECUTE_IF("simulate_out_of_memory",
{
if (mem_root->error_handler)
(*mem_root->error_handler)();
DBUG_SET("-d,simulate_out_of_memory");
DBUG_RETURN((void*) 0); /* purecov: inspected */
});
length+=ALIGN_SIZE(sizeof(USED_MEM));
if (!(next = (USED_MEM*) my_malloc(mem_root->m_psi_key, length,
MYF(MY_WME | ME_FATAL |
MALLOC_FLAG(mem_root->block_size)))))
{
if (mem_root->error_handler)
(*mem_root->error_handler)();
DBUG_RETURN((uchar*) 0); /* purecov: inspected */
}
next->next= mem_root->used;
next->left= 0;
next->size= length;
mem_root->used= next;
DBUG_PRINT("exit",("ptr: %p", (((char*)next)+ALIGN_SIZE(sizeof(USED_MEM)))));
DBUG_RETURN((((uchar*) next)+ALIGN_SIZE(sizeof(USED_MEM))));
#else
size_t get_size, block_size;
uchar* point;
reg1 USED_MEM *next= 0;
reg2 USED_MEM **prev;
size_t original_length __attribute__((unused)) = length;
DBUG_ENTER("alloc_root");
DBUG_PRINT("enter",("root: %p", mem_root));
DBUG_ASSERT(alloc_root_inited(mem_root));
DBUG_EXECUTE_IF("simulate_out_of_memory",
{
/* Avoid reusing an already allocated block */
if (mem_root->error_handler)
(*mem_root->error_handler)();
DBUG_SET("-d,simulate_out_of_memory");
DBUG_RETURN((void*) 0); /* purecov: inspected */
});
length= ALIGN_SIZE(length) + REDZONE_SIZE;
if ((*(prev= &mem_root->free)) != NULL)
{
if ((*prev)->left < length &&
mem_root->first_block_usage++ >= ALLOC_MAX_BLOCK_USAGE_BEFORE_DROP &&
(*prev)->left < ALLOC_MAX_BLOCK_TO_DROP)
{
next= *prev;
*prev= next->next; /* Remove block from list */
next->next= mem_root->used;
mem_root->used= next;
mem_root->first_block_usage= 0;
}
for (next= *prev ; next && next->left < length ; next= next->next)
prev= &next->next;
}
if (! next)
{ /* Time to alloc new block */
block_size= (mem_root->block_size & ~1) * (mem_root->block_num >> 2);
get_size= length+ALIGN_SIZE(sizeof(USED_MEM));
get_size= MY_MAX(get_size, block_size);
if (!(next = (USED_MEM*) my_malloc(mem_root->m_psi_key, get_size,
MYF(MY_WME | ME_FATAL |
MALLOC_FLAG(mem_root->
block_size)))))
{
if (mem_root->error_handler)
(*mem_root->error_handler)();
DBUG_RETURN((void*) 0); /* purecov: inspected */
}
mem_root->block_num++;
next->next= *prev;
next->size= get_size;
next->left= get_size-ALIGN_SIZE(sizeof(USED_MEM));
*prev=next;
TRASH_MEM(next);
}
point= (uchar*) ((char*) next+ (next->size-next->left));
/*TODO: next part may be unneded due to mem_root->first_block_usage counter*/
if ((next->left-= length) < mem_root->min_malloc)
{ /* Full block */
*prev= next->next; /* Remove block from list */
next->next= mem_root->used;
mem_root->used= next;
mem_root->first_block_usage= 0;
}
point+= REDZONE_SIZE;
TRASH_ALLOC(point, original_length);
DBUG_PRINT("exit",("ptr: %p", point));
DBUG_RETURN((void*) point);
#endif
} | O3 | c | alloc_root:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
addq $0x7, %r14
andq $-0x8, %r14
movq (%rdi), %rax
movq %rdi, %r12
testq %rax, %rax
je 0x9cd0e
cmpq %r14, 0x8(%rax)
jae 0x9ccf5
movl 0x2c(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x2c(%rbx)
cmpl $0xa, %ecx
jb 0x9ccf5
cmpq $0xfff, 0x8(%rax) # imm = 0xFFF
ja 0x9ccf5
movq (%rax), %rcx
movq %rcx, (%rbx)
movq 0x8(%rbx), %rcx
movq %rcx, (%rax)
movq %rax, 0x8(%rbx)
movl $0x0, 0x2c(%rbx)
movq %rbx, %rax
movq %rax, %r12
movq (%rax), %rax
testq %rax, %rax
je 0x9cd0e
movq 0x8(%rax), %rdx
cmpq %r14, %rdx
jb 0x9ccf8
jmp 0x9cd6b
movq 0x20(%rbx), %rdx
movq %rdx, %rax
andq $-0x2, %rax
movl 0x28(%rbx), %r15d
shrl $0x2, %r15d
imulq %rax, %r15
leaq 0x18(%r14), %rax
cmpq %r15, %rax
cmovaq %rax, %r15
movl 0x38(%rbx), %edi
andl $0x1, %edx
shll $0x10, %edx
orq $0x1010, %rdx # imm = 0x1010
movq %r15, %rsi
callq 0x9fdb1
testq %rax, %rax
je 0x9cd9d
incl 0x28(%rbx)
movq (%r12), %rcx
movq %rcx, (%rax)
movq %r15, 0x10(%rax)
addq $-0x18, %r15
movq %r15, 0x8(%rax)
movq %rax, (%r12)
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rcx
subq %rdx, %rcx
addq %rax, %rcx
subq %r14, %rdx
movq %rdx, 0x8(%rax)
cmpq 0x18(%rbx), %rdx
jae 0x9cdaa
movq (%rax), %rdx
movq %rdx, (%r12)
movq 0x8(%rbx), %rdx
movq %rdx, (%rax)
movq %rax, 0x8(%rbx)
movl $0x0, 0x2c(%rbx)
jmp 0x9cdaa
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x9cda8
callq *%rax
xorl %ecx, %ecx
movq %rcx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| alloc_root:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r14, rsi
mov rbx, rdi
add r14, 7
and r14, 0FFFFFFFFFFFFFFF8h
mov rax, [rdi]
mov r12, rdi
test rax, rax
jz short loc_9CD0E
cmp [rax+8], r14
jnb short loc_9CCF5
mov ecx, [rbx+2Ch]
lea edx, [rcx+1]
mov [rbx+2Ch], edx
cmp ecx, 0Ah
jb short loc_9CCF5
cmp qword ptr [rax+8], 0FFFh
ja short loc_9CCF5
mov rcx, [rax]
mov [rbx], rcx
mov rcx, [rbx+8]
mov [rax], rcx
mov [rbx+8], rax
mov dword ptr [rbx+2Ch], 0
loc_9CCF5:
mov rax, rbx
loc_9CCF8:
mov r12, rax
mov rax, [rax]
test rax, rax
jz short loc_9CD0E
mov rdx, [rax+8]
cmp rdx, r14
jb short loc_9CCF8
jmp short loc_9CD6B
loc_9CD0E:
mov rdx, [rbx+20h]
mov rax, rdx
and rax, 0FFFFFFFFFFFFFFFEh
mov r15d, [rbx+28h]
shr r15d, 2
imul r15, rax
lea rax, [r14+18h]
cmp rax, r15
cmova r15, rax
mov edi, [rbx+38h]
and edx, 1
shl edx, 10h
or rdx, 1010h
mov rsi, r15
call my_malloc
test rax, rax
jz short loc_9CD9D
inc dword ptr [rbx+28h]
mov rcx, [r12]
mov [rax], rcx
mov [rax+10h], r15
add r15, 0FFFFFFFFFFFFFFE8h
mov [rax+8], r15
mov [r12], rax
mov rdx, [rax+8]
loc_9CD6B:
mov rcx, [rax+10h]
sub rcx, rdx
add rcx, rax
sub rdx, r14
mov [rax+8], rdx
cmp rdx, [rbx+18h]
jnb short loc_9CDAA
mov rdx, [rax]
mov [r12], rdx
mov rdx, [rbx+8]
mov [rax], rdx
mov [rbx+8], rax
mov dword ptr [rbx+2Ch], 0
jmp short loc_9CDAA
loc_9CD9D:
mov rax, [rbx+30h]
test rax, rax
jz short loc_9CDA8
call rax
loc_9CDA8:
xor ecx, ecx
loc_9CDAA:
mov rax, rcx
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| char * alloc_root(long long a1, long long a2)
{
unsigned long long v2; // r14
_QWORD *v3; // rax
_QWORD *v4; // r12
unsigned int v5; // ecx
_QWORD *v6; // rax
unsigned long long v7; // rdx
long long v8; // rdx
unsigned long long v9; // r15
char *v10; // rcx
unsigned long long v11; // rdx
void (*v12)(void); // rax
v2 = (a2 + 7) & 0xFFFFFFFFFFFFFFF8LL;
v3 = *(_QWORD **)a1;
v4 = (_QWORD *)a1;
if ( *(_QWORD *)a1 )
{
if ( v3[1] < v2 )
{
v5 = *(_DWORD *)(a1 + 44);
*(_DWORD *)(a1 + 44) = v5 + 1;
if ( v5 >= 0xA && v3[1] <= 0xFFFuLL )
{
*(_QWORD *)a1 = *v3;
*v3 = *(_QWORD *)(a1 + 8);
*(_QWORD *)(a1 + 8) = v3;
*(_DWORD *)(a1 + 44) = 0;
}
}
v6 = (_QWORD *)a1;
while ( 1 )
{
v4 = v6;
v6 = (_QWORD *)*v6;
if ( !v6 )
break;
v7 = v6[1];
if ( v7 >= v2 )
goto LABEL_14;
}
}
v8 = *(_QWORD *)(a1 + 32);
v9 = (v8 & 0xFFFFFFFFFFFFFFFELL) * (*(_DWORD *)(a1 + 40) >> 2);
if ( v2 + 24 > v9 )
v9 = v2 + 24;
v6 = (_QWORD *)my_malloc(*(unsigned int *)(a1 + 56), v9, ((unsigned __int8)(v8 & 1) << 16) | 0x1010LL);
if ( v6 )
{
++*(_DWORD *)(a1 + 40);
*v6 = *v4;
v6[2] = v9;
v6[1] = v9 - 24;
*v4 = v6;
v7 = v6[1];
LABEL_14:
v10 = (char *)v6 + v6[2] - v7;
v11 = v7 - v2;
v6[1] = v11;
if ( v11 < *(_QWORD *)(a1 + 24) )
{
*v4 = *v6;
*v6 = *(_QWORD *)(a1 + 8);
*(_QWORD *)(a1 + 8) = v6;
*(_DWORD *)(a1 + 44) = 0;
}
}
else
{
v12 = *(void (**)(void))(a1 + 48);
if ( v12 )
v12();
return 0LL;
}
return v10;
}
| alloc_root:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
ADD R14,0x7
AND R14,-0x8
MOV RAX,qword ptr [RDI]
MOV R12,RDI
TEST RAX,RAX
JZ 0x0019cd0e
CMP qword ptr [RAX + 0x8],R14
JNC 0x0019ccf5
MOV ECX,dword ptr [RBX + 0x2c]
LEA EDX,[RCX + 0x1]
MOV dword ptr [RBX + 0x2c],EDX
CMP ECX,0xa
JC 0x0019ccf5
CMP qword ptr [RAX + 0x8],0xfff
JA 0x0019ccf5
MOV RCX,qword ptr [RAX]
MOV qword ptr [RBX],RCX
MOV RCX,qword ptr [RBX + 0x8]
MOV qword ptr [RAX],RCX
MOV qword ptr [RBX + 0x8],RAX
MOV dword ptr [RBX + 0x2c],0x0
LAB_0019ccf5:
MOV RAX,RBX
LAB_0019ccf8:
MOV R12,RAX
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x0019cd0e
MOV RDX,qword ptr [RAX + 0x8]
CMP RDX,R14
JC 0x0019ccf8
JMP 0x0019cd6b
LAB_0019cd0e:
MOV RDX,qword ptr [RBX + 0x20]
MOV RAX,RDX
AND RAX,-0x2
MOV R15D,dword ptr [RBX + 0x28]
SHR R15D,0x2
IMUL R15,RAX
LEA RAX,[R14 + 0x18]
CMP RAX,R15
CMOVA R15,RAX
MOV EDI,dword ptr [RBX + 0x38]
AND EDX,0x1
SHL EDX,0x10
OR RDX,0x1010
MOV RSI,R15
CALL 0x0019fdb1
TEST RAX,RAX
JZ 0x0019cd9d
INC dword ptr [RBX + 0x28]
MOV RCX,qword ptr [R12]
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x10],R15
ADD R15,-0x18
MOV qword ptr [RAX + 0x8],R15
MOV qword ptr [R12],RAX
MOV RDX,qword ptr [RAX + 0x8]
LAB_0019cd6b:
MOV RCX,qword ptr [RAX + 0x10]
SUB RCX,RDX
ADD RCX,RAX
SUB RDX,R14
MOV qword ptr [RAX + 0x8],RDX
CMP RDX,qword ptr [RBX + 0x18]
JNC 0x0019cdaa
MOV RDX,qword ptr [RAX]
MOV qword ptr [R12],RDX
MOV RDX,qword ptr [RBX + 0x8]
MOV qword ptr [RAX],RDX
MOV qword ptr [RBX + 0x8],RAX
MOV dword ptr [RBX + 0x2c],0x0
JMP 0x0019cdaa
LAB_0019cd9d:
MOV RAX,qword ptr [RBX + 0x30]
TEST RAX,RAX
JZ 0x0019cda8
CALL RAX
LAB_0019cda8:
XOR ECX,ECX
LAB_0019cdaa:
MOV RAX,RCX
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
long alloc_root(long *param_1,long param_2)
{
uint uVar1;
long *plVar2;
long lVar3;
long *plVar4;
long *plVar5;
ulong uVar6;
ulong uVar7;
uVar6 = param_2 + 7U & 0xfffffffffffffff8;
plVar2 = (long *)*param_1;
plVar5 = param_1;
if (plVar2 == (long *)0x0) {
LAB_0019cd0e:
uVar7 = (ulong)(*(uint *)(param_1 + 5) >> 2) * (param_1[4] & 0xfffffffffffffffeU);
if (uVar7 < uVar6 + 0x18) {
uVar7 = uVar6 + 0x18;
}
plVar4 = (long *)my_malloc((int)param_1[7],uVar7,((uint)param_1[4] & 1) << 0x10 | 0x1010);
if (plVar4 == (long *)0x0) {
if ((code *)param_1[6] != (code *)0x0) {
(*(code *)param_1[6])();
}
return 0;
}
*(int *)(param_1 + 5) = (int)param_1[5] + 1;
*plVar4 = *plVar5;
plVar4[2] = uVar7;
plVar4[1] = uVar7 - 0x18;
*plVar5 = (long)plVar4;
uVar7 = plVar4[1];
}
else {
plVar4 = param_1;
if ((((ulong)plVar2[1] < uVar6) &&
(uVar1 = *(uint *)((long)param_1 + 0x2c), *(uint *)((long)param_1 + 0x2c) = uVar1 + 1,
9 < uVar1)) && ((ulong)plVar2[1] < 0x1000)) {
*param_1 = *plVar2;
*plVar2 = param_1[1];
param_1[1] = (long)plVar2;
*(int4 *)((long)param_1 + 0x2c) = 0;
}
do {
plVar5 = plVar4;
plVar4 = (long *)*plVar5;
if (plVar4 == (long *)0x0) goto LAB_0019cd0e;
uVar7 = plVar4[1];
} while (uVar7 < uVar6);
}
lVar3 = plVar4[2];
plVar4[1] = uVar7 - uVar6;
if (uVar7 - uVar6 < (ulong)param_1[3]) {
*plVar5 = *plVar4;
*plVar4 = param_1[1];
param_1[1] = (long)plVar4;
*(int4 *)((long)param_1 + 0x2c) = 0;
}
return (lVar3 - uVar7) + (long)plVar4;
}
|
|
5,828 | build_select_string | eloqsql/client/mysqlslap.c | static statement *
build_select_string(my_bool key)
{
char buf[HUGE_STRING_LENGTH];
unsigned int col_count;
statement *ptr;
static DYNAMIC_STRING query_string;
DBUG_ENTER("build_select_string");
init_dynamic_string(&query_string, "", 1024, 1024);
dynstr_append_mem(&query_string, "SELECT ", 7);
for (col_count= 1; col_count <= num_int_cols; col_count++)
{
if (snprintf(buf, HUGE_STRING_LENGTH, "intcol%d", col_count)
> HUGE_STRING_LENGTH)
{
fprintf(stderr, "Memory Allocation error in creating select\n");
exit(1);
}
dynstr_append(&query_string, buf);
if (col_count < num_int_cols || num_char_cols > 0)
dynstr_append_mem(&query_string, ",", 1);
}
for (col_count= 1; col_count <= num_char_cols; col_count++)
{
if (snprintf(buf, HUGE_STRING_LENGTH, "charcol%d", col_count)
> HUGE_STRING_LENGTH)
{
fprintf(stderr, "Memory Allocation error in creating select\n");
exit(1);
}
dynstr_append(&query_string, buf);
if (col_count < num_char_cols)
dynstr_append_mem(&query_string, ",", 1);
}
dynstr_append(&query_string, " FROM t1");
if ((key) &&
(auto_generate_sql_autoincrement || auto_generate_sql_guid_primary))
dynstr_append(&query_string, " WHERE id = ");
ptr= (statement *)my_malloc(PSI_NOT_INSTRUMENTED, sizeof(statement),
MYF(MY_ZEROFILL|MY_FAE|MY_WME));
ptr->string= (char *)my_malloc(PSI_NOT_INSTRUMENTED, query_string.length + 1,
MYF(MY_ZEROFILL|MY_FAE|MY_WME));
ptr->length= query_string.length+1;
if ((key) &&
(auto_generate_sql_autoincrement || auto_generate_sql_guid_primary))
ptr->type= SELECT_TYPE_REQUIRES_PREFIX;
else
ptr->type= SELECT_TYPE;
strmov(ptr->string, query_string.str);
dynstr_free(&query_string);
DBUG_RETURN(ptr);
} | O0 | c | build_select_string:
pushq %rbp
movq %rsp, %rbp
subq $0x2030, %rsp # imm = 0x2030
movb %dil, %al
movq %fs:0x28, %rcx
movq %rcx, -0x8(%rbp)
movb %al, -0x2011(%rbp)
leaq 0x3b3360(%rip), %rdi # 0x3ef6b8
leaq 0x98947(%rip), %rsi # 0xd4ca6
movl $0x400, %ecx # imm = 0x400
movq %rcx, %rdx
callq 0x82510
leaq 0x3b3345(%rip), %rdi # 0x3ef6b8
leaq 0x925c4(%rip), %rsi # 0xce93e
movl $0x7, %edx
callq 0x82820
movl $0x1, -0x2018(%rbp)
movl -0x2018(%rbp), %eax
cmpl 0x1f95e6(%rip), %eax # 0x235980
ja 0x3c441
leaq -0x2010(%rbp), %rdi
movl -0x2018(%rbp), %ecx
movl $0x2004, %esi # imm = 0x2004
leaq 0x9258d(%rip), %rdx # 0xce946
movb $0x0, %al
callq 0x374d0
cmpl $0x2004, %eax # imm = 0x2004
jle 0x3c3e9
movq 0x1f7c0a(%rip), %rax # 0x233fd8
movq (%rax), %rdi
leaq 0x92577(%rip), %rsi # 0xce94f
movb $0x0, %al
callq 0x371e0
movl $0x1, %edi
callq 0x37670
leaq -0x2010(%rbp), %rsi
leaq 0x3b32c1(%rip), %rdi # 0x3ef6b8
callq 0x827e0
movl -0x2018(%rbp), %eax
cmpl 0x1f9578(%rip), %eax # 0x235980
jb 0x3c413
cmpl $0x0, 0x1f9573(%rip) # 0x235984
jbe 0x3c42b
leaq 0x3b329e(%rip), %rdi # 0x3ef6b8
leaq 0x96526(%rip), %rsi # 0xd2947
movl $0x1, %edx
callq 0x82820
jmp 0x3c42d
movl -0x2018(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2018(%rbp)
jmp 0x3c38e
movl $0x1, -0x2018(%rbp)
movl -0x2018(%rbp), %eax
cmpl 0x1f952d(%rip), %eax # 0x235984
ja 0x3c4f5
leaq -0x2010(%rbp), %rdi
movl -0x2018(%rbp), %ecx
movl $0x2004, %esi # imm = 0x2004
leaq 0x92505(%rip), %rdx # 0xce97b
movb $0x0, %al
callq 0x374d0
cmpl $0x2004, %eax # imm = 0x2004
jle 0x3c4a6
movq 0x1f7b4d(%rip), %rax # 0x233fd8
movq (%rax), %rdi
leaq 0x924ba(%rip), %rsi # 0xce94f
movb $0x0, %al
callq 0x371e0
movl $0x1, %edi
callq 0x37670
leaq -0x2010(%rbp), %rsi
leaq 0x3b3204(%rip), %rdi # 0x3ef6b8
callq 0x827e0
movl -0x2018(%rbp), %eax
cmpl 0x1f94bf(%rip), %eax # 0x235984
jae 0x3c4df
leaq 0x3b31ea(%rip), %rdi # 0x3ef6b8
leaq 0x96472(%rip), %rsi # 0xd2947
movl $0x1, %edx
callq 0x82820
jmp 0x3c4e1
movl -0x2018(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2018(%rbp)
jmp 0x3c44b
leaq 0x3b31bc(%rip), %rdi # 0x3ef6b8
leaq 0x92482(%rip), %rsi # 0xce985
callq 0x827e0
movsbl -0x2011(%rbp), %eax
cmpl $0x0, %eax
je 0x3c53f
movsbl 0x3b2ec5(%rip), %eax # 0x3ef3e0
cmpl $0x0, %eax
jne 0x3c52c
movsbl 0x3b2eba(%rip), %eax # 0x3ef3e1
cmpl $0x0, %eax
je 0x3c53f
leaq 0x3b3185(%rip), %rdi # 0x3ef6b8
leaq 0x92454(%rip), %rsi # 0xce98e
callq 0x827e0
xorl %edi, %edi
movl $0x30, %esi
movl $0x38, %edx
callq 0x7fad0
movq %rax, -0x2020(%rbp)
movq 0x3b3162(%rip), %rsi # 0x3ef6c0
addq $0x1, %rsi
xorl %edi, %edi
movl $0x38, %edx
callq 0x7fad0
movq %rax, %rcx
movq -0x2020(%rbp), %rax
movq %rcx, (%rax)
movq 0x3b313e(%rip), %rcx # 0x3ef6c0
addq $0x1, %rcx
movq -0x2020(%rbp), %rax
movq %rcx, 0x8(%rax)
movsbl -0x2011(%rbp), %eax
cmpl $0x0, %eax
je 0x3c5c2
movsbl 0x3b2e3c(%rip), %eax # 0x3ef3e0
cmpl $0x0, %eax
jne 0x3c5b5
movsbl 0x3b2e31(%rip), %eax # 0x3ef3e1
cmpl $0x0, %eax
je 0x3c5c2
movq -0x2020(%rbp), %rax
movb $0x5, 0x10(%rax)
jmp 0x3c5cd
movq -0x2020(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x2020(%rbp), %rax
movq (%rax), %rdi
movq 0x3b30da(%rip), %rsi # 0x3ef6b8
callq 0x379c0
leaq 0x3b30ce(%rip), %rdi # 0x3ef6b8
callq 0x82cf0
movq -0x2020(%rbp), %rax
movq %rax, -0x2028(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x3c61f
movq -0x2028(%rbp), %rax
addq $0x2030, %rsp # imm = 0x2030
popq %rbp
retq
callq 0x372c0
nopw %cs:(%rax,%rax)
| build_select_string:
push rbp
mov rbp, rsp
sub rsp, 2030h
mov al, dil
mov rcx, fs:28h
mov [rbp+var_8], rcx
mov [rbp+var_2011], al
lea rdi, build_select_string_query_string
lea rsi, asc_D4CA2+4; ""
mov ecx, 400h
mov rdx, rcx
call init_dynamic_string
lea rdi, build_select_string_query_string
lea rsi, aSelect_0; "SELECT "
mov edx, 7
call dynstr_append_mem
mov [rbp+var_2018], 1
loc_3C38E:
mov eax, [rbp+var_2018]
cmp eax, cs:num_int_cols
ja loc_3C441
lea rdi, [rbp+var_2010]
mov ecx, [rbp+var_2018]
mov esi, 2004h
lea rdx, aIntcolD; "intcol%d"
mov al, 0
call _snprintf
cmp eax, 2004h
jle short loc_3C3E9
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aMemoryAllocati_2; "Memory Allocation error in creating sel"...
mov al, 0
call _fprintf
mov edi, 1
call _exit
loc_3C3E9:
lea rsi, [rbp+var_2010]
lea rdi, build_select_string_query_string
call dynstr_append
mov eax, [rbp+var_2018]
cmp eax, cs:num_int_cols
jb short loc_3C413
cmp cs:num_char_cols, 0
jbe short loc_3C42B
loc_3C413:
lea rdi, build_select_string_query_string
lea rsi, aS_0+2; ","
mov edx, 1
call dynstr_append_mem
loc_3C42B:
jmp short $+2
loc_3C42D:
mov eax, [rbp+var_2018]
add eax, 1
mov [rbp+var_2018], eax
jmp loc_3C38E
loc_3C441:
mov [rbp+var_2018], 1
loc_3C44B:
mov eax, [rbp+var_2018]
cmp eax, cs:num_char_cols
ja loc_3C4F5
lea rdi, [rbp+var_2010]
mov ecx, [rbp+var_2018]
mov esi, 2004h
lea rdx, aCharcolD; "charcol%d"
mov al, 0
call _snprintf
cmp eax, 2004h
jle short loc_3C4A6
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aMemoryAllocati_2; "Memory Allocation error in creating sel"...
mov al, 0
call _fprintf
mov edi, 1
call _exit
loc_3C4A6:
lea rsi, [rbp+var_2010]
lea rdi, build_select_string_query_string
call dynstr_append
mov eax, [rbp+var_2018]
cmp eax, cs:num_char_cols
jnb short loc_3C4DF
lea rdi, build_select_string_query_string
lea rsi, aS_0+2; ","
mov edx, 1
call dynstr_append_mem
loc_3C4DF:
jmp short $+2
loc_3C4E1:
mov eax, [rbp+var_2018]
add eax, 1
mov [rbp+var_2018], eax
jmp loc_3C44B
loc_3C4F5:
lea rdi, build_select_string_query_string
lea rsi, aFromT1; " FROM t1"
call dynstr_append
movsx eax, [rbp+var_2011]
cmp eax, 0
jz short loc_3C53F
movsx eax, cs:auto_generate_sql_autoincrement
cmp eax, 0
jnz short loc_3C52C
movsx eax, cs:auto_generate_sql_guid_primary
cmp eax, 0
jz short loc_3C53F
loc_3C52C:
lea rdi, build_select_string_query_string
lea rsi, aWhereId; " WHERE id = "
call dynstr_append
loc_3C53F:
xor edi, edi
mov esi, 30h ; '0'
mov edx, 38h ; '8'
call my_malloc
mov [rbp+var_2020], rax
mov rsi, cs:qword_3EF6C0
add rsi, 1
xor edi, edi
mov edx, 38h ; '8'
call my_malloc
mov rcx, rax
mov rax, [rbp+var_2020]
mov [rax], rcx
mov rcx, cs:qword_3EF6C0
add rcx, 1
mov rax, [rbp+var_2020]
mov [rax+8], rcx
movsx eax, [rbp+var_2011]
cmp eax, 0
jz short loc_3C5C2
movsx eax, cs:auto_generate_sql_autoincrement
cmp eax, 0
jnz short loc_3C5B5
movsx eax, cs:auto_generate_sql_guid_primary
cmp eax, 0
jz short loc_3C5C2
loc_3C5B5:
mov rax, [rbp+var_2020]
mov byte ptr [rax+10h], 5
jmp short loc_3C5CD
loc_3C5C2:
mov rax, [rbp+var_2020]
mov byte ptr [rax+10h], 0
loc_3C5CD:
mov rax, [rbp+var_2020]
mov rdi, [rax]
mov rsi, cs:build_select_string_query_string
call _stpcpy
lea rdi, build_select_string_query_string
call dynstr_free
mov rax, [rbp+var_2020]
mov [rbp+var_2028], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_3C61F
mov rax, [rbp+var_2028]
add rsp, 2030h
pop rbp
retn
loc_3C61F:
call ___stack_chk_fail
| long long build_select_string(char a1)
{
long long v2; // [rsp+10h] [rbp-2020h]
unsigned int i; // [rsp+18h] [rbp-2018h]
unsigned int j; // [rsp+18h] [rbp-2018h]
_BYTE v5[8200]; // [rsp+20h] [rbp-2010h] BYREF
unsigned long long v6; // [rsp+2028h] [rbp-8h]
v6 = __readfsqword(0x28u);
init_dynamic_string(&build_select_string_query_string, "", 1024LL);
dynstr_append_mem(&build_select_string_query_string, "SELECT ", 7LL);
for ( i = 1; i <= num_int_cols; ++i )
{
if ( (int)snprintf(v5, "getlogin", "intcol%d", i) > 8196 )
{
fprintf(stderr, "Memory Allocation error in creating select\n");
exit(1LL);
}
dynstr_append(&build_select_string_query_string, v5);
if ( i < num_int_cols || num_char_cols )
dynstr_append_mem(&build_select_string_query_string, ",", 1LL);
}
for ( j = 1; j <= num_char_cols; ++j )
{
if ( (int)snprintf(v5, "getlogin", "charcol%d", j) > 8196 )
{
fprintf(stderr, "Memory Allocation error in creating select\n");
exit(1LL);
}
dynstr_append(&build_select_string_query_string, v5);
if ( j < num_char_cols )
dynstr_append_mem(&build_select_string_query_string, ",", 1LL);
}
dynstr_append(&build_select_string_query_string, " FROM t1");
if ( a1 && (auto_generate_sql_autoincrement || auto_generate_sql_guid_primary) )
dynstr_append(&build_select_string_query_string, " WHERE id = ");
v2 = my_malloc(0LL, 48LL, 56LL);
*(_QWORD *)v2 = my_malloc(0LL, qword_3EF6C0 + 1, 56LL);
*(_QWORD *)(v2 + 8) = qword_3EF6C0 + 1;
if ( a1 && (auto_generate_sql_autoincrement || auto_generate_sql_guid_primary) )
*(_BYTE *)(v2 + 16) = 5;
else
*(_BYTE *)(v2 + 16) = 0;
stpcpy(*(_QWORD *)v2, build_select_string_query_string);
dynstr_free(&build_select_string_query_string);
return v2;
}
| build_select_string:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x2030
MOV AL,DIL
MOV RCX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RCX
MOV byte ptr [RBP + -0x2011],AL
LEA RDI,[0x4ef6b8]
LEA RSI,[0x1d4ca6]
MOV ECX,0x400
MOV RDX,RCX
CALL 0x00182510
LEA RDI,[0x4ef6b8]
LEA RSI,[0x1ce93e]
MOV EDX,0x7
CALL 0x00182820
MOV dword ptr [RBP + -0x2018],0x1
LAB_0013c38e:
MOV EAX,dword ptr [RBP + -0x2018]
CMP EAX,dword ptr [0x00335980]
JA 0x0013c441
LEA RDI,[RBP + -0x2010]
MOV ECX,dword ptr [RBP + -0x2018]
MOV ESI,0x2004
LEA RDX,[0x1ce946]
MOV AL,0x0
CALL 0x001374d0
CMP EAX,0x2004
JLE 0x0013c3e9
MOV RAX,qword ptr [0x00333fd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x1ce94f]
MOV AL,0x0
CALL 0x001371e0
MOV EDI,0x1
CALL 0x00137670
LAB_0013c3e9:
LEA RSI,[RBP + -0x2010]
LEA RDI,[0x4ef6b8]
CALL 0x001827e0
MOV EAX,dword ptr [RBP + -0x2018]
CMP EAX,dword ptr [0x00335980]
JC 0x0013c413
CMP dword ptr [0x00335984],0x0
JBE 0x0013c42b
LAB_0013c413:
LEA RDI,[0x4ef6b8]
LEA RSI,[0x1d2947]
MOV EDX,0x1
CALL 0x00182820
LAB_0013c42b:
JMP 0x0013c42d
LAB_0013c42d:
MOV EAX,dword ptr [RBP + -0x2018]
ADD EAX,0x1
MOV dword ptr [RBP + -0x2018],EAX
JMP 0x0013c38e
LAB_0013c441:
MOV dword ptr [RBP + -0x2018],0x1
LAB_0013c44b:
MOV EAX,dword ptr [RBP + -0x2018]
CMP EAX,dword ptr [0x00335984]
JA 0x0013c4f5
LEA RDI,[RBP + -0x2010]
MOV ECX,dword ptr [RBP + -0x2018]
MOV ESI,0x2004
LEA RDX,[0x1ce97b]
MOV AL,0x0
CALL 0x001374d0
CMP EAX,0x2004
JLE 0x0013c4a6
MOV RAX,qword ptr [0x00333fd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x1ce94f]
MOV AL,0x0
CALL 0x001371e0
MOV EDI,0x1
CALL 0x00137670
LAB_0013c4a6:
LEA RSI,[RBP + -0x2010]
LEA RDI,[0x4ef6b8]
CALL 0x001827e0
MOV EAX,dword ptr [RBP + -0x2018]
CMP EAX,dword ptr [0x00335984]
JNC 0x0013c4df
LEA RDI,[0x4ef6b8]
LEA RSI,[0x1d2947]
MOV EDX,0x1
CALL 0x00182820
LAB_0013c4df:
JMP 0x0013c4e1
LAB_0013c4e1:
MOV EAX,dword ptr [RBP + -0x2018]
ADD EAX,0x1
MOV dword ptr [RBP + -0x2018],EAX
JMP 0x0013c44b
LAB_0013c4f5:
LEA RDI,[0x4ef6b8]
LEA RSI,[0x1ce985]
CALL 0x001827e0
MOVSX EAX,byte ptr [RBP + -0x2011]
CMP EAX,0x0
JZ 0x0013c53f
MOVSX EAX,byte ptr [0x004ef3e0]
CMP EAX,0x0
JNZ 0x0013c52c
MOVSX EAX,byte ptr [0x004ef3e1]
CMP EAX,0x0
JZ 0x0013c53f
LAB_0013c52c:
LEA RDI,[0x4ef6b8]
LEA RSI,[0x1ce98e]
CALL 0x001827e0
LAB_0013c53f:
XOR EDI,EDI
MOV ESI,0x30
MOV EDX,0x38
CALL 0x0017fad0
MOV qword ptr [RBP + -0x2020],RAX
MOV RSI,qword ptr [0x004ef6c0]
ADD RSI,0x1
XOR EDI,EDI
MOV EDX,0x38
CALL 0x0017fad0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x2020]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [0x004ef6c0]
ADD RCX,0x1
MOV RAX,qword ptr [RBP + -0x2020]
MOV qword ptr [RAX + 0x8],RCX
MOVSX EAX,byte ptr [RBP + -0x2011]
CMP EAX,0x0
JZ 0x0013c5c2
MOVSX EAX,byte ptr [0x004ef3e0]
CMP EAX,0x0
JNZ 0x0013c5b5
MOVSX EAX,byte ptr [0x004ef3e1]
CMP EAX,0x0
JZ 0x0013c5c2
LAB_0013c5b5:
MOV RAX,qword ptr [RBP + -0x2020]
MOV byte ptr [RAX + 0x10],0x5
JMP 0x0013c5cd
LAB_0013c5c2:
MOV RAX,qword ptr [RBP + -0x2020]
MOV byte ptr [RAX + 0x10],0x0
LAB_0013c5cd:
MOV RAX,qword ptr [RBP + -0x2020]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [0x004ef6b8]
CALL 0x001379c0
LEA RDI,[0x4ef6b8]
CALL 0x00182cf0
MOV RAX,qword ptr [RBP + -0x2020]
MOV qword ptr [RBP + -0x2028],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0013c61f
MOV RAX,qword ptr [RBP + -0x2028]
ADD RSP,0x2030
POP RBP
RET
LAB_0013c61f:
CALL 0x001372c0
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8 * build_select_string(char param_1)
{
int iVar1;
int8 *puVar2;
int8 uVar3;
long in_FS_OFFSET;
uint local_2020;
char local_2018 [8200];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
init_dynamic_string(&build_select_string_query_string,&DAT_001d4ca6,0x400);
dynstr_append_mem(&build_select_string_query_string,"SELECT ",7);
for (local_2020 = 1; local_2020 <= num_int_cols; local_2020 = local_2020 + 1) {
iVar1 = snprintf(local_2018,0x2004,"intcol%d",(ulong)local_2020);
if (0x2004 < iVar1) {
fprintf(*(FILE **)PTR_stderr_00333fd8,"Memory Allocation error in creating select\n");
/* WARNING: Subroutine does not return */
exit(1);
}
dynstr_append(&build_select_string_query_string,local_2018);
if ((local_2020 < num_int_cols) || (num_char_cols != 0)) {
dynstr_append_mem(&build_select_string_query_string,&DAT_001d2947,1);
}
}
for (local_2020 = 1; local_2020 <= num_char_cols; local_2020 = local_2020 + 1) {
iVar1 = snprintf(local_2018,0x2004,"charcol%d",(ulong)local_2020);
if (0x2004 < iVar1) {
fprintf(*(FILE **)PTR_stderr_00333fd8,"Memory Allocation error in creating select\n");
/* WARNING: Subroutine does not return */
exit(1);
}
dynstr_append(&build_select_string_query_string,local_2018);
if (local_2020 < num_char_cols) {
dynstr_append_mem(&build_select_string_query_string,&DAT_001d2947,1);
}
}
dynstr_append(&build_select_string_query_string," FROM t1");
if ((param_1 != '\0') &&
((auto_generate_sql_autoincrement != '\0' || (auto_generate_sql_guid_primary != '\0')))) {
dynstr_append(&build_select_string_query_string," WHERE id = ");
}
puVar2 = (int8 *)my_malloc(0,0x30,0x38);
uVar3 = my_malloc(0,_DAT_004ef6c0 + 1,0x38);
*puVar2 = uVar3;
puVar2[1] = _DAT_004ef6c0 + 1;
if ((param_1 == '\0') ||
((auto_generate_sql_autoincrement == '\0' && (auto_generate_sql_guid_primary == '\0')))) {
*(int1 *)(puVar2 + 2) = 0;
}
else {
*(int1 *)(puVar2 + 2) = 5;
}
stpcpy((char *)*puVar2,build_select_string_query_string);
dynstr_free(&build_select_string_query_string);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return puVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
5,829 | llama_sampler_init_dist | monkey531[P]llama/src/llama-sampling.cpp | struct llama_sampler * llama_sampler_init_dist(uint32_t seed) {
auto seed_cur = get_rng_seed(seed);
return new llama_sampler {
/* .iface = */ &llama_sampler_dist_i,
/* .ctx = */ new llama_sampler_dist {
/* .seed = */ seed,
/* .seed_cur = */ seed_cur,
/* .rng = */ std::mt19937(seed_cur),
},
};
} | O3 | cpp | llama_sampler_init_dist:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebp
callq 0xdb646
movl %eax, %r14d
movl $0x10, %edi
callq 0x68030
movq %rax, %rbx
leaq 0x85cfb(%rip), %rax # 0x1612d0
movq %rax, (%rbx)
movl $0x1390, %edi # imm = 0x1390
callq 0x68030
movl %ebp, (%rax)
movl %r14d, 0x4(%rax)
movl %r14d, %edx
movq %rdx, 0x8(%rax)
movl $0x2, %ecx
movq %rdx, %rsi
shrq $0x1e, %rsi
xorl %edx, %esi
imull $0x6c078965, %esi, %edx # imm = 0x6C078965
addl %ecx, %edx
decl %edx
movq %rdx, (%rax,%rcx,8)
incq %rcx
cmpq $0x271, %rcx # imm = 0x271
jne 0xdb5f4
movq $0x270, 0x1388(%rax) # imm = 0x270
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movl $0x10, %esi
movq %rbx, %rdi
callq 0x681a0
movq %r14, %rdi
callq 0x6b5d0
| llama_sampler_init_dist:
push rbp
push r14
push rbx
mov ebp, edi
call _ZL12get_rng_seedj; get_rng_seed(uint)
mov r14d, eax
mov edi, 10h; unsigned __int64
call __Znwm; operator new(ulong)
mov rbx, rax
lea rax, _ZL20llama_sampler_dist_i; llama_sampler_dist_i
mov [rbx], rax
mov edi, 1390h; unsigned __int64
call __Znwm; operator new(ulong)
mov [rax], ebp
mov [rax+4], r14d
mov edx, r14d
mov [rax+8], rdx
mov ecx, 2
loc_DB5F4:
mov rsi, rdx
shr rsi, 1Eh
xor esi, edx
imul edx, esi, 6C078965h
add edx, ecx
dec edx
mov [rax+rcx*8], rdx
inc rcx
cmp rcx, 271h
jnz short loc_DB5F4
mov qword ptr [rax+1388h], 270h
mov [rbx+8], rax
mov rax, rbx
pop rbx
pop r14
pop rbp
retn
mov r14, rax
mov esi, 10h; unsigned __int64
mov rdi, rbx; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rdi, r14
call __Unwind_Resume
| _QWORD * llama_sampler_init_dist(unsigned int a1)
{
unsigned int rng_seed; // r14d
_QWORD *v2; // rbx
long long v3; // rax
unsigned long long v4; // rdx
long long i; // rcx
rng_seed = get_rng_seed(a1);
v2 = (_QWORD *)operator new(0x10uLL);
*v2 = &llama_sampler_dist_i;
v3 = operator new(0x1390uLL);
*(_DWORD *)v3 = a1;
*(_DWORD *)(v3 + 4) = rng_seed;
v4 = rng_seed;
*(_QWORD *)(v3 + 8) = rng_seed;
for ( i = 2LL; i != 625; ++i )
{
v4 = (unsigned int)i + 1812433253 * ((unsigned int)v4 ^ (unsigned int)(v4 >> 30)) - 1;
*(_QWORD *)(v3 + 8 * i) = v4;
}
*(_QWORD *)(v3 + 5000) = 624LL;
v2[1] = v3;
return v2;
}
| llama_sampler_init_dist:
PUSH RBP
PUSH R14
PUSH RBX
MOV EBP,EDI
CALL 0x001db646
MOV R14D,EAX
MOV EDI,0x10
CALL 0x00168030
MOV RBX,RAX
LEA RAX,[0x2612d0]
MOV qword ptr [RBX],RAX
LAB_001db5d8:
MOV EDI,0x1390
CALL 0x00168030
LAB_001db5e2:
MOV dword ptr [RAX],EBP
MOV dword ptr [RAX + 0x4],R14D
MOV EDX,R14D
MOV qword ptr [RAX + 0x8],RDX
MOV ECX,0x2
LAB_001db5f4:
MOV RSI,RDX
SHR RSI,0x1e
XOR ESI,EDX
IMUL EDX,ESI,0x6c078965
ADD EDX,ECX
DEC EDX
MOV qword ptr [RAX + RCX*0x8],RDX
INC RCX
CMP RCX,0x271
JNZ 0x001db5f4
MOV qword ptr [RAX + 0x1388],0x270
MOV qword ptr [RBX + 0x8],RAX
MOV RAX,RBX
POP RBX
POP R14
POP RBP
RET
|
int8 * llama_sampler_init_dist(uint param_1)
{
uint uVar1;
int8 *puVar2;
uint *puVar3;
long lVar4;
ulong uVar5;
uVar1 = get_rng_seed(param_1);
puVar2 = (int8 *)operator_new(0x10);
*puVar2 = llama_sampler_dist_i;
/* try { // try from 001db5d8 to 001db5e1 has its CatchHandler @ 001db62e */
puVar3 = (uint *)operator_new(0x1390);
*puVar3 = param_1;
puVar3[1] = uVar1;
uVar5 = (ulong)uVar1;
*(ulong *)(puVar3 + 2) = uVar5;
lVar4 = 2;
do {
uVar5 = (ulong)((((uint)(uVar5 >> 0x1e) ^ (uint)uVar5) * 0x6c078965 + (int)lVar4) - 1);
*(ulong *)(puVar3 + lVar4 * 2) = uVar5;
lVar4 = lVar4 + 1;
} while (lVar4 != 0x271);
puVar3[0x4e2] = 0x270;
puVar3[0x4e3] = 0;
puVar2[1] = puVar3;
return puVar2;
}
|
|
5,830 | nglog::LogMessage::WriteToStringAndLog() | ng-log[P]ng-log/src/logging.cc | EXCLUSIVE_LOCKS_REQUIRED(log_mutex) {
if (data_->message_ != nullptr) {
RAW_DCHECK(data_->num_chars_to_log_ > 0 &&
data_->message_text_[data_->num_chars_to_log_ - 1] == '\n',
"");
// Omit prefix of message and trailing newline when writing to message_.
const char* start = data_->message_text_ + data_->num_prefix_chars_;
size_t len = data_->num_chars_to_log_ - data_->num_prefix_chars_ - 1;
data_->message_->assign(start, len);
}
SendToLog();
} | O2 | cpp | nglog::LogMessage::WriteToStringAndLog():
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x76b0(%rax), %rdi
testq %rdi, %rdi
je 0xc124
movq 0x76c0(%rax), %rcx
testq %rcx, %rcx
je 0xc0cd
cmpb $0xa, 0x3(%rcx,%rax)
je 0xc10a
leaq 0x14836(%rip), %rsi # 0x2090a
leaq 0x14876(%rip), %rcx # 0x20951
leaq 0x14883(%rip), %r8 # 0x20965
leaq 0x14d92(%rip), %r9 # 0x20e7b
pushq $0x3
popq %rdi
movl $0x78c, %edx # imm = 0x78C
xorl %eax, %eax
callq 0x1cf9c
movq 0x8(%rbx), %rax
movq 0x76b0(%rax), %rdi
movq 0x76c0(%rax), %rcx
movq 0x76b8(%rax), %rdx
leaq (%rax,%rdx), %rsi
addq $0x4, %rsi
notq %rdx
addq %rcx, %rdx
callq 0x87d0
movq %rbx, %rdi
popq %rbx
jmp 0xbabc
nop
| _ZN5nglog10LogMessage19WriteToStringAndLogEv:
push rbx
mov rbx, rdi
mov rax, [rdi+8]
mov rdi, [rax+76B0h]
test rdi, rdi
jz short loc_C124
mov rcx, [rax+76C0h]
test rcx, rcx
jz short loc_C0CD
cmp byte ptr [rcx+rax+3], 0Ah
jz short loc_C10A
loc_C0CD:
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aCheckSFailedS; "Check %s failed: %s"
lea r8, aDataNumCharsTo; "data_->num_chars_to_log_ > 0 && data_->"...
lea r9, asc_20E79+2; ""
push 3
pop rdi
mov edx, 78Ch
xor eax, eax
call _ZN5nglog6RawLogENS_11LogSeverityEPKciS2_z; nglog::RawLog(nglog::LogSeverity,char const*,int,char const*,...)
mov rax, [rbx+8]
mov rdi, [rax+76B0h]
mov rcx, [rax+76C0h]
loc_C10A:
mov rdx, [rax+76B8h]
lea rsi, [rax+rdx]
add rsi, 4
not rdx
add rdx, rcx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6assignEPKcm; std::string::assign(char const*,ulong)
loc_C124:
mov rdi, rbx; this
pop rbx
jmp _ZN5nglog10LogMessage9SendToLogEv; nglog::LogMessage::SendToLog(void)
| long long nglog::LogMessage::WriteToStringAndLog(nglog::LogMessage *this)
{
_QWORD *v2; // rax
long long v3; // rdi
long long v4; // rcx
v2 = (_QWORD *)*((_QWORD *)this + 1);
v3 = v2[3798];
if ( v3 )
{
v4 = v2[3800];
if ( !v4 || *((_BYTE *)v2 + v4 + 3) != 10 )
{
nglog::RawLog(
3LL,
"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/logging.cc",
1932LL,
"Check %s failed: %s",
"data_->num_chars_to_log_ > 0 && data_->message_text_[data_->num_chars_to_log_ - 1] == '\\n'",
"");
v2 = (_QWORD *)*((_QWORD *)this + 1);
v3 = v2[3798];
v4 = v2[3800];
}
std::string::assign(v3, (char *)v2 + v2[3799] + 4, v4 + ~v2[3799]);
}
return nglog::LogMessage::SendToLog(this);
}
| WriteToStringAndLog:
PUSH RBX
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x8]
MOV RDI,qword ptr [RAX + 0x76b0]
TEST RDI,RDI
JZ 0x0010c124
MOV RCX,qword ptr [RAX + 0x76c0]
TEST RCX,RCX
JZ 0x0010c0cd
CMP byte ptr [RCX + RAX*0x1 + 0x3],0xa
JZ 0x0010c10a
LAB_0010c0cd:
LEA RSI,[0x12090a]
LEA RCX,[0x120951]
LEA R8,[0x120965]
LEA R9,[0x120e7b]
PUSH 0x3
POP RDI
MOV EDX,0x78c
XOR EAX,EAX
CALL 0x0011cf9c
MOV RAX,qword ptr [RBX + 0x8]
MOV RDI,qword ptr [RAX + 0x76b0]
MOV RCX,qword ptr [RAX + 0x76c0]
LAB_0010c10a:
MOV RDX,qword ptr [RAX + 0x76b8]
LEA RSI,[RAX + RDX*0x1]
ADD RSI,0x4
NOT RDX
ADD RDX,RCX
CALL 0x001087d0
LAB_0010c124:
MOV RDI,RBX
POP RBX
JMP 0x0010babc
|
/* nglog::LogMessage::WriteToStringAndLog() */
void __thiscall nglog::LogMessage::WriteToStringAndLog(LogMessage *this)
{
long lVar1;
char *pcVar2;
lVar1 = *(long *)(this + 8);
pcVar2 = *(char **)(lVar1 + 0x76b0);
if (pcVar2 != (char *)0x0) {
if ((*(long *)(lVar1 + 0x76c0) == 0) ||
(*(char *)(*(long *)(lVar1 + 0x76c0) + 3 + lVar1) != '\n')) {
RawLog(3,"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/logging.cc",0x78c,
"Check %s failed: %s",
"data_->num_chars_to_log_ > 0 && data_->message_text_[data_->num_chars_to_log_ - 1] == \'\\n\'"
,&DAT_00120e7b);
lVar1 = *(long *)(this + 8);
pcVar2 = *(char **)(lVar1 + 0x76b0);
}
std::__cxx11::string::assign(pcVar2,lVar1 + *(long *)(lVar1 + 0x76b8) + 4);
}
SendToLog(this);
return;
}
|
|
5,831 | write_hook_for_clr_end | eloqsql/storage/maria/ma_key_recover.c | my_bool write_hook_for_clr_end(enum translog_record_type type
__attribute__ ((unused)),
TRN *trn, MARIA_HA *tbl_info,
LSN *lsn __attribute__ ((unused)),
void *hook_arg)
{
MARIA_SHARE *share= tbl_info->s;
struct st_msg_to_write_hook_for_clr_end *msg=
(struct st_msg_to_write_hook_for_clr_end *)hook_arg;
my_bool error= FALSE;
DBUG_ENTER("write_hook_for_clr_end");
DBUG_ASSERT(trn->trid != 0);
trn->undo_lsn= msg->previous_undo_lsn;
switch (msg->undone_record_type) {
case LOGREC_UNDO_ROW_DELETE:
share->state.state.records++;
share->state.state.checksum+= msg->checksum_delta;
break;
case LOGREC_UNDO_ROW_INSERT:
share->state.state.records--;
share->state.state.checksum+= msg->checksum_delta;
break;
case LOGREC_UNDO_ROW_UPDATE:
share->state.state.checksum+= msg->checksum_delta;
break;
case LOGREC_UNDO_KEY_INSERT_WITH_ROOT:
case LOGREC_UNDO_KEY_DELETE_WITH_ROOT:
{
/* Update key root */
struct st_msg_to_write_hook_for_undo_key *extra_msg=
(struct st_msg_to_write_hook_for_undo_key *) msg->extra_msg;
*extra_msg->root= extra_msg->value;
break;
}
case LOGREC_UNDO_KEY_INSERT:
case LOGREC_UNDO_KEY_DELETE:
break;
case LOGREC_UNDO_BULK_INSERT:
mysql_mutex_assert_owner(&share->intern_lock);
error= (maria_enable_indexes(tbl_info) ||
/* we enabled indices, need '2' below */
_ma_state_info_write(share,
MA_STATE_INFO_WRITE_DONT_MOVE_OFFSET |
MA_STATE_INFO_WRITE_FULL_INFO));
/* no need for _ma_reset_status(): REDO_DELETE_ALL is just before us */
break;
default:
DBUG_ASSERT(0);
}
if (trn->undo_lsn == LSN_IMPOSSIBLE) /* has fully rolled back */
trn->first_undo_lsn= LSN_WITH_FLAGS_TO_FLAGS(trn->first_undo_lsn);
DBUG_RETURN(error);
} | O3 | c | write_hook_for_clr_end:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq (%rdx), %r14
movq (%r8), %rcx
movq %rcx, 0x98(%rsi)
movl 0x8(%r8), %esi
xorl %eax, %eax
leal -0x12(%rsi), %edi
cmpl $0x6, %edi
ja 0x599be
leaq 0x87a57(%rip), %rdx # 0xe13fc
movslq (%rdx,%rdi,4), %rsi
addq %rdx, %rsi
jmpq *%rsi
movq 0x10(%r8), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rax
movq %rax, (%rcx)
jmp 0x599f9
cmpl $0x27, %esi
jne 0x59a02
movq %rdx, %rdi
callq 0x55c67
movl %eax, %ecx
movb $0x1, %al
testl %ecx, %ecx
jne 0x599fb
movq %r14, %rdi
movl $0x3, %esi
callq 0x54df6
testl %eax, %eax
setne %al
jmp 0x599fb
incq 0x18(%r14)
jmp 0x599f1
decq 0x18(%r14)
movl 0xc(%r8), %eax
addl %eax, 0x48(%r14)
xorl %eax, %eax
movq 0x98(%rbx), %rcx
testq %rcx, %rcx
jne 0x59a19
movzbl 0xa7(%rbx), %ecx
shlq $0x38, %rcx
movq %rcx, 0xa0(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
| write_hook_for_clr_end:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rsi
mov r14, [rdx]
mov rcx, [r8]
mov [rsi+98h], rcx
mov esi, [r8+8]
xor eax, eax
lea edi, [rsi-12h]; switch 7 cases
cmp edi, 6
ja short def_599AC; jumptable 00000000000599AC default case
lea rdx, jpt_599AC
movsxd rsi, ds:(jpt_599AC - 0E13FCh)[rdx+rdi*4]
add rsi, rdx
jmp rsi; switch jump
loc_599AE:
mov rax, [r8+10h]; jumptable 00000000000599AC cases 22,24
mov rcx, [rax]
mov rax, [rax+8]
mov [rcx], rax
jmp short loc_599F9
def_599AC:
cmp esi, 27h ; '''; jumptable 00000000000599AC default case
jnz short loc_59A02; jumptable 00000000000599AC cases 21,23
mov rdi, rdx
call maria_enable_indexes
mov ecx, eax
mov al, 1
test ecx, ecx
jnz short loc_599FB
mov rdi, r14
mov esi, 3
call _ma_state_info_write
test eax, eax
setnz al
jmp short loc_599FB
loc_599E7:
inc qword ptr [r14+18h]; jumptable 00000000000599AC case 19
jmp short loc_599F1; jumptable 00000000000599AC case 20
loc_599ED:
dec qword ptr [r14+18h]; jumptable 00000000000599AC case 18
loc_599F1:
mov eax, [r8+0Ch]; jumptable 00000000000599AC case 20
add [r14+48h], eax
loc_599F9:
xor eax, eax
loc_599FB:
mov rcx, [rbx+98h]
loc_59A02:
test rcx, rcx; jumptable 00000000000599AC cases 21,23
jnz short loc_59A19
movzx ecx, byte ptr [rbx+0A7h]
shl rcx, 38h
mov [rbx+0A0h], rcx
loc_59A19:
pop rbx
pop r14
pop rbp
retn
| bool write_hook_for_clr_end(long long a1, long long a2, _DWORD *a3, long long a4, long long a5, int a6)
{
long long v7; // r14
long long v8; // rcx
long long v9; // rsi
bool result; // al
int v11; // ecx
v7 = *(_QWORD *)a3;
v8 = *(_QWORD *)a5;
*(_QWORD *)(a2 + 152) = *(_QWORD *)a5;
v9 = *(unsigned int *)(a5 + 8);
result = 0;
switch ( (int)v9 )
{
case 18:
--*(_QWORD *)(v7 + 24);
goto LABEL_8;
case 19:
++*(_QWORD *)(v7 + 24);
goto LABEL_8;
case 20:
LABEL_8:
*(_DWORD *)(v7 + 72) += *(_DWORD *)(a5 + 12);
goto LABEL_9;
case 21:
case 23:
goto LABEL_11;
case 22:
case 24:
***(_QWORD ***)(a5 + 16) = *(_QWORD *)(*(_QWORD *)(a5 + 16) + 8LL);
LABEL_9:
result = 0;
goto LABEL_10;
default:
if ( (_DWORD)v9 != 39 )
goto LABEL_11;
v11 = maria_enable_indexes(a3, v9, (long long)a3, v8, a5, a6);
result = 1;
if ( !v11 )
result = (unsigned int)ma_state_info_write(v7, 3u) != 0;
LABEL_10:
v8 = *(_QWORD *)(a2 + 152);
LABEL_11:
if ( !v8 )
*(_QWORD *)(a2 + 160) = (unsigned long long)*(unsigned __int8 *)(a2 + 167) << 56;
return result;
}
}
| write_hook_for_clr_end:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,qword ptr [RDX]
MOV RCX,qword ptr [R8]
MOV qword ptr [RSI + 0x98],RCX
MOV ESI,dword ptr [R8 + 0x8]
XOR EAX,EAX
LEA EDI,[RSI + -0x12]
CMP EDI,0x6
JA 0x001599be
LEA RDX,[0x1e13fc]
MOVSXD RSI,dword ptr [RDX + RDI*0x4]
ADD RSI,RDX
switchD:
JMP RSI
caseD_16:
MOV RAX,qword ptr [R8 + 0x10]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RCX],RAX
JMP 0x001599f9
default:
CMP ESI,0x27
JNZ 0x00159a02
MOV RDI,RDX
CALL 0x00155c67
MOV ECX,EAX
MOV AL,0x1
TEST ECX,ECX
JNZ 0x001599fb
MOV RDI,R14
MOV ESI,0x3
CALL 0x00154df6
TEST EAX,EAX
SETNZ AL
JMP 0x001599fb
caseD_13:
INC qword ptr [R14 + 0x18]
JMP 0x001599f1
caseD_12:
DEC qword ptr [R14 + 0x18]
caseD_14:
MOV EAX,dword ptr [R8 + 0xc]
ADD dword ptr [R14 + 0x48],EAX
LAB_001599f9:
XOR EAX,EAX
LAB_001599fb:
MOV RCX,qword ptr [RBX + 0x98]
caseD_15:
TEST RCX,RCX
JNZ 0x00159a19
MOVZX ECX,byte ptr [RBX + 0xa7]
SHL RCX,0x38
MOV qword ptr [RBX + 0xa0],RCX
LAB_00159a19:
POP RBX
POP R14
POP RBP
RET
|
bool write_hook_for_clr_end
(int8 param_1,long param_2,long *param_3,int8 param_4,long *param_5)
{
long lVar1;
int iVar2;
long lVar3;
bool bVar4;
lVar1 = *param_3;
lVar3 = *param_5;
*(long *)(param_2 + 0x98) = lVar3;
bVar4 = false;
switch((int)param_5[1]) {
case 0x12:
*(long *)(lVar1 + 0x18) = *(long *)(lVar1 + 0x18) + -1;
break;
case 0x13:
*(long *)(lVar1 + 0x18) = *(long *)(lVar1 + 0x18) + 1;
break;
case 0x14:
break;
case 0x15:
case 0x17:
goto switchD_001599ac_caseD_15;
case 0x16:
case 0x18:
**(int8 **)param_5[2] = ((int8 *)param_5[2])[1];
goto LAB_001599f9;
default:
if ((int)param_5[1] != 0x27) goto switchD_001599ac_caseD_15;
iVar2 = maria_enable_indexes(param_3);
bVar4 = true;
if (iVar2 == 0) {
iVar2 = _ma_state_info_write(lVar1,3);
bVar4 = iVar2 != 0;
}
goto LAB_001599fb;
}
*(int *)(lVar1 + 0x48) = *(int *)(lVar1 + 0x48) + *(int *)((long)param_5 + 0xc);
LAB_001599f9:
bVar4 = false;
LAB_001599fb:
lVar3 = *(long *)(param_2 + 0x98);
switchD_001599ac_caseD_15:
if (lVar3 == 0) {
*(ulong *)(param_2 + 0xa0) = (ulong)*(byte *)(param_2 + 0xa7) << 0x38;
}
return bVar4;
}
|
|
5,832 | wait_for_free_space | eloqsql/mysys/errors.c | void wait_for_free_space(const char *filename, int errors)
{
if (errors == 0)
my_error(EE_DISK_FULL,MYF(ME_BELL | ME_ERROR_LOG | ME_WARNING),
filename,my_errno,MY_WAIT_FOR_USER_TO_FIX_PANIC);
if (!(errors % MY_WAIT_GIVE_USER_A_MESSAGE))
my_printf_error(EE_DISK_FULL,
"Retry in %d secs. Message reprinted in %d secs",
MYF(ME_BELL | ME_ERROR_LOG | ME_WARNING),
MY_WAIT_FOR_USER_TO_FIX_PANIC,
MY_WAIT_GIVE_USER_A_MESSAGE * MY_WAIT_FOR_USER_TO_FIX_PANIC );
(void) sleep(MY_WAIT_FOR_USER_TO_FIX_PANIC);
} | O0 | c | wait_for_free_space:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x3a45f
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x31370
movq -0x18(%rbp), %rdx
movl (%rax), %ecx
movl $0x14, %edi
movl $0x844, %esi # imm = 0x844
movl $0x3c, %r8d
movb $0x0, %al
callq 0x3d7e0
movl -0xc(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x3a492
movl $0x14, %edi
leaq 0x4e569(%rip), %rsi # 0x889e4
movl $0x844, %edx # imm = 0x844
movl $0x3c, %ecx
movl $0x258, %r8d # imm = 0x258
movb $0x0, %al
callq 0x3d930
movl $0x3c, %edi
callq 0x241d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| wait_for_free_space:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
cmp [rbp+var_C], 0
jnz short loc_3A45F
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
call _my_thread_var
mov rdx, [rbp+var_18]
mov ecx, [rax]
mov edi, 14h
mov esi, 844h
mov r8d, 3Ch ; '<'
mov al, 0
call my_error
loc_3A45F:
mov eax, [rbp+var_C]
mov ecx, 0Ah
cdq
idiv ecx
cmp edx, 0
jnz short loc_3A492
mov edi, 14h
lea rsi, aRetryInDSecsMe; "Retry in %d secs. Message reprinted in "...
mov edx, 844h
mov ecx, 3Ch ; '<'
mov r8d, 258h
mov al, 0
call my_printf_error
loc_3A492:
mov edi, 3Ch ; '<'
call _sleep
add rsp, 20h
pop rbp
retn
| long long wait_for_free_space(int a1, int a2, long long a3, long long a4, long long a5, int a6)
{
_DWORD *v6; // rax
int v7; // r9d
if ( !a2 )
{
v6 = (_DWORD *)my_thread_var();
my_error(20, 2116, a1, *v6, 60, v7);
}
if ( !(a2 % 10) )
my_printf_error(20, (unsigned int)"Retry in %d secs. Message reprinted in %d secs", 2116, 60, 600, a6);
return sleep(60LL);
}
| wait_for_free_space:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
CMP dword ptr [RBP + -0xc],0x0
JNZ 0x0013a45f
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
CALL 0x00131370
MOV RDX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RAX]
MOV EDI,0x14
MOV ESI,0x844
MOV R8D,0x3c
MOV AL,0x0
CALL 0x0013d7e0
LAB_0013a45f:
MOV EAX,dword ptr [RBP + -0xc]
MOV ECX,0xa
CDQ
IDIV ECX
CMP EDX,0x0
JNZ 0x0013a492
MOV EDI,0x14
LEA RSI,[0x1889e4]
MOV EDX,0x844
MOV ECX,0x3c
MOV R8D,0x258
MOV AL,0x0
CALL 0x0013d930
LAB_0013a492:
MOV EDI,0x3c
CALL 0x001241d0
ADD RSP,0x20
POP RBP
RET
|
void wait_for_free_space(int8 param_1,int param_2)
{
int4 *puVar1;
if (param_2 == 0) {
puVar1 = (int4 *)_my_thread_var();
my_error(0x14,0x844,param_1,*puVar1,0x3c);
}
if (param_2 % 10 == 0) {
my_printf_error(0x14,"Retry in %d secs. Message reprinted in %d secs",0x844,0x3c,600);
}
sleep(0x3c);
return;
}
|
|
5,833 | ma_net_write_command | eloqsql/libmariadb/libmariadb/ma_net.c | int ma_net_write_command(NET *net, uchar command,
const char *packet, size_t len,
my_bool disable_flush)
{
uchar buff[NET_HEADER_SIZE+1];
size_t buff_size= NET_HEADER_SIZE + 1;
size_t length= 1 + len; /* 1 extra byte for command */
int rc;
buff[NET_HEADER_SIZE]= 0;
buff[4]=command;
if (length >= MAX_PACKET_LENGTH)
{
len= MAX_PACKET_LENGTH - 1;
do
{
int3store(buff, MAX_PACKET_LENGTH);
buff[3]= (net->compress) ? 0 : (uchar) (net->pkt_nr++);
if (ma_net_write_buff(net, (char *)buff, buff_size) ||
ma_net_write_buff(net, packet, len))
return(1);
packet+= len;
length-= MAX_PACKET_LENGTH;
len= MAX_PACKET_LENGTH;
buff_size= NET_HEADER_SIZE; /* don't send command for further packets */
} while (length >= MAX_PACKET_LENGTH);
len= length;
}
int3store(buff,length);
buff[3]= (net->compress) ? 0 :(uchar) (net->pkt_nr++);
rc= test (ma_net_write_buff(net,(char *)buff, buff_size) ||
ma_net_write_buff(net,packet,len));
if (!rc && !disable_flush)
return test(ma_net_flush(net));
return rc;
} | O3 | c | ma_net_write_command:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, -0x3c(%rbp)
movq %rdx, %r15
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
leaq 0x1(%rcx), %rax
movb %sil, -0x31(%rbp)
movl $0x5, %edx
cmpq $0xffffff, %rax # imm = 0xFFFFFF
jb 0x314d2
movl $0xfffffe, %r14d # imm = 0xFFFFFE
movq %rax, %r12
movb $0x1, %r13b
movw $0xffff, -0x35(%rbp) # imm = 0xFFFF
movb $-0x1, -0x33(%rbp)
cmpb $0x0, 0x84(%rbx)
je 0x31479
xorl %eax, %eax
jmp 0x31482
movl 0x60(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x60(%rbx)
movb %al, -0x32(%rbp)
movq %rbx, %rdi
leaq -0x35(%rbp), %rsi
callq 0x312fd
testl %eax, %eax
jne 0x31539
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x312fd
testl %eax, %eax
jne 0x31539
addq %r14, %r15
addq $-0xffffff, %r12 # imm = 0xFF000001
movl $0x4, %edx
movl $0xffffff, %r14d # imm = 0xFFFFFF
movq %r12, %rax
cmpq $0xfffffe, %r12 # imm = 0xFFFFFE
ja 0x31462
jmp 0x314d5
movq %rcx, %r12
movb %al, -0x35(%rbp)
movb %ah, -0x34(%rbp)
shrl $0x10, %eax
movb %al, -0x33(%rbp)
cmpb $0x0, 0x84(%rbx)
je 0x314ee
xorl %eax, %eax
jmp 0x314f7
movl 0x60(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x60(%rbx)
leaq -0x35(%rbp), %rsi
movb %al, 0x3(%rsi)
movq %rbx, %rdi
callq 0x312fd
movb $0x1, %r13b
testl %eax, %eax
jne 0x31539
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x312fd
testl %eax, %eax
setne %r13b
cmpb $0x0, -0x3c(%rbp)
jne 0x31539
testl %eax, %eax
jne 0x31539
movq %rbx, %rdi
callq 0x30fba
testl %eax, %eax
setne %r13b
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x3155b
movzbl %r13b, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13500
| ma_net_write_command:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov [rbp+var_3C], r8d
mov r15, rdx
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
lea rax, [rcx+1]
mov [rbp+var_31], sil
mov edx, 5
cmp rax, 0FFFFFFh
jb short loc_314D2
mov r14d, 0FFFFFEh
mov r12, rax
mov r13b, 1
loc_31462:
mov [rbp+var_35], 0FFFFh
mov [rbp+var_33], 0FFh
cmp byte ptr [rbx+84h], 0
jz short loc_31479
xor eax, eax
jmp short loc_31482
loc_31479:
mov eax, [rbx+60h]
lea ecx, [rax+1]
mov [rbx+60h], ecx
loc_31482:
mov [rbp+var_32], al
mov rdi, rbx
lea rsi, [rbp+var_35]
call ma_net_write_buff
test eax, eax
jnz loc_31539
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call ma_net_write_buff
test eax, eax
jnz loc_31539
add r15, r14
add r12, 0FFFFFFFFFF000001h
mov edx, 4
mov r14d, 0FFFFFFh
mov rax, r12
cmp r12, 0FFFFFEh
ja short loc_31462
jmp short loc_314D5
loc_314D2:
mov r12, rcx
loc_314D5:
mov byte ptr [rbp+var_35], al
mov byte ptr [rbp+var_35+1], ah
shr eax, 10h
mov [rbp+var_33], al
cmp byte ptr [rbx+84h], 0
jz short loc_314EE
xor eax, eax
jmp short loc_314F7
loc_314EE:
mov eax, [rbx+60h]
lea ecx, [rax+1]
mov [rbx+60h], ecx
loc_314F7:
lea rsi, [rbp+var_35]
mov [rsi+3], al
mov rdi, rbx
call ma_net_write_buff
mov r13b, 1
test eax, eax
jnz short loc_31539
mov rdi, rbx
mov rsi, r15
mov rdx, r12
call ma_net_write_buff
test eax, eax
setnz r13b
cmp byte ptr [rbp+var_3C], 0
jnz short loc_31539
test eax, eax
jnz short loc_31539
mov rdi, rbx
call ma_net_flush
test eax, eax
setnz r13b
loc_31539:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_3155B
movzx eax, r13b
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3155B:
call ___stack_chk_fail
| _BOOL8 ma_net_write_command(long long a1, char a2, long long a3, unsigned long long a4, char a5)
{
int v6; // eax
unsigned long long v7; // rdx
unsigned long long v8; // r14
unsigned long long v9; // r12
bool v10; // r13
int v11; // eax
int v12; // eax
BOOL v13; // eax
__int16 v16; // [rsp+Bh] [rbp-35h] BYREF
char v17; // [rsp+Dh] [rbp-33h]
char v18; // [rsp+Eh] [rbp-32h]
char v19; // [rsp+Fh] [rbp-31h]
unsigned long long v20; // [rsp+10h] [rbp-30h]
v20 = __readfsqword(0x28u);
v6 = a4 + 1;
v19 = a2;
v7 = 5LL;
if ( a4 + 1 < 0xFFFFFF )
{
v9 = a4;
LABEL_11:
v16 = v6;
v17 = BYTE2(v6);
if ( *(_BYTE *)(a1 + 132) )
{
LOBYTE(v12) = 0;
}
else
{
v12 = *(_DWORD *)(a1 + 96);
*(_DWORD *)(a1 + 96) = v12 + 1;
}
v18 = v12;
v10 = 1;
if ( !ma_net_write_buff(a1, (long long)&v16, v7) )
{
v13 = ma_net_write_buff(a1, a3, v9);
v10 = v13;
if ( !a5 && !v13 )
return (unsigned int)ma_net_flush(a1) != 0;
}
}
else
{
v8 = 16777214LL;
v9 = a4 + 1;
v10 = 1;
while ( 1 )
{
v16 = -1;
v17 = -1;
if ( *(_BYTE *)(a1 + 132) )
{
LOBYTE(v11) = 0;
}
else
{
v11 = *(_DWORD *)(a1 + 96);
*(_DWORD *)(a1 + 96) = v11 + 1;
}
v18 = v11;
if ( ma_net_write_buff(a1, (long long)&v16, v7) || ma_net_write_buff(a1, a3, v8) )
break;
a3 += v8;
v9 -= 0xFFFFFFLL;
v7 = 4LL;
v8 = 0xFFFFFFLL;
v6 = v9;
if ( v9 <= 0xFFFFFE )
goto LABEL_11;
}
}
return v10;
}
| ma_net_write_command:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV dword ptr [RBP + -0x3c],R8D
MOV R15,RDX
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
LEA RAX,[RCX + 0x1]
MOV byte ptr [RBP + -0x31],SIL
MOV EDX,0x5
CMP RAX,0xffffff
JC 0x001314d2
MOV R14D,0xfffffe
MOV R12,RAX
MOV R13B,0x1
LAB_00131462:
MOV word ptr [RBP + -0x35],0xffff
MOV byte ptr [RBP + -0x33],0xff
CMP byte ptr [RBX + 0x84],0x0
JZ 0x00131479
XOR EAX,EAX
JMP 0x00131482
LAB_00131479:
MOV EAX,dword ptr [RBX + 0x60]
LEA ECX,[RAX + 0x1]
MOV dword ptr [RBX + 0x60],ECX
LAB_00131482:
MOV byte ptr [RBP + -0x32],AL
MOV RDI,RBX
LEA RSI,[RBP + -0x35]
CALL 0x001312fd
TEST EAX,EAX
JNZ 0x00131539
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x001312fd
TEST EAX,EAX
JNZ 0x00131539
ADD R15,R14
ADD R12,-0xffffff
MOV EDX,0x4
MOV R14D,0xffffff
MOV RAX,R12
CMP R12,0xfffffe
JA 0x00131462
JMP 0x001314d5
LAB_001314d2:
MOV R12,RCX
LAB_001314d5:
MOV byte ptr [RBP + -0x35],AL
MOV byte ptr [RBP + -0x34],AH
SHR EAX,0x10
MOV byte ptr [RBP + -0x33],AL
CMP byte ptr [RBX + 0x84],0x0
JZ 0x001314ee
XOR EAX,EAX
JMP 0x001314f7
LAB_001314ee:
MOV EAX,dword ptr [RBX + 0x60]
LEA ECX,[RAX + 0x1]
MOV dword ptr [RBX + 0x60],ECX
LAB_001314f7:
LEA RSI,[RBP + -0x35]
MOV byte ptr [RSI + 0x3],AL
MOV RDI,RBX
CALL 0x001312fd
MOV R13B,0x1
TEST EAX,EAX
JNZ 0x00131539
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R12
CALL 0x001312fd
TEST EAX,EAX
SETNZ R13B
CMP byte ptr [RBP + -0x3c],0x0
JNZ 0x00131539
TEST EAX,EAX
JNZ 0x00131539
MOV RDI,RBX
CALL 0x00130fba
TEST EAX,EAX
SETNZ R13B
LAB_00131539:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0013155b
MOVZX EAX,R13B
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013155b:
CALL 0x00113500
|
bool ma_net_write_command(long param_1,int1 param_2,long param_3,ulong param_4,char param_5)
{
int iVar1;
int8 uVar2;
ulong uVar3;
long lVar4;
long in_FS_OFFSET;
bool bVar5;
int2 local_3d;
int1 local_3b;
int1 local_3a;
int1 local_39;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
uVar3 = param_4 + 1;
uVar2 = 5;
local_39 = param_2;
if (0xfffffe < uVar3) {
lVar4 = 0xfffffe;
bVar5 = true;
do {
local_3d = 0xffff;
local_3b = 0xff;
if (*(char *)(param_1 + 0x84) == '\0') {
iVar1 = *(int *)(param_1 + 0x60);
*(int *)(param_1 + 0x60) = iVar1 + 1;
}
else {
iVar1 = 0;
}
local_3a = (int1)iVar1;
iVar1 = ma_net_write_buff(param_1,&local_3d,uVar2);
if ((iVar1 != 0) || (iVar1 = ma_net_write_buff(param_1,param_3,lVar4), iVar1 != 0))
goto LAB_00131539;
param_3 = param_3 + lVar4;
uVar3 = uVar3 - 0xffffff;
uVar2 = 4;
lVar4 = 0xffffff;
param_4 = uVar3;
} while (0xfffffe < uVar3);
}
local_3d = (int2)uVar3;
local_3b = (int1)(uVar3 >> 0x10);
if (*(char *)(param_1 + 0x84) == '\0') {
iVar1 = *(int *)(param_1 + 0x60);
*(int *)(param_1 + 0x60) = iVar1 + 1;
}
else {
iVar1 = 0;
}
local_3a = (int1)iVar1;
iVar1 = ma_net_write_buff(param_1,&local_3d,uVar2);
bVar5 = true;
if (iVar1 == 0) {
iVar1 = ma_net_write_buff(param_1,param_3,param_4);
bVar5 = iVar1 != 0;
if ((param_5 == '\0') && (iVar1 == 0)) {
iVar1 = ma_net_flush(param_1);
bVar5 = iVar1 != 0;
}
}
LAB_00131539:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return bVar5;
}
|
|
5,834 | llama_perf_context | monkey531[P]llama/src/llama.cpp | struct llama_perf_context_data llama_perf_context(const struct llama_context * ctx) {
struct llama_perf_context_data data = {};
if (ctx == nullptr) {
return data;
}
data.t_start_ms = 1e-3 * ctx->t_start_us;
data.t_load_ms = 1e-3 * ctx->t_load_us;
data.t_p_eval_ms = 1e-3 * ctx->t_p_eval_us;
data.t_eval_ms = 1e-3 * ctx->t_eval_us;
data.n_p_eval = std::max(1, ctx->n_p_eval);
data.n_eval = std::max(1, ctx->n_eval);
return data;
} | O2 | cpp | llama_perf_context:
movq %rdi, %rax
pxor %xmm0, %xmm0
movdqu %xmm0, 0x10(%rdi)
movdqu %xmm0, (%rdi)
andq $0x0, 0x20(%rdi)
testq %rsi, %rsi
je 0xaec9d
cvtsi2sdq 0x2d0(%rsi), %xmm0
cvtsi2sdq 0x2c8(%rsi), %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movapd 0x8f433(%rip), %xmm0 # 0x13e080
mulpd %xmm0, %xmm1
movupd %xmm1, (%rax)
cvtsi2sdq 0x2e0(%rsi), %xmm1
cvtsi2sdq 0x2d8(%rsi), %xmm2
unpcklpd %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
mulpd %xmm0, %xmm2
movupd %xmm2, 0x10(%rax)
movq 0x2f8(%rsi), %xmm0
movdqa 0x8f40c(%rip), %xmm1 # 0x13e090
movdqa %xmm0, %xmm2
pcmpgtd %xmm1, %xmm2
pand %xmm2, %xmm0
pandn %xmm1, %xmm2
por %xmm0, %xmm2
movq %xmm2, 0x20(%rax)
retq
| llama_perf_context:
mov rax, rdi
pxor xmm0, xmm0
movdqu xmmword ptr [rdi+10h], xmm0
movdqu xmmword ptr [rdi], xmm0
and qword ptr [rdi+20h], 0
test rsi, rsi
jz short locret_AEC9D
cvtsi2sd xmm0, qword ptr [rsi+2D0h]
cvtsi2sd xmm1, qword ptr [rsi+2C8h]
unpcklpd xmm1, xmm0
movapd xmm0, cs:xmmword_13E080
mulpd xmm1, xmm0
movupd xmmword ptr [rax], xmm1
cvtsi2sd xmm1, qword ptr [rsi+2E0h]
cvtsi2sd xmm2, qword ptr [rsi+2D8h]
unpcklpd xmm2, xmm1
mulpd xmm2, xmm0
movupd xmmword ptr [rax+10h], xmm2
movq xmm0, qword ptr [rsi+2F8h]
movdqa xmm1, cs:xmmword_13E090
movdqa xmm2, xmm0
pcmpgtd xmm2, xmm1
pand xmm0, xmm2
pandn xmm2, xmm1
por xmm2, xmm0
movq qword ptr [rax+20h], xmm2
locret_AEC9D:
retn
| long long llama_perf_context(long long a1, long long a2, double a3, __m128d a4, __m128d a5)
{
long long result; // rax
__m128d v6; // xmm0
__m128d v7; // xmm1
__m128i v8; // xmm0
__m128i si128; // xmm1
__m128i v10; // xmm2
result = a1;
v6 = 0LL;
*(_OWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 32) = 0LL;
if ( a2 )
{
v6.m128d_f64[0] = (double)(int)*(_QWORD *)(a2 + 720);
a4.m128d_f64[0] = (double)(int)*(_QWORD *)(a2 + 712);
v7 = _mm_mul_pd(_mm_unpacklo_pd(a4, v6), (__m128d)xmmword_13E080);
*(__m128d *)a1 = v7;
v7.m128d_f64[0] = (double)(int)*(_QWORD *)(a2 + 736);
a5.m128d_f64[0] = (double)(int)*(_QWORD *)(a2 + 728);
*(__m128d *)(a1 + 16) = _mm_mul_pd(_mm_unpacklo_pd(a5, v7), (__m128d)xmmword_13E080);
v8 = _mm_loadl_epi64((const __m128i *)(a2 + 760));
si128 = _mm_load_si128((const __m128i *)&xmmword_13E090);
v10 = _mm_cmpgt_epi32(v8, si128);
*(_QWORD *)(a1 + 32) = _mm_or_si128(_mm_andnot_si128(v10, si128), _mm_and_si128(v8, v10)).m128i_u64[0];
}
return result;
}
| llama_perf_context:
MOV RAX,RDI
PXOR XMM0,XMM0
MOVDQU xmmword ptr [RDI + 0x10],XMM0
MOVDQU xmmword ptr [RDI],XMM0
AND qword ptr [RDI + 0x20],0x0
TEST RSI,RSI
JZ 0x001aec9d
CVTSI2SD XMM0,qword ptr [RSI + 0x2d0]
CVTSI2SD XMM1,qword ptr [RSI + 0x2c8]
UNPCKLPD XMM1,XMM0
MOVAPD XMM0,xmmword ptr [0x0023e080]
MULPD XMM1,XMM0
MOVUPD xmmword ptr [RAX],XMM1
CVTSI2SD XMM1,qword ptr [RSI + 0x2e0]
CVTSI2SD XMM2,qword ptr [RSI + 0x2d8]
UNPCKLPD XMM2,XMM1
MULPD XMM2,XMM0
MOVUPD xmmword ptr [RAX + 0x10],XMM2
MOVQ XMM0,qword ptr [RSI + 0x2f8]
MOVDQA XMM1,xmmword ptr [0x0023e090]
MOVDQA XMM2,XMM0
PCMPGTD XMM2,XMM1
PAND XMM0,XMM2
PANDN XMM2,XMM1
POR XMM2,XMM0
MOVQ qword ptr [RAX + 0x20],XMM2
LAB_001aec9d:
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void llama_perf_context(int1 (*param_1) [16],long param_2)
{
long lVar1;
uint uVar2;
uint uVar3;
double dVar4;
double dVar5;
double dVar6;
uint uVar7;
uint uVar8;
param_1[1] = (int1 [16])0x0;
*param_1 = (int1 [16])0x0;
*(int8 *)param_1[2] = 0;
dVar5 = _UNK_0023e088;
dVar4 = _DAT_0023e080;
if (param_2 != 0) {
dVar6 = (double)*(long *)(param_2 + 0x2d0) * _UNK_0023e088;
*(double *)*param_1 = (double)*(long *)(param_2 + 0x2c8) * _DAT_0023e080;
*(double *)(*param_1 + 8) = dVar6;
lVar1 = *(long *)(param_2 + 0x2e0);
*(double *)param_1[1] = (double)*(long *)(param_2 + 0x2d8) * dVar4;
*(double *)(param_1[1] + 8) = (double)lVar1 * dVar5;
uVar3 = *(uint *)(param_2 + 0x2fc);
uVar7 = -(uint)((int)_DAT_0023e090 < (int)*(uint *)(param_2 + 0x2f8));
uVar8 = -(uint)((int)_UNK_0023e094 < (int)uVar3);
uVar2 = ~uVar8 & _UNK_0023e094;
*(uint *)param_1[2] = ~uVar7 & _DAT_0023e090 | *(uint *)(param_2 + 0x2f8) & uVar7;
*(uint *)(param_1[2] + 4) = uVar2 | uVar3 & uVar8;
}
return;
}
|
|
5,835 | seek_io_cache | eloqsql/mysys/mf_iocache.c | void seek_io_cache(IO_CACHE *cache, my_off_t needed_offset)
{
my_off_t cached_data_start= cache->pos_in_file;
my_off_t cached_data_end= cache->pos_in_file + (cache->read_end -
cache->buffer);
if (needed_offset >= cached_data_start &&
needed_offset < cached_data_end)
{
/*
The offset we're seeking to is in the buffer.
Move buffer's read position accordingly
*/
cache->read_pos= cache->buffer + (needed_offset - cached_data_start);
}
else
{
if (needed_offset > cache->end_of_file)
needed_offset= cache->end_of_file;
/*
The offset we're seeking to is not in the buffer.
- Set the buffer to be exhausted.
- Make the next read to a mysql_file_seek() call to the required
offset.
TODO(cvicentiu, spetrunia) properly implement aligned seeks for
efficiency.
*/
cache->seek_not_done= 1;
cache->pos_in_file= needed_offset;
/* When reading it must appear as if we've started from the offset
that we've seeked here. We must let _my_b_cache_read assume that
by implying "no reading starting from pos_in_file" has happened. */
cache->read_pos= cache->buffer;
cache->read_end= cache->buffer;
}
} | O0 | c | seek_io_cache:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq -0x8(%rbp), %rdx
movq 0x20(%rdx), %rdx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0xe0539
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xe0539
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
subq -0x18(%rbp), %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xe058c
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0xe0553
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, 0xe0(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
popq %rbp
retq
nop
| seek_io_cache:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_18], rax
mov rax, [rbp+var_8]
mov rax, [rax]
mov rcx, [rbp+var_8]
mov rcx, [rcx+18h]
mov rdx, [rbp+var_8]
mov rdx, [rdx+20h]
sub rcx, rdx
add rax, rcx
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
cmp rax, [rbp+var_18]
jb short loc_E0539
mov rax, [rbp+var_10]
cmp rax, [rbp+var_20]
jnb short loc_E0539
mov rax, [rbp+var_8]
mov rcx, [rax+20h]
mov rax, [rbp+var_10]
sub rax, [rbp+var_18]
add rcx, rax
mov rax, [rbp+var_8]
mov [rax+10h], rcx
jmp short loc_E058C
loc_E0539:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_8]
cmp rax, [rcx+8]
jbe short loc_E0553
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov [rbp+var_10], rax
loc_E0553:
mov rax, [rbp+var_8]
mov dword ptr [rax+0E0h], 1
mov rcx, [rbp+var_10]
mov rax, [rbp+var_8]
mov [rax], rcx
mov rax, [rbp+var_8]
mov rcx, [rax+20h]
mov rax, [rbp+var_8]
mov [rax+10h], rcx
mov rax, [rbp+var_8]
mov rcx, [rax+20h]
mov rax, [rbp+var_8]
mov [rax+18h], rcx
loc_E058C:
pop rbp
retn
| long long seek_io_cache(long long a1, unsigned long long a2)
{
long long result; // rax
unsigned long long v3; // [rsp+10h] [rbp-10h]
v3 = a2;
if ( a2 < *(_QWORD *)a1 || a2 >= *(_QWORD *)(a1 + 24) - *(_QWORD *)(a1 + 32) + *(_QWORD *)a1 )
{
if ( a2 > *(_QWORD *)(a1 + 8) )
v3 = *(_QWORD *)(a1 + 8);
*(_DWORD *)(a1 + 224) = 1;
*(_QWORD *)a1 = v3;
*(_QWORD *)(a1 + 16) = *(_QWORD *)(a1 + 32);
result = a1;
*(_QWORD *)(a1 + 24) = *(_QWORD *)(a1 + 32);
}
else
{
result = a1;
*(_QWORD *)(a1 + 16) = a2 - *(_QWORD *)a1 + *(_QWORD *)(a1 + 32);
}
return result;
}
| seek_io_cache:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RCX + 0x18]
MOV RDX,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RDX + 0x20]
SUB RCX,RDX
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x18]
JC 0x001e0539
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x001e0539
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x10]
SUB RAX,qword ptr [RBP + -0x18]
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x10],RCX
JMP 0x001e058c
LAB_001e0539:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RCX + 0x8]
JBE 0x001e0553
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x10],RAX
LAB_001e0553:
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0xe0],0x1
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x18],RCX
LAB_001e058c:
POP RBP
RET
|
void seek_io_cache(ulong *param_1,ulong param_2)
{
ulong local_18;
if ((param_2 < *param_1) || (*param_1 + (param_1[3] - param_1[4]) <= param_2)) {
local_18 = param_2;
if (param_1[1] < param_2) {
local_18 = param_1[1];
}
*(int4 *)(param_1 + 0x1c) = 1;
*param_1 = local_18;
param_1[2] = param_1[4];
param_1[3] = param_1[4];
}
else {
param_1[2] = param_1[4] + (param_2 - *param_1);
}
return;
}
|
|
5,836 | 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;
}
|
|
5,837 | 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;
}
|
|
5,838 | my_casedn_ucs2 | eloqsql/strings/ctype-ucs2.c | static size_t my_casedn_ucs2(CHARSET_INFO *cs, const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
int res;
const char *srcend= src + srclen;
char *dstend= dst + dstlen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(srclen <= dstlen);
while ((src < srcend) &&
(res= my_ucs2_uni(cs, &wc, (uchar*) src, (uchar*) srcend)) > 0)
{
my_tolower_ucs2(uni_plane, &wc);
if (res != my_uni_ucs2(cs, wc, (uchar*) dst, (uchar*) dstend))
break;
src+= res;
dst+= res;
}
return srclen;
} | O3 | c | my_casedn_ucs2:
movq %rdx, %rax
cmpq $0x2, %rdx
jl 0x488ee
pushq %rbp
movq %rsp, %rbp
leaq (%rsi,%rax), %rdx
addq %rcx, %r8
movq 0x78(%rdi), %rdi
addq $0x2, %rcx
movzbl (%rsi), %r9d
movzbl 0x1(%rsi), %r10d
movq 0x8(%rdi), %r11
movq (%r11,%r9,8), %r11
testq %r11, %r11
je 0x488b5
leaq (%r10,%r10,2), %r9
movl 0x4(%r11,%r9,4), %r9d
jmp 0x488bc
shll $0x8, %r9d
orq %r10, %r9
cmpq %r8, %rcx
ja 0x488ed
cmpl $0xffff, %r9d # imm = 0xFFFF
ja 0x488ed
rolw $0x8, %r9w
movw %r9w, -0x2(%rcx)
leaq 0x2(%rsi), %r9
cmpq %rdx, %r9
jae 0x488ed
addq $0x4, %rsi
addq $0x2, %rcx
cmpq %rdx, %rsi
movq %r9, %rsi
jbe 0x48894
popq %rbp
retq
| my_casedn_ucs2:
mov rax, rdx
cmp rdx, 2
jl short locret_488EE
push rbp
mov rbp, rsp
lea rdx, [rsi+rax]
add r8, rcx
mov rdi, [rdi+78h]
add rcx, 2
loc_48894:
movzx r9d, byte ptr [rsi]
movzx r10d, byte ptr [rsi+1]
mov r11, [rdi+8]
mov r11, [r11+r9*8]
test r11, r11
jz short loc_488B5
lea r9, [r10+r10*2]
mov r9d, [r11+r9*4+4]
jmp short loc_488BC
loc_488B5:
shl r9d, 8
or r9, r10
loc_488BC:
cmp rcx, r8
ja short loc_488ED
cmp r9d, 0FFFFh
ja short loc_488ED
rol r9w, 8
mov [rcx-2], r9w
lea r9, [rsi+2]
cmp r9, rdx
jnb short loc_488ED
add rsi, 4
add rcx, 2
cmp rsi, rdx
mov rsi, r9
jbe short loc_48894
loc_488ED:
pop rbp
locret_488EE:
retn
| long long my_casedn_ucs2(long long a1, unsigned __int8 *a2, long long a3, long long a4, long long a5)
{
long long result; // rax
unsigned long long v6; // rdx
unsigned long long v7; // r8
long long v8; // rdi
unsigned long long v9; // rcx
long long v10; // r9
long long v11; // r10
long long v12; // r11
unsigned int v13; // r9d
bool v14; // cc
result = a3;
if ( a3 >= 2 )
{
v6 = (unsigned long long)&a2[a3];
v7 = a4 + a5;
v8 = *(_QWORD *)(a1 + 120);
v9 = a4 + 2;
do
{
v10 = *a2;
v11 = a2[1];
v12 = *(_QWORD *)(*(_QWORD *)(v8 + 8) + 8 * v10);
if ( v12 )
v13 = *(_DWORD *)(v12 + 12 * v11 + 4);
else
v13 = v11 | ((_DWORD)v10 << 8);
if ( v9 > v7 )
break;
if ( v13 > 0xFFFF )
break;
*(_WORD *)(v9 - 2) = __ROL2__(v13, 8);
if ( (unsigned long long)(a2 + 2) >= v6 )
break;
v9 += 2LL;
v14 = (unsigned long long)(a2 + 4) <= v6;
a2 += 2;
}
while ( v14 );
}
return result;
}
| my_casedn_ucs2:
MOV RAX,RDX
CMP RDX,0x2
JL 0x001488ee
PUSH RBP
MOV RBP,RSP
LEA RDX,[RSI + RAX*0x1]
ADD R8,RCX
MOV RDI,qword ptr [RDI + 0x78]
ADD RCX,0x2
LAB_00148894:
MOVZX R9D,byte ptr [RSI]
MOVZX R10D,byte ptr [RSI + 0x1]
MOV R11,qword ptr [RDI + 0x8]
MOV R11,qword ptr [R11 + R9*0x8]
TEST R11,R11
JZ 0x001488b5
LEA R9,[R10 + R10*0x2]
MOV R9D,dword ptr [R11 + R9*0x4 + 0x4]
JMP 0x001488bc
LAB_001488b5:
SHL R9D,0x8
OR R9,R10
LAB_001488bc:
CMP RCX,R8
JA 0x001488ed
CMP R9D,0xffff
JA 0x001488ed
ROL R9W,0x8
MOV word ptr [RCX + -0x2],R9W
LEA R9,[RSI + 0x2]
CMP R9,RDX
JNC 0x001488ed
ADD RSI,0x4
ADD RCX,0x2
CMP RSI,RDX
MOV RSI,R9
JBE 0x00148894
LAB_001488ed:
POP RBP
LAB_001488ee:
RET
|
void my_casedn_ucs2(long param_1,byte *param_2,long param_3,long param_4,long param_5)
{
long lVar1;
long lVar2;
ulong uVar3;
byte *pbVar4;
byte *pbVar5;
uint uVar6;
if (1 < param_3) {
lVar1 = *(long *)(param_1 + 0x78);
uVar3 = param_4 + 2;
pbVar4 = param_2;
while( true ) {
lVar2 = *(long *)(*(long *)(lVar1 + 8) + (ulong)*pbVar4 * 8);
if (lVar2 == 0) {
uVar6 = (uint)CONCAT11(*pbVar4,pbVar4[1]);
}
else {
uVar6 = *(uint *)(lVar2 + 4 + (ulong)pbVar4[1] * 0xc);
}
if (((ulong)(param_5 + param_4) < uVar3) || (0xffff < uVar6)) break;
*(ushort *)(uVar3 - 2) = (ushort)uVar6 << 8 | (ushort)uVar6 >> 8;
if (param_2 + param_3 <= pbVar4 + 2) {
return;
}
pbVar5 = pbVar4 + 4;
uVar3 = uVar3 + 2;
pbVar4 = pbVar4 + 2;
if (param_2 + param_3 < pbVar5) {
return;
}
}
}
return;
}
|
|
5,839 | ma_net_write | eloqsql/libmariadb/libmariadb/ma_net.c | int ma_net_write(NET *net, const uchar *packet, size_t len)
{
uchar buff[NET_HEADER_SIZE];
while (len >= MAX_PACKET_LENGTH)
{
const ulong max_len= MAX_PACKET_LENGTH;
int3store(buff,max_len);
buff[3]= (uchar)net->pkt_nr++;
if (ma_net_write_buff(net,(char*) buff,NET_HEADER_SIZE) ||
ma_net_write_buff(net, (char *)packet, max_len))
return 1;
packet+= max_len;
len-= max_len;
}
/* write last remaining packet, size can be zero */
int3store(buff, len);
buff[3]= (uchar)net->pkt_nr++;
if (ma_net_write_buff(net,(char*) buff,NET_HEADER_SIZE) ||
ma_net_write_buff(net, (char *)packet, len))
return 1;
return 0;
} | O3 | c | ma_net_write:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
cmpq $0xffffff, %rdx # imm = 0xFFFFFF
jb 0x38220
leaq -0x34(%rbp), %r12
movl $0x1, %r13d
movw $0xffff, -0x34(%rbp) # imm = 0xFFFF
movb $-0x1, -0x32(%rbp)
movl 0x60(%r15), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x60(%r15)
movb %al, -0x31(%rbp)
movl $0x4, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x3828d
testl %eax, %eax
jne 0x38267
movl $0xffffff, %edx # imm = 0xFFFFFF
movq %r15, %rdi
movq %r14, %rsi
callq 0x3828d
testl %eax, %eax
jne 0x38267
addq $0xffffff, %r14 # imm = 0xFFFFFF
addq $-0xffffff, %rbx # imm = 0xFF000001
cmpq $0xfffffe, %rbx # imm = 0xFFFFFE
ja 0x381c9
leaq -0x34(%rbp), %rsi
movb %bl, (%rsi)
movb %bh, -0x33(%rbp)
movl %ebx, %eax
shrl $0x10, %eax
movb %al, 0x2(%rsi)
movl 0x60(%r15), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x60(%r15)
movb %al, 0x3(%rsi)
movl $0x4, %edx
movq %r15, %rdi
callq 0x3828d
movl $0x1, %r13d
testl %eax, %eax
jne 0x38267
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3828d
movl %eax, %r13d
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x38288
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13530
| ma_net_write:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
cmp rdx, 0FFFFFFh
jb short loc_38220
lea r12, [rbp+var_34]
mov r13d, 1
loc_381C9:
mov [rbp+var_34], 0FFFFh
mov [rbp+var_32], 0FFh
mov eax, [r15+60h]
lea ecx, [rax+1]
mov [r15+60h], ecx
mov [rbp+var_31], al
mov edx, 4
mov rdi, r15
mov rsi, r12
call ma_net_write_buff
test eax, eax
jnz short loc_38267
mov edx, 0FFFFFFh
mov rdi, r15
mov rsi, r14
call ma_net_write_buff
test eax, eax
jnz short loc_38267
add r14, 0FFFFFFh
add rbx, 0FFFFFFFFFF000001h
cmp rbx, 0FFFFFEh
ja short loc_381C9
loc_38220:
lea rsi, [rbp+var_34]
mov [rsi], bl
mov byte ptr [rbp+var_34+1], bh
mov eax, ebx
shr eax, 10h
mov [rsi+2], al
mov eax, [r15+60h]
lea ecx, [rax+1]
mov [r15+60h], ecx
mov [rsi+3], al
mov edx, 4
mov rdi, r15
call ma_net_write_buff
mov r13d, 1
test eax, eax
jnz short loc_38267
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call ma_net_write_buff
mov r13d, eax
loc_38267:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_38288
mov eax, r13d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_38288:
call ___stack_chk_fail
| long long ma_net_write(long long a1, long long a2, unsigned long long a3)
{
unsigned long long v3; // rbx
unsigned int v5; // r13d
int v6; // eax
int v7; // eax
__int16 v9; // [rsp+Ch] [rbp-34h] BYREF
char v10; // [rsp+Eh] [rbp-32h]
char v11; // [rsp+Fh] [rbp-31h]
unsigned long long v12; // [rsp+10h] [rbp-30h]
v3 = a3;
v12 = __readfsqword(0x28u);
if ( a3 < 0xFFFFFF )
{
LABEL_6:
v9 = v3;
v10 = BYTE2(v3);
v7 = *(_DWORD *)(a1 + 96);
*(_DWORD *)(a1 + 96) = v7 + 1;
v11 = v7;
v5 = 1;
if ( !(unsigned int)ma_net_write_buff(a1, &v9, 4LL) )
return (unsigned int)ma_net_write_buff(a1, a2, v3);
}
else
{
v5 = 1;
while ( 1 )
{
v9 = -1;
v10 = -1;
v6 = *(_DWORD *)(a1 + 96);
*(_DWORD *)(a1 + 96) = v6 + 1;
v11 = v6;
if ( (unsigned int)ma_net_write_buff(a1, &v9, 4LL) || (unsigned int)ma_net_write_buff(a1, a2, 0xFFFFFFLL) )
break;
a2 += 0xFFFFFFLL;
v3 -= 0xFFFFFFLL;
if ( v3 <= 0xFFFFFE )
goto LABEL_6;
}
}
return v5;
}
| ma_net_write:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
CMP RDX,0xffffff
JC 0x00138220
LEA R12,[RBP + -0x34]
MOV R13D,0x1
LAB_001381c9:
MOV word ptr [RBP + -0x34],0xffff
MOV byte ptr [RBP + -0x32],0xff
MOV EAX,dword ptr [R15 + 0x60]
LEA ECX,[RAX + 0x1]
MOV dword ptr [R15 + 0x60],ECX
MOV byte ptr [RBP + -0x31],AL
MOV EDX,0x4
MOV RDI,R15
MOV RSI,R12
CALL 0x0013828d
TEST EAX,EAX
JNZ 0x00138267
MOV EDX,0xffffff
MOV RDI,R15
MOV RSI,R14
CALL 0x0013828d
TEST EAX,EAX
JNZ 0x00138267
ADD R14,0xffffff
ADD RBX,-0xffffff
CMP RBX,0xfffffe
JA 0x001381c9
LAB_00138220:
LEA RSI,[RBP + -0x34]
MOV byte ptr [RSI],BL
MOV byte ptr [RBP + -0x33],BH
MOV EAX,EBX
SHR EAX,0x10
MOV byte ptr [RSI + 0x2],AL
MOV EAX,dword ptr [R15 + 0x60]
LEA ECX,[RAX + 0x1]
MOV dword ptr [R15 + 0x60],ECX
MOV byte ptr [RSI + 0x3],AL
MOV EDX,0x4
MOV RDI,R15
CALL 0x0013828d
MOV R13D,0x1
TEST EAX,EAX
JNZ 0x00138267
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x0013828d
MOV R13D,EAX
LAB_00138267:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00138288
MOV EAX,R13D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00138288:
CALL 0x00113530
|
int4 ma_net_write(long param_1,long param_2,ulong param_3)
{
int iVar1;
int4 uVar2;
long in_FS_OFFSET;
int2 local_3c;
int1 local_3a;
int1 local_39;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
if (0xfffffe < param_3) {
uVar2 = 1;
do {
local_3c = 0xffff;
local_3a = 0xff;
iVar1 = *(int *)(param_1 + 0x60);
*(int *)(param_1 + 0x60) = iVar1 + 1;
local_39 = (int1)iVar1;
iVar1 = ma_net_write_buff(param_1,&local_3c,4);
if (iVar1 != 0) goto LAB_00138267;
iVar1 = ma_net_write_buff(param_1,param_2,0xffffff);
if (iVar1 != 0) goto LAB_00138267;
param_2 = param_2 + 0xffffff;
param_3 = param_3 - 0xffffff;
} while (0xfffffe < param_3);
}
local_3c = (int2)param_3;
local_3a = (int1)(param_3 >> 0x10);
iVar1 = *(int *)(param_1 + 0x60);
*(int *)(param_1 + 0x60) = iVar1 + 1;
local_39 = (int1)iVar1;
iVar1 = ma_net_write_buff(param_1,&local_3c,4);
uVar2 = 1;
if (iVar1 == 0) {
uVar2 = ma_net_write_buff(param_1,param_2,param_3);
}
LAB_00138267:
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return uVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
5,840 | SearchFree | seiftnesse[P]memoryallocator/src/custom_alloc_util.c | segment_t *SearchFree(segment_t *s, int size) {
segment_t *best_fit = NULL;
int best_size = INT_MAX;
HEAP_LOG("Searching for free segment: required blocks=%d\n", size);
// Best-fit strategy: find smallest free block that fits
while (s) {
if (s->is_free && s->size >= size) {
check_memory_corruption(s);
if (s->size < best_size) {
best_fit = s;
best_size = s->size;
HEAP_LOG("Found potential segment: addr=%p, size=%d blocks\n", s, s->size);
// Perfect fit - return immediately
if (s->size == size) {
HEAP_LOG("Perfect fit found at %p\n", s);
return s;
}
}
}
s = s->next;
}
if (best_fit) {
HEAP_LOG("Best fit segment found: addr=%p, size=%d blocks\n", best_fit, best_fit->size);
} else {
HEAP_LOG("No suitable free segment found\n");
}
return best_fit;
} | O1 | c | SearchFree:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3a65
movl %esi, %ebp
movq %rdi, %rbx
movl $0x7fffffff, %r15d # imm = 0x7FFFFFFF
xorl %r14d, %r14d
cmpl $0x0, (%rbx)
je 0x3a5a
cmpl %ebp, 0x4(%rbx)
jl 0x3a5a
movq %rbx, %rdi
callq 0x4258
movl 0x4(%rbx), %eax
cmpl %r15d, %eax
jge 0x3a5a
movq %rbx, %r14
movl %eax, %r15d
cmpl %ebp, %eax
je 0x3a76
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x3a36
jmp 0x3a68
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %r14
jmp 0x3a68
| SearchFree:
push rbp
push r15
push r14
push rbx
push rax
test rdi, rdi
jz short loc_3A65
mov ebp, esi
mov rbx, rdi
mov r15d, 7FFFFFFFh
xor r14d, r14d
loc_3A36:
cmp dword ptr [rbx], 0
jz short loc_3A5A
cmp [rbx+4], ebp
jl short loc_3A5A
mov rdi, rbx
call check_memory_corruption
mov eax, [rbx+4]
cmp eax, r15d
jge short loc_3A5A
mov r14, rbx
mov r15d, eax
cmp eax, ebp
jz short loc_3A76
loc_3A5A:
mov rbx, [rbx+8]
test rbx, rbx
jnz short loc_3A36
jmp short loc_3A68
loc_3A65:
xor r14d, r14d
loc_3A68:
mov rax, r14
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_3A76:
mov r14, rbx
jmp short loc_3A68
| long long SearchFree(long long a1, int a2)
{
long long v2; // rbx
int v3; // r15d
long long v4; // r14
int v5; // eax
if ( !a1 )
return 0LL;
v2 = a1;
v3 = 0x7FFFFFFF;
v4 = 0LL;
while ( 1 )
{
if ( *(_DWORD *)v2 )
{
if ( *(_DWORD *)(v2 + 4) >= a2 )
{
check_memory_corruption(v2);
v5 = *(_DWORD *)(v2 + 4);
if ( v5 < v3 )
{
v4 = v2;
v3 = *(_DWORD *)(v2 + 4);
if ( v5 == a2 )
break;
}
}
}
v2 = *(_QWORD *)(v2 + 8);
if ( !v2 )
return v4;
}
return v2;
}
| SearchFree:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
TEST RDI,RDI
JZ 0x00103a65
MOV EBP,ESI
MOV RBX,RDI
MOV R15D,0x7fffffff
XOR R14D,R14D
LAB_00103a36:
CMP dword ptr [RBX],0x0
JZ 0x00103a5a
CMP dword ptr [RBX + 0x4],EBP
JL 0x00103a5a
MOV RDI,RBX
CALL 0x00104258
MOV EAX,dword ptr [RBX + 0x4]
CMP EAX,R15D
JGE 0x00103a5a
MOV R14,RBX
MOV R15D,EAX
CMP EAX,EBP
JZ 0x00103a76
LAB_00103a5a:
MOV RBX,qword ptr [RBX + 0x8]
TEST RBX,RBX
JNZ 0x00103a36
JMP 0x00103a68
LAB_00103a65:
XOR R14D,R14D
LAB_00103a68:
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00103a76:
MOV R14,RBX
JMP 0x00103a68
|
int * SearchFree(int *param_1,int param_2)
{
int iVar1;
int *piVar2;
int iVar3;
if (param_1 == (int *)0x0) {
piVar2 = (int *)0x0;
}
else {
iVar3 = 0x7fffffff;
piVar2 = (int *)0x0;
do {
if ((*param_1 != 0) && (param_2 <= param_1[1])) {
check_memory_corruption(param_1);
iVar1 = param_1[1];
if ((iVar1 < iVar3) && (piVar2 = param_1, iVar3 = iVar1, iVar1 == param_2)) {
return param_1;
}
}
param_1 = *(int **)(param_1 + 2);
} while (param_1 != (int *)0x0);
}
return piVar2;
}
|
|
5,841 | set_account_key(PFS_account_key*, char const*, unsigned int, char const*, unsigned int) | eloqsql/storage/perfschema/pfs_account.cc | static void set_account_key(PFS_account_key *key,
const char *user, uint user_length,
const char *host, uint host_length)
{
assert(user_length <= USERNAME_LENGTH);
assert(host_length <= HOSTNAME_LENGTH);
char *ptr= &key->m_hash_key[0];
if (user_length > 0)
{
memcpy(ptr, user, user_length);
ptr+= user_length;
}
ptr[0]= 0;
ptr++;
if (host_length > 0)
{
memcpy(ptr, host, host_length);
ptr+= host_length;
}
ptr[0]= 0;
ptr++;
key->m_key_length= (uint)(ptr - &key->m_hash_key[0]);
} | O0 | cpp | set_account_key(PFS_account_key*, char const*, unsigned int, char const*, unsigned int):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x14(%rbp)
jbe 0x52b1b
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x26280
movl -0x14(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x24(%rbp)
jbe 0x52b56
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %eax
movl %eax, %edx
callq 0x26280
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x284(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZL15set_account_keyP15PFS_account_keyPKcjS2_j:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_20], rcx
mov [rbp+var_24], r8d
mov rax, [rbp+var_8]
mov [rbp+var_30], rax
cmp [rbp+var_14], 0
jbe short loc_52B1B
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_10]
mov eax, [rbp+var_14]
mov edx, eax
call _memcpy
mov ecx, [rbp+var_14]
mov rax, [rbp+var_30]
mov ecx, ecx
add rax, rcx
mov [rbp+var_30], rax
loc_52B1B:
mov rax, [rbp+var_30]
mov byte ptr [rax], 0
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_30], rax
cmp [rbp+var_24], 0
jbe short loc_52B56
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_20]
mov eax, [rbp+var_24]
mov edx, eax
call _memcpy
mov ecx, [rbp+var_24]
mov rax, [rbp+var_30]
mov ecx, ecx
add rax, rcx
mov [rbp+var_30], rax
loc_52B56:
mov rax, [rbp+var_30]
mov byte ptr [rax], 0
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
mov rcx, [rbp+var_8]
sub rax, rcx
mov ecx, eax
mov rax, [rbp+var_8]
mov [rax+284h], ecx
add rsp, 30h
pop rbp
retn
| long long set_account_key(long long a1, long long a2, unsigned int a3, long long a4, unsigned int a5)
{
long long result; // rax
_BYTE *v6; // [rsp+0h] [rbp-30h]
_BYTE *v7; // [rsp+0h] [rbp-30h]
v6 = (_BYTE *)a1;
if ( a3 )
{
memcpy(a1, a2, a3);
v6 = (_BYTE *)(a3 + a1);
}
*v6 = 0;
v7 = v6 + 1;
if ( a5 )
{
memcpy(v7, a4, a5);
v7 += a5;
}
*v7 = 0;
result = a1;
*(_DWORD *)(a1 + 644) = (_DWORD)v7 + 1 - a1;
return result;
}
| set_account_key:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV dword ptr [RBP + -0x24],R8D
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x30],RAX
CMP dword ptr [RBP + -0x14],0x0
JBE 0x00152b1b
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x14]
MOV EDX,EAX
CALL 0x00126280
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
LAB_00152b1b:
MOV RAX,qword ptr [RBP + -0x30]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
CMP dword ptr [RBP + -0x24],0x0
JBE 0x00152b56
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RBP + -0x24]
MOV EDX,EAX
CALL 0x00126280
MOV ECX,dword ptr [RBP + -0x24]
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
LAB_00152b56:
MOV RAX,qword ptr [RBP + -0x30]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x8]
SUB RAX,RCX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x284],ECX
ADD RSP,0x30
POP RBP
RET
|
/* set_account_key(PFS_account_key*, char const*, unsigned int, char const*, unsigned int) */
void set_account_key(PFS_account_key *param_1,char *param_2,uint param_3,char *param_4,uint param_5)
{
PFS_account_key *local_38;
local_38 = param_1;
if (param_3 != 0) {
memcpy(param_1,param_2,(ulong)param_3);
local_38 = param_1 + param_3;
}
*local_38 = (PFS_account_key)0x0;
local_38 = local_38 + 1;
if (param_5 != 0) {
memcpy(local_38,param_4,(ulong)param_5);
local_38 = local_38 + param_5;
}
*local_38 = (PFS_account_key)0x0;
*(int *)(param_1 + 0x284) = ((int)local_38 + 1) - (int)param_1;
return;
}
|
|
5,842 | ft_stroker_cap | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-ft-stroker.c | static PVG_FT_Error
ft_stroker_cap(PVG_FT_Stroker stroker,
PVG_FT_Angle angle,
PVG_FT_Int side)
{
PVG_FT_Error error = 0;
if (stroker->line_cap == PVG_FT_STROKER_LINECAP_ROUND)
{
/* add a round cap */
stroker->angle_in = angle;
stroker->angle_out = angle + PVG_FT_ANGLE_PI;
error = ft_stroker_arcto(stroker, side);
}
else
{
/* add a square or butt cap */
PVG_FT_Vector middle, delta;
PVG_FT_Fixed radius = stroker->radius;
PVG_FT_StrokeBorder border = stroker->borders + side;
/* compute middle point and first angle point */
PVG_FT_Vector_From_Polar( &middle, radius, angle );
delta.x = side ? middle.y : -middle.y;
delta.y = side ? -middle.x : middle.x;
if ( stroker->line_cap == PVG_FT_STROKER_LINECAP_SQUARE )
{
middle.x += stroker->center.x;
middle.y += stroker->center.y;
}
else /* PVG_FT_STROKER_LINECAP_BUTT */
{
middle.x = stroker->center.x;
middle.y = stroker->center.y;
}
delta.x += middle.x;
delta.y += middle.y;
error = ft_stroke_border_lineto( border, &delta, FALSE );
if ( error )
goto Exit;
/* compute second angle point */
delta.x = middle.x - delta.x + middle.x;
delta.y = middle.y - delta.y + middle.y;
error = ft_stroke_border_lineto( border, &delta, FALSE );
}
Exit:
return error;
} | O1 | c | ft_stroker_cap:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rdx
movq %rdi, %r14
cmpl $0x1, 0x54(%rdi)
jne 0x3e38f
movq %rdx, (%r14)
addq $0xb40000, %rdx # imm = 0xB40000
movq %rdx, 0x8(%r14)
movq %r14, %rdi
xorl %esi, %esi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3f03a
movq 0x68(%r14), %rsi
leaq 0x70(%r14), %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x42802
movq (%r15), %r12
movq 0x8(%r15), %rax
movq %rax, %rcx
negq %rcx
movq %rcx, 0x18(%rsp)
movq %r12, 0x20(%rsp)
cmpl $0x2, 0x54(%r14)
movq 0x10(%r14), %rcx
jne 0x3e3d7
addq %r12, %rcx
movq %rcx, 0x8(%rsp)
movq 0x18(%r14), %rcx
addq %rax, %rcx
jmp 0x3e3e0
movq %rcx, 0x8(%rsp)
movq 0x18(%r14), %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rsp), %r15
subq %rax, %r15
leaq 0x18(%rsp), %r14
movq %r15, (%r14)
addq %rcx, %r12
movq %r12, 0x8(%r14)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3d138
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
addq %rax, %rax
subq %r15, %rax
movq %rax, (%r14)
addq %rcx, %rcx
subq %r12, %rcx
movq %rcx, 0x8(%r14)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3d138
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| ft_stroker_cap:
push r15
push r14
push r12
push rbx
sub rsp, 28h
mov rdx, rsi
mov r14, rdi
cmp dword ptr [rdi+54h], 1
jnz short loc_3E38F
mov [r14], rdx
add rdx, 0B40000h
mov [r14+8], rdx
mov rdi, r14
xor esi, esi
add rsp, 28h
pop rbx
pop r12
pop r14
pop r15
jmp ft_stroker_arcto
loc_3E38F:
mov rsi, [r14+68h]
lea rbx, [r14+70h]
lea r15, [rsp+48h+var_40]
mov rdi, r15
call PVG_FT_Vector_From_Polar
mov r12, [r15]
mov rax, [r15+8]
mov rcx, rax
neg rcx
mov [rsp+48h+var_30], rcx
mov [rsp+48h+var_28], r12
cmp dword ptr [r14+54h], 2
mov rcx, [r14+10h]
jnz short loc_3E3D7
add rcx, r12
mov [rsp+48h+var_40], rcx
mov rcx, [r14+18h]
add rcx, rax
jmp short loc_3E3E0
loc_3E3D7:
mov [rsp+48h+var_40], rcx
mov rcx, [r14+18h]
loc_3E3E0:
mov [rsp+48h+var_38], rcx
mov r15, [rsp+48h+var_40]
sub r15, rax
lea r14, [rsp+48h+var_30]
mov [r14], r15
add r12, rcx
mov [r14+8], r12
mov rdi, rbx
mov rsi, r14
xor edx, edx
call ft_stroke_border_lineto
mov rax, [rsp+48h+var_40]
mov rcx, [rsp+48h+var_38]
add rax, rax
sub rax, r15
mov [r14], rax
add rcx, rcx
sub rcx, r12
mov [r14+8], rcx
mov rdi, rbx
mov rsi, r14
xor edx, edx
call ft_stroke_border_lineto
add rsp, 28h
pop rbx
pop r12
pop r14
pop r15
retn
| unsigned long long ft_stroker_cap(long long a1, long long a2)
{
int *v3; // rbx
long long v4; // r12
long long v5; // rax
long long v6; // rcx
long long v7; // r15
long long v8; // r12
long long v9; // [rsp+8h] [rbp-40h] BYREF
long long v10; // [rsp+10h] [rbp-38h]
long long v11; // [rsp+18h] [rbp-30h] BYREF
long long v12; // [rsp+20h] [rbp-28h]
if ( *(_DWORD *)(a1 + 84) == 1 )
{
*(_QWORD *)a1 = a2;
*(_QWORD *)(a1 + 8) = a2 + 11796480;
return ft_stroker_arcto(a1, 0LL);
}
else
{
v3 = (int *)(a1 + 112);
PVG_FT_Vector_From_Polar(&v9, *(_QWORD *)(a1 + 104), a2);
v4 = v9;
v5 = v10;
v11 = -v10;
v12 = v9;
if ( *(_DWORD *)(a1 + 84) == 2 )
{
v9 += *(_QWORD *)(a1 + 16);
v6 = v10 + *(_QWORD *)(a1 + 24);
}
else
{
v9 = *(_QWORD *)(a1 + 16);
v6 = *(_QWORD *)(a1 + 24);
}
v10 = v6;
v7 = v9 - v5;
v11 = v9 - v5;
v8 = v6 + v4;
v12 = v8;
ft_stroke_border_lineto(v3, (long long)&v11, 0);
v11 = 2 * v9 - v7;
v12 = 2 * v10 - v8;
return ft_stroke_border_lineto(v3, (long long)&v11, 0);
}
}
| ft_stroker_cap:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RDX,RSI
MOV R14,RDI
CMP dword ptr [RDI + 0x54],0x1
JNZ 0x0013e38f
MOV qword ptr [R14],RDX
ADD RDX,0xb40000
MOV qword ptr [R14 + 0x8],RDX
MOV RDI,R14
XOR ESI,ESI
ADD RSP,0x28
POP RBX
POP R12
POP R14
POP R15
JMP 0x0013f03a
LAB_0013e38f:
MOV RSI,qword ptr [R14 + 0x68]
LEA RBX,[R14 + 0x70]
LEA R15,[RSP + 0x8]
MOV RDI,R15
CALL 0x00142802
MOV R12,qword ptr [R15]
MOV RAX,qword ptr [R15 + 0x8]
MOV RCX,RAX
NEG RCX
MOV qword ptr [RSP + 0x18],RCX
MOV qword ptr [RSP + 0x20],R12
CMP dword ptr [R14 + 0x54],0x2
MOV RCX,qword ptr [R14 + 0x10]
JNZ 0x0013e3d7
ADD RCX,R12
MOV qword ptr [RSP + 0x8],RCX
MOV RCX,qword ptr [R14 + 0x18]
ADD RCX,RAX
JMP 0x0013e3e0
LAB_0013e3d7:
MOV qword ptr [RSP + 0x8],RCX
MOV RCX,qword ptr [R14 + 0x18]
LAB_0013e3e0:
MOV qword ptr [RSP + 0x10],RCX
MOV R15,qword ptr [RSP + 0x8]
SUB R15,RAX
LEA R14,[RSP + 0x18]
MOV qword ptr [R14],R15
ADD R12,RCX
MOV qword ptr [R14 + 0x8],R12
MOV RDI,RBX
MOV RSI,R14
XOR EDX,EDX
CALL 0x0013d138
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP + 0x10]
ADD RAX,RAX
SUB RAX,R15
MOV qword ptr [R14],RAX
ADD RCX,RCX
SUB RCX,R12
MOV qword ptr [R14 + 0x8],RCX
MOV RDI,RBX
MOV RSI,R14
XOR EDX,EDX
CALL 0x0013d138
ADD RSP,0x28
POP RBX
POP R12
POP R14
POP R15
RET
|
void ft_stroker_cap(long *param_1,long param_2)
{
long lVar1;
long lVar2;
long lVar3;
long local_40;
long local_38;
long local_30;
long local_28;
if (*(int *)((long)param_1 + 0x54) == 1) {
*param_1 = param_2;
param_1[1] = param_2 + 0xb40000;
ft_stroker_arcto(param_1,0);
return;
}
PVG_FT_Vector_From_Polar(&local_40,param_1[0xd]);
lVar1 = local_40;
if (*(int *)((long)param_1 + 0x54) == 2) {
lVar2 = param_1[3] + local_38;
local_40 = param_1[2] + local_40;
}
else {
lVar2 = param_1[3];
local_40 = param_1[2];
}
lVar3 = local_40 - local_38;
local_38 = lVar2;
local_30 = lVar3;
local_28 = lVar1 + lVar2;
ft_stroke_border_lineto(param_1 + 0xe,&local_30,0);
local_30 = local_40 * 2 - lVar3;
local_28 = local_38 * 2 - (lVar1 + lVar2);
ft_stroke_border_lineto(param_1 + 0xe,&local_30,0);
return;
}
|
|
5,843 | ft_stroker_cap | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-ft-stroker.c | static PVG_FT_Error
ft_stroker_cap(PVG_FT_Stroker stroker,
PVG_FT_Angle angle,
PVG_FT_Int side)
{
PVG_FT_Error error = 0;
if (stroker->line_cap == PVG_FT_STROKER_LINECAP_ROUND)
{
/* add a round cap */
stroker->angle_in = angle;
stroker->angle_out = angle + PVG_FT_ANGLE_PI;
error = ft_stroker_arcto(stroker, side);
}
else
{
/* add a square or butt cap */
PVG_FT_Vector middle, delta;
PVG_FT_Fixed radius = stroker->radius;
PVG_FT_StrokeBorder border = stroker->borders + side;
/* compute middle point and first angle point */
PVG_FT_Vector_From_Polar( &middle, radius, angle );
delta.x = side ? middle.y : -middle.y;
delta.y = side ? -middle.x : middle.x;
if ( stroker->line_cap == PVG_FT_STROKER_LINECAP_SQUARE )
{
middle.x += stroker->center.x;
middle.y += stroker->center.y;
}
else /* PVG_FT_STROKER_LINECAP_BUTT */
{
middle.x = stroker->center.x;
middle.y = stroker->center.y;
}
delta.x += middle.x;
delta.y += middle.y;
error = ft_stroke_border_lineto( border, &delta, FALSE );
if ( error )
goto Exit;
/* compute second angle point */
delta.x = middle.x - delta.x + middle.x;
delta.y = middle.y - delta.y + middle.y;
error = ft_stroke_border_lineto( border, &delta, FALSE );
}
Exit:
return error;
} | O2 | c | ft_stroker_cap:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rdx
movq %rdi, %r14
cmpl $0x1, 0x54(%rdi)
jne 0x368b5
movq %rdx, (%r14)
addq $0xb40000, %rdx # imm = 0xB40000
movq %rdx, 0x8(%r14)
movq %r14, %rdi
xorl %esi, %esi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x373ea
movq 0x68(%r14), %rsi
leaq 0x70(%r14), %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x39a32
movq (%r15), %r12
movq 0x8(%r15), %rax
cmpl $0x2, 0x54(%r14)
movq 0x10(%r14), %r15
jne 0x368e8
addq %r12, %r15
movq 0x18(%r14), %rcx
addq %rax, %rcx
jmp 0x368ec
movq 0x18(%r14), %rcx
movq %r15, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
subq %rax, %r15
leaq 0x18(%rsp), %r14
movq %r15, (%r14)
addq %rcx, %r12
movq %r12, 0x8(%r14)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x35640
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
addq %rax, %rax
subq %r15, %rax
movq %rax, (%r14)
addq %rcx, %rcx
subq %r12, %rcx
movq %rcx, 0x8(%r14)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x35640
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| ft_stroker_cap:
push r15
push r14
push r12
push rbx
sub rsp, 28h
mov rdx, rsi
mov r14, rdi
cmp dword ptr [rdi+54h], 1
jnz short loc_368B5
mov [r14], rdx
add rdx, 0B40000h
mov [r14+8], rdx
mov rdi, r14
xor esi, esi
add rsp, 28h
pop rbx
pop r12
pop r14
pop r15
jmp ft_stroker_arcto
loc_368B5:
mov rsi, [r14+68h]
lea rbx, [r14+70h]
lea r15, [rsp+48h+var_40]
mov rdi, r15
call PVG_FT_Vector_From_Polar
mov r12, [r15]
mov rax, [r15+8]
cmp dword ptr [r14+54h], 2
mov r15, [r14+10h]
jnz short loc_368E8
add r15, r12
mov rcx, [r14+18h]
add rcx, rax
jmp short loc_368EC
loc_368E8:
mov rcx, [r14+18h]
loc_368EC:
mov [rsp+48h+var_40], r15
mov [rsp+48h+var_38], rcx
sub r15, rax
lea r14, [rsp+48h+var_30]
mov [r14], r15
add r12, rcx
mov [r14+8], r12
mov rdi, rbx
mov rsi, r14
xor edx, edx
call ft_stroke_border_lineto
mov rax, [rsp+48h+var_40]
mov rcx, [rsp+48h+var_38]
add rax, rax
sub rax, r15
mov [r14], rax
add rcx, rcx
sub rcx, r12
mov [r14+8], rcx
mov rdi, rbx
mov rsi, r14
xor edx, edx
call ft_stroke_border_lineto
add rsp, 28h
pop rbx
pop r12
pop r14
pop r15
retn
| unsigned long long ft_stroker_cap(long long a1, long long a2)
{
int *v3; // rbx
long long v4; // r12
long long v5; // rax
long long v6; // r15
long long v7; // rcx
long long v8; // r15
long long v9; // r12
long long v10; // [rsp+8h] [rbp-40h] BYREF
long long v11; // [rsp+10h] [rbp-38h]
long long v12; // [rsp+18h] [rbp-30h] BYREF
long long v13; // [rsp+20h] [rbp-28h]
if ( *(_DWORD *)(a1 + 84) == 1 )
{
*(_QWORD *)a1 = a2;
*(_QWORD *)(a1 + 8) = a2 + 11796480;
return ft_stroker_arcto(a1, 0LL);
}
else
{
v3 = (int *)(a1 + 112);
PVG_FT_Vector_From_Polar(&v10, *(_QWORD *)(a1 + 104), a2);
v4 = v10;
v5 = v11;
v6 = *(_QWORD *)(a1 + 16);
if ( *(_DWORD *)(a1 + 84) == 2 )
{
v6 += v10;
v7 = v11 + *(_QWORD *)(a1 + 24);
}
else
{
v7 = *(_QWORD *)(a1 + 24);
}
v10 = v6;
v11 = v7;
v8 = v6 - v5;
v12 = v8;
v9 = v7 + v4;
v13 = v9;
ft_stroke_border_lineto(v3, (long long)&v12, 0);
v12 = 2 * v10 - v8;
v13 = 2 * v11 - v9;
return ft_stroke_border_lineto(v3, (long long)&v12, 0);
}
}
| ft_stroker_cap:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RDX,RSI
MOV R14,RDI
CMP dword ptr [RDI + 0x54],0x1
JNZ 0x001368b5
MOV qword ptr [R14],RDX
ADD RDX,0xb40000
MOV qword ptr [R14 + 0x8],RDX
MOV RDI,R14
XOR ESI,ESI
ADD RSP,0x28
POP RBX
POP R12
POP R14
POP R15
JMP 0x001373ea
LAB_001368b5:
MOV RSI,qword ptr [R14 + 0x68]
LEA RBX,[R14 + 0x70]
LEA R15,[RSP + 0x8]
MOV RDI,R15
CALL 0x00139a32
MOV R12,qword ptr [R15]
MOV RAX,qword ptr [R15 + 0x8]
CMP dword ptr [R14 + 0x54],0x2
MOV R15,qword ptr [R14 + 0x10]
JNZ 0x001368e8
ADD R15,R12
MOV RCX,qword ptr [R14 + 0x18]
ADD RCX,RAX
JMP 0x001368ec
LAB_001368e8:
MOV RCX,qword ptr [R14 + 0x18]
LAB_001368ec:
MOV qword ptr [RSP + 0x8],R15
MOV qword ptr [RSP + 0x10],RCX
SUB R15,RAX
LEA R14,[RSP + 0x18]
MOV qword ptr [R14],R15
ADD R12,RCX
MOV qword ptr [R14 + 0x8],R12
MOV RDI,RBX
MOV RSI,R14
XOR EDX,EDX
CALL 0x00135640
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP + 0x10]
ADD RAX,RAX
SUB RAX,R15
MOV qword ptr [R14],RAX
ADD RCX,RCX
SUB RCX,R12
MOV qword ptr [R14 + 0x8],RCX
MOV RDI,RBX
MOV RSI,R14
XOR EDX,EDX
CALL 0x00135640
ADD RSP,0x28
POP RBX
POP R12
POP R14
POP R15
RET
|
void ft_stroker_cap(long *param_1,long param_2)
{
long lVar1;
long lVar2;
long lVar3;
long lVar4;
long local_40;
long local_38;
long local_30;
long local_28;
if (*(int *)((long)param_1 + 0x54) == 1) {
*param_1 = param_2;
param_1[1] = param_2 + 0xb40000;
ft_stroker_arcto(param_1,0);
return;
}
PVG_FT_Vector_From_Polar(&local_40,param_1[0xd]);
lVar3 = param_1[2];
if (*(int *)((long)param_1 + 0x54) == 2) {
lVar3 = lVar3 + local_40;
lVar1 = param_1[3] + local_38;
}
else {
lVar1 = param_1[3];
}
lVar4 = lVar3 - local_38;
lVar2 = local_40 + lVar1;
local_40 = lVar3;
local_38 = lVar1;
local_30 = lVar4;
local_28 = lVar2;
ft_stroke_border_lineto(param_1 + 0xe,&local_30,0);
local_30 = local_40 * 2 - lVar4;
local_28 = local_38 * 2 - lVar2;
ft_stroke_border_lineto(param_1 + 0xe,&local_30,0);
return;
}
|
|
5,844 | Field_bit::do_last_null_byte() const | eloqsql/sql/field.cc | size_t
Field_bit::do_last_null_byte() const
{
/*
Code elsewhere is assuming that bytes are 8 bits, so I'm using
that value instead of the correct one: CHAR_BIT.
REFACTOR SUGGESTION (Matz): Change to use the correct number of
bits. On systems with CHAR_BIT > 8 (not very common), the storage
will lose the extra bits.
*/
DBUG_PRINT("test", ("bit_ofs: %d, bit_len: %d bit_ptr: %p",
bit_ofs, bit_len, bit_ptr));
uchar *result;
if (bit_len == 0)
result= null_ptr;
else if (bit_ofs + bit_len > 8)
result= bit_ptr + 1;
else
result= bit_ptr;
if (result)
return (size_t) (result - table->record[0]) + 1;
return LAST_NULL_BYTE_UNDEF;
} | O0 | cpp | Field_bit::do_last_null_byte() const:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xcf1452
movq -0x20(%rbp), %rax
cmpl $0x0, 0xd4(%rax)
jne 0xcf146d
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xcf14a9
movq -0x20(%rbp), %rcx
movzbl 0xd0(%rcx), %eax
addl 0xd4(%rcx), %eax
cmpl $0x8, %eax
jbe 0xcf1498
movq -0x20(%rbp), %rax
movq 0xc8(%rax), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xcf14a7
movq -0x20(%rbp), %rax
movq 0xc8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xcf14a9
cmpq $0x0, -0x18(%rbp)
je 0xcf14cd
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x18(%rcx), %rcx
movq 0x50(%rcx), %rcx
subq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xcf14d5
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
| _ZNK9Field_bit17do_last_null_byteEv:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov [rbp+var_20], rax
jmp short $+2
loc_CF1452:
mov rax, [rbp+var_20]
cmp dword ptr [rax+0D4h], 0
jnz short loc_CF146D
mov rax, [rbp+var_20]
mov rax, [rax+10h]
mov [rbp+var_18], rax
jmp short loc_CF14A9
loc_CF146D:
mov rcx, [rbp+var_20]
movzx eax, byte ptr [rcx+0D0h]
add eax, [rcx+0D4h]
cmp eax, 8
jbe short loc_CF1498
mov rax, [rbp+var_20]
mov rax, [rax+0C8h]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_CF14A7
loc_CF1498:
mov rax, [rbp+var_20]
mov rax, [rax+0C8h]
mov [rbp+var_18], rax
loc_CF14A7:
jmp short $+2
loc_CF14A9:
cmp [rbp+var_18], 0
jz short loc_CF14CD
mov rcx, [rbp+var_20]
mov rax, [rbp+var_18]
mov rcx, [rcx+18h]
mov rcx, [rcx+50h]
sub rax, rcx
add rax, 1
mov [rbp+var_8], rax
jmp short loc_CF14D5
loc_CF14CD:
mov [rbp+var_8], 0
loc_CF14D5:
mov rax, [rbp+var_8]
pop rbp
retn
| long long Field_bit::do_last_null_byte(Field_bit *this)
{
long long v2; // [rsp+8h] [rbp-18h]
if ( *((_DWORD *)this + 53) )
{
if ( *((_DWORD *)this + 53) + (unsigned int)*((unsigned __int8 *)this + 208) <= 8 )
v2 = *((_QWORD *)this + 25);
else
v2 = *((_QWORD *)this + 25) + 1LL;
}
else
{
v2 = *((_QWORD *)this + 2);
}
if ( v2 )
return v2 - *(_QWORD *)(*((_QWORD *)this + 3) + 80LL) + 1;
else
return 0LL;
}
| Item_func_min_max_get_date:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x2c],R8D
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV qword ptr [RBP + -0x48],RDX
MOV qword ptr [RBP + -0x50],RCX
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x48]
LEA RDI,[RBP + -0x28]
MOV qword ptr [RBP + -0x90],RDI
CALL 0x00d01e60
MOV RSI,qword ptr [RBP + -0x90]
MOV RDX,qword ptr [RBP + -0x40]
LAB_00cf148f:
LEA RDI,[RBP + -0x78]
CALL 0x00d01e90
JMP 0x00cf149a
LAB_00cf149a:
MOV RSI,qword ptr [RBP + -0x50]
LEA RDI,[RBP + -0x78]
CALL 0x00d02100
LAB_00cf14a7:
MOV byte ptr [RBP + -0x91],AL
JMP 0x00cf14af
LAB_00cf14af:
LEA RDI,[RBP + -0x28]
CALL 0x00d00770
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00cf151c
MOV AL,byte ptr [RBP + -0x91]
AND AL,0x1
ADD RSP,0xa0
POP RBP
RET
LAB_00cf151c:
CALL 0x008754c0
|
/* Type_handler_timestamp_common::Item_func_min_max_get_date(THD*, Item_func_min_max*,
st_mysql_time*, date_mode_t) const */
ulong __thiscall
Type_handler_timestamp_common::Item_func_min_max_get_date
(Type_handler_timestamp_common *this,THD *param_1,Item *param_2,st_mysql_time *param_3,
int4 param_5)
{
int1 uVar1;
long in_FS_OFFSET;
Timestamp_or_zero_datetime_native_null local_80 [40];
st_mysql_time *local_58;
Item *local_50;
THD *local_48;
Type_handler_timestamp_common *local_40;
int4 local_34;
Timestamp_or_zero_datetime_native_null local_30 [32];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_58 = param_3;
local_50 = param_2;
local_48 = param_1;
local_40 = this;
local_34 = param_5;
Timestamp_or_zero_datetime_native_null::Timestamp_or_zero_datetime_native_null
(local_30,param_1,param_2);
/* try { // try from 00cf148f to 00cf14a6 has its CatchHandler @ 00cf14db */
Timestamp_or_zero_datetime_native_null::to_datetime(local_80,(THD *)local_30);
uVar1 = ::Datetime::copy_to_mysql_time((Datetime *)local_80,local_58);
Timestamp_or_zero_datetime_native_null::~Timestamp_or_zero_datetime_native_null(local_30);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),uVar1) & 0xffffffffffffff01;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
5,845 | testing::internal::FilePath::CalculateRootLength() const | AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest-filepath.cc | size_t FilePath::CalculateRootLength() const {
const auto& path = pathname_;
auto s = path.begin();
auto end = path.end();
#ifdef GTEST_OS_WINDOWS
if (end - s >= 2 && s[1] == ':' && (end - s == 2 || IsPathSeparator(s[2])) &&
(('A' <= s[0] && s[0] <= 'Z') || ('a' <= s[0] && s[0] <= 'z'))) {
// A typical absolute path like "C:\Windows" or "D:"
s += 2;
if (s != end) {
++s;
}
} else if (end - s >= 3 && IsPathSeparator(*s) && IsPathSeparator(*(s + 1)) &&
!IsPathSeparator(*(s + 2))) {
// Move past the "\\" prefix in a UNC path like "\\Server\Share\Folder"
s += 2;
// Skip 2 components and their following separators ("Server\" and "Share\")
for (int i = 0; i < 2; ++i) {
while (s != end) {
bool stop = IsPathSeparator(*s);
++s;
if (stop) {
break;
}
}
}
} else if (s != end && IsPathSeparator(*s)) {
// A drive-rooted path like "\Windows"
++s;
}
#else
if (s != end && IsPathSeparator(*s)) {
++s;
}
#endif
return static_cast<size_t>(s - path.begin());
} | O0 | cpp | testing::internal::FilePath::CalculateRootLength() const:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x46100
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x46130
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x46180
xorb $-0x1, %al
testb $0x1, %al
jne 0x19148
jmp 0x1916a
leaq 0x10(%rsp), %rdi
callq 0x461c0
movsbl (%rax), %edi
callq 0x19190
testb $0x1, %al
jne 0x19160
jmp 0x1916a
leaq 0x10(%rsp), %rdi
callq 0x461d0
movq 0x18(%rsp), %rdi
callq 0x46100
movq %rax, (%rsp)
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x461f0
addq $0x28, %rsp
retq
nopw (%rax,%rax)
| _ZNK7testing8internal8FilePath19CalculateRootLengthEv:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov rax, [rsp+28h+var_8]
mov [rsp+28h+var_10], rax
mov rdi, [rsp+28h+var_10]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5beginEv; std::string::begin(void)
mov [rsp+28h+var_18], rax
mov rdi, [rsp+28h+var_10]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE3endEv; std::string::end(void)
mov qword ptr [rsp+28h+var_20], rax
lea rdi, [rsp+28h+var_18]
lea rsi, [rsp+28h+var_20]; char
call _ZN9__gnu_cxxeqIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEbRKNS_17__normal_iteratorIT_T0_EESE_QrqXeqcldtfp_4baseEcldtfp0_4baseERSt14convertible_toIbEE
xor al, 0FFh
test al, 1
jnz short loc_19148
jmp short loc_1916A
loc_19148:
lea rdi, [rsp+28h+var_18]
call _ZNK9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEdeEv; __gnu_cxx::__normal_iterator<char const*,std::string>::operator*(void)
movsx edi, byte ptr [rax]; this
call _ZN7testing8internalL15IsPathSeparatorEc; testing::internal::IsPathSeparator(char)
test al, 1
jnz short loc_19160
jmp short loc_1916A
loc_19160:
lea rdi, [rsp+28h+var_18]
call _ZN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEppEv; __gnu_cxx::__normal_iterator<char const*,std::string>::operator++(void)
loc_1916A:
mov rdi, [rsp+28h+var_10]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5beginEv; std::string::begin(void)
mov [rsp+28h+var_28], rax
lea rdi, [rsp+28h+var_18]
mov rsi, rsp
call _ZN9__gnu_cxxmiIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEENS_17__normal_iteratorIT_T0_E15difference_typeERKSC_SF_; __gnu_cxx::operator-<char const*,std::string>(__gnu_cxx::__normal_iterator<char const*,std::string> const&,__gnu_cxx::__normal_iterator<char const*,std::string> const&)
add rsp, 28h
retn
| long long testing::internal::FilePath::CalculateRootLength(testing::internal::FilePath *this)
{
char *v1; // rax
long long v3; // [rsp+0h] [rbp-28h] BYREF
char v4[8]; // [rsp+8h] [rbp-20h] BYREF
long long v5; // [rsp+10h] [rbp-18h] BYREF
testing::internal::FilePath *v6; // [rsp+18h] [rbp-10h]
testing::internal::FilePath *v7; // [rsp+20h] [rbp-8h]
v7 = this;
v6 = this;
v5 = std::string::begin(this);
*(_QWORD *)v4 = std::string::end(this);
if ( (__gnu_cxx::operator==<char const*,std::string>(&v5, v4) & 1) == 0 )
{
v1 = (char *)__gnu_cxx::__normal_iterator<char const*,std::string>::operator*(&v5);
if ( (testing::internal::IsPathSeparator((testing::internal *)(unsigned int)*v1, (char)v4) & 1) != 0 )
__gnu_cxx::__normal_iterator<char const*,std::string>::operator++(&v5);
}
v3 = std::string::begin(v6);
return __gnu_cxx::operator-<char const*,std::string>(&v5, &v3);
}
| CalculateRootLength:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x18],RAX
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x00146100
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x00146130
MOV qword ptr [RSP + 0x8],RAX
LEA RDI,[RSP + 0x10]
LEA RSI,[RSP + 0x8]
CALL 0x00146180
XOR AL,0xff
TEST AL,0x1
JNZ 0x00119148
JMP 0x0011916a
LAB_00119148:
LEA RDI,[RSP + 0x10]
CALL 0x001461c0
MOVSX EDI,byte ptr [RAX]
CALL 0x00119190
TEST AL,0x1
JNZ 0x00119160
JMP 0x0011916a
LAB_00119160:
LEA RDI,[RSP + 0x10]
CALL 0x001461d0
LAB_0011916a:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x00146100
MOV qword ptr [RSP],RAX
LEA RDI,[RSP + 0x10]
MOV RSI,RSP
CALL 0x001461f0
ADD RSP,0x28
RET
|
/* testing::internal::FilePath::CalculateRootLength() const */
void __thiscall testing::internal::FilePath::CalculateRootLength(FilePath *this)
{
byte bVar1;
char *pcVar2;
ulong uVar3;
int8 local_28;
int8 local_20;
int8 local_18;
string *local_10;
FilePath *local_8;
local_10 = (string *)this;
local_8 = this;
local_18 = std::__cxx11::string::begin((string *)this);
local_20 = std::__cxx11::string::end(local_10);
bVar1 = _ZN9__gnu_cxxeqIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEbRKNS_17__normal_iteratorIT_T0_EESE_QrqXeqcldtfp_4baseEcldtfp0_4baseERSt14convertible_toIbEE
(&local_18,&local_20);
if (((bVar1 ^ 0xff) & 1) != 0) {
pcVar2 = (char *)__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>::operator*
((__normal_iterator<char_const*,std::__cxx11::string> *)&local_18);
uVar3 = IsPathSeparator(*pcVar2);
if ((uVar3 & 1) != 0) {
__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>::operator++
((__normal_iterator<char_const*,std::__cxx11::string> *)&local_18);
}
}
local_28 = std::__cxx11::string::begin(local_10);
__gnu_cxx::operator-((__normal_iterator *)&local_18,(__normal_iterator *)&local_28);
return;
}
|
|
5,846 | my_fill_ucs2 | eloqsql/strings/ctype-ucs2.c | static void
my_fill_ucs2(CHARSET_INFO *cs __attribute__((unused)),
char *s, size_t l, int fill)
{
DBUG_ASSERT(fill <= 0xFFFF);
#ifdef WAITING_FOR_GCC_VECTORIZATION_BUG_TO_BE_FIXED
/*
This code with int2store() is known to be faster on some processors,
but crashes on other processors due to a possible bug in GCC's
-ftree-vectorization (which is enabled in -O3) in case of
a non-aligned memory. See here for details:
http://gcc.gnu.org/bugzilla/show_bug.cgi?id=58039
*/
char *last= s + l - 2;
uint16 tmp= (fill >> 8) + ((fill & 0xFF) << 8); /* swap bytes */
DBUG_ASSERT(fill <= 0xFFFF);
for ( ; s <= last; s+= 2)
int2store(s, tmp); /* store little-endian */
#else
for ( ; l >= 2; s[0]= (fill >> 8), s[1]= (fill & 0xFF), s+= 2, l-= 2);
#endif
} | O3 | c | my_fill_ucs2:
cmpq $0x2, %rdx
jb 0xc52ae
pushq %rbp
movq %rsp, %rbp
movl %ecx, %eax
shrl $0x8, %eax
movb %al, (%rsi)
movb %cl, 0x1(%rsi)
addq $0x2, %rsi
addq $-0x2, %rdx
cmpq $0x1, %rdx
ja 0xc529a
popq %rbp
retq
| my_fill_ucs2:
cmp rdx, 2
jb short locret_C52AE
push rbp
mov rbp, rsp
mov eax, ecx
shr eax, 8
loc_C529A:
mov [rsi], al
mov [rsi+1], cl
add rsi, 2
add rdx, 0FFFFFFFFFFFFFFFEh
cmp rdx, 1
ja short loc_C529A
pop rbp
locret_C52AE:
retn
| void my_fill_ucs2(long long a1, _BYTE *a2, unsigned long long a3, __int16 a4)
{
bool v4; // cf
if ( a3 >= 2 )
{
do
{
*a2 = HIBYTE(a4);
a2[1] = a4;
a2 += 2;
v4 = a3 == 2;
a3 -= 2LL;
}
while ( !v4 && a3 != 1 );
}
}
| my_fill_ucs2:
CMP RDX,0x2
JC 0x001c52ae
PUSH RBP
MOV RBP,RSP
MOV EAX,ECX
SHR EAX,0x8
LAB_001c529a:
MOV byte ptr [RSI],AL
MOV byte ptr [RSI + 0x1],CL
ADD RSI,0x2
ADD RDX,-0x2
CMP RDX,0x1
JA 0x001c529a
POP RBP
LAB_001c52ae:
RET
|
void my_fill_ucs2(int8 param_1,int1 *param_2,ulong param_3,int4 param_4)
{
if (1 < param_3) {
do {
*param_2 = (char)((uint)param_4 >> 8);
param_2[1] = (char)param_4;
param_2 = param_2 + 2;
param_3 = param_3 - 2;
} while (1 < param_3);
}
return;
}
|
|
5,847 | type_inference_get_function_signature | tsotchke[P]eshkol/src/frontend/type_inference/context.c | Type* type_inference_get_function_signature(TypeInferenceContext* context, StringId function_name) {
assert(context != NULL);
// Check if function_name is NULL
if (function_name == NULL) {
return NULL;
}
// Check if the function is in the context
for (size_t i = 0; i < context->signature_count; i++) {
if (context->function_names[i] == function_name) {
return context->function_signatures[i];
}
}
return NULL;
} | O2 | c | type_inference_get_function_signature:
pushq %rax
testq %rdi, %rdi
je 0x8171
testq %rsi, %rsi
je 0x8163
movq 0x70(%rdi), %rcx
xorl %eax, %eax
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x816f
movq 0x58(%rdi), %r8
cmpq %rsi, (%r8,%rdx,8)
je 0x8167
incq %rdx
jmp 0x814f
xorl %eax, %eax
jmp 0x816f
movq 0x60(%rdi), %rax
movq (%rax,%rdx,8), %rax
popq %rcx
retq
leaq 0xfbe7(%rip), %rdi # 0x17d5f
leaq 0x117ac(%rip), %rsi # 0x1992b
leaq 0x11a04(%rip), %rcx # 0x19b8a
movl $0x11c, %edx # imm = 0x11C
callq 0x2180
| type_inference_get_function_signature:
push rax
test rdi, rdi
jz short loc_8171
test rsi, rsi
jz short loc_8163
mov rcx, [rdi+70h]
xor eax, eax
xor edx, edx
loc_814F:
cmp rcx, rdx
jz short loc_816F
mov r8, [rdi+58h]
cmp [r8+rdx*8], rsi
jz short loc_8167
inc rdx
jmp short loc_814F
loc_8163:
xor eax, eax
jmp short loc_816F
loc_8167:
mov rax, [rdi+60h]
mov rax, [rax+rdx*8]
loc_816F:
pop rcx
retn
loc_8171:
lea rdi, aContextNull; "context != NULL"
lea rsi, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aTypeTypeInfere_1; "Type *type_inference_get_function_signa"...
mov edx, 11Ch
call ___assert_fail
| long long type_inference_get_function_signature(_QWORD *a1, long long a2)
{
long long result; // rax
long long i; // rdx
if ( !a1 )
__assert_fail(
"context != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/frontend/type_inference/context.c",
284LL,
"Type *type_inference_get_function_signature(TypeInferenceContext *, StringId)");
if ( !a2 )
return 0LL;
result = 0LL;
for ( i = 0LL; a1[14] != i; ++i )
{
if ( *(_QWORD *)(a1[11] + 8 * i) == a2 )
return *(_QWORD *)(a1[12] + 8 * i);
}
return result;
}
| type_inference_get_function_signature:
PUSH RAX
TEST RDI,RDI
JZ 0x00108171
TEST RSI,RSI
JZ 0x00108163
MOV RCX,qword ptr [RDI + 0x70]
XOR EAX,EAX
XOR EDX,EDX
LAB_0010814f:
CMP RCX,RDX
JZ 0x0010816f
MOV R8,qword ptr [RDI + 0x58]
CMP qword ptr [R8 + RDX*0x8],RSI
JZ 0x00108167
INC RDX
JMP 0x0010814f
LAB_00108163:
XOR EAX,EAX
JMP 0x0010816f
LAB_00108167:
MOV RAX,qword ptr [RDI + 0x60]
MOV RAX,qword ptr [RAX + RDX*0x8]
LAB_0010816f:
POP RCX
RET
LAB_00108171:
LEA RDI,[0x117d5f]
LEA RSI,[0x11992b]
LEA RCX,[0x119b8a]
MOV EDX,0x11c
CALL 0x00102180
|
int8 type_inference_get_function_signature(long param_1,long param_2)
{
long lVar1;
if (param_1 == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("context != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/frontend/type_inference/context.c"
,0x11c,
"Type *type_inference_get_function_signature(TypeInferenceContext *, StringId)");
}
if (param_2 != 0) {
for (lVar1 = 0; *(long *)(param_1 + 0x70) != lVar1; lVar1 = lVar1 + 1) {
if (*(long *)(*(long *)(param_1 + 0x58) + lVar1 * 8) == param_2) {
return *(int8 *)(*(long *)(param_1 + 0x60) + lVar1 * 8);
}
}
}
return 0;
}
|
|
5,848 | my_hash_sort_simple | eloqsql/strings/ctype-simple.c | void my_hash_sort_simple(CHARSET_INFO *cs,
const uchar *key, size_t len,
ulong *nr1, ulong *nr2)
{
register const uchar *sort_order=cs->sort_order;
const uchar *end;
uint16 space_weight= sort_order[' '];
/*
Remove all trailing characters that are equal to space.
We have to do this to be able to compare 'A ' and 'A' as identical.
If the key is long enough, cut the trailing spaces (0x20) using an
optimized function implemented in skip_trailing_spaces().
"len > 16" is just some heuristic here.
Calling skip_triling_space() for short values is not desirable,
because its initialization block may be more expensive than the
performance gained.
*/
end= len > 16 ? skip_trailing_space(key, len) : key + len;
/*
We removed all trailing characters that are binary equal to space 0x20.
Now remove all trailing characters that have weights equal to space.
Some 8bit simple collations may have such characters:
- cp1250_general_ci 0xA0 NO-BREAK SPACE == 0x20 SPACE
- cp1251_ukrainian_ci 0x60 GRAVE ACCENT == 0x20 SPACE
- koi8u_general_ci 0x60 GRAVE ACCENT == 0x20 SPACE
*/
for ( ; key < end ; )
{
if (sort_order[*--end] != space_weight)
{
end++;
break;
}
}
my_hash_sort_simple_nopad(cs, key, end - key, nr1, nr2);
} | O3 | c | my_hash_sort_simple:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movq 0x58(%rdi), %rax
leaq (%rsi,%rdx), %rdi
cmpq $0x11, %rdx
jb 0x7094d
cmpq $0x15, %rdx
jb 0x70938
movq %rdi, %r10
andq $-0x4, %r10
cmpq %rsi, %r10
jbe 0x70938
leaq 0x3(%rsi), %r9
andq $-0x4, %r9
movq %rdi, %rdx
movb -0x1(%rdi), %r11b
cmpq %r10, %rdi
jbe 0x709b8
leaq -0x1(%rdx), %rdi
cmpb $0x20, %r11b
je 0x7091c
jmp 0x7093b
movq %rdi, %rdx
movq %rdx, %rdi
cmpq %rsi, %rdx
jbe 0x7094d
leaq -0x1(%rdi), %rdx
cmpb $0x20, -0x1(%rdi)
je 0x7093b
movb 0x20(%rax), %r9b
movq %rdi, %r11
subq %rsi, %r11
movq %rdi, %rdx
movq %r11, %r10
cmpq %rsi, %rdi
jbe 0x70974
leaq -0x1(%rdx), %rdi
movzbl -0x1(%rdx), %ebx
leaq -0x1(%r10), %r11
cmpb %r9b, (%rax,%rbx)
je 0x70957
movq (%rcx), %rdi
movq (%r8), %r9
testq %r10, %r10
jle 0x709af
movl %edi, %r10d
andl $0x3f, %r10d
addq %r9, %r10
movzbl (%rsi), %r11d
movzbl (%rax,%r11), %r11d
imulq %r10, %r11
movq %rdi, %r10
shlq $0x8, %r10
addq %r11, %r10
xorq %r10, %rdi
addq $0x3, %r9
incq %rsi
cmpq %rdx, %rsi
jb 0x7097f
movq %rdi, (%rcx)
movq %r9, (%r8)
popq %rbx
popq %rbp
retq
cmpb $0x20, %r11b
setne %dil
cmpq %r10, %r9
setae %r10b
orb %dil, %r10b
jne 0x7093b
movq %rdx, %rdi
movq %rdi, %rdx
cmpq %r9, %rdi
jbe 0x7093b
leaq -0x4(%rdx), %rdi
cmpl $0x20202020, -0x4(%rdx) # imm = 0x20202020
je 0x709d3
jmp 0x7093b
| my_hash_sort_simple:
push rbp
mov rbp, rsp
push rbx
mov rax, [rdi+58h]
lea rdi, [rsi+rdx]
cmp rdx, 11h
jb short loc_7094D
cmp rdx, 15h
jb short loc_70938
mov r10, rdi
and r10, 0FFFFFFFFFFFFFFFCh
cmp r10, rsi
jbe short loc_70938
lea r9, [rsi+3]
and r9, 0FFFFFFFFFFFFFFFCh
loc_7091C:
mov rdx, rdi
mov r11b, [rdi-1]
cmp rdi, r10
jbe loc_709B8
lea rdi, [rdx-1]
cmp r11b, 20h ; ' '
jz short loc_7091C
jmp short loc_7093B
loc_70938:
mov rdx, rdi
loc_7093B:
mov rdi, rdx
cmp rdx, rsi
jbe short loc_7094D
lea rdx, [rdi-1]
cmp byte ptr [rdi-1], 20h ; ' '
jz short loc_7093B
loc_7094D:
mov r9b, [rax+20h]
mov r11, rdi
sub r11, rsi
loc_70957:
mov rdx, rdi
mov r10, r11
cmp rdi, rsi
jbe short loc_70974
lea rdi, [rdx-1]
movzx ebx, byte ptr [rdx-1]
lea r11, [r10-1]
cmp [rax+rbx], r9b
jz short loc_70957
loc_70974:
mov rdi, [rcx]
mov r9, [r8]
test r10, r10
jle short loc_709AF
loc_7097F:
mov r10d, edi
and r10d, 3Fh
add r10, r9
movzx r11d, byte ptr [rsi]
movzx r11d, byte ptr [rax+r11]
imul r11, r10
mov r10, rdi
shl r10, 8
add r10, r11
xor rdi, r10
add r9, 3
inc rsi
cmp rsi, rdx
jb short loc_7097F
loc_709AF:
mov [rcx], rdi
mov [r8], r9
pop rbx
pop rbp
retn
loc_709B8:
cmp r11b, 20h ; ' '
setnz dil
cmp r9, r10
setnb r10b
or r10b, dil
jnz loc_7093B
mov rdi, rdx
loc_709D3:
mov rdx, rdi
cmp rdi, r9
jbe loc_7093B
lea rdi, [rdx-4]
cmp dword ptr [rdx-4], 20202020h
jz short loc_709D3
jmp loc_7093B
| long long my_hash_sort_simple(long long a1, unsigned __int8 *a2, unsigned long long a3, long long *a4, long long *a5)
{
long long result; // rax
unsigned long long v6; // rdi
unsigned long long v7; // r10
unsigned long long v8; // r9
unsigned __int8 *v9; // rdx
char v10; // r11
long long v11; // r11
unsigned long long v12; // rdx
long long v13; // r10
long long v14; // rdi
long long v15; // r9
result = *(_QWORD *)(a1 + 88);
v6 = (unsigned long long)&a2[a3];
if ( a3 >= 0x11 )
{
if ( a3 < 0x15 || (v7 = v6 & 0xFFFFFFFFFFFFFFFCLL, (v6 & 0xFFFFFFFFFFFFFFFCLL) <= (unsigned long long)a2) )
{
v9 = &a2[a3];
}
else
{
v8 = (unsigned long long)(a2 + 3) & 0xFFFFFFFFFFFFFFFCLL;
while ( 1 )
{
v9 = (unsigned __int8 *)v6;
v10 = *(_BYTE *)(v6 - 1);
if ( v6 <= v7 )
break;
--v6;
if ( v10 != 32 )
goto LABEL_9;
}
if ( v10 == 32 && v8 < v7 )
{
do
{
v9 = (unsigned __int8 *)v6;
if ( v6 <= v8 )
break;
v6 -= 4LL;
}
while ( *((_DWORD *)v9 - 1) == 538976288 );
}
}
do
{
LABEL_9:
v6 = (unsigned long long)v9;
if ( v9 <= a2 )
break;
--v9;
}
while ( *(_BYTE *)(v6 - 1) == 32 );
}
v11 = v6 - (_QWORD)a2;
do
{
v12 = v6;
v13 = v11;
if ( v6 <= (unsigned long long)a2 )
break;
--v6;
--v11;
}
while ( *(_BYTE *)(result + *(unsigned __int8 *)(v12 - 1)) == *(_BYTE *)(result + 32) );
v14 = *a4;
v15 = *a5;
if ( v13 > 0 )
{
do
{
v14 ^= (v15 + (v14 & 0x3F)) * *(unsigned __int8 *)(result + *a2) + (v14 << 8);
v15 += 3LL;
++a2;
}
while ( (unsigned long long)a2 < v12 );
}
*a4 = v14;
*a5 = v15;
return result;
}
| my_hash_sort_simple:
PUSH RBP
MOV RBP,RSP
PUSH RBX
MOV RAX,qword ptr [RDI + 0x58]
LEA RDI,[RSI + RDX*0x1]
CMP RDX,0x11
JC 0x0017094d
CMP RDX,0x15
JC 0x00170938
MOV R10,RDI
AND R10,-0x4
CMP R10,RSI
JBE 0x00170938
LEA R9,[RSI + 0x3]
AND R9,-0x4
LAB_0017091c:
MOV RDX,RDI
MOV R11B,byte ptr [RDI + -0x1]
CMP RDI,R10
JBE 0x001709b8
LEA RDI,[RDX + -0x1]
CMP R11B,0x20
JZ 0x0017091c
JMP 0x0017093b
LAB_00170938:
MOV RDX,RDI
LAB_0017093b:
MOV RDI,RDX
CMP RDX,RSI
JBE 0x0017094d
LEA RDX,[RDI + -0x1]
CMP byte ptr [RDI + -0x1],0x20
JZ 0x0017093b
LAB_0017094d:
MOV R9B,byte ptr [RAX + 0x20]
MOV R11,RDI
SUB R11,RSI
LAB_00170957:
MOV RDX,RDI
MOV R10,R11
CMP RDI,RSI
JBE 0x00170974
LEA RDI,[RDX + -0x1]
MOVZX EBX,byte ptr [RDX + -0x1]
LEA R11,[R10 + -0x1]
CMP byte ptr [RAX + RBX*0x1],R9B
JZ 0x00170957
LAB_00170974:
MOV RDI,qword ptr [RCX]
MOV R9,qword ptr [R8]
TEST R10,R10
JLE 0x001709af
LAB_0017097f:
MOV R10D,EDI
AND R10D,0x3f
ADD R10,R9
MOVZX R11D,byte ptr [RSI]
MOVZX R11D,byte ptr [RAX + R11*0x1]
IMUL R11,R10
MOV R10,RDI
SHL R10,0x8
ADD R10,R11
XOR RDI,R10
ADD R9,0x3
INC RSI
CMP RSI,RDX
JC 0x0017097f
LAB_001709af:
MOV qword ptr [RCX],RDI
MOV qword ptr [R8],R9
POP RBX
POP RBP
RET
LAB_001709b8:
CMP R11B,0x20
SETNZ DIL
CMP R9,R10
SETNC R10B
OR R10B,DIL
JNZ 0x0017093b
MOV RDI,RDX
LAB_001709d3:
MOV RDX,RDI
CMP RDI,R9
JBE 0x0017093b
LEA RDI,[RDX + -0x4]
CMP dword ptr [RDX + -0x4],0x20202020
JZ 0x001709d3
JMP 0x0017093b
|
void my_hash_sort_simple(long param_1,byte *param_2,ulong param_3,ulong *param_4,long *param_5)
{
byte *pbVar1;
long lVar2;
byte *pbVar3;
ulong uVar4;
byte *pbVar5;
long lVar6;
byte *pbVar7;
long lVar8;
lVar2 = *(long *)(param_1 + 0x58);
pbVar5 = param_2 + param_3;
if (param_3 < 0x11) goto LAB_0017094d;
pbVar3 = pbVar5;
if ((0x14 < param_3) && (pbVar7 = (byte *)((ulong)pbVar5 & 0xfffffffffffffffc), param_2 < pbVar7))
{
do {
pbVar1 = pbVar5 + -1;
pbVar3 = pbVar5;
if (pbVar5 <= pbVar7) {
if ((byte *)((ulong)(param_2 + 3) & 0xfffffffffffffffc) < pbVar7 && *pbVar1 == 0x20)
goto LAB_001709d3;
break;
}
pbVar5 = pbVar5 + -1;
} while (*pbVar1 == 0x20);
}
goto LAB_0017093b;
while (pbVar7 = pbVar5 + -4, pbVar5 = pbVar5 + -4, *(int *)pbVar7 == 0x20202020) {
LAB_001709d3:
pbVar3 = pbVar5;
if (pbVar5 <= (byte *)((ulong)(param_2 + 3) & 0xfffffffffffffffc)) break;
}
LAB_0017093b:
do {
pbVar5 = pbVar3;
if (pbVar5 <= param_2) break;
pbVar3 = pbVar5 + -1;
} while (pbVar5[-1] == 0x20);
LAB_0017094d:
lVar6 = (long)pbVar5 - (long)param_2;
do {
lVar8 = lVar6;
pbVar3 = pbVar5;
if (pbVar3 <= param_2) break;
pbVar5 = pbVar3 + -1;
lVar6 = lVar8 + -1;
} while (*(char *)(lVar2 + (ulong)pbVar3[-1]) == *(char *)(lVar2 + 0x20));
uVar4 = *param_4;
lVar6 = *param_5;
if (0 < lVar8) {
do {
uVar4 = uVar4 ^ uVar4 * 0x100 +
(ulong)*(byte *)(lVar2 + (ulong)*param_2) *
((ulong)((uint)uVar4 & 0x3f) + lVar6);
lVar6 = lVar6 + 3;
param_2 = param_2 + 1;
} while (param_2 < pbVar3);
}
*param_4 = uVar4;
*param_5 = lVar6;
return;
}
|
|
5,849 | update_func_str(THD*, st_mysql_sys_var*, void*, void const*) | eloqsql/sql/sql_plugin.cc | static void update_func_str(THD *thd, struct st_mysql_sys_var *var,
void *tgt, const void *save)
{
char *value= *(char**) save;
if (var->flags & PLUGIN_VAR_MEMALLOC)
{
char *old= *(char**) tgt;
if (value)
*(char**) tgt= my_strdup(key_memory_global_system_variables,
value, MYF(0));
else
*(char**) tgt= 0;
my_free(old);
}
else
*(char**) tgt= value;
} | O0 | cpp | update_func_str(THD*, st_mysql_sys_var*, void*, void const*):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x8000, %eax # imm = 0x8000
cmpl $0x0, %eax
je 0x9174dd
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x9174c7
leaq 0x13b6d08(%rip), %rax # 0x1cce1b4
movl (%rax), %edi
movq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x12c7620
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x9174d2
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x30(%rbp), %rdi
callq 0x12c7520
jmp 0x9174e8
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
| _ZL15update_func_strP3THDP16st_mysql_sys_varPvPKv:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
mov eax, [rax]
and eax, 8000h
cmp eax, 0
jz short loc_9174DD
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_30], rax
cmp [rbp+var_28], 0
jz short loc_9174C7
lea rax, key_memory_global_system_variables
mov edi, [rax]
mov rsi, [rbp+var_28]
xor eax, eax
mov edx, eax
call my_strdup
mov rcx, rax
mov rax, [rbp+var_18]
mov [rax], rcx
jmp short loc_9174D2
loc_9174C7:
mov rax, [rbp+var_18]
mov qword ptr [rax], 0
loc_9174D2:
mov rdi, [rbp+var_30]
call my_free
jmp short loc_9174E8
loc_9174DD:
mov rcx, [rbp+var_28]
mov rax, [rbp+var_18]
mov [rax], rcx
loc_9174E8:
add rsp, 30h
pop rbp
retn
| long long update_func_str(long long a1, _DWORD *a2, long long *a3, long long *a4)
{
long long result; // rax
long long v5; // [rsp+0h] [rbp-30h]
long long v6; // [rsp+8h] [rbp-28h]
v6 = *a4;
if ( (*a2 & 0x8000) != 0 )
{
v5 = *a3;
if ( v6 )
*a3 = my_strdup(key_memory_global_system_variables, v6, 0LL);
else
*a3 = 0LL;
return my_free(v5);
}
else
{
result = (long long)a3;
*a3 = v6;
}
return result;
}
| check_execute_access:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
CMP qword ptr [RAX + 0x80],0x0
JZ 0x0091749b
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x80]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x00917460
MOV byte ptr [RBP + -0x19],AL
JMP 0x009174cc
LAB_0091749b:
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,RAX
ADD RDX,0x20
MOV RCX,RAX
ADD RCX,0x20
ADD RCX,0x10
MOV R8,qword ptr [RAX + 0x88]
MOV ESI,0x40000
XOR R9D,R9D
CALL 0x009f6f80
MOV byte ptr [RBP + -0x19],AL
LAB_009174cc:
MOV AL,byte ptr [RBP + -0x19]
AND AL,0x1
ADD RSP,0x20
POP RBP
RET
|
/* sp_head::check_execute_access(THD*) const */
ulong __thiscall sp_head::check_execute_access(sp_head *this,THD *param_1)
{
int8 uVar1;
int1 local_21;
if (*(long *)(this + 0x80) == 0) {
uVar1 = check_routine_access
(param_1,0x40000,this + 0x20,this + 0x30,*(int8 *)(this + 0x88),0);
local_21 = (int1)uVar1;
}
else {
uVar1 = check_execute_access(*(sp_head **)(this + 0x80),param_1);
local_21 = (int1)uVar1;
}
return CONCAT71((int7)((ulong)uVar1 >> 8),local_21) & 0xffffffffffffff01;
}
|
|
5,850 | update_func_str(THD*, st_mysql_sys_var*, void*, void const*) | eloqsql/sql/sql_plugin.cc | static void update_func_str(THD *thd, struct st_mysql_sys_var *var,
void *tgt, const void *save)
{
char *value= *(char**) save;
if (var->flags & PLUGIN_VAR_MEMALLOC)
{
char *old= *(char**) tgt;
if (value)
*(char**) tgt= my_strdup(key_memory_global_system_variables,
value, MYF(0));
else
*(char**) tgt= 0;
my_free(old);
}
else
*(char**) tgt= value;
} | O3 | cpp | update_func_str(THD*, st_mysql_sys_var*, void*, void const*):
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %rax
movq (%rcx), %rsi
testb $-0x80, 0x1(%rax)
jne 0x76e90a
movq %rsi, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq (%rbx), %r14
testq %rsi, %rsi
je 0x76e924
leaq 0xdec84b(%rip), %rax # 0x155b164
movl (%rax), %edi
xorl %edx, %edx
callq 0xcc4090
jmp 0x76e926
xorl %eax, %eax
movq %rax, (%rbx)
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xcc3ffa
| _ZL15update_func_strP3THDP16st_mysql_sys_varPvPKv:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdx
mov rax, rsi
mov rsi, [rcx]
test byte ptr [rax+1], 80h
jnz short loc_76E90A
mov [rbx], rsi
pop rbx
pop r14
pop rbp
retn
loc_76E90A:
mov r14, [rbx]
test rsi, rsi
jz short loc_76E924
lea rax, key_memory_global_system_variables
mov edi, [rax]
xor edx, edx
call my_strdup
jmp short loc_76E926
loc_76E924:
xor eax, eax
loc_76E926:
mov [rbx], rax
mov rdi, r14
pop rbx
pop r14
pop rbp
jmp my_free
| long long update_func_str(long long a1, long long a2, long long *a3, long long *a4)
{
long long result; // rax
long long v6; // rsi
long long v7; // r14
long long v8; // rax
result = a2;
v6 = *a4;
if ( *(char *)(result + 1) < 0 )
{
v7 = *a3;
if ( v6 )
v8 = my_strdup(key_memory_global_system_variables, v6, 0LL);
else
v8 = 0LL;
*a3 = v8;
return my_free(v7);
}
else
{
*a3 = v6;
}
return result;
}
| |||
5,851 | my_utf8mb3_uni_no_range | eloqsql/strings/ctype-utf8.c | static int my_utf8mb3_uni_no_range(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t * pwc, const uchar *s)
{
uchar c;
c= s[0];
if (c < 0x80)
{
*pwc = c;
return 1;
}
if (c < 0xc2)
return MY_CS_ILSEQ;
if (c < 0xe0)
{
if (!((s[1] ^ 0x80) < 0x40))
return MY_CS_ILSEQ;
*pwc= UTF8MB2_CODE(c, s[1]);
return 2;
}
if (c < 0xf0)
{
if (!IS_UTF8MB3_STEP2(c, s[1], s[2]))
return MY_CS_ILSEQ;
*pwc= UTF8MB3_CODE(c, s[1], s[2]);
return 3;
}
return MY_CS_ILSEQ;
} | O0 | c | my_utf8mb3_uni_no_range:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
cmpl $0x80, %eax
jge 0xb949d
movzbl -0x21(%rbp), %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0xb95b3
movzbl -0x21(%rbp), %eax
cmpl $0xc2, %eax
jge 0xb94b4
movl $0x0, -0x4(%rbp)
jmp 0xb95b3
movzbl -0x21(%rbp), %eax
cmpl $0xe0, %eax
jge 0xb9510
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jl 0xb94dd
movl $0x0, -0x4(%rbp)
jmp 0xb95b3
movzbl -0x21(%rbp), %eax
andl $0x1f, %eax
movslq %eax, %rcx
shlq $0x6, %rcx
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cltq
orq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x2, -0x4(%rbp)
jmp 0xb95b3
movzbl -0x21(%rbp), %eax
cmpl $0xf0, %eax
jge 0xb95ac
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0xb955d
movq -0x20(%rbp), %rax
movzbl 0x2(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0xb955d
movzbl -0x21(%rbp), %eax
cmpl $0xe1, %eax
jge 0xb9566
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xa0, %eax
jge 0xb9566
movl $0x0, -0x4(%rbp)
jmp 0xb95b3
movzbl -0x21(%rbp), %eax
andl $0xf, %eax
movslq %eax, %rcx
shlq $0xc, %rcx
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cltq
shlq $0x6, %rax
orq %rax, %rcx
movq -0x20(%rbp), %rax
movzbl 0x2(%rax), %eax
xorl $0x80, %eax
cltq
orq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x3, -0x4(%rbp)
jmp 0xb95b3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
| my_utf8mb3_uni_no_range:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_20]
mov al, [rax]
mov [rbp+var_21], al
movzx eax, [rbp+var_21]
cmp eax, 80h
jge short loc_B949D
movzx eax, [rbp+var_21]
mov ecx, eax
mov rax, [rbp+var_18]
mov [rax], rcx
mov [rbp+var_4], 1
jmp loc_B95B3
loc_B949D:
movzx eax, [rbp+var_21]
cmp eax, 0C2h
jge short loc_B94B4
mov [rbp+var_4], 0
jmp loc_B95B3
loc_B94B4:
movzx eax, [rbp+var_21]
cmp eax, 0E0h
jge short loc_B9510
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cmp eax, 40h ; '@'
jl short loc_B94DD
mov [rbp+var_4], 0
jmp loc_B95B3
loc_B94DD:
movzx eax, [rbp+var_21]
and eax, 1Fh
movsxd rcx, eax
shl rcx, 6
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cdqe
or rcx, rax
mov rax, [rbp+var_18]
mov [rax], rcx
mov [rbp+var_4], 2
jmp loc_B95B3
loc_B9510:
movzx eax, [rbp+var_21]
cmp eax, 0F0h
jge loc_B95AC
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_B955D
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+2]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_B955D
movzx eax, [rbp+var_21]
cmp eax, 0E1h
jge short loc_B9566
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
cmp eax, 0A0h
jge short loc_B9566
loc_B955D:
mov [rbp+var_4], 0
jmp short loc_B95B3
loc_B9566:
movzx eax, [rbp+var_21]
and eax, 0Fh
movsxd rcx, eax
shl rcx, 0Ch
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cdqe
shl rax, 6
or rcx, rax
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+2]
xor eax, 80h
cdqe
or rcx, rax
mov rax, [rbp+var_18]
mov [rax], rcx
mov [rbp+var_4], 3
jmp short loc_B95B3
loc_B95AC:
mov [rbp+var_4], 0
loc_B95B3:
mov eax, [rbp+var_4]
pop rbp
retn
| long long my_utf8mb3_uni_no_range(long long a1, unsigned long long *a2, unsigned __int8 *a3)
{
unsigned __int8 v4; // [rsp+1h] [rbp-21h]
v4 = *a3;
if ( *a3 >= 0x80u )
{
if ( v4 >= 0xC2u )
{
if ( v4 >= 0xE0u )
{
if ( v4 >= 0xF0u )
{
return 0;
}
else if ( (a3[1] ^ 0x80) < 64 && (a3[2] ^ 0x80) < 64 && (v4 >= 0xE1u || a3[1] >= 0xA0u) )
{
*a2 = a3[2] ^ 0x80u | ((long long)(a3[1] ^ 0x80u) << 6) | ((unsigned long long)(v4 & 0xF) << 12);
return 3;
}
else
{
return 0;
}
}
else if ( (a3[1] ^ 0x80) < 64 )
{
*a2 = a3[1] ^ 0x80u | ((unsigned long long)(v4 & 0x1F) << 6);
return 2;
}
else
{
return 0;
}
}
else
{
return 0;
}
}
else
{
*a2 = v4;
return 1;
}
}
| my_utf8mb3_uni_no_range:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x20]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x21],AL
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0x80
JGE 0x001b949d
MOVZX EAX,byte ptr [RBP + -0x21]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001b95b3
LAB_001b949d:
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xc2
JGE 0x001b94b4
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001b95b3
LAB_001b94b4:
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xe0
JGE 0x001b9510
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CMP EAX,0x40
JL 0x001b94dd
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001b95b3
LAB_001b94dd:
MOVZX EAX,byte ptr [RBP + -0x21]
AND EAX,0x1f
MOVSXD RCX,EAX
SHL RCX,0x6
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CDQE
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x2
JMP 0x001b95b3
LAB_001b9510:
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xf0
JGE 0x001b95ac
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x001b955d
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x2]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x001b955d
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xe1
JGE 0x001b9566
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0xa0
JGE 0x001b9566
LAB_001b955d:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001b95b3
LAB_001b9566:
MOVZX EAX,byte ptr [RBP + -0x21]
AND EAX,0xf
MOVSXD RCX,EAX
SHL RCX,0xc
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CDQE
SHL RAX,0x6
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x2]
XOR EAX,0x80
CDQE
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x3
JMP 0x001b95b3
LAB_001b95ac:
MOV dword ptr [RBP + -0x4],0x0
LAB_001b95b3:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_utf8mb3_uni_no_range(int8 param_1,ulong *param_2,byte *param_3)
{
byte bVar1;
int4 local_c;
bVar1 = *param_3;
if (bVar1 < 0x80) {
*param_2 = (ulong)bVar1;
local_c = 1;
}
else if (bVar1 < 0xc2) {
local_c = 0;
}
else if (bVar1 < 0xe0) {
if ((param_3[1] ^ 0x80) < 0x40) {
*param_2 = (long)(int)(bVar1 & 0x1f) << 6 | (long)(int)(param_3[1] ^ 0x80);
local_c = 2;
}
else {
local_c = 0;
}
}
else if (bVar1 < 0xf0) {
if ((((param_3[1] ^ 0x80) < 0x40) && ((param_3[2] ^ 0x80) < 0x40)) &&
((0xe0 < bVar1 || (0x9f < param_3[1])))) {
*param_2 = (long)(int)(bVar1 & 0xf) << 0xc | (long)(int)(param_3[1] ^ 0x80) << 6 |
(long)(int)(param_3[2] ^ 0x80);
local_c = 3;
}
else {
local_c = 0;
}
}
else {
local_c = 0;
}
return local_c;
}
|
|
5,852 | my_utf8mb3_uni_no_range | eloqsql/strings/ctype-utf8.c | static int my_utf8mb3_uni_no_range(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t * pwc, const uchar *s)
{
uchar c;
c= s[0];
if (c < 0x80)
{
*pwc = c;
return 1;
}
if (c < 0xc2)
return MY_CS_ILSEQ;
if (c < 0xe0)
{
if (!((s[1] ^ 0x80) < 0x40))
return MY_CS_ILSEQ;
*pwc= UTF8MB2_CODE(c, s[1]);
return 2;
}
if (c < 0xf0)
{
if (!IS_UTF8MB3_STEP2(c, s[1], s[2]))
return MY_CS_ILSEQ;
*pwc= UTF8MB3_CODE(c, s[1], s[2]);
return 3;
}
return MY_CS_ILSEQ;
} | O3 | c | my_utf8mb3_uni_no_range:
pushq %rbp
movq %rsp, %rbp
movzbl (%rsi), %ecx
testb %cl, %cl
js 0x87b55
movl $0x1, %eax
movq %rcx, (%rdi)
jmp 0x87b5c
xorl %eax, %eax
cmpb $-0x3e, %cl
jae 0x87b5e
popq %rbp
retq
cmpb $-0x21, %cl
ja 0x87b81
movzbl 0x1(%rsi), %edx
xorl $0x80, %edx
cmpb $0x3f, %dl
ja 0x87b5c
andl $0x1f, %ecx
shll $0x6, %ecx
orl %edx, %ecx
movl $0x2, %eax
jmp 0x87b50
cmpb $-0x11, %cl
ja 0x87b5c
movzbl 0x1(%rsi), %edx
cmpb $-0x41, %dl
jg 0x87b5c
movzbl 0x2(%rsi), %esi
cmpb $-0x41, %sil
jg 0x87b5c
cmpl $0xe0, %ecx
sete %r8b
cmpb $-0x60, %dl
setb %r9b
testb %r9b, %r8b
jne 0x87b5c
shll $0xc, %ecx
movzwl %cx, %eax
andl $0x3f, %edx
shll $0x6, %edx
orl %eax, %edx
andl $0x3f, %esi
orq %rdx, %rsi
movl $0x3, %eax
movq %rsi, %rcx
jmp 0x87b50
| my_utf8mb3_uni_no_range:
push rbp
mov rbp, rsp
movzx ecx, byte ptr [rsi]
test cl, cl
js short loc_87B55
mov eax, 1
loc_87B50:
mov [rdi], rcx
jmp short loc_87B5C
loc_87B55:
xor eax, eax
cmp cl, 0C2h
jnb short loc_87B5E
loc_87B5C:
pop rbp
retn
loc_87B5E:
cmp cl, 0DFh
ja short loc_87B81
movzx edx, byte ptr [rsi+1]
xor edx, 80h
cmp dl, 3Fh ; '?'
ja short loc_87B5C
and ecx, 1Fh
shl ecx, 6
or ecx, edx
mov eax, 2
jmp short loc_87B50
loc_87B81:
cmp cl, 0EFh
ja short loc_87B5C
movzx edx, byte ptr [rsi+1]
cmp dl, 0BFh
jg short loc_87B5C
movzx esi, byte ptr [rsi+2]
cmp sil, 0BFh
jg short loc_87B5C
cmp ecx, 0E0h
setz r8b
cmp dl, 0A0h
setb r9b
test r8b, r9b
jnz short loc_87B5C
shl ecx, 0Ch
movzx eax, cx
and edx, 3Fh
shl edx, 6
or edx, eax
and esi, 3Fh
or rsi, rdx
mov eax, 3
mov rcx, rsi
jmp short loc_87B50
| long long my_utf8mb3_uni_no_range(unsigned long long *a1, unsigned __int8 *a2)
{
unsigned long long v2; // rcx
long long result; // rax
char v4; // dl
char v5; // si
v2 = *a2;
if ( (v2 & 0x80u) == 0LL )
{
result = 1LL;
LABEL_3:
*a1 = v2;
return result;
}
result = 0LL;
if ( (unsigned __int8)v2 >= 0xC2u )
{
if ( (unsigned __int8)v2 > 0xDFu )
{
if ( (unsigned __int8)v2 <= 0xEFu )
{
v4 = a2[1];
if ( v4 <= -65 )
{
v5 = a2[2];
if ( v5 <= -65 && ((unsigned __int8)v4 >= 0xA0u || (_DWORD)v2 != 224) )
{
result = 3LL;
v2 = (unsigned __int16)((_WORD)v2 << 12) | ((unsigned __int8)(v4 & 0x3F) << 6) | (unsigned long long)(v5 & 0x3F);
goto LABEL_3;
}
}
}
}
else if ( (a2[1] ^ 0x80u) <= 0x3F )
{
v2 = a2[1] ^ 0x80 | ((unsigned __int8)(v2 & 0x1F) << 6);
result = 2LL;
goto LABEL_3;
}
}
return result;
}
| my_utf8mb3_uni_no_range:
PUSH RBP
MOV RBP,RSP
MOVZX ECX,byte ptr [RSI]
TEST CL,CL
JS 0x00187b55
MOV EAX,0x1
LAB_00187b50:
MOV qword ptr [RDI],RCX
JMP 0x00187b5c
LAB_00187b55:
XOR EAX,EAX
CMP CL,0xc2
JNC 0x00187b5e
LAB_00187b5c:
POP RBP
RET
LAB_00187b5e:
CMP CL,0xdf
JA 0x00187b81
MOVZX EDX,byte ptr [RSI + 0x1]
XOR EDX,0x80
CMP DL,0x3f
JA 0x00187b5c
AND ECX,0x1f
SHL ECX,0x6
OR ECX,EDX
MOV EAX,0x2
JMP 0x00187b50
LAB_00187b81:
CMP CL,0xef
JA 0x00187b5c
MOVZX EDX,byte ptr [RSI + 0x1]
CMP DL,0xbf
JG 0x00187b5c
MOVZX ESI,byte ptr [RSI + 0x2]
CMP SIL,0xbf
JG 0x00187b5c
CMP ECX,0xe0
SETZ R8B
CMP DL,0xa0
SETC R9B
TEST R8B,R9B
JNZ 0x00187b5c
SHL ECX,0xc
MOVZX EAX,CX
AND EDX,0x3f
SHL EDX,0x6
OR EDX,EAX
AND ESI,0x3f
OR RSI,RDX
MOV EAX,0x3
MOV RCX,RSI
JMP 0x00187b50
|
int8 my_utf8mb3_uni_no_range(ulong *param_1,byte *param_2)
{
byte bVar1;
byte bVar2;
int8 uVar3;
ulong uVar4;
bVar1 = *param_2;
uVar4 = (ulong)bVar1;
if ((char)bVar1 < '\0') {
if (bVar1 < 0xc2) {
return 0;
}
if (bVar1 < 0xe0) {
if (0x3f < (byte)(param_2[1] ^ 0x80)) {
return 0;
}
uVar4 = (ulong)((bVar1 & 0x1f) << 6 | param_2[1] ^ 0x80);
uVar3 = 2;
}
else {
if (0xef < bVar1) {
return 0;
}
bVar2 = param_2[1];
if (-0x41 < (char)bVar2) {
return 0;
}
if (-0x41 < (char)param_2[2]) {
return 0;
}
if (bVar1 == 0xe0 && bVar2 < 0xa0) {
return 0;
}
uVar4 = (ulong)(param_2[2] & 0x3f | (bVar2 & 0x3f) << 6 | (bVar1 & 0xf) << 0xc);
uVar3 = 3;
}
}
else {
uVar3 = 1;
}
*param_1 = uVar4;
return uVar3;
}
|
|
5,853 | change_pagecache_param | eloqsql/storage/maria/ma_pagecache.c | void change_pagecache_param(PAGECACHE *pagecache, uint division_limit,
uint age_threshold)
{
DBUG_ENTER("change_pagecache_param");
pagecache_pthread_mutex_lock(&pagecache->cache_lock);
if (division_limit)
pagecache->min_warm_blocks= (pagecache->disk_blocks *
division_limit / 100 + 1);
if (age_threshold)
pagecache->age_threshold= (pagecache->disk_blocks *
age_threshold / 100);
pagecache_pthread_mutex_unlock(&pagecache->cache_lock);
DBUG_VOID_RETURN;
} | O3 | c | change_pagecache_param:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r14
leaq 0xc8(%rdi), %rbx
cmpq $0x0, 0x108(%rdi)
jne 0x4bd7c
movq %rbx, %rdi
callq 0x29210
movabsq $-0x5c28f5c28f5c28f5, %rsi # imm = 0xA3D70A3D70A3D70B
testl %r12d, %r12d
je 0x4bd38
movl %r12d, %ecx
imulq 0x40(%r14), %rcx
movq %rcx, %rax
imulq %rsi
addq %rcx, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x6, %rdx
addq %rdx, %rax
incq %rax
movq %rax, 0x8(%r14)
testl %r15d, %r15d
je 0x4bd60
movl %r15d, %ecx
imulq 0x40(%r14), %rcx
movq %rcx, %rax
imulq %rsi
addq %rcx, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x6, %rdx
addq %rax, %rdx
movq %rdx, 0x10(%r14)
movq 0x108(%r14), %rdi
testq %rdi, %rdi
jne 0x4bd95
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x291e0
leaq 0x8d9b4(%rip), %rsi # 0xd9737
movq %rbx, %rdi
movl $0x46d, %edx # imm = 0x46D
callq 0x2eb6f
jmp 0x4bd03
leaq 0x339274(%rip), %rax # 0x385010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x4bd6c
| change_pagecache_param:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r15d, edx
mov r12d, esi
mov r14, rdi
lea rbx, [rdi+0C8h]
cmp qword ptr [rdi+108h], 0
jnz loc_4BD7C
mov rdi, rbx
call _pthread_mutex_lock
loc_4BD03:
mov rsi, 0A3D70A3D70A3D70Bh
test r12d, r12d
jz short loc_4BD38
mov ecx, r12d
imul rcx, [r14+40h]
mov rax, rcx
imul rsi
add rdx, rcx
mov rax, rdx
shr rax, 3Fh
sar rdx, 6
add rax, rdx
inc rax
mov [r14+8], rax
loc_4BD38:
test r15d, r15d
jz short loc_4BD60
mov ecx, r15d
imul rcx, [r14+40h]
mov rax, rcx
imul rsi
add rdx, rcx
mov rax, rdx
shr rax, 3Fh
sar rdx, 6
add rdx, rax
mov [r14+10h], rdx
loc_4BD60:
mov rdi, [r14+108h]
test rdi, rdi
jnz short loc_4BD95
loc_4BD6C:
mov rdi, rbx
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp _pthread_mutex_unlock
loc_4BD7C:
lea rsi, aWorkspaceLlm4b_28; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, rbx
mov edx, 46Dh
call psi_mutex_lock
jmp loc_4BD03
loc_4BD95:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_4BD6C
| long long change_pagecache_param(_QWORD *a1, unsigned int a2, unsigned int a3)
{
_QWORD *v4; // rbx
long long v5; // rdi
v4 = a1 + 25;
if ( a1[33] )
psi_mutex_lock(
(long long)(a1 + 25),
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0x46Du);
else
pthread_mutex_lock(a1 + 25);
if ( a2 )
a1[1] = a1[8] * a2 / 100LL + 1;
if ( a3 )
a1[2] = a1[8] * a3 / 100LL;
v5 = a1[33];
if ( v5 )
((void ( *)(long long, unsigned long long))PSI_server[44])(v5, 0xA3D70A3D70A3D70BLL);
return pthread_mutex_unlock(v4);
}
| change_pagecache_param:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R15D,EDX
MOV R12D,ESI
MOV R14,RDI
LEA RBX,[RDI + 0xc8]
CMP qword ptr [RDI + 0x108],0x0
JNZ 0x0014bd7c
MOV RDI,RBX
CALL 0x00129210
LAB_0014bd03:
MOV RSI,-0x5c28f5c28f5c28f5
TEST R12D,R12D
JZ 0x0014bd38
MOV ECX,R12D
IMUL RCX,qword ptr [R14 + 0x40]
MOV RAX,RCX
IMUL RSI
ADD RDX,RCX
MOV RAX,RDX
SHR RAX,0x3f
SAR RDX,0x6
ADD RAX,RDX
INC RAX
MOV qword ptr [R14 + 0x8],RAX
LAB_0014bd38:
TEST R15D,R15D
JZ 0x0014bd60
MOV ECX,R15D
IMUL RCX,qword ptr [R14 + 0x40]
MOV RAX,RCX
IMUL RSI
ADD RDX,RCX
MOV RAX,RDX
SHR RAX,0x3f
SAR RDX,0x6
ADD RDX,RAX
MOV qword ptr [R14 + 0x10],RDX
LAB_0014bd60:
MOV RDI,qword ptr [R14 + 0x108]
TEST RDI,RDI
JNZ 0x0014bd95
LAB_0014bd6c:
MOV RDI,RBX
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x001291e0
LAB_0014bd7c:
LEA RSI,[0x1d9737]
MOV RDI,RBX
MOV EDX,0x46d
CALL 0x0012eb6f
JMP 0x0014bd03
LAB_0014bd95:
LEA RAX,[0x485010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0014bd6c
|
void change_pagecache_param(long param_1,uint param_2,uint param_3)
{
pthread_mutex_t *__mutex;
__mutex = (pthread_mutex_t *)(param_1 + 200);
if (*(long *)(param_1 + 0x108) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0x46d);
}
if (param_2 != 0) {
*(long *)(param_1 + 8) = (long)((ulong)param_2 * *(long *)(param_1 + 0x40)) / 100 + 1;
}
if (param_3 != 0) {
*(long *)(param_1 + 0x10) = (long)((ulong)param_3 * *(long *)(param_1 + 0x40)) / 100;
}
if (*(long *)(param_1 + 0x108) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
return;
}
|
|
5,854 | mthd_stmt_fetch_to_bind | eloqsql/libmariadb/libmariadb/mariadb_stmt.c | int mthd_stmt_fetch_to_bind(MYSQL_STMT *stmt, unsigned char *row)
{
uint i;
size_t truncations= 0;
unsigned char *null_ptr, bit_offset= 4;
row++; /* skip status byte */
null_ptr= row;
row+= (stmt->field_count + 9) / 8;
for (i=0; i < stmt->field_count; i++)
{
/* save row position for fetching values in pieces */
if (*null_ptr & bit_offset)
{
if (stmt->result_callback)
stmt->result_callback(stmt->user_data, i, NULL);
else
{
if (!stmt->bind[i].is_null)
stmt->bind[i].is_null= &stmt->bind[i].is_null_value;
*stmt->bind[i].is_null= 1;
stmt->bind[i].u.row_ptr= NULL;
}
} else
{
stmt->bind[i].u.row_ptr= row;
if (!stmt->bind_result_done ||
stmt->bind[i].flags & MADB_BIND_DUMMY)
{
unsigned long length;
if (stmt->result_callback)
stmt->result_callback(stmt->user_data, i, &row);
else {
if (mysql_ps_fetch_functions[stmt->fields[i].type].pack_len >= 0)
length= mysql_ps_fetch_functions[stmt->fields[i].type].pack_len;
else
length= net_field_length(&row);
row+= length;
if (!stmt->bind[i].length)
stmt->bind[i].length= &stmt->bind[i].length_value;
*stmt->bind[i].length= stmt->bind[i].length_value= length;
}
}
else
{
if (!stmt->bind[i].length)
stmt->bind[i].length= &stmt->bind[i].length_value;
if (!stmt->bind[i].is_null)
stmt->bind[i].is_null= &stmt->bind[i].is_null_value;
*stmt->bind[i].is_null= 0;
mysql_ps_fetch_functions[stmt->fields[i].type].func(&stmt->bind[i], &stmt->fields[i], &row);
if (stmt->mysql->options.report_data_truncation)
truncations+= *stmt->bind[i].error;
}
}
if (!((bit_offset <<=1) & 255)) {
bit_offset= 1; /* To next byte */
null_ptr++;
}
}
return((truncations) ? MYSQL_DATA_TRUNCATED : 0);
} | O3 | c | mthd_stmt_fetch_to_bind:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl 0x60(%rdi), %eax
leal 0x9(%rax), %ecx
shrl $0x3, %ecx
addq %rsi, %rcx
incq %rcx
movq %rcx, -0x38(%rbp)
testl %eax, %eax
je 0x1e7eb
movq %rsi, %rbx
incq %rbx
movl $0x4, %r14d
movl $0x50, %r13d
xorl %r15d, %r15d
xorl %r12d, %r12d
movq $0x0, -0x40(%rbp)
movq %rdi, -0x30(%rbp)
movzbl (%rbx), %eax
testl %eax, %r14d
je 0x1e63b
movq 0x388(%rdi), %rax
testq %rax, %rax
je 0x1e717
movq -0x30(%rbp), %rcx
movq 0x380(%rcx), %rdi
movl %r12d, %esi
xorl %edx, %edx
jmp 0x1e70c
movq -0x38(%rbp), %rcx
movq 0x78(%rdi), %rax
movq %rcx, -0x30(%rax,%r13)
cmpb $0x0, 0xe8(%rdi)
je 0x1e6ee
movq 0x78(%rdi), %rax
testb $0x1, 0x8(%rax,%r13)
jne 0x1e6ee
cmpq $0x0, -0x50(%rax,%r13)
jne 0x1e67a
leaq (%rax,%r13), %rcx
movq %rcx, -0x50(%rax,%r13)
movq 0x78(%rdi), %rax
cmpq $0x0, -0x48(%rax,%r13)
jne 0x1e691
addq %r13, %rax
addq $0x17, %rax
movq %rax, -0x5f(%rax)
movq 0x78(%rdi), %rax
movq -0x48(%rax,%r13), %rax
movb $0x0, (%rax)
movq 0x58(%rdi), %rsi
movq 0x78(%rdi), %rax
movl 0x70(%rsi,%r15), %ecx
addq %r15, %rsi
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%r13), %rdi
addq $-0x50, %rdi
leaq -0x38(%rbp), %rdx
leaq 0x2a880(%rip), %rax # 0x48f40
callq *(%rax,%rcx,8)
movq -0x30(%rbp), %rdi
movq 0x38(%rdi), %rax
cmpb $0x0, 0x451(%rax)
je 0x1e7a8
movq 0x78(%rdi), %rax
movq -0x38(%rax,%r13), %rax
movsbq (%rax), %rax
addq %rax, -0x40(%rbp)
jmp 0x1e7a8
movq 0x388(%rdi), %rax
testq %rax, %rax
je 0x1e749
movq -0x30(%rbp), %rcx
movq 0x380(%rcx), %rdi
movl %r12d, %esi
leaq -0x38(%rbp), %rdx
callq *%rax
movq -0x30(%rbp), %rdi
jmp 0x1e7a8
movq 0x78(%rdi), %rax
cmpq $0x0, -0x48(%rax,%r13)
jne 0x1e732
addq %r13, %rax
addq $0x17, %rax
movq %rax, -0x5f(%rax)
movq 0x78(%rdi), %rax
movq -0x48(%rax,%r13), %rax
movb $0x1, (%rax)
movq 0x78(%rdi), %rax
movq $0x0, -0x30(%rax,%r13)
jmp 0x1e7a8
movq 0x58(%rdi), %rax
movl 0x70(%rax,%r15), %eax
leaq (%rax,%rax,2), %rax
leaq 0x2a7e3(%rip), %rdx # 0x48f40
movslq 0x8(%rdx,%rax,8), %rax
testq %rax, %rax
jns 0x1e778
leaq -0x38(%rbp), %rdi
callq 0x156d9
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rcx
addq %rax, %rcx
movq %rcx, -0x38(%rbp)
movq 0x78(%rdi), %rcx
cmpq $0x0, -0x50(%rcx,%r13)
jne 0x1e798
leaq (%rcx,%r13), %rdx
movq %rdx, -0x50(%rcx,%r13)
movq 0x78(%rdi), %rcx
movq %rax, (%rcx,%r13)
movq 0x78(%rdi), %rcx
movq -0x50(%rcx,%r13), %rcx
movq %rax, (%rcx)
movzbl %r14b, %eax
leal (%rax,%rax), %r14d
xorl %ecx, %ecx
testb $0x7f, %al
sete %cl
movl $0x1, %eax
cmovel %eax, %r14d
addq %rcx, %rbx
incq %r12
movl 0x60(%rdi), %eax
addq $0x70, %r13
subq $-0x80, %r15
cmpq %rax, %r12
jb 0x1e60e
xorl %ecx, %ecx
cmpq $0x0, -0x40(%rbp)
movl $0x65, %eax
cmovel %ecx, %eax
jmp 0x1e7ed
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| mthd_stmt_fetch_to_bind:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov eax, [rdi+60h]
lea ecx, [rax+9]
shr ecx, 3
add rcx, rsi
inc rcx
mov [rbp+var_38], rcx
test eax, eax
jz loc_1E7EB
mov rbx, rsi
inc rbx
mov r14d, 4
mov r13d, 50h ; 'P'
xor r15d, r15d
xor r12d, r12d
mov [rbp+var_40], 0
mov [rbp+var_30], rdi
loc_1E60E:
movzx eax, byte ptr [rbx]
test r14d, eax
jz short loc_1E63B
mov rax, [rdi+388h]
test rax, rax
jz loc_1E717
mov rcx, [rbp+var_30]
mov rdi, [rcx+380h]
mov esi, r12d
xor edx, edx
jmp loc_1E70C
loc_1E63B:
mov rcx, [rbp+var_38]
mov rax, [rdi+78h]
mov [rax+r13-30h], rcx
cmp byte ptr [rdi+0E8h], 0
jz loc_1E6EE
mov rax, [rdi+78h]
test byte ptr [rax+r13+8], 1
jnz loc_1E6EE
cmp qword ptr [rax+r13-50h], 0
jnz short loc_1E67A
lea rcx, [rax+r13]
mov [rax+r13-50h], rcx
mov rax, [rdi+78h]
loc_1E67A:
cmp qword ptr [rax+r13-48h], 0
jnz short loc_1E691
add rax, r13
add rax, 17h
mov [rax-5Fh], rax
mov rax, [rdi+78h]
loc_1E691:
mov rax, [rax+r13-48h]
mov byte ptr [rax], 0
mov rsi, [rdi+58h]
mov rax, [rdi+78h]
mov ecx, [rsi+r15+70h]
add rsi, r15
lea rcx, [rcx+rcx*2]
lea rdi, [rax+r13]
add rdi, 0FFFFFFFFFFFFFFB0h
lea rdx, [rbp+var_38]
lea rax, mysql_ps_fetch_functions
call qword ptr [rax+rcx*8]
mov rdi, [rbp+var_30]
mov rax, [rdi+38h]
cmp byte ptr [rax+451h], 0
jz loc_1E7A8
mov rax, [rdi+78h]
mov rax, [rax+r13-38h]
movsx rax, byte ptr [rax]
add [rbp+var_40], rax
jmp loc_1E7A8
loc_1E6EE:
mov rax, [rdi+388h]
test rax, rax
jz short loc_1E749
mov rcx, [rbp+var_30]
mov rdi, [rcx+380h]
mov esi, r12d
lea rdx, [rbp+var_38]
loc_1E70C:
call rax
mov rdi, [rbp+var_30]
jmp loc_1E7A8
loc_1E717:
mov rax, [rdi+78h]
cmp qword ptr [rax+r13-48h], 0
jnz short loc_1E732
add rax, r13
add rax, 17h
mov [rax-5Fh], rax
mov rax, [rdi+78h]
loc_1E732:
mov rax, [rax+r13-48h]
mov byte ptr [rax], 1
mov rax, [rdi+78h]
mov qword ptr [rax+r13-30h], 0
jmp short loc_1E7A8
loc_1E749:
mov rax, [rdi+58h]
mov eax, [rax+r15+70h]
lea rax, [rax+rax*2]
lea rdx, mysql_ps_fetch_functions
movsxd rax, dword ptr [rdx+rax*8+8]
test rax, rax
jns short loc_1E778
lea rdi, [rbp+var_38]
call net_field_length
mov rdi, [rbp+var_30]
mov rcx, [rbp+var_38]
loc_1E778:
add rcx, rax
mov [rbp+var_38], rcx
mov rcx, [rdi+78h]
cmp qword ptr [rcx+r13-50h], 0
jnz short loc_1E798
lea rdx, [rcx+r13]
mov [rcx+r13-50h], rdx
mov rcx, [rdi+78h]
loc_1E798:
mov [rcx+r13], rax
mov rcx, [rdi+78h]
mov rcx, [rcx+r13-50h]
mov [rcx], rax
loc_1E7A8:
movzx eax, r14b
lea r14d, [rax+rax]
xor ecx, ecx
test al, 7Fh
setz cl
mov eax, 1
cmovz r14d, eax
add rbx, rcx
inc r12
mov eax, [rdi+60h]
add r13, 70h ; 'p'
sub r15, 0FFFFFFFFFFFFFF80h
cmp r12, rax
jb loc_1E60E
xor ecx, ecx
cmp [rbp+var_40], 0
mov eax, 65h ; 'e'
cmovz eax, ecx
jmp short loc_1E7ED
loc_1E7EB:
xor eax, eax
loc_1E7ED:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long mthd_stmt_fetch_to_bind(_QWORD *a1, long long a2)
{
int v2; // eax
_BYTE *v3; // rbx
char v4; // r14
long long v5; // r13
long long v6; // r15
unsigned long long v7; // r12
void ( *v8)(long long, long long, unsigned __int8 **); // rax
long long v9; // rdi
long long v10; // rsi
unsigned __int8 **v11; // rdx
unsigned __int8 *v12; // rcx
long long v13; // rax
long long v14; // rax
signed long long v15; // rax
long long v16; // rcx
char v17; // al
long long result; // rax
long long v19; // [rsp+0h] [rbp-40h]
unsigned __int8 *v20; // [rsp+8h] [rbp-38h] BYREF
_QWORD *v21; // [rsp+10h] [rbp-30h]
v2 = *((_DWORD *)a1 + 24);
v20 = (unsigned __int8 *)(a2 + ((unsigned int)(v2 + 9) >> 3) + 1);
if ( !v2 )
return 0LL;
v3 = (_BYTE *)(a2 + 1);
v4 = 4;
v5 = 80LL;
v6 = 0LL;
v7 = 0LL;
v19 = 0LL;
v21 = a1;
do
{
if ( (*v3 & (unsigned __int8)v4) != 0 )
{
v8 = (void ( *)(long long, long long, unsigned __int8 **))a1[113];
if ( v8 )
{
v9 = v21[112];
v10 = (unsigned int)v7;
v11 = 0LL;
LABEL_16:
v8(v9, v10, v11);
a1 = v21;
goto LABEL_25;
}
v14 = a1[15];
if ( !*(_QWORD *)(v14 + v5 - 72) )
{
*(_QWORD *)(v5 + v14 - 72) = v5 + v14 + 23;
v14 = a1[15];
}
**(_BYTE **)(v14 + v5 - 72) = 1;
*(_QWORD *)(a1[15] + v5 - 48) = 0LL;
}
else
{
v12 = v20;
*(_QWORD *)(a1[15] + v5 - 48) = v20;
if ( !*((_BYTE *)a1 + 232) || (v13 = a1[15], (*(_BYTE *)(v13 + v5 + 8) & 1) != 0) )
{
v8 = (void ( *)(long long, long long, unsigned __int8 **))a1[113];
if ( v8 )
{
v9 = v21[112];
v10 = (unsigned int)v7;
v11 = &v20;
goto LABEL_16;
}
v15 = *((int *)&mysql_ps_fetch_functions + 6 * *(unsigned int *)(a1[11] + v6 + 112) + 2);
if ( v15 < 0 )
{
v15 = net_field_length(&v20);
a1 = v21;
v12 = v20;
}
v20 = &v12[v15];
v16 = a1[15];
if ( !*(_QWORD *)(v16 + v5 - 80) )
{
*(_QWORD *)(v16 + v5 - 80) = v16 + v5;
v16 = a1[15];
}
*(_QWORD *)(v16 + v5) = v15;
**(_QWORD **)(a1[15] + v5 - 80) = v15;
}
else
{
if ( !*(_QWORD *)(v13 + v5 - 80) )
{
*(_QWORD *)(v13 + v5 - 80) = v13 + v5;
v13 = a1[15];
}
if ( !*(_QWORD *)(v13 + v5 - 72) )
{
*(_QWORD *)(v5 + v13 - 72) = v5 + v13 + 23;
v13 = a1[15];
}
**(_BYTE **)(v13 + v5 - 72) = 0;
(*((void ( **)(long long, long long, unsigned __int8 **))&mysql_ps_fetch_functions
+ 3 * *(unsigned int *)(a1[11] + v6 + 112)))(
a1[15] + v5 - 80,
v6 + a1[11],
&v20);
a1 = v21;
if ( *(_BYTE *)(v21[7] + 1105LL) )
v19 += **(char **)(v21[15] + v5 - 56);
}
}
LABEL_25:
v17 = v4;
v4 *= 2;
if ( (v17 & 0x7F) == 0 )
v4 = 1;
v3 += (v17 & 0x7F) == 0;
++v7;
v5 += 112LL;
v6 += 128LL;
}
while ( v7 < *((unsigned int *)a1 + 24) );
result = 101LL;
if ( !v19 )
return 0LL;
return result;
}
| mthd_stmt_fetch_to_bind:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV EAX,dword ptr [RDI + 0x60]
LEA ECX,[RAX + 0x9]
SHR ECX,0x3
ADD RCX,RSI
INC RCX
MOV qword ptr [RBP + -0x38],RCX
TEST EAX,EAX
JZ 0x0011e7eb
MOV RBX,RSI
INC RBX
MOV R14D,0x4
MOV R13D,0x50
XOR R15D,R15D
XOR R12D,R12D
MOV qword ptr [RBP + -0x40],0x0
MOV qword ptr [RBP + -0x30],RDI
LAB_0011e60e:
MOVZX EAX,byte ptr [RBX]
TEST R14D,EAX
JZ 0x0011e63b
MOV RAX,qword ptr [RDI + 0x388]
TEST RAX,RAX
JZ 0x0011e717
MOV RCX,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RCX + 0x380]
MOV ESI,R12D
XOR EDX,EDX
JMP 0x0011e70c
LAB_0011e63b:
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RDI + 0x78]
MOV qword ptr [RAX + R13*0x1 + -0x30],RCX
CMP byte ptr [RDI + 0xe8],0x0
JZ 0x0011e6ee
MOV RAX,qword ptr [RDI + 0x78]
TEST byte ptr [RAX + R13*0x1 + 0x8],0x1
JNZ 0x0011e6ee
CMP qword ptr [RAX + R13*0x1 + -0x50],0x0
JNZ 0x0011e67a
LEA RCX,[RAX + R13*0x1]
MOV qword ptr [RAX + R13*0x1 + -0x50],RCX
MOV RAX,qword ptr [RDI + 0x78]
LAB_0011e67a:
CMP qword ptr [RAX + R13*0x1 + -0x48],0x0
JNZ 0x0011e691
ADD RAX,R13
ADD RAX,0x17
MOV qword ptr [RAX + -0x5f],RAX
MOV RAX,qword ptr [RDI + 0x78]
LAB_0011e691:
MOV RAX,qword ptr [RAX + R13*0x1 + -0x48]
MOV byte ptr [RAX],0x0
MOV RSI,qword ptr [RDI + 0x58]
MOV RAX,qword ptr [RDI + 0x78]
MOV ECX,dword ptr [RSI + R15*0x1 + 0x70]
ADD RSI,R15
LEA RCX,[RCX + RCX*0x2]
LEA RDI,[RAX + R13*0x1]
ADD RDI,-0x50
LEA RDX,[RBP + -0x38]
LEA RAX,[0x148f40]
CALL qword ptr [RAX + RCX*0x8]
MOV RDI,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RDI + 0x38]
CMP byte ptr [RAX + 0x451],0x0
JZ 0x0011e7a8
MOV RAX,qword ptr [RDI + 0x78]
MOV RAX,qword ptr [RAX + R13*0x1 + -0x38]
MOVSX RAX,byte ptr [RAX]
ADD qword ptr [RBP + -0x40],RAX
JMP 0x0011e7a8
LAB_0011e6ee:
MOV RAX,qword ptr [RDI + 0x388]
TEST RAX,RAX
JZ 0x0011e749
MOV RCX,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RCX + 0x380]
MOV ESI,R12D
LEA RDX,[RBP + -0x38]
LAB_0011e70c:
CALL RAX
MOV RDI,qword ptr [RBP + -0x30]
JMP 0x0011e7a8
LAB_0011e717:
MOV RAX,qword ptr [RDI + 0x78]
CMP qword ptr [RAX + R13*0x1 + -0x48],0x0
JNZ 0x0011e732
ADD RAX,R13
ADD RAX,0x17
MOV qword ptr [RAX + -0x5f],RAX
MOV RAX,qword ptr [RDI + 0x78]
LAB_0011e732:
MOV RAX,qword ptr [RAX + R13*0x1 + -0x48]
MOV byte ptr [RAX],0x1
MOV RAX,qword ptr [RDI + 0x78]
MOV qword ptr [RAX + R13*0x1 + -0x30],0x0
JMP 0x0011e7a8
LAB_0011e749:
MOV RAX,qword ptr [RDI + 0x58]
MOV EAX,dword ptr [RAX + R15*0x1 + 0x70]
LEA RAX,[RAX + RAX*0x2]
LEA RDX,[0x148f40]
MOVSXD RAX,dword ptr [RDX + RAX*0x8 + 0x8]
TEST RAX,RAX
JNS 0x0011e778
LEA RDI,[RBP + -0x38]
CALL 0x001156d9
MOV RDI,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x38]
LAB_0011e778:
ADD RCX,RAX
MOV qword ptr [RBP + -0x38],RCX
MOV RCX,qword ptr [RDI + 0x78]
CMP qword ptr [RCX + R13*0x1 + -0x50],0x0
JNZ 0x0011e798
LEA RDX,[RCX + R13*0x1]
MOV qword ptr [RCX + R13*0x1 + -0x50],RDX
MOV RCX,qword ptr [RDI + 0x78]
LAB_0011e798:
MOV qword ptr [RCX + R13*0x1],RAX
MOV RCX,qword ptr [RDI + 0x78]
MOV RCX,qword ptr [RCX + R13*0x1 + -0x50]
MOV qword ptr [RCX],RAX
LAB_0011e7a8:
MOVZX EAX,R14B
LEA R14D,[RAX + RAX*0x1]
XOR ECX,ECX
TEST AL,0x7f
SETZ CL
MOV EAX,0x1
CMOVZ R14D,EAX
ADD RBX,RCX
INC R12
MOV EAX,dword ptr [RDI + 0x60]
ADD R13,0x70
SUB R15,-0x80
CMP R12,RAX
JC 0x0011e60e
XOR ECX,ECX
CMP qword ptr [RBP + -0x40],0x0
MOV EAX,0x65
CMOVZ EAX,ECX
JMP 0x0011e7ed
LAB_0011e7eb:
XOR EAX,EAX
LAB_0011e7ed:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 mthd_stmt_fetch_to_bind(long param_1,long param_2)
{
code *pcVar1;
long lVar2;
int8 uVar3;
long lVar4;
long *plVar5;
byte *pbVar6;
ulong uVar7;
long lVar8;
byte bVar9;
long lVar10;
bool bVar11;
long local_48;
long local_40;
long local_38;
local_40 = (ulong)(*(int *)(param_1 + 0x60) + 9U >> 3) + param_2 + 1;
if (*(int *)(param_1 + 0x60) == 0) {
uVar3 = 0;
}
else {
pbVar6 = (byte *)(param_2 + 1);
bVar9 = 4;
lVar8 = 0x50;
lVar10 = 0;
uVar7 = 0;
local_48 = 0;
local_38 = param_1;
do {
if ((bVar9 & *pbVar6) == 0) {
*(long *)(*(long *)(param_1 + 0x78) + -0x30 + lVar8) = local_40;
if ((*(char *)(param_1 + 0xe8) == '\0') ||
(lVar2 = *(long *)(param_1 + 0x78), (*(byte *)(lVar2 + 8 + lVar8) & 1) != 0)) {
pcVar1 = *(code **)(param_1 + 0x388);
if (pcVar1 != (code *)0x0) {
uVar3 = *(int8 *)(local_38 + 0x380);
plVar5 = &local_40;
goto LAB_0011e70c;
}
lVar2 = (long)(int)(&DAT_00148f48)
[(ulong)*(uint *)(*(long *)(param_1 + 0x58) + 0x70 + lVar10) * 6];
if (lVar2 < 0) {
lVar2 = net_field_length(&local_40);
param_1 = local_38;
}
local_40 = local_40 + lVar2;
lVar4 = *(long *)(param_1 + 0x78);
if (*(long *)(lVar4 + -0x50 + lVar8) == 0) {
*(long *)(lVar4 + -0x50 + lVar8) = lVar4 + lVar8;
lVar4 = *(long *)(param_1 + 0x78);
}
*(long *)(lVar4 + lVar8) = lVar2;
**(long **)(*(long *)(param_1 + 0x78) + -0x50 + lVar8) = lVar2;
}
else {
if (*(long *)(lVar2 + -0x50 + lVar8) == 0) {
*(long *)(lVar2 + -0x50 + lVar8) = lVar2 + lVar8;
lVar2 = *(long *)(param_1 + 0x78);
}
if (*(long *)(lVar2 + -0x48 + lVar8) == 0) {
*(long *)(lVar2 + lVar8 + -0x48) = lVar2 + lVar8 + 0x17;
lVar2 = *(long *)(param_1 + 0x78);
}
**(int1 **)(lVar2 + -0x48 + lVar8) = 0;
(*(code *)(&mysql_ps_fetch_functions)
[(ulong)*(uint *)(*(long *)(param_1 + 0x58) + 0x70 + lVar10) * 3])
(*(long *)(param_1 + 0x78) + lVar8 + -0x50,*(long *)(param_1 + 0x58) + lVar10,
&local_40);
param_1 = local_38;
if (*(char *)(*(long *)(local_38 + 0x38) + 0x451) != '\0') {
local_48 = local_48 + **(char **)(*(long *)(local_38 + 0x78) + -0x38 + lVar8);
}
}
}
else {
pcVar1 = *(code **)(param_1 + 0x388);
if (pcVar1 == (code *)0x0) {
lVar2 = *(long *)(param_1 + 0x78);
if (*(long *)(lVar2 + -0x48 + lVar8) == 0) {
*(long *)(lVar2 + lVar8 + -0x48) = lVar2 + lVar8 + 0x17;
lVar2 = *(long *)(param_1 + 0x78);
}
**(int1 **)(lVar2 + -0x48 + lVar8) = 1;
*(int8 *)(*(long *)(param_1 + 0x78) + -0x30 + lVar8) = 0;
}
else {
uVar3 = *(int8 *)(local_38 + 0x380);
plVar5 = (long *)0x0;
LAB_0011e70c:
(*pcVar1)(uVar3,uVar7 & 0xffffffff,plVar5);
param_1 = local_38;
}
}
bVar11 = (bVar9 & 0x7f) == 0;
bVar9 = bVar9 * '\x02';
if (bVar11) {
bVar9 = 1;
}
pbVar6 = pbVar6 + bVar11;
uVar7 = uVar7 + 1;
lVar8 = lVar8 + 0x70;
lVar10 = lVar10 + 0x80;
} while (uVar7 < *(uint *)(param_1 + 0x60));
uVar3 = 0x65;
if (local_48 == 0) {
uVar3 = 0;
}
}
return uVar3;
}
|
|
5,855 | strmake | eloqsql/strings/strmake.c | char *strmake(register char *dst, register const char *src, size_t length)
{
while (length--)
{
if (! (*dst++ = *src++))
{
#ifdef EXTRA_DEBUG
/*
'length' is the maximum length of the string; the buffer needs
to be one character larger to accommodate the terminating
'\0'. This is easy to get wrong, so we make sure we write to
the entire length of the buffer to identify incorrect
buffer-sizes. We only initialism the "unused" part of the
buffer here, a) for efficiency, and b) because dst==src is
allowed, so initializing the entire buffer would overwrite the
source-string. Also, we write a character rather than '\0' as
this makes spotting these problems in the results easier.
If we are using purify/valgrind, we only set one character at
end to be able to detect also wrong accesses after the end of
dst.
*/
if (length)
{
#ifdef HAVE_valgrind
dst[length-1]= 'Z';
#else
bfill(dst, length-1, (int) 'Z');
#endif /* HAVE_valgrind */
}
#endif /* EXTRA_DEBUG */
return dst-1;
}
}
*dst=0;
return dst;
} | O3 | c | strmake:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
xorl %edi, %edi
movq %rdi, %rcx
cmpq %rdi, %rdx
je 0x79fd8
movb (%rsi,%rcx), %r8b
movb %r8b, (%rax,%rcx)
leaq 0x1(%rcx), %rdi
testb %r8b, %r8b
jne 0x79fbd
jmp 0x79fdc
movb $0x0, (%rax,%rcx)
addq %rcx, %rax
popq %rbp
retq
nopl (%rax)
| strmake:
push rbp
mov rbp, rsp
mov rax, rdi
xor edi, edi
loc_79FBD:
mov rcx, rdi
cmp rdx, rdi
jz short loc_79FD8
mov r8b, [rsi+rcx]
mov [rax+rcx], r8b
lea rdi, [rcx+1]
test r8b, r8b
jnz short loc_79FBD
jmp short loc_79FDC
loc_79FD8:
mov byte ptr [rax+rcx], 0
loc_79FDC:
add rax, rcx
pop rbp
retn
| long long strmake(long long a1, long long a2, long long a3)
{
long long v4; // rdi
long long v5; // rcx
char v6; // r8
v4 = 0LL;
while ( 1 )
{
v5 = v4;
if ( a3 == v4 )
break;
v6 = *(_BYTE *)(a2 + v4);
*(_BYTE *)(a1 + v4++) = v6;
if ( !v6 )
return v5 + a1;
}
*(_BYTE *)(a1 + v4) = 0;
return v5 + a1;
}
| strmake:
PUSH RBP
MOV RBP,RSP
MOV RAX,RDI
XOR EDI,EDI
LAB_00179fbd:
MOV RCX,RDI
CMP RDX,RDI
JZ 0x00179fd8
MOV R8B,byte ptr [RSI + RCX*0x1]
MOV byte ptr [RAX + RCX*0x1],R8B
LEA RDI,[RCX + 0x1]
TEST R8B,R8B
JNZ 0x00179fbd
JMP 0x00179fdc
LAB_00179fd8:
MOV byte ptr [RAX + RCX*0x1],0x0
LAB_00179fdc:
ADD RAX,RCX
POP RBP
RET
|
long strmake(long param_1,long param_2,long param_3)
{
char cVar1;
long lVar2;
long lVar3;
lVar2 = 0;
do {
lVar3 = lVar2;
if (param_3 == lVar3) {
*(int1 *)(param_1 + lVar3) = 0;
break;
}
cVar1 = *(char *)(param_2 + lVar3);
*(char *)(param_1 + lVar3) = cVar1;
lVar2 = lVar3 + 1;
} while (cVar1 != '\0');
return param_1 + lVar3;
}
|
|
5,856 | context_apply | corpus-core[P]colibri-stateless/src/chains/eth/verifier/call_ctx.h | static void context_apply(evmone_context_t* ctx) {
if (!ctx->parent) return;
bool created;
for (changed_account_t* acc = ctx->changed_accounts; acc; acc = acc->next) {
changed_account_t* parent_acc = create_changed_account(ctx->parent, acc->address, &created);
memcpy(parent_acc->balance, acc->balance, 32);
parent_acc->code = acc->code;
parent_acc->free_code = acc->free_code;
for (changed_storage_t* s = acc->storage; s; s = s->next)
set_changed_storage(ctx->parent, acc->address, s->key, s->value, &created, &created);
}
} | O0 | c | context_apply:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x90(%rax)
jne 0x2ed8f
jmp 0x2ee6e
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2ee6e
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rdi
movq -0x18(%rbp), %rsi
leaq -0x9(%rbp), %rdx
callq 0x2ea60
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x14(%rcx), %rdx
movq %rdx, 0x14(%rax)
movq 0x1c(%rcx), %rdx
movq %rdx, 0x1c(%rax)
movq 0x24(%rcx), %rdx
movq %rdx, 0x24(%rax)
movq 0x2c(%rcx), %rcx
movq %rcx, 0x2c(%rax)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x38(%rcx), %rdx
movq %rdx, 0x38(%rax)
movq 0x40(%rcx), %rcx
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rax
movb 0x59(%rax), %cl
movq -0x20(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x59(%rax)
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2ee5b
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x28(%rbp), %rcx
addq $0x20, %rcx
leaq -0x9(%rbp), %r9
movq %r9, %r8
callq 0x2e940
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x2ee1f
jmp 0x2ee5d
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2ed9b
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| context_apply:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
cmp qword ptr [rax+90h], 0
jnz short loc_2ED8F
jmp loc_2EE6E
loc_2ED8F:
mov rax, [rbp+var_8]
mov rax, [rax+28h]
mov [rbp+var_18], rax
loc_2ED9B:
cmp [rbp+var_18], 0
jz loc_2EE6E
mov rax, [rbp+var_8]
mov rdi, [rax+90h]
mov rsi, [rbp+var_18]
lea rdx, [rbp+var_9]
call create_changed_account
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
mov rdx, [rcx+14h]
mov [rax+14h], rdx
mov rdx, [rcx+1Ch]
mov [rax+1Ch], rdx
mov rdx, [rcx+24h]
mov [rax+24h], rdx
mov rcx, [rcx+2Ch]
mov [rax+2Ch], rcx
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
mov rdx, [rcx+38h]
mov [rax+38h], rdx
mov rcx, [rcx+40h]
mov [rax+40h], rcx
mov rax, [rbp+var_18]
mov cl, [rax+59h]
mov rax, [rbp+var_20]
and cl, 1
mov [rax+59h], cl
mov rax, [rbp+var_18]
mov rax, [rax+50h]
mov [rbp+var_28], rax
loc_2EE1F:
cmp [rbp+var_28], 0
jz short loc_2EE5B
mov rax, [rbp+var_8]
mov rdi, [rax+90h]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_28]
add rcx, 20h ; ' '
lea r9, [rbp+var_9]
mov r8, r9
call set_changed_storage
mov rax, [rbp+var_28]
mov rax, [rax+40h]
mov [rbp+var_28], rax
jmp short loc_2EE1F
loc_2EE5B:
jmp short $+2
loc_2EE5D:
mov rax, [rbp+var_18]
mov rax, [rax+48h]
mov [rbp+var_18], rax
jmp loc_2ED9B
loc_2EE6E:
add rsp, 30h
pop rbp
retn
| long long context_apply(long long a1, long long a2, long long a3, long long a4, int a5, int a6)
{
long long result; // rax
_QWORD *j; // [rsp+8h] [rbp-28h]
_QWORD *v8; // [rsp+10h] [rbp-20h]
long long i; // [rsp+18h] [rbp-18h]
bool v10; // [rsp+27h] [rbp-9h] BYREF
long long v11; // [rsp+28h] [rbp-8h]
v11 = a1;
result = a1;
if ( *(_QWORD *)(a1 + 144) )
{
result = *(_QWORD *)(v11 + 40);
for ( i = result; i; i = result )
{
v8 = create_changed_account(*(_QWORD **)(v11 + 144), (_QWORD *)i, &v10, a4, a5, a6);
*(_QWORD *)((char *)v8 + 20) = *(_QWORD *)(i + 20);
*(_QWORD *)((char *)v8 + 28) = *(_QWORD *)(i + 28);
*(_QWORD *)((char *)v8 + 36) = *(_QWORD *)(i + 36);
*(_QWORD *)((char *)v8 + 44) = *(_QWORD *)(i + 44);
v8[7] = *(_QWORD *)(i + 56);
a4 = *(_QWORD *)(i + 64);
v8[8] = a4;
LOBYTE(a4) = *(_BYTE *)(i + 89) & 1;
*((_BYTE *)v8 + 89) = a4;
for ( j = *(_QWORD **)(i + 80); j; j = (_QWORD *)j[8] )
set_changed_storage(*(_QWORD *)(v11 + 144), i, j, j + 4, &v10, &v10);
result = *(_QWORD *)(i + 72);
}
}
return result;
}
| context_apply:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x90],0x0
JNZ 0x0012ed8f
JMP 0x0012ee6e
LAB_0012ed8f:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x18],RAX
LAB_0012ed9b:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x0012ee6e
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x90]
MOV RSI,qword ptr [RBP + -0x18]
LEA RDX,[RBP + -0x9]
CALL 0x0012ea60
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RCX + 0x14]
MOV qword ptr [RAX + 0x14],RDX
MOV RDX,qword ptr [RCX + 0x1c]
MOV qword ptr [RAX + 0x1c],RDX
MOV RDX,qword ptr [RCX + 0x24]
MOV qword ptr [RAX + 0x24],RDX
MOV RCX,qword ptr [RCX + 0x2c]
MOV qword ptr [RAX + 0x2c],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RCX + 0x38]
MOV qword ptr [RAX + 0x38],RDX
MOV RCX,qword ptr [RCX + 0x40]
MOV qword ptr [RAX + 0x40],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV CL,byte ptr [RAX + 0x59]
MOV RAX,qword ptr [RBP + -0x20]
AND CL,0x1
MOV byte ptr [RAX + 0x59],CL
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x50]
MOV qword ptr [RBP + -0x28],RAX
LAB_0012ee1f:
CMP qword ptr [RBP + -0x28],0x0
JZ 0x0012ee5b
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x90]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x28]
ADD RCX,0x20
LEA R9,[RBP + -0x9]
MOV R8,R9
CALL 0x0012e940
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x40]
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0012ee1f
LAB_0012ee5b:
JMP 0x0012ee5d
LAB_0012ee5d:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x48]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0012ed9b
LAB_0012ee6e:
ADD RSP,0x30
POP RBP
RET
|
void context_apply(long param_1)
{
long lVar1;
long local_30;
long local_20;
int1 local_11;
long local_10;
if (*(long *)(param_1 + 0x90) != 0) {
local_10 = param_1;
for (local_20 = *(long *)(param_1 + 0x28); local_20 != 0; local_20 = *(long *)(local_20 + 0x48))
{
lVar1 = create_changed_account(*(int8 *)(local_10 + 0x90),local_20,&local_11);
*(int8 *)(lVar1 + 0x14) = *(int8 *)(local_20 + 0x14);
*(int8 *)(lVar1 + 0x1c) = *(int8 *)(local_20 + 0x1c);
*(int8 *)(lVar1 + 0x24) = *(int8 *)(local_20 + 0x24);
*(int8 *)(lVar1 + 0x2c) = *(int8 *)(local_20 + 0x2c);
*(int8 *)(lVar1 + 0x38) = *(int8 *)(local_20 + 0x38);
*(int8 *)(lVar1 + 0x40) = *(int8 *)(local_20 + 0x40);
*(byte *)(lVar1 + 0x59) = *(byte *)(local_20 + 0x59) & 1;
for (local_30 = *(long *)(local_20 + 0x50); local_30 != 0;
local_30 = *(long *)(local_30 + 0x40)) {
set_changed_storage(*(int8 *)(local_10 + 0x90),local_20,local_30,local_30 + 0x20,
&local_11);
}
}
}
return;
}
|
|
5,857 | R3D_GetShadowUpdateMode | r3d/src/r3d_lighting.c | R3D_ShadowUpdateMode R3D_GetShadowUpdateMode(R3D_Light id)
{
r3d_get_and_check_light(light, id, 0);
return light->shadow.updateConf.mode;
} | O3 | c | R3D_GetShadowUpdateMode:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %edx
testl %edi, %edi
je 0xbe8cc
leaq 0xf138e(%rip), %rax # 0x1afc20
cmpl %edx, 0x168(%rax)
jbe 0xbe8cc
movq 0x128(%rax), %rsi
leal -0x1(%rdx), %ecx
cmpb $0x1, (%rsi,%rcx)
jne 0xbe8cc
movq 0x108(%rax), %rsi
cmpq %rcx, 0x110(%rax)
setbe %dil
testq %rsi, %rsi
sete %r8b
orb %dil, %r8b
cmpb $0x1, %r8b
jne 0xbe8ea
leaq 0x53510(%rip), %rsi # 0x111de3
xorl %ebx, %ebx
movl $0x5, %edi
xorl %eax, %eax
callq 0xa9c29
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
imulq 0x120(%rax), %rcx
movl (%rsi,%rcx), %ebx
jmp 0xbe8e1
| R3D_GetShadowUpdateMode:
push rbp
mov rbp, rsp
push rbx
push rax
mov edx, edi
test edi, edi
jz short loc_BE8CC
lea rax, R3D
cmp [rax+168h], edx
jbe short loc_BE8CC
mov rsi, [rax+128h]
lea ecx, [rdx-1]
cmp byte ptr [rsi+rcx], 1
jnz short loc_BE8CC
mov rsi, [rax+108h]
cmp [rax+110h], rcx
setbe dil
test rsi, rsi
setz r8b
or r8b, dil
cmp r8b, 1
jnz short loc_BE8EA
loc_BE8CC:
lea rsi, aLightIdIIsNotV; "Light [ID %i] is not valid"
xor ebx, ebx
mov edi, 5
xor eax, eax
call TraceLog
loc_BE8E1:
mov eax, ebx
add rsp, 8
pop rbx
pop rbp
retn
loc_BE8EA:
imul rcx, [rax+120h]
mov ebx, [rsi+rcx]
jmp short loc_BE8E1
| long long R3D_GetShadowUpdateMode(unsigned int a1)
{
unsigned long long v1; // rcx
long long v2; // rsi
unsigned int v3; // ebx
if ( a1
&& *((_DWORD *)&R3D + 90) > a1
&& (v1 = a1 - 1, *(_BYTE *)(*((_QWORD *)&R3D + 37) + v1) == 1)
&& (v2 = *((_QWORD *)&R3D + 33), *((_QWORD *)&R3D + 34) > v1 && v2 != 0) )
{
return *(unsigned int *)(v2 + *((_QWORD *)&R3D + 36) * v1);
}
else
{
v3 = 0;
TraceLog(5, (long long)"Light [ID %i] is not valid", a1);
}
return v3;
}
| R3D_GetShadowUpdateMode:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV EDX,EDI
TEST EDI,EDI
JZ 0x001be8cc
LEA RAX,[0x2afc20]
CMP dword ptr [RAX + 0x168],EDX
JBE 0x001be8cc
MOV RSI,qword ptr [RAX + 0x128]
LEA ECX,[RDX + -0x1]
CMP byte ptr [RSI + RCX*0x1],0x1
JNZ 0x001be8cc
MOV RSI,qword ptr [RAX + 0x108]
CMP qword ptr [RAX + 0x110],RCX
SETBE DIL
TEST RSI,RSI
SETZ R8B
OR R8B,DIL
CMP R8B,0x1
JNZ 0x001be8ea
LAB_001be8cc:
LEA RSI,[0x211de3]
XOR EBX,EBX
MOV EDI,0x5
XOR EAX,EAX
CALL 0x001a9c29
LAB_001be8e1:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_001be8ea:
IMUL RCX,qword ptr [RAX + 0x120]
MOV EBX,dword ptr [RSI + RCX*0x1]
JMP 0x001be8e1
|
int4 R3D_GetShadowUpdateMode(uint param_1)
{
ulong uVar1;
if ((((param_1 != 0) && (param_1 < DAT_002afd88)) &&
(uVar1 = (ulong)(param_1 - 1), *(char *)(DAT_002afd48 + uVar1) == '\x01')) &&
(DAT_002afd28 != 0 && uVar1 < DAT_002afd30)) {
return *(int4 *)(DAT_002afd28 + uVar1 * DAT_002afd40);
}
TraceLog(5,"Light [ID %i] is not valid");
return 0;
}
|
|
5,858 | JS_ReadTypedArray | bluesky950520[P]quickjs/quickjs.c | static JSValue JS_ReadTypedArray(BCReaderState *s)
{
JSContext *ctx = s->ctx;
JSValue obj = JS_UNDEFINED, array_buffer = JS_UNDEFINED;
uint8_t array_tag;
JSValue args[3];
uint32_t offset, len, idx;
if (bc_get_u8(s, &array_tag))
return JS_EXCEPTION;
if (array_tag >= JS_TYPED_ARRAY_COUNT)
return JS_ThrowTypeError(ctx, "invalid typed array");
if (bc_get_leb128(s, &len))
return JS_EXCEPTION;
if (bc_get_leb128(s, &offset))
return JS_EXCEPTION;
/* XXX: this hack could be avoided if the typed array could be
created before the array buffer */
idx = s->objects_count;
if (BC_add_object_ref1(s, NULL))
goto fail;
array_buffer = JS_ReadObjectRec(s);
if (JS_IsException(array_buffer))
return JS_EXCEPTION;
if (!js_get_array_buffer(ctx, array_buffer)) {
JS_FreeValue(ctx, array_buffer);
return JS_EXCEPTION;
}
args[0] = array_buffer;
args[1] = js_int64(offset);
args[2] = js_int64(len);
obj = js_typed_array_constructor(ctx, JS_UNDEFINED,
3, args,
JS_CLASS_UINT8C_ARRAY + array_tag);
if (JS_IsException(obj))
goto fail;
if (s->allow_reference) {
s->objects[idx] = JS_VALUE_GET_OBJ(obj);
}
JS_FreeValue(ctx, array_buffer);
return obj;
fail:
JS_FreeValue(ctx, array_buffer);
JS_FreeValue(ctx, obj);
return JS_EXCEPTION;
} | O1 | c | JS_ReadTypedArray:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r15
movq (%rdi), %rbx
movq $0x0, 0x10(%rsp)
leaq 0xf(%rsp), %rsi
callq 0x45a3d
movl $0x6, %r14d
testl %eax, %eax
je 0x4677a
xorl %ebp, %ebp
movq %rbp, %rax
movq %r14, %rdx
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzbl 0xf(%rsp), %ebp
cmpl $0xc, %ebp
jb 0x46799
leaq 0x59269(%rip), %rsi # 0x9f9f4
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22567
jmp 0x46765
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0x45a75
testl %eax, %eax
jne 0x46763
leaq 0x1c(%rsp), %rsi
movq %r15, %rdi
callq 0x45a75
testl %eax, %eax
jne 0x46763
movl 0x40(%r15), %eax
movq %rax, 0x28(%rsp)
xorl %r13d, %r13d
movq %r15, %rdi
xorl %esi, %esi
callq 0x47091
movl $0x3, %edx
movl $0x3, %r12d
testl %eax, %eax
je 0x4680a
movq 0x18(%rbx), %rdi
movq %r13, %rsi
callq 0x1d8c6
movq 0x10(%rsp), %rsi
movq 0x18(%rbx), %rdi
movq %r12, %rdx
callq 0x1d8c6
xorl %ebp, %ebp
movl $0x6, %r14d
jmp 0x46765
movq %r15, %rdi
callq 0x32909
cmpl $0x6, %edx
je 0x46763
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
movq %rdx, %r13
callq 0x38fcf
testq %rax, %rax
je 0x468c8
movl 0x1c(%rsp), %eax
xorl %ecx, %ecx
cvtsi2sd %rax, %xmm0
testl %eax, %eax
movq %xmm0, %rdx
cmovnsq %rax, %rdx
movl $0x7, %eax
cmovnsq %rcx, %rax
movl 0x18(%rsp), %esi
xorps %xmm0, %xmm0
cvtsi2sd %rsi, %xmm0
testl %esi, %esi
movq %xmm0, %rdi
cmovnsq %rsi, %rdi
leaq 0x30(%rsp), %r8
movq %r12, (%r8)
movq %r13, 0x20(%rsp)
movq %r13, 0x8(%r8)
movq %rdx, 0x10(%r8)
movl $0x7, %edx
cmovnsq %rcx, %rdx
movq %rax, 0x18(%r8)
movq %rdi, 0x20(%r8)
movq %rdx, 0x28(%r8)
addl $0x15, %ebp
movl $0x3, %edx
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %r9d
callq 0x39038
movq %rdx, %r14
movq %rax, 0x10(%rsp)
cmpl $0x6, %r14d
jne 0x468dc
movq %r12, %r13
movq %r14, %r12
movq 0x20(%rsp), %rdx
jmp 0x467e0
movq 0x18(%rbx), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1d8c6
jmp 0x46763
movq %rax, %rbp
cmpb $0x0, 0x36(%r15)
je 0x468f8
movq 0x10(%rsp), %rax
movq 0x38(%r15), %rcx
movq 0x28(%rsp), %rdx
movq %rax, (%rcx,%rdx,8)
movq 0x18(%rbx), %rdi
movq %r12, %rsi
movq 0x20(%rsp), %rdx
callq 0x1d8c6
jmp 0x46765
| JS_ReadTypedArray:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r15, rdi
mov rbx, [rdi]
mov [rsp+98h+var_88], 0
lea rsi, [rsp+98h+var_89]
call bc_get_u8
mov r14d, 6
test eax, eax
jz short loc_4677A
loc_46763:
xor ebp, ebp
loc_46765:
mov rax, rbp
mov rdx, r14
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4677A:
movzx ebp, [rsp+98h+var_89]
cmp ebp, 0Ch
jb short loc_46799
lea rsi, aInvalidTypedAr_0; "invalid typed array"
xor ebp, ebp
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
jmp short loc_46765
loc_46799:
lea rsi, [rsp+98h+var_80]
mov rdi, r15
call bc_get_leb128
test eax, eax
jnz short loc_46763
lea rsi, [rsp+98h+var_7C]
mov rdi, r15
call bc_get_leb128
test eax, eax
jnz short loc_46763
mov eax, [r15+40h]
mov [rsp+98h+var_70], rax
xor r13d, r13d
mov rdi, r15
xor esi, esi
call BC_add_object_ref1
mov edx, 3
mov r12d, 3
test eax, eax
jz short loc_4680A
loc_467E0:
mov rdi, [rbx+18h]
mov rsi, r13
call JS_FreeValueRT
mov rsi, [rsp+98h+var_88]
mov rdi, [rbx+18h]
mov rdx, r12
call JS_FreeValueRT
xor ebp, ebp
mov r14d, 6
jmp loc_46765
loc_4680A:
mov rdi, r15
call JS_ReadObjectRec
cmp edx, 6
jz loc_46763
mov r12, rax
mov rdi, rbx
mov rsi, rax
mov r13, rdx
call js_get_array_buffer
test rax, rax
jz loc_468C8
mov eax, [rsp+98h+var_7C]
xor ecx, ecx
cvtsi2sd xmm0, rax
test eax, eax
movq rdx, xmm0
cmovns rdx, rax
mov eax, 7
cmovns rax, rcx
mov esi, [rsp+98h+var_80]
xorps xmm0, xmm0
cvtsi2sd xmm0, rsi
test esi, esi
movq rdi, xmm0
cmovns rdi, rsi
lea r8, [rsp+98h+var_68]
mov [r8], r12
mov [rsp+98h+var_78], r13
mov [r8+8], r13
mov [r8+10h], rdx
mov edx, 7
cmovns rdx, rcx
mov [r8+18h], rax
mov [r8+20h], rdi
mov [r8+28h], rdx
add ebp, 15h
mov edx, 3
mov rdi, rbx
xor esi, esi
mov r9d, ebp
call js_typed_array_constructor
mov r14, rdx
mov [rsp+98h+var_88], rax
cmp r14d, 6
jnz short loc_468DC
mov r13, r12
mov r12, r14
mov rdx, [rsp+98h+var_78]
jmp loc_467E0
loc_468C8:
mov rdi, [rbx+18h]
mov rsi, r12
mov rdx, r13
call JS_FreeValueRT
jmp loc_46763
loc_468DC:
mov rbp, rax
cmp byte ptr [r15+36h], 0
jz short loc_468F8
mov rax, [rsp+98h+var_88]
mov rcx, [r15+38h]
mov rdx, [rsp+98h+var_70]
mov [rcx+rdx*8], rax
loc_468F8:
mov rdi, [rbx+18h]
mov rsi, r12
mov rdx, [rsp+98h+var_78]
call JS_FreeValueRT
jmp loc_46765
| _DWORD * JS_ReadTypedArray(
long long a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
double a6,
double a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
long long a12,
int a13,
int a14)
{
long long v15; // rbx
long long v16; // rdx
long long v17; // rcx
unsigned long long v18; // r8
long long v19; // r9
__m128 v20; // xmm4
__m128 v21; // xmm5
_DWORD *v22; // rbp
int v24; // ebp
long long v25; // rdx
int v26; // ecx
unsigned long long v27; // r8
_DWORD *v28; // r13
int v29; // eax
long long v30; // rcx
long long v31; // r8
long long v32; // r9
__m128 v33; // xmm4
__m128 v34; // xmm5
long long v35; // rdx
long long v36; // r12
long long ObjectRec; // rax
long long v38; // rdx
double v39; // xmm4_8
double v40; // xmm5_8
_DWORD *v41; // r12
long long v42; // r13
double v43; // xmm4_8
double v44; // xmm5_8
double v45; // rdx
long long v46; // rax
__m128 v47; // xmm0
double v48; // rdi
long long v49; // rdx
_DWORD *v50; // rax
long long v51; // rdx
char v52; // [rsp+0h] [rbp-98h]
unsigned __int8 v53; // [rsp+Fh] [rbp-89h] BYREF
_DWORD *v54; // [rsp+10h] [rbp-88h]
int v55; // [rsp+18h] [rbp-80h] BYREF
int v56; // [rsp+1Ch] [rbp-7Ch] BYREF
long long v57; // [rsp+20h] [rbp-78h]
long long v58; // [rsp+28h] [rbp-70h]
long long v59[13]; // [rsp+30h] [rbp-68h] BYREF
v15 = *(_QWORD *)a1;
v54 = 0LL;
if ( (unsigned int)bc_get_u8(a1, &v53, a11, a12, a13, a14) )
return 0LL;
v24 = v53;
if ( v53 >= 0xCu )
{
v22 = 0LL;
JS_ThrowTypeError(v15, (long long)"invalid typed array", v16, v17, v18, v19, a2, a3, a4, a5, v20, v21, a8, a9, v52);
return v22;
}
if ( (unsigned int)bc_get_leb128(a1, &v55, v16, v17, v18) || (unsigned int)bc_get_leb128(a1, &v56, v25, v26, v27) )
return 0LL;
v58 = *(unsigned int *)(a1 + 64);
v28 = 0LL;
v29 = BC_add_object_ref1(a1, 0LL);
v35 = 3LL;
v36 = 3LL;
if ( v29 )
{
LABEL_9:
JS_FreeValueRT(*(_QWORD *)(v15 + 24), v28, v35);
JS_FreeValueRT(*(_QWORD *)(v15 + 24), v54, v36);
return 0LL;
}
ObjectRec = JS_ReadObjectRec(a1, a2, a3, a4, a5, v33, v34, a8, a9, 0LL, 3LL, v30, v31, v32);
if ( (_DWORD)v38 == 6 )
return 0LL;
v41 = (_DWORD *)ObjectRec;
v42 = v38;
if ( !js_get_array_buffer(v15, ObjectRec, v38, a2, a3, a4, a5, v39, v40, a8, a9) )
{
JS_FreeValueRT(*(_QWORD *)(v15 + 24), v41, v42);
return 0LL;
}
v45 = (double)v56;
if ( v56 >= 0 )
*(_QWORD *)&v45 = (unsigned int)v56;
v46 = 7LL;
if ( v56 >= 0 )
v46 = 0LL;
v47 = 0LL;
v48 = (double)v55;
if ( v55 >= 0 )
*(_QWORD *)&v48 = (unsigned int)v55;
v59[0] = (long long)v41;
v57 = v42;
v59[1] = v42;
*(double *)&v59[2] = v45;
v49 = 7LL;
if ( v55 >= 0 )
v49 = 0LL;
v59[3] = v46;
*(double *)&v59[4] = v48;
v59[5] = v49;
*(double *)v47.m128_u64 = (double)v55;
v50 = (_DWORD *)js_typed_array_constructor(v15, 0LL, 3LL, v47, a3, a4, a5, v43, v44, a8, a9, 0LL, v59, v24 + 21);
v54 = v50;
if ( (_DWORD)v51 == 6 )
{
v28 = v41;
v36 = v51;
v35 = v57;
goto LABEL_9;
}
v22 = v50;
if ( *(_BYTE *)(a1 + 54) )
*(_QWORD *)(*(_QWORD *)(a1 + 56) + 8 * v58) = v54;
JS_FreeValueRT(*(_QWORD *)(v15 + 24), v41, v57);
return v22;
}
| JS_ReadTypedArray:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R15,RDI
MOV RBX,qword ptr [RDI]
MOV qword ptr [RSP + 0x10],0x0
LEA RSI,[RSP + 0xf]
CALL 0x00145a3d
MOV R14D,0x6
TEST EAX,EAX
JZ 0x0014677a
LAB_00146763:
XOR EBP,EBP
LAB_00146765:
MOV RAX,RBP
MOV RDX,R14
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0014677a:
MOVZX EBP,byte ptr [RSP + 0xf]
CMP EBP,0xc
JC 0x00146799
LEA RSI,[0x19f9f4]
XOR EBP,EBP
MOV RDI,RBX
XOR EAX,EAX
CALL 0x00122567
JMP 0x00146765
LAB_00146799:
LEA RSI,[RSP + 0x18]
MOV RDI,R15
CALL 0x00145a75
TEST EAX,EAX
JNZ 0x00146763
LEA RSI,[RSP + 0x1c]
MOV RDI,R15
CALL 0x00145a75
TEST EAX,EAX
JNZ 0x00146763
MOV EAX,dword ptr [R15 + 0x40]
MOV qword ptr [RSP + 0x28],RAX
XOR R13D,R13D
MOV RDI,R15
XOR ESI,ESI
CALL 0x00147091
MOV EDX,0x3
MOV R12D,0x3
TEST EAX,EAX
JZ 0x0014680a
LAB_001467e0:
MOV RDI,qword ptr [RBX + 0x18]
MOV RSI,R13
CALL 0x0011d8c6
MOV RSI,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RBX + 0x18]
MOV RDX,R12
CALL 0x0011d8c6
XOR EBP,EBP
MOV R14D,0x6
JMP 0x00146765
LAB_0014680a:
MOV RDI,R15
CALL 0x00132909
CMP EDX,0x6
JZ 0x00146763
MOV R12,RAX
MOV RDI,RBX
MOV RSI,RAX
MOV R13,RDX
CALL 0x00138fcf
TEST RAX,RAX
JZ 0x001468c8
MOV EAX,dword ptr [RSP + 0x1c]
XOR ECX,ECX
CVTSI2SD XMM0,RAX
TEST EAX,EAX
MOVQ RDX,XMM0
CMOVNS RDX,RAX
MOV EAX,0x7
CMOVNS RAX,RCX
MOV ESI,dword ptr [RSP + 0x18]
XORPS XMM0,XMM0
CVTSI2SD XMM0,RSI
TEST ESI,ESI
MOVQ RDI,XMM0
CMOVNS RDI,RSI
LEA R8,[RSP + 0x30]
MOV qword ptr [R8],R12
MOV qword ptr [RSP + 0x20],R13
MOV qword ptr [R8 + 0x8],R13
MOV qword ptr [R8 + 0x10],RDX
MOV EDX,0x7
CMOVNS RDX,RCX
MOV qword ptr [R8 + 0x18],RAX
MOV qword ptr [R8 + 0x20],RDI
MOV qword ptr [R8 + 0x28],RDX
ADD EBP,0x15
MOV EDX,0x3
MOV RDI,RBX
XOR ESI,ESI
MOV R9D,EBP
CALL 0x00139038
MOV R14,RDX
MOV qword ptr [RSP + 0x10],RAX
CMP R14D,0x6
JNZ 0x001468dc
MOV R13,R12
MOV R12,R14
MOV RDX,qword ptr [RSP + 0x20]
JMP 0x001467e0
LAB_001468c8:
MOV RDI,qword ptr [RBX + 0x18]
MOV RSI,R12
MOV RDX,R13
CALL 0x0011d8c6
JMP 0x00146763
LAB_001468dc:
MOV RBP,RAX
CMP byte ptr [R15 + 0x36],0x0
JZ 0x001468f8
MOV RAX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [R15 + 0x38]
MOV RDX,qword ptr [RSP + 0x28]
MOV qword ptr [RCX + RDX*0x8],RAX
LAB_001468f8:
MOV RDI,qword ptr [RBX + 0x18]
MOV RSI,R12
MOV RDX,qword ptr [RSP + 0x20]
CALL 0x0011d8c6
JMP 0x00146765
|
int1 [16] JS_ReadTypedArray(long *param_1)
{
long lVar1;
int iVar2;
long lVar3;
int8 uVar4;
int8 uVar5;
int1 auVar6 [16];
byte local_89;
int8 local_88;
uint local_80;
uint local_7c;
int8 local_78;
ulong local_70;
int1 local_68 [16];
double local_58;
int8 local_50;
double local_48;
int8 local_40;
lVar1 = *param_1;
local_88 = 0;
iVar2 = bc_get_u8(param_1,&local_89);
if (iVar2 == 0) {
if (0xb < local_89) {
JS_ThrowTypeError(lVar1,"invalid typed array");
return ZEXT816(6) << 0x40;
}
iVar2 = bc_get_leb128(param_1,&local_80);
if ((iVar2 == 0) && (iVar2 = bc_get_leb128(param_1,&local_7c), iVar2 == 0)) {
local_70 = (ulong)*(uint *)(param_1 + 8);
uVar5 = 0;
iVar2 = BC_add_object_ref1(param_1,0);
auVar6._8_8_ = 3;
auVar6._0_8_ = local_88;
uVar4 = 3;
if (iVar2 != 0) {
LAB_001467e0:
local_88 = auVar6._0_8_;
JS_FreeValueRT(*(int8 *)(lVar1 + 0x18),uVar5,uVar4);
JS_FreeValueRT(*(int8 *)(lVar1 + 0x18),local_88,auVar6._8_8_);
return ZEXT816(6) << 0x40;
}
local_68 = JS_ReadObjectRec(param_1);
local_78 = local_68._8_8_;
uVar5 = local_68._0_8_;
if (local_68._8_4_ != 6) {
lVar3 = js_get_array_buffer(lVar1,uVar5);
if (lVar3 != 0) {
local_58 = (double)local_7c;
if (-1 < (int)local_7c) {
local_58 = (double)(ulong)local_7c;
}
local_50 = 7;
if (-1 < (int)local_7c) {
local_50 = 0;
}
local_48 = (double)local_80;
if (-1 < (int)local_80) {
local_48 = (double)(ulong)local_80;
}
local_40 = 7;
if (-1 < (int)local_80) {
local_40 = 0;
}
auVar6 = js_typed_array_constructor(lVar1,0,3,0,local_68,local_89 + 0x15);
local_88 = auVar6._0_8_;
uVar4 = local_78;
if (auVar6._8_4_ != 6) {
if (*(char *)((long)param_1 + 0x36) != '\0') {
*(int8 *)(param_1[7] + local_70 * 8) = local_88;
}
JS_FreeValueRT(*(int8 *)(lVar1 + 0x18),uVar5,local_78);
return auVar6;
}
goto LAB_001467e0;
}
JS_FreeValueRT(*(int8 *)(lVar1 + 0x18),uVar5,local_78);
}
}
}
return ZEXT816(6) << 0x40;
}
|
|
5,859 | CLI::Option* CLI::Option::ignore_case<CLI::App>(bool) | MikePodsytnik[P]TCRtrie/build_O3/_deps/cli11-src/include/CLI/impl/Option_inl.hpp | Option *Option::ignore_case(bool value) {
if(!ignore_case_ && value) {
ignore_case_ = value;
auto *parent = static_cast<T *>(parent_);
for(const Option_p &opt : parent->options_) {
if(opt.get() == this) {
continue;
}
const auto &omatch = opt->matching_name(*this);
if(!omatch.empty()) {
ignore_case_ = false;
throw OptionAlreadyAdded("adding ignore case caused a name conflict with " + omatch);
}
}
} else {
ignore_case_ = value;
}
return this;
} | O3 | cpp | CLI::Option* CLI::Option::ignore_case<CLI::App>(bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movb 0x21(%rdi), %al
movb %sil, 0x21(%rdi)
testl %esi, %esi
je 0x1d1a7
testb %al, %al
jne 0x1d1a7
movq 0x1f0(%rbx), %rax
movq 0xd8(%rax), %r15
movq 0xe0(%rax), %r12
cmpq %r12, %r15
je 0x1d1a7
movq (%r15), %rdi
cmpq %rbx, %rdi
je 0x1d1a1
movq %rbx, %rsi
callq 0x1bc08
cmpq $0x0, 0x8(%rax)
jne 0x1d1b7
addq $0x8, %r15
jmp 0x1d185
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movb $0x0, 0x21(%rbx)
movl $0x38, %edi
callq 0x71d0
movq %rax, %rbx
leaq 0x1a585(%rip), %rsi # 0x37757
movq %rsp, %rdi
movq %r14, %rdx
callq 0x11e48
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1be52
xorl %ebp, %ebp
leaq 0x2c3bc(%rip), %rsi # 0x495b0
leaq 0xc6ab(%rip), %rdx # 0x298a6
movq %rbx, %rdi
callq 0x7750
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d221
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7430
testb %bpl, %bpl
jne 0x1d22b
jmp 0x1d233
movq %rax, %r14
movq %rbx, %rdi
callq 0x7310
movq %r14, %rdi
callq 0x7780
nop
| _ZN3CLI6Option11ignore_caseINS_3AppEEEPS0_b:
push rbp; __int64
push r15; int
push r14; int
push r12; int
push rbx; __int64
sub rsp, 20h
mov rbx, rdi
mov al, [rdi+21h]
mov [rdi+21h], sil
test esi, esi
jz short loc_1D1A7
test al, al
jnz short loc_1D1A7
mov rax, [rbx+1F0h]
mov r15, [rax+0D8h]
mov r12, [rax+0E0h]
loc_1D185:
cmp r15, r12
jz short loc_1D1A7
mov rdi, [r15]; int
cmp rdi, rbx
jz short loc_1D1A1
mov rsi, rbx; int
call _ZNK3CLI6Option13matching_nameB5cxx11ERKS0_; CLI::Option::matching_name(CLI::Option const&)
cmp qword ptr [rax+8], 0
jnz short loc_1D1B7
loc_1D1A1:
add r15, 8
jmp short loc_1D185
loc_1D1A7:
mov rax, rbx
add rsp, 20h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_1D1B7:
mov r14, rax
mov byte ptr [rbx+21h], 0
mov edi, 38h ; '8'; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aAddingIgnoreCa; "adding ignore case caused a name confli"...
mov rdi, rsp
mov rdx, r14
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
mov bpl, 1
mov rsi, rsp
mov rdi, rbx; int
call _ZN3CLI18OptionAlreadyAddedC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; CLI::OptionAlreadyAdded::OptionAlreadyAdded(std::string)
xor ebp, ebp
lea rsi, _ZTIN3CLI18OptionAlreadyAddedE; lptinfo
lea rdx, _ZN3CLI5ErrorD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+48h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_1D221
mov rsi, [rsp+48h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1D221:
test bpl, bpl
jnz short loc_1D22B
jmp short loc_1D233
mov r14, rax
loc_1D22B:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_1D233:
mov rdi, r14
call __Unwind_Resume
| long long CLI::Option::ignore_case<CLI::App>(long long a1, int a2)
{
char v2; // al
long long v3; // rax
long long *v4; // r15
long long *v5; // r12
long long *v6; // rax
long long *v8; // r14
void *exception; // rbx
_BYTE v10[16]; // [rsp+0h] [rbp-48h] BYREF
v2 = *(_BYTE *)(a1 + 33);
*(_BYTE *)(a1 + 33) = a2;
if ( a2 && !v2 )
{
v3 = *(_QWORD *)(a1 + 496);
v4 = *(long long **)(v3 + 216);
v5 = *(long long **)(v3 + 224);
while ( v4 != v5 )
{
if ( *v4 != a1 )
{
v6 = CLI::Option::matching_name[abi:cxx11](*v4, (_QWORD *)a1);
if ( v6[1] )
{
v8 = v6;
*(_BYTE *)(a1 + 33) = 0;
exception = __cxa_allocate_exception(0x38uLL);
std::operator+<char>((long long)v10, (long long)"adding ignore case caused a name conflict with ", v8);
CLI::OptionAlreadyAdded::OptionAlreadyAdded((int)exception, (long long)v10);
__cxa_throw(exception, (struct type_info *)&`typeinfo for'CLI::OptionAlreadyAdded, CLI::Error::~Error);
}
}
++v4;
}
}
return a1;
}
| ignore_case<CLI::App>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x20
MOV RBX,RDI
MOV AL,byte ptr [RDI + 0x21]
MOV byte ptr [RDI + 0x21],SIL
TEST ESI,ESI
JZ 0x0011d1a7
TEST AL,AL
JNZ 0x0011d1a7
MOV RAX,qword ptr [RBX + 0x1f0]
MOV R15,qword ptr [RAX + 0xd8]
MOV R12,qword ptr [RAX + 0xe0]
LAB_0011d185:
CMP R15,R12
JZ 0x0011d1a7
MOV RDI,qword ptr [R15]
CMP RDI,RBX
JZ 0x0011d1a1
MOV RSI,RBX
CALL 0x0011bc08
CMP qword ptr [RAX + 0x8],0x0
JNZ 0x0011d1b7
LAB_0011d1a1:
ADD R15,0x8
JMP 0x0011d185
LAB_0011d1a7:
MOV RAX,RBX
ADD RSP,0x20
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0011d1b7:
MOV R14,RAX
MOV byte ptr [RBX + 0x21],0x0
MOV EDI,0x38
CALL 0x001071d0
MOV RBX,RAX
LAB_0011d1cb:
LEA RSI,[0x137757]
MOV RDI,RSP
MOV RDX,R14
CALL 0x00111e48
MOV BPL,0x1
LAB_0011d1e0:
MOV RSI,RSP
MOV RDI,RBX
CALL 0x0011be52
XOR EBP,EBP
LEA RSI,[0x1495b0]
LEA RDX,[0x1298a6]
MOV RDI,RBX
CALL 0x00107750
|
/* CLI::Option* CLI::Option::ignore_case<CLI::App>(bool) */
Option * __thiscall CLI::Option::ignore_case<CLI::App>(Option *this,bool param_1)
{
Option OVar1;
int8 *puVar2;
long lVar3;
OptionAlreadyAdded *pOVar4;
int7 in_register_00000031;
int8 *puVar5;
char acStack_48 [32];
OVar1 = this[0x21];
this[0x21] = (Option)param_1;
if (((int)CONCAT71(in_register_00000031,param_1) != 0) && (OVar1 == (Option)0x0)) {
puVar2 = *(int8 **)(*(long *)(this + 0x1f0) + 0xe0);
for (puVar5 = *(int8 **)(*(long *)(this + 0x1f0) + 0xd8); puVar5 != puVar2;
puVar5 = puVar5 + 1) {
if ((Option *)*puVar5 != this) {
lVar3 = matching_name_abi_cxx11_((Option *)*puVar5,this);
if (*(long *)(lVar3 + 8) != 0) {
this[0x21] = (Option)0x0;
pOVar4 = (OptionAlreadyAdded *)__cxa_allocate_exception(0x38);
/* try { // try from 0011d1cb to 0011d1dc has its CatchHandler @ 0011d228 */
std::operator+(acStack_48,(string *)"adding ignore case caused a name conflict with ");
/* try { // try from 0011d1e0 to 0011d202 has its CatchHandler @ 0011d203 */
OptionAlreadyAdded::OptionAlreadyAdded(pOVar4,acStack_48);
/* WARNING: Subroutine does not return */
__cxa_throw(pOVar4,&OptionAlreadyAdded::typeinfo,Error::~Error);
}
}
}
}
return this;
}
|
|
5,860 | ggml_vec_dot_bf16 | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c | static void ggml_vec_dot_bf16(int n, float * restrict s, size_t bs, ggml_bf16_t * restrict x, size_t bx, ggml_bf16_t * restrict y, size_t by, int nrc) {
assert(nrc == 1);
UNUSED(nrc);
UNUSED(bx);
UNUSED(by);
UNUSED(bs);
int i = 0;
ggml_float sumf = 0;
#if defined(__AVX512BF16__)
__m512 c1 = _mm512_setzero_ps();
__m512 c2 = _mm512_setzero_ps();
for (; i + 64 <= n; i += 64) {
c1 = _mm512_dpbf16_ps(c1, m512bh(_mm512_loadu_si512((x + i))),
m512bh(_mm512_loadu_si512((y + i))));
c2 = _mm512_dpbf16_ps(c2, m512bh(_mm512_loadu_si512((x + i + 32))),
m512bh(_mm512_loadu_si512((y + i + 32))));
}
sumf += (ggml_float)_mm512_reduce_add_ps(c1);
sumf += (ggml_float)_mm512_reduce_add_ps(c2);
#elif defined(__AVX512F__)
#define LOAD(p) _mm512_castsi512_ps(_mm512_slli_epi32(_mm512_cvtepu16_epi32(_mm256_loadu_si256((const __m256i *)(p))), 16))
__m512 c1 = _mm512_setzero_ps();
__m512 c2 = _mm512_setzero_ps();
for (; i + 32 <= n; i += 32) {
c1 = _mm512_add_ps(_mm512_mul_ps(LOAD(x + i), LOAD(y + i)), c1);
c2 = _mm512_add_ps(_mm512_mul_ps(LOAD(x + i + 16), LOAD(y + i + 16)), c2);
}
sumf += (ggml_float)_mm512_reduce_add_ps(c1);
sumf += (ggml_float)_mm512_reduce_add_ps(c2);
#undef LOAD
#elif defined(__AVX2__) || defined(__AVX__)
#if defined(__AVX2__)
#define LOAD(p) _mm256_castsi256_ps(_mm256_slli_epi32(_mm256_cvtepu16_epi32(_mm_loadu_si128((const __m128i *)(p))), 16))
#else
#define LOAD(p) _mm256_castsi256_ps(_mm256_insertf128_si256(_mm256_castsi128_si256(_mm_slli_epi32(_mm_cvtepu16_epi32(_mm_loadu_si128((const __m128i *)(p))), 16)), (_mm_slli_epi32(_mm_cvtepu16_epi32(_mm_bsrli_si128(_mm_loadu_si128((const __m128i *)(p)), 8)), 16)), 1))
#endif
__m256 c1 = _mm256_setzero_ps();
__m256 c2 = _mm256_setzero_ps();
__m256 c3 = _mm256_setzero_ps();
__m256 c4 = _mm256_setzero_ps();
for (; i + 32 <= n; i += 32) {
c1 = _mm256_add_ps(_mm256_mul_ps(LOAD(x + i), LOAD(y + i)), c1);
c2 = _mm256_add_ps(_mm256_mul_ps(LOAD(x + i + 8), LOAD(y + i + 8)), c2);
c3 = _mm256_add_ps(_mm256_mul_ps(LOAD(x + i + 16), LOAD(y + i + 16)), c3);
c4 = _mm256_add_ps(_mm256_mul_ps(LOAD(x + i + 24), LOAD(y + i + 24)), c4);
}
__m128 g;
c1 = _mm256_add_ps(_mm256_add_ps(c1, c3),
_mm256_add_ps(c2, c4));
g = _mm_add_ps(_mm256_extractf128_ps(c1, 1),
_mm256_castps256_ps128(c1));
g = _mm_add_ps(g, _mm_movehl_ps(g, g));
g = _mm_add_ss(g, _mm_movehdup_ps(g));
sumf += (ggml_float)_mm_cvtss_f32(g);
#undef LOAD
#endif
for (; i < n; ++i) {
sumf += (ggml_float)(GGML_BF16_TO_FP32(x[i]) *
GGML_BF16_TO_FP32(y[i]));
}
*s = sumf;
} | O0 | c | ggml_vec_dot_bf16:
pushq %rbp
movq %rsp, %rbp
andq $-0x40, %rsp
subq $0x800, %rsp # imm = 0x800
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movl %edi, 0xfc(%rsp)
movq %rsi, 0xf0(%rsp)
movq %rdx, 0xe8(%rsp)
movq %rcx, 0xe0(%rsp)
movq %r8, 0xd8(%rsp)
movq %r9, 0xd0(%rsp)
cmpl $0x1, 0x18(%rbp)
jne 0x12b6d
jmp 0x12b8c
leaq 0x613ba(%rip), %rdi # 0x73f2e
leaq 0x60fe7(%rip), %rsi # 0x73b62
movl $0x574, %edx # imm = 0x574
leaq 0x6149e(%rip), %rcx # 0x74025
callq 0xd690
movl $0x0, 0xcc(%rsp)
movq $0x0, 0xc0(%rsp)
vpxor %xmm0, %xmm0, %xmm0
vmovaps %zmm0, 0x140(%rsp)
vmovaps 0x140(%rsp), %zmm1
vmovaps %zmm1, 0x80(%rsp)
vmovaps %zmm0, 0x100(%rsp)
vmovaps 0x100(%rsp), %zmm0
vmovaps %zmm0, 0x40(%rsp)
movl 0xcc(%rsp), %eax
addl $0x20, %eax
cmpl 0xfc(%rsp), %eax
jg 0x12ea4
movq 0xe0(%rsp), %rax
movslq 0xcc(%rsp), %rcx
shlq %rcx
addq %rcx, %rax
movq %rax, 0x338(%rsp)
movq 0x338(%rsp), %rax
vmovdqu (%rax), %ymm0
vmovdqa %ymm0, 0x7c0(%rsp)
vmovdqa 0x7c0(%rsp), %ymm0
vpmovzxwd %ymm0, %zmm0 # zmm0 = ymm0[0],zero,ymm0[1],zero,ymm0[2],zero,ymm0[3],zero,ymm0[4],zero,ymm0[5],zero,ymm0[6],zero,ymm0[7],zero,ymm0[8],zero,ymm0[9],zero,ymm0[10],zero,ymm0[11],zero,ymm0[12],zero,ymm0[13],zero,ymm0[14],zero,ymm0[15],zero
vmovdqa64 %zmm0, 0x700(%rsp)
movl $0x10, 0x6fc(%rsp)
vmovdqa64 0x700(%rsp), %zmm0
movl 0x6fc(%rsp), %eax
vmovd %eax, %xmm1
vpslld %xmm1, %zmm0, %zmm0
vmovdqa64 %zmm0, 0x500(%rsp)
vmovdqa64 0x500(%rsp), %zmm1
movq 0xd0(%rsp), %rax
movslq 0xcc(%rsp), %rcx
shlq %rcx
addq %rcx, %rax
movq %rax, 0x330(%rsp)
movq 0x330(%rsp), %rax
vmovdqu (%rax), %ymm0
vmovdqa %ymm0, 0x7a0(%rsp)
vmovdqa 0x7a0(%rsp), %ymm0
vpmovzxwd %ymm0, %zmm0 # zmm0 = ymm0[0],zero,ymm0[1],zero,ymm0[2],zero,ymm0[3],zero,ymm0[4],zero,ymm0[5],zero,ymm0[6],zero,ymm0[7],zero,ymm0[8],zero,ymm0[9],zero,ymm0[10],zero,ymm0[11],zero,ymm0[12],zero,ymm0[13],zero,ymm0[14],zero,ymm0[15],zero
vmovdqa64 %zmm0, 0x680(%rsp)
movl $0x10, 0x67c(%rsp)
vmovdqa64 0x680(%rsp), %zmm0
movl 0x67c(%rsp), %eax
vmovd %eax, %xmm2
vpslld %xmm2, %zmm0, %zmm0
vmovdqa64 %zmm0, 0x4c0(%rsp)
vmovdqa64 0x4c0(%rsp), %zmm0
vmovaps %zmm1, 0x400(%rsp)
vmovaps %zmm0, 0x3c0(%rsp)
vmovaps 0x400(%rsp), %zmm0
vmulps 0x3c0(%rsp), %zmm0, %zmm1
vmovaps 0x80(%rsp), %zmm0
vmovaps %zmm1, 0x240(%rsp)
vmovaps %zmm0, 0x200(%rsp)
vmovaps 0x240(%rsp), %zmm0
vaddps 0x200(%rsp), %zmm0, %zmm0
vmovaps %zmm0, 0x80(%rsp)
movq 0xe0(%rsp), %rax
movslq 0xcc(%rsp), %rcx
shlq %rcx
addq %rcx, %rax
addq $0x20, %rax
movq %rax, 0x328(%rsp)
movq 0x328(%rsp), %rax
vmovdqu (%rax), %ymm0
vmovdqa %ymm0, 0x780(%rsp)
vmovdqa 0x780(%rsp), %ymm0
vpmovzxwd %ymm0, %zmm0 # zmm0 = ymm0[0],zero,ymm0[1],zero,ymm0[2],zero,ymm0[3],zero,ymm0[4],zero,ymm0[5],zero,ymm0[6],zero,ymm0[7],zero,ymm0[8],zero,ymm0[9],zero,ymm0[10],zero,ymm0[11],zero,ymm0[12],zero,ymm0[13],zero,ymm0[14],zero,ymm0[15],zero
vmovdqa64 %zmm0, 0x600(%rsp)
movl $0x10, 0x5fc(%rsp)
vmovdqa64 0x600(%rsp), %zmm0
movl 0x5fc(%rsp), %eax
vmovd %eax, %xmm1
vpslld %xmm1, %zmm0, %zmm0
vmovdqa64 %zmm0, 0x480(%rsp)
vmovdqa64 0x480(%rsp), %zmm1
movq 0xd0(%rsp), %rax
movslq 0xcc(%rsp), %rcx
shlq %rcx
addq %rcx, %rax
addq $0x20, %rax
movq %rax, 0x320(%rsp)
movq 0x320(%rsp), %rax
vmovdqu (%rax), %ymm0
vmovdqa %ymm0, 0x760(%rsp)
vmovdqa 0x760(%rsp), %ymm0
vpmovzxwd %ymm0, %zmm0 # zmm0 = ymm0[0],zero,ymm0[1],zero,ymm0[2],zero,ymm0[3],zero,ymm0[4],zero,ymm0[5],zero,ymm0[6],zero,ymm0[7],zero,ymm0[8],zero,ymm0[9],zero,ymm0[10],zero,ymm0[11],zero,ymm0[12],zero,ymm0[13],zero,ymm0[14],zero,ymm0[15],zero
vmovdqa64 %zmm0, 0x580(%rsp)
movl $0x10, 0x57c(%rsp)
vmovdqa64 0x580(%rsp), %zmm0
movl 0x57c(%rsp), %eax
vmovd %eax, %xmm2
vpslld %xmm2, %zmm0, %zmm0
vmovdqa64 %zmm0, 0x440(%rsp)
vmovdqa64 0x440(%rsp), %zmm0
vmovaps %zmm1, 0x380(%rsp)
vmovaps %zmm0, 0x340(%rsp)
vmovaps 0x380(%rsp), %zmm0
vmulps 0x340(%rsp), %zmm0, %zmm1
vmovaps 0x40(%rsp), %zmm0
vmovaps %zmm1, 0x1c0(%rsp)
vmovaps %zmm0, 0x180(%rsp)
vmovaps 0x1c0(%rsp), %zmm0
vaddps 0x180(%rsp), %zmm0, %zmm0
vmovaps %zmm0, 0x40(%rsp)
movl 0xcc(%rsp), %eax
addl $0x20, %eax
movl %eax, 0xcc(%rsp)
jmp 0x12bd7
vmovaps 0x80(%rsp), %zmm0
vmovaps %zmm0, 0x2c0(%rsp)
vmovaps 0x2c0(%rsp), %zmm0
vmovapd 0x2e0(%rsp), %ymm2
vmovaps %ymm2, %ymm1
vaddps %zmm1, %zmm0, %zmm0
vmovaps %ymm0, %ymm1
vextractf128 $0x1, %ymm1, %xmm1
vaddps %xmm1, %xmm0, %xmm0
vpermilpd $0x1, %xmm0, %xmm1 # xmm1 = xmm0[1,0]
vaddps %xmm1, %xmm0, %xmm1
vmovaps %xmm1, %xmm0
vmovshdup %xmm1, %xmm1 # xmm1 = xmm1[1,1,3,3]
vaddss %xmm1, %xmm0, %xmm1
vcvtss2sd %xmm1, %xmm0, %xmm1
vmovsd 0xc0(%rsp), %xmm0
vaddsd %xmm1, %xmm0, %xmm0
vmovsd %xmm0, 0xc0(%rsp)
vmovaps 0x40(%rsp), %zmm0
vmovaps %zmm0, 0x280(%rsp)
vmovaps 0x280(%rsp), %zmm0
vmovapd 0x2a0(%rsp), %ymm2
vmovaps %ymm2, %ymm1
vaddps %zmm1, %zmm0, %zmm0
vmovaps %ymm0, %ymm1
vextractf128 $0x1, %ymm1, %xmm1
vaddps %xmm1, %xmm0, %xmm0
vpermilpd $0x1, %xmm0, %xmm1 # xmm1 = xmm0[1,0]
vaddps %xmm1, %xmm0, %xmm1
vmovaps %xmm1, %xmm0
vmovshdup %xmm1, %xmm1 # xmm1 = xmm1[1,1,3,3]
vaddss %xmm1, %xmm0, %xmm1
vmovss 0x60b6c(%rip), %xmm0 # 0x73ad0
vaddss %xmm1, %xmm0, %xmm1
vcvtss2sd %xmm1, %xmm0, %xmm0
vaddsd 0xc0(%rsp), %xmm0, %xmm0
vmovsd %xmm0, 0xc0(%rsp)
movl 0xcc(%rsp), %eax
cmpl 0xfc(%rsp), %eax
jge 0x13003
movq 0xe0(%rsp), %rax
movslq 0xcc(%rsp), %rcx
movzwl (%rax,%rcx,2), %edi
vzeroupper
callq 0xfae0
vmovss %xmm0, 0x3c(%rsp)
movq 0xd0(%rsp), %rax
movslq 0xcc(%rsp), %rcx
movzwl (%rax,%rcx,2), %edi
callq 0xfae0
vmovaps %xmm0, %xmm1
vmovss 0x3c(%rsp), %xmm0
vmulss %xmm1, %xmm0, %xmm1
vcvtss2sd %xmm1, %xmm0, %xmm0
vaddsd 0xc0(%rsp), %xmm0, %xmm0
vmovsd %xmm0, 0xc0(%rsp)
movl 0xcc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xcc(%rsp)
jmp 0x12f7e
vmovsd 0xc0(%rsp), %xmm1
vcvtsd2ss %xmm1, %xmm0, %xmm0
movq 0xf0(%rsp), %rax
vmovss %xmm0, (%rax)
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
nopw %cs:(%rax,%rax)
| ggml_vec_dot_bf16:
push rbp
mov rbp, rsp
and rsp, 0FFFFFFFFFFFFFFC0h
sub rsp, 800h
mov eax, [rbp+arg_8]
mov rax, [rbp+arg_0]
mov [rsp+800h+var_704], edi
mov [rsp+800h+var_710], rsi
mov [rsp+800h+var_718], rdx
mov [rsp+800h+var_720], rcx
mov [rsp+800h+var_728], r8
mov [rsp+800h+var_730], r9
cmp [rbp+arg_8], 1
jnz short loc_12B6D
jmp short loc_12B8C
loc_12B6D:
lea rdi, aNrc1; "nrc == 1"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 574h
lea rcx, aVoidGgmlVecDot_1; "void ggml_vec_dot_bf16(int, float *rest"...
call ___assert_fail
loc_12B8C:
mov [rsp+800h+var_734], 0
mov [rsp+800h+var_740], 0
vpxor xmm0, xmm0, xmm0
vmovaps zmmword ptr [rsp+800h+var_6C0], zmm0
vmovaps zmm1, zmmword ptr [rsp+800h+var_6C0]
vmovaps zmmword ptr [rsp+800h+var_780], zmm1
vmovaps zmmword ptr [rsp+800h+var_700], zmm0
vmovaps zmm0, zmmword ptr [rsp+800h+var_700]
vmovaps zmmword ptr [rsp+800h+var_7C0], zmm0
loc_12BD7:
mov eax, [rsp+800h+var_734]
add eax, 20h ; ' '
cmp eax, [rsp+800h+var_704]
jg loc_12EA4
mov rax, [rsp+800h+var_720]
movsxd rcx, [rsp+800h+var_734]
shl rcx, 1
add rax, rcx
mov [rsp+800h+var_4C8], rax
mov rax, [rsp+800h+var_4C8]
vmovdqu ymm0, ymmword ptr [rax]
vmovdqa [rsp+800h+var_40], ymm0
vmovdqa ymm0, [rsp+800h+var_40]
vpmovzxwd zmm0, ymm0
vmovdqa64 zmmword ptr [rsp+800h+var_100], zmm0
mov [rsp+800h+var_104], 10h
vmovdqa64 zmm0, zmmword ptr [rsp+800h+var_100]
mov eax, [rsp+800h+var_104]
vmovd xmm1, eax
vpslld zmm0, zmm0, xmm1
vmovdqa64 zmmword ptr [rsp+800h+var_300], zmm0
vmovdqa64 zmm1, zmmword ptr [rsp+800h+var_300]
mov rax, [rsp+800h+var_730]
movsxd rcx, [rsp+800h+var_734]
shl rcx, 1
add rax, rcx
mov [rsp+800h+var_4D0], rax
mov rax, [rsp+800h+var_4D0]
vmovdqu ymm0, ymmword ptr [rax]
vmovdqa [rsp+800h+var_60], ymm0
vmovdqa ymm0, [rsp+800h+var_60]
vpmovzxwd zmm0, ymm0
vmovdqa64 zmmword ptr [rsp+800h+var_180], zmm0
mov [rsp+800h+var_184], 10h
vmovdqa64 zmm0, zmmword ptr [rsp+800h+var_180]
mov eax, [rsp+800h+var_184]
vmovd xmm2, eax
vpslld zmm0, zmm0, xmm2
vmovdqa64 zmmword ptr [rsp+800h+var_340], zmm0
vmovdqa64 zmm0, zmmword ptr [rsp+800h+var_340]
vmovaps zmmword ptr [rsp+800h+var_400], zmm1
vmovaps zmmword ptr [rsp+800h+var_440], zmm0
vmovaps zmm0, zmmword ptr [rsp+800h+var_400]
vmulps zmm1, zmm0, zmmword ptr [rsp+800h+var_440]
vmovaps zmm0, zmmword ptr [rsp+800h+var_780]
vmovaps zmmword ptr [rsp+800h+var_5C0], zmm1
vmovaps zmmword ptr [rsp+800h+var_600], zmm0
vmovaps zmm0, zmmword ptr [rsp+800h+var_5C0]
vaddps zmm0, zmm0, zmmword ptr [rsp+800h+var_600]
vmovaps zmmword ptr [rsp+800h+var_780], zmm0
mov rax, [rsp+800h+var_720]
movsxd rcx, [rsp+800h+var_734]
shl rcx, 1
add rax, rcx
add rax, 20h ; ' '
mov [rsp+800h+var_4D8], rax
mov rax, [rsp+800h+var_4D8]
vmovdqu ymm0, ymmword ptr [rax]
vmovdqa [rsp+800h+var_80], ymm0
vmovdqa ymm0, [rsp+800h+var_80]
vpmovzxwd zmm0, ymm0
vmovdqa64 zmmword ptr [rsp+800h+var_200], zmm0
mov [rsp+800h+var_204], 10h
vmovdqa64 zmm0, zmmword ptr [rsp+800h+var_200]
mov eax, [rsp+800h+var_204]
vmovd xmm1, eax
vpslld zmm0, zmm0, xmm1
vmovdqa64 zmmword ptr [rsp+800h+var_380], zmm0
vmovdqa64 zmm1, zmmword ptr [rsp+800h+var_380]
mov rax, [rsp+800h+var_730]
movsxd rcx, [rsp+800h+var_734]
shl rcx, 1
add rax, rcx
add rax, 20h ; ' '
mov [rsp+800h+var_4E0], rax
mov rax, [rsp+800h+var_4E0]
vmovdqu ymm0, ymmword ptr [rax]
vmovdqa [rsp+800h+var_A0], ymm0
vmovdqa ymm0, [rsp+800h+var_A0]
vpmovzxwd zmm0, ymm0
vmovdqa64 zmmword ptr [rsp+800h+var_280], zmm0
mov [rsp+800h+var_284], 10h
vmovdqa64 zmm0, zmmword ptr [rsp+800h+var_280]
mov eax, [rsp+800h+var_284]
vmovd xmm2, eax
vpslld zmm0, zmm0, xmm2
vmovdqa64 zmmword ptr [rsp+800h+var_3C0], zmm0
vmovdqa64 zmm0, zmmword ptr [rsp+800h+var_3C0]
vmovaps zmmword ptr [rsp+800h+var_480], zmm1
vmovaps zmmword ptr [rsp+800h+var_4C0], zmm0
vmovaps zmm0, zmmword ptr [rsp+800h+var_480]
vmulps zmm1, zmm0, zmmword ptr [rsp+800h+var_4C0]
vmovaps zmm0, zmmword ptr [rsp+800h+var_7C0]
vmovaps zmmword ptr [rsp+800h+var_640], zmm1
vmovaps zmmword ptr [rsp+800h+var_680], zmm0
vmovaps zmm0, zmmword ptr [rsp+800h+var_640]
vaddps zmm0, zmm0, zmmword ptr [rsp+800h+var_680]
vmovaps zmmword ptr [rsp+800h+var_7C0], zmm0
mov eax, [rsp+800h+var_734]
add eax, 20h ; ' '
mov [rsp+800h+var_734], eax
jmp loc_12BD7
loc_12EA4:
vmovaps zmm0, zmmword ptr [rsp+800h+var_780]
vmovaps zmmword ptr [rsp+800h+var_540], zmm0
vmovaps zmm0, zmmword ptr [rsp+800h+var_540]
vmovapd ymm2, [rsp+800h+var_520]
vmovaps ymm1, ymm2
vaddps zmm0, zmm0, zmm1
vmovaps ymm1, ymm0
vextractf128 xmm1, ymm1, 1
vaddps xmm0, xmm0, xmm1
vpermilpd xmm1, xmm0, 1
vaddps xmm1, xmm0, xmm1
vmovaps xmm0, xmm1
vmovshdup xmm1, xmm1
vaddss xmm1, xmm0, xmm1
vcvtss2sd xmm1, xmm0, xmm1
vmovsd xmm0, [rsp+800h+var_740]
vaddsd xmm0, xmm0, xmm1
vmovsd [rsp+800h+var_740], xmm0
vmovaps zmm0, zmmword ptr [rsp+800h+var_7C0]
vmovaps zmmword ptr [rsp+800h+var_580], zmm0
vmovaps zmm0, zmmword ptr [rsp+800h+var_580]
vmovapd ymm2, [rsp+800h+var_560]
vmovaps ymm1, ymm2
vaddps zmm0, zmm0, zmm1
vmovaps ymm1, ymm0
vextractf128 xmm1, ymm1, 1
vaddps xmm0, xmm0, xmm1
vpermilpd xmm1, xmm0, 1
vaddps xmm1, xmm0, xmm1
vmovaps xmm0, xmm1
vmovshdup xmm1, xmm1
vaddss xmm1, xmm0, xmm1
vmovss xmm0, cs:dword_73AD0
vaddss xmm1, xmm0, xmm1
vcvtss2sd xmm0, xmm0, xmm1
vaddsd xmm0, xmm0, [rsp+800h+var_740]
vmovsd [rsp+800h+var_740], xmm0
loc_12F7E:
mov eax, [rsp+800h+var_734]
cmp eax, [rsp+800h+var_704]
jge short loc_13003
mov rax, [rsp+800h+var_720]
movsxd rcx, [rsp+800h+var_734]
movzx edi, word ptr [rax+rcx*2]
vzeroupper
call ggml_compute_bf16_to_fp32
vmovss [rsp+800h+var_7C4], xmm0
mov rax, [rsp+800h+var_730]
movsxd rcx, [rsp+800h+var_734]
movzx edi, word ptr [rax+rcx*2]
call ggml_compute_bf16_to_fp32
vmovaps xmm1, xmm0
vmovss xmm0, [rsp+800h+var_7C4]
vmulss xmm1, xmm0, xmm1
vcvtss2sd xmm0, xmm0, xmm1
vaddsd xmm0, xmm0, [rsp+800h+var_740]
vmovsd [rsp+800h+var_740], xmm0
mov eax, [rsp+800h+var_734]
add eax, 1
mov [rsp+800h+var_734], eax
jmp loc_12F7E
loc_13003:
vmovsd xmm1, [rsp+800h+var_740]
vcvtsd2ss xmm0, xmm0, xmm1
mov rax, [rsp+800h+var_710]
vmovss dword ptr [rax], xmm0
mov rsp, rbp
pop rbp
vzeroupper
retn
| long long ggml_vec_dot_bf16(
int a1,
long long a2,
__m128 _XMM0,
long long a4,
long long a5,
long long a6,
long long a7,
long long a8,
int a9)
{
long long result; // rax
long long v101; // [rsp+C0h] [rbp-740h]
int v103; // [rsp+CCh] [rbp-734h]
if ( a9 != 1 )
__assert_fail(
"nrc == 1",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
1396LL,
"void ggml_vec_dot_bf16(int, float *restrict, size_t, ggml_bf16_t *restrict, size_t, ggml_bf16_t *restrict, size_t, int)");
v103 = 0;
v101 = 0LL;
__asm
{
vpxor xmm0, xmm0, xmm0
vmovaps zmmword ptr [rsp+800h+var_6C0], zmm0
vmovaps zmm1, zmmword ptr [rsp+800h+var_6C0]
vmovaps zmmword ptr [rsp+800h+var_780], zmm1
vmovaps zmmword ptr [rsp+800h+var_700], zmm0
vmovaps zmm0, zmmword ptr [rsp+800h+var_700]
vmovaps zmmword ptr [rsp+800h+var_7C0], zmm0
}
while ( v103 + 32 <= a1 )
{
_RAX = 2LL * v103 + a5;
__asm
{
vmovdqu ymm0, ymmword ptr [rax]
vmovdqa [rsp+800h+var_40], ymm0
vmovdqa ymm0, [rsp+800h+var_40]
vpmovzxwd zmm0, ymm0
vmovdqa64 zmmword ptr [rsp+800h+var_100], zmm0
vmovdqa64 zmm0, zmmword ptr [rsp+800h+var_100]
}
LODWORD(_RAX) = 16;
__asm
{
vmovd xmm1, eax
vpslld zmm0, zmm0, xmm1
vmovdqa64 zmmword ptr [rsp+800h+var_300], zmm0
vmovdqa64 zmm1, zmmword ptr [rsp+800h+var_300]
}
_RAX = 2LL * v103 + a7;
__asm
{
vmovdqu ymm0, ymmword ptr [rax]
vmovdqa [rsp+800h+var_60], ymm0
vmovdqa ymm0, [rsp+800h+var_60]
vpmovzxwd zmm0, ymm0
vmovdqa64 zmmword ptr [rsp+800h+var_180], zmm0
vmovdqa64 zmm0, zmmword ptr [rsp+800h+var_180]
}
LODWORD(_RAX) = 16;
__asm
{
vmovd xmm2, eax
vpslld zmm0, zmm0, xmm2
vmovdqa64 zmmword ptr [rsp+800h+var_340], zmm0
vmovdqa64 zmm0, zmmword ptr [rsp+800h+var_340]
vmovaps zmmword ptr [rsp+800h+var_400], zmm1
vmovaps zmmword ptr [rsp+800h+var_440], zmm0
vmovaps zmm0, zmmword ptr [rsp+800h+var_400]
vmulps zmm1, zmm0, zmmword ptr [rsp+800h+var_440]
vmovaps zmm0, zmmword ptr [rsp+800h+var_780]
vmovaps zmmword ptr [rsp+800h+var_5C0], zmm1
vmovaps zmmword ptr [rsp+800h+var_600], zmm0
vmovaps zmm0, zmmword ptr [rsp+800h+var_5C0]
vaddps zmm0, zmm0, zmmword ptr [rsp+800h+var_600]
vmovaps zmmword ptr [rsp+800h+var_780], zmm0
}
_RAX = 2LL * v103 + a5 + 32;
__asm
{
vmovdqu ymm0, ymmword ptr [rax]
vmovdqa [rsp+800h+var_80], ymm0
vmovdqa ymm0, [rsp+800h+var_80]
vpmovzxwd zmm0, ymm0
vmovdqa64 zmmword ptr [rsp+800h+var_200], zmm0
vmovdqa64 zmm0, zmmword ptr [rsp+800h+var_200]
}
LODWORD(_RAX) = 16;
__asm
{
vmovd xmm1, eax
vpslld zmm0, zmm0, xmm1
vmovdqa64 zmmword ptr [rsp+800h+var_380], zmm0
vmovdqa64 zmm1, zmmword ptr [rsp+800h+var_380]
}
_RAX = 2LL * v103 + a7 + 32;
__asm
{
vmovdqu ymm0, ymmword ptr [rax]
vmovdqa [rsp+800h+var_A0], ymm0
vmovdqa ymm0, [rsp+800h+var_A0]
vpmovzxwd zmm0, ymm0
vmovdqa64 zmmword ptr [rsp+800h+var_280], zmm0
vmovdqa64 zmm0, zmmword ptr [rsp+800h+var_280]
}
LODWORD(_RAX) = 16;
__asm
{
vmovd xmm2, eax
vpslld zmm0, zmm0, xmm2
vmovdqa64 zmmword ptr [rsp+800h+var_3C0], zmm0
vmovdqa64 zmm0, zmmword ptr [rsp+800h+var_3C0]
vmovaps zmmword ptr [rsp+800h+var_480], zmm1
vmovaps zmmword ptr [rsp+800h+var_4C0], zmm0
vmovaps zmm0, zmmword ptr [rsp+800h+var_480]
vmulps zmm1, zmm0, zmmword ptr [rsp+800h+var_4C0]
vmovaps zmm0, zmmword ptr [rsp+800h+var_7C0]
vmovaps zmmword ptr [rsp+800h+var_640], zmm1
vmovaps zmmword ptr [rsp+800h+var_680], zmm0
vmovaps zmm0, zmmword ptr [rsp+800h+var_640]
vaddps zmm0, zmm0, zmmword ptr [rsp+800h+var_680]
vmovaps zmmword ptr [rsp+800h+var_7C0], zmm0
}
v103 += 32;
}
__asm
{
vmovaps zmm0, zmmword ptr [rsp+800h+var_780]
vmovaps zmmword ptr [rsp+800h+var_540], zmm0
vmovaps zmm0, zmmword ptr [rsp+800h+var_540]
vmovapd ymm2, [rsp+800h+var_520]
vmovaps ymm1, ymm2
vaddps zmm0, zmm0, zmm1
vmovaps ymm1, ymm0
vextractf128 xmm1, ymm1, 1
vaddps xmm0, xmm0, xmm1
vpermilpd xmm1, xmm0, 1
vaddps xmm1, xmm0, xmm1
vmovaps xmm0, xmm1
vmovshdup xmm1, xmm1
vaddss xmm1, xmm0, xmm1
vcvtss2sd xmm1, xmm0, xmm1
vmovsd xmm0, [rsp+800h+var_740]
vaddsd xmm0, xmm0, xmm1
vmovsd [rsp+800h+var_740], xmm0
vmovaps zmm0, zmmword ptr [rsp+800h+var_7C0]
vmovaps zmmword ptr [rsp+800h+var_580], zmm0
vmovaps zmm0, zmmword ptr [rsp+800h+var_580]
vmovapd ymm2, [rsp+800h+var_560]
vmovaps ymm1, ymm2
vaddps zmm0, zmm0, zmm1
vmovaps ymm1, ymm0
vextractf128 xmm1, ymm1, 1
vaddps xmm0, xmm0, xmm1
vpermilpd xmm1, xmm0, 1
vaddps xmm1, xmm0, xmm1
vmovaps xmm0, xmm1
vmovshdup xmm1, xmm1
vaddss xmm1, xmm0, xmm1
vmovss xmm0, cs:dword_73AD0
vaddss xmm1, xmm0, xmm1
vcvtss2sd xmm0, xmm0, xmm1
vaddsd xmm0, xmm0, [rsp+800h+var_740]
vmovsd [rsp+800h+var_740], xmm0
}
while ( v103 < a1 )
{
__asm { vzeroupper }
_XMM0 = ggml_compute_bf16_to_fp32(*(_WORD *)(a5 + 2LL * v103));
__asm { vmovss [rsp+800h+var_7C4], xmm0 }
_XMM0 = ggml_compute_bf16_to_fp32(*(_WORD *)(a7 + 2LL * v103));
__asm
{
vmovaps xmm1, xmm0
vmovss xmm0, [rsp+800h+var_7C4]
vmulss xmm1, xmm0, xmm1
vcvtss2sd xmm0, xmm0, xmm1
vaddsd xmm0, xmm0, [rsp+800h+var_740]
vmovsd [rsp+800h+var_740], xmm0
}
++v103;
}
__asm
{
vmovsd xmm1, [rsp+800h+var_740]
vcvtsd2ss xmm0, xmm0, xmm1
}
result = a2;
__asm
{
vmovss dword ptr [rax], xmm0
vzeroupper
}
return result;
}
| ggml_vec_dot_bf16:
PUSH RBP
MOV RBP,RSP
AND RSP,-0x40
SUB RSP,0x800
MOV EAX,dword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + 0x10]
MOV dword ptr [RSP + 0xfc],EDI
MOV qword ptr [RSP + 0xf0],RSI
MOV qword ptr [RSP + 0xe8],RDX
MOV qword ptr [RSP + 0xe0],RCX
MOV qword ptr [RSP + 0xd8],R8
MOV qword ptr [RSP + 0xd0],R9
CMP dword ptr [RBP + 0x18],0x1
JNZ 0x00112b6d
JMP 0x00112b8c
LAB_00112b6d:
LEA RDI,[0x173f2e]
LEA RSI,[0x173b62]
MOV EDX,0x574
LEA RCX,[0x174025]
CALL 0x0010d690
LAB_00112b8c:
MOV dword ptr [RSP + 0xcc],0x0
MOV qword ptr [RSP + 0xc0],0x0
VPXOR XMM0,XMM0,XMM0
VMOVAPS zmmword ptr [RSP + 0x140] ,ZMM0
VMOVAPS ZMM1,zmmword ptr [RSP + 0x140]
VMOVAPS zmmword ptr [RSP + 0x80] ,ZMM1
VMOVAPS zmmword ptr [RSP + 0x100] ,ZMM0
VMOVAPS ZMM0,zmmword ptr [RSP + 0x100]
VMOVAPS zmmword ptr [RSP + 0x40] ,ZMM0
LAB_00112bd7:
MOV EAX,dword ptr [RSP + 0xcc]
ADD EAX,0x20
CMP EAX,dword ptr [RSP + 0xfc]
JG 0x00112ea4
MOV RAX,qword ptr [RSP + 0xe0]
MOVSXD RCX,dword ptr [RSP + 0xcc]
SHL RCX,0x1
ADD RAX,RCX
MOV qword ptr [RSP + 0x338],RAX
MOV RAX,qword ptr [RSP + 0x338]
VMOVDQU YMM0,ymmword ptr [RAX]
VMOVDQA ymmword ptr [RSP + 0x7c0],YMM0
VMOVDQA YMM0,ymmword ptr [RSP + 0x7c0]
VPMOVZXWD ZMM0,YMM0
VMOVDQA64 zmmword ptr [RSP + 0x700],ZMM0
MOV dword ptr [RSP + 0x6fc],0x10
VMOVDQA64 ZMM0,zmmword ptr [RSP + 0x700]
MOV EAX,dword ptr [RSP + 0x6fc]
VMOVD XMM1,EAX
VPSLLD ZMM0,ZMM0,XMM1
VMOVDQA64 zmmword ptr [RSP + 0x500],ZMM0
VMOVDQA64 ZMM1,zmmword ptr [RSP + 0x500]
MOV RAX,qword ptr [RSP + 0xd0]
MOVSXD RCX,dword ptr [RSP + 0xcc]
SHL RCX,0x1
ADD RAX,RCX
MOV qword ptr [RSP + 0x330],RAX
MOV RAX,qword ptr [RSP + 0x330]
VMOVDQU YMM0,ymmword ptr [RAX]
VMOVDQA ymmword ptr [RSP + 0x7a0],YMM0
VMOVDQA YMM0,ymmword ptr [RSP + 0x7a0]
VPMOVZXWD ZMM0,YMM0
VMOVDQA64 zmmword ptr [RSP + 0x680],ZMM0
MOV dword ptr [RSP + 0x67c],0x10
VMOVDQA64 ZMM0,zmmword ptr [RSP + 0x680]
MOV EAX,dword ptr [RSP + 0x67c]
VMOVD XMM2,EAX
VPSLLD ZMM0,ZMM0,XMM2
VMOVDQA64 zmmword ptr [RSP + 0x4c0],ZMM0
VMOVDQA64 ZMM0,zmmword ptr [RSP + 0x4c0]
VMOVAPS zmmword ptr [RSP + 0x400] ,ZMM1
VMOVAPS zmmword ptr [RSP + 0x3c0] ,ZMM0
VMOVAPS ZMM0,zmmword ptr [RSP + 0x400]
VMULPS ZMM1,ZMM0,zmmword ptr [RSP + 0x3c0]
VMOVAPS ZMM0,zmmword ptr [RSP + 0x80]
VMOVAPS zmmword ptr [RSP + 0x240] ,ZMM1
VMOVAPS zmmword ptr [RSP + 0x200] ,ZMM0
VMOVAPS ZMM0,zmmword ptr [RSP + 0x240]
VADDPS ZMM0,ZMM0,zmmword ptr [RSP + 0x200]
VMOVAPS zmmword ptr [RSP + 0x80] ,ZMM0
MOV RAX,qword ptr [RSP + 0xe0]
MOVSXD RCX,dword ptr [RSP + 0xcc]
SHL RCX,0x1
ADD RAX,RCX
ADD RAX,0x20
MOV qword ptr [RSP + 0x328],RAX
MOV RAX,qword ptr [RSP + 0x328]
VMOVDQU YMM0,ymmword ptr [RAX]
VMOVDQA ymmword ptr [RSP + 0x780],YMM0
VMOVDQA YMM0,ymmword ptr [RSP + 0x780]
VPMOVZXWD ZMM0,YMM0
VMOVDQA64 zmmword ptr [RSP + 0x600],ZMM0
MOV dword ptr [RSP + 0x5fc],0x10
VMOVDQA64 ZMM0,zmmword ptr [RSP + 0x600]
MOV EAX,dword ptr [RSP + 0x5fc]
VMOVD XMM1,EAX
VPSLLD ZMM0,ZMM0,XMM1
VMOVDQA64 zmmword ptr [RSP + 0x480],ZMM0
VMOVDQA64 ZMM1,zmmword ptr [RSP + 0x480]
MOV RAX,qword ptr [RSP + 0xd0]
MOVSXD RCX,dword ptr [RSP + 0xcc]
SHL RCX,0x1
ADD RAX,RCX
ADD RAX,0x20
MOV qword ptr [RSP + 0x320],RAX
MOV RAX,qword ptr [RSP + 0x320]
VMOVDQU YMM0,ymmword ptr [RAX]
VMOVDQA ymmword ptr [RSP + 0x760],YMM0
VMOVDQA YMM0,ymmword ptr [RSP + 0x760]
VPMOVZXWD ZMM0,YMM0
VMOVDQA64 zmmword ptr [RSP + 0x580],ZMM0
MOV dword ptr [RSP + 0x57c],0x10
VMOVDQA64 ZMM0,zmmword ptr [RSP + 0x580]
MOV EAX,dword ptr [RSP + 0x57c]
VMOVD XMM2,EAX
VPSLLD ZMM0,ZMM0,XMM2
VMOVDQA64 zmmword ptr [RSP + 0x440],ZMM0
VMOVDQA64 ZMM0,zmmword ptr [RSP + 0x440]
VMOVAPS zmmword ptr [RSP + 0x380] ,ZMM1
VMOVAPS zmmword ptr [RSP + 0x340] ,ZMM0
VMOVAPS ZMM0,zmmword ptr [RSP + 0x380]
VMULPS ZMM1,ZMM0,zmmword ptr [RSP + 0x340]
VMOVAPS ZMM0,zmmword ptr [RSP + 0x40]
VMOVAPS zmmword ptr [RSP + 0x1c0] ,ZMM1
VMOVAPS zmmword ptr [RSP + 0x180] ,ZMM0
VMOVAPS ZMM0,zmmword ptr [RSP + 0x1c0]
VADDPS ZMM0,ZMM0,zmmword ptr [RSP + 0x180]
VMOVAPS zmmword ptr [RSP + 0x40] ,ZMM0
MOV EAX,dword ptr [RSP + 0xcc]
ADD EAX,0x20
MOV dword ptr [RSP + 0xcc],EAX
JMP 0x00112bd7
LAB_00112ea4:
VMOVAPS ZMM0,zmmword ptr [RSP + 0x80]
VMOVAPS zmmword ptr [RSP + 0x2c0] ,ZMM0
VMOVAPS ZMM0,zmmword ptr [RSP + 0x2c0]
VMOVAPD YMM2,ymmword ptr [RSP + 0x2e0]
VMOVAPS YMM1,YMM2
VADDPS ZMM0,ZMM0,ZMM1
VMOVAPS YMM1,YMM0
VEXTRACTF128 XMM1,YMM1,0x1
VADDPS XMM0,XMM0,XMM1
VPERMILPD XMM1,XMM0,0x1
VADDPS XMM1,XMM0,XMM1
VMOVAPS XMM0,XMM1
VMOVSHDUP XMM1,XMM1
VADDSS XMM1,XMM0,XMM1
VCVTSS2SD XMM1,XMM0,XMM1
VMOVSD XMM0,qword ptr [RSP + 0xc0]
VADDSD XMM0,XMM0,XMM1
VMOVSD qword ptr [RSP + 0xc0],XMM0
VMOVAPS ZMM0,zmmword ptr [RSP + 0x40]
VMOVAPS zmmword ptr [RSP + 0x280] ,ZMM0
VMOVAPS ZMM0,zmmword ptr [RSP + 0x280]
VMOVAPD YMM2,ymmword ptr [RSP + 0x2a0]
VMOVAPS YMM1,YMM2
VADDPS ZMM0,ZMM0,ZMM1
VMOVAPS YMM1,YMM0
VEXTRACTF128 XMM1,YMM1,0x1
VADDPS XMM0,XMM0,XMM1
VPERMILPD XMM1,XMM0,0x1
VADDPS XMM1,XMM0,XMM1
VMOVAPS XMM0,XMM1
VMOVSHDUP XMM1,XMM1
VADDSS XMM1,XMM0,XMM1
VMOVSS XMM0,dword ptr [0x00173ad0]
VADDSS XMM1,XMM0,XMM1
VCVTSS2SD XMM0,XMM0,XMM1
VADDSD XMM0,XMM0,qword ptr [RSP + 0xc0]
VMOVSD qword ptr [RSP + 0xc0],XMM0
LAB_00112f7e:
MOV EAX,dword ptr [RSP + 0xcc]
CMP EAX,dword ptr [RSP + 0xfc]
JGE 0x00113003
MOV RAX,qword ptr [RSP + 0xe0]
MOVSXD RCX,dword ptr [RSP + 0xcc]
MOVZX EDI,word ptr [RAX + RCX*0x2]
VZEROUPPER
CALL 0x0010fae0
VMOVSS dword ptr [RSP + 0x3c],XMM0
MOV RAX,qword ptr [RSP + 0xd0]
MOVSXD RCX,dword ptr [RSP + 0xcc]
MOVZX EDI,word ptr [RAX + RCX*0x2]
CALL 0x0010fae0
VMOVAPS XMM1,XMM0
VMOVSS XMM0,dword ptr [RSP + 0x3c]
VMULSS XMM1,XMM0,XMM1
VCVTSS2SD XMM0,XMM0,XMM1
VADDSD XMM0,XMM0,qword ptr [RSP + 0xc0]
VMOVSD qword ptr [RSP + 0xc0],XMM0
MOV EAX,dword ptr [RSP + 0xcc]
ADD EAX,0x1
MOV dword ptr [RSP + 0xcc],EAX
JMP 0x00112f7e
LAB_00113003:
VMOVSD XMM1,qword ptr [RSP + 0xc0]
VCVTSD2SS XMM0,XMM0,XMM1
MOV RAX,qword ptr [RSP + 0xf0]
VMOVSS dword ptr [RAX],XMM0
MOV RSP,RBP
POP RBP
VZEROUPPER
RET
|
void ggml_vec_dot_bf16(int param_1,float *param_2,int8 param_3,long param_4,int8 param_5
,long param_6,int8 param_7,int param_8)
{
int1 auVar1 [16];
float fVar2;
int1 auVar3 [64];
int1 auVar4 [64];
float fVar5;
float fVar6;
int1 auVar7 [16];
int1 auVar8 [16];
int1 auVar9 [16];
int1 auVar10 [16];
int1 local_800 [64];
int1 local_7c0 [64];
int local_774;
if (param_8 != 1) {
/* WARNING: Subroutine does not return */
__assert_fail("nrc == 1",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c"
,0x574,
"void ggml_vec_dot_bf16(int, float *restrict, size_t, ggml_bf16_t *restrict, size_t, ggml_bf16_t *restrict, size_t, int)"
);
}
local_7c0 = ZEXT1664(ZEXT816(0));
local_800 = ZEXT1664(ZEXT816(0));
for (local_774 = 0; local_774 + 0x20 <= param_1; local_774 = local_774 + 0x20) {
auVar3 = vpmovzxwd_avx512f(*(int1 (*) [32])(param_4 + (long)local_774 * 2));
auVar3 = vmovdqa64_avx512f(auVar3);
auVar3 = vmovdqa64_avx512f(auVar3);
auVar3 = vpslld_avx512f(auVar3,ZEXT416(0x10));
auVar3 = vmovdqa64_avx512f(auVar3);
auVar4 = vmovdqa64_avx512f(auVar3);
auVar3 = vpmovzxwd_avx512f(*(int1 (*) [32])(param_6 + (long)local_774 * 2));
auVar3 = vmovdqa64_avx512f(auVar3);
auVar3 = vmovdqa64_avx512f(auVar3);
auVar3 = vpslld_avx512f(auVar3,ZEXT416(0x10));
auVar3 = vmovdqa64_avx512f(auVar3);
auVar3 = vmovdqa64_avx512f(auVar3);
auVar3 = vmulps_avx512f(auVar4,auVar3);
local_7c0 = vaddps_avx512f(auVar3,local_7c0);
auVar3 = vpmovzxwd_avx512f(*(int1 (*) [32])(param_4 + (long)local_774 * 2 + 0x20));
auVar3 = vmovdqa64_avx512f(auVar3);
auVar3 = vmovdqa64_avx512f(auVar3);
auVar3 = vpslld_avx512f(auVar3,ZEXT416(0x10));
auVar3 = vmovdqa64_avx512f(auVar3);
auVar4 = vmovdqa64_avx512f(auVar3);
auVar3 = vpmovzxwd_avx512f(*(int1 (*) [32])(param_6 + (long)local_774 * 2 + 0x20));
auVar3 = vmovdqa64_avx512f(auVar3);
auVar3 = vmovdqa64_avx512f(auVar3);
auVar3 = vpslld_avx512f(auVar3,ZEXT416(0x10));
auVar3 = vmovdqa64_avx512f(auVar3);
auVar3 = vmovdqa64_avx512f(auVar3);
auVar3 = vmulps_avx512f(auVar4,auVar3);
local_800 = vaddps_avx512f(auVar3,local_800);
}
auVar3 = vaddps_avx512f(local_7c0,ZEXT3264(local_7c0._32_32_));
auVar7._0_4_ = auVar3._0_4_ + auVar3._16_4_;
auVar7._4_4_ = auVar3._4_4_ + auVar3._20_4_;
auVar7._8_4_ = auVar3._8_4_ + auVar3._24_4_;
auVar7._12_4_ = auVar3._12_4_ + auVar3._28_4_;
auVar1 = vpermilpd_avx(auVar7,1);
auVar9._0_4_ = auVar7._0_4_ + auVar1._0_4_;
auVar9._4_4_ = auVar7._4_4_ + auVar1._4_4_;
auVar9._8_4_ = auVar7._8_4_ + auVar1._8_4_;
auVar9._12_4_ = auVar7._12_4_ + auVar1._12_4_;
auVar1 = vmovshdup_avx(auVar9);
auVar3 = vaddps_avx512f(local_800,ZEXT3264(local_800._32_32_));
auVar8._0_4_ = auVar3._0_4_ + auVar3._16_4_;
auVar8._4_4_ = auVar3._4_4_ + auVar3._20_4_;
auVar8._8_4_ = auVar3._8_4_ + auVar3._24_4_;
auVar8._12_4_ = auVar3._12_4_ + auVar3._28_4_;
auVar7 = vpermilpd_avx(auVar8,1);
auVar10._0_4_ = auVar8._0_4_ + auVar7._0_4_;
auVar10._4_4_ = auVar8._4_4_ + auVar7._4_4_;
auVar10._8_4_ = auVar8._8_4_ + auVar7._8_4_;
auVar10._12_4_ = auVar8._12_4_ + auVar7._12_4_;
auVar7 = vmovshdup_avx(auVar10);
fVar2 = DAT_00173ad0 + auVar10._0_4_ + auVar7._0_4_ + auVar9._0_4_ + auVar1._0_4_ + 0.0;
for (; local_774 < param_1; local_774 = local_774 + 1) {
fVar5 = (float)ggml_compute_bf16_to_fp32(*(int2 *)(param_4 + (long)local_774 * 2));
fVar6 = (float)ggml_compute_bf16_to_fp32(*(int2 *)(param_6 + (long)local_774 * 2));
fVar2 = fVar5 * fVar6 + fVar2;
}
*param_2 = fVar2;
return;
}
|
|
5,861 | ggml_vec_dot_bf16 | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c | static void ggml_vec_dot_bf16(int n, float * restrict s, size_t bs, ggml_bf16_t * restrict x, size_t bx, ggml_bf16_t * restrict y, size_t by, int nrc) {
assert(nrc == 1);
UNUSED(nrc);
UNUSED(bx);
UNUSED(by);
UNUSED(bs);
int i = 0;
ggml_float sumf = 0;
#if defined(__AVX512BF16__)
__m512 c1 = _mm512_setzero_ps();
__m512 c2 = _mm512_setzero_ps();
for (; i + 64 <= n; i += 64) {
c1 = _mm512_dpbf16_ps(c1, m512bh(_mm512_loadu_si512((x + i))),
m512bh(_mm512_loadu_si512((y + i))));
c2 = _mm512_dpbf16_ps(c2, m512bh(_mm512_loadu_si512((x + i + 32))),
m512bh(_mm512_loadu_si512((y + i + 32))));
}
sumf += (ggml_float)_mm512_reduce_add_ps(c1);
sumf += (ggml_float)_mm512_reduce_add_ps(c2);
#elif defined(__AVX512F__)
#define LOAD(p) _mm512_castsi512_ps(_mm512_slli_epi32(_mm512_cvtepu16_epi32(_mm256_loadu_si256((const __m256i *)(p))), 16))
__m512 c1 = _mm512_setzero_ps();
__m512 c2 = _mm512_setzero_ps();
for (; i + 32 <= n; i += 32) {
c1 = _mm512_add_ps(_mm512_mul_ps(LOAD(x + i), LOAD(y + i)), c1);
c2 = _mm512_add_ps(_mm512_mul_ps(LOAD(x + i + 16), LOAD(y + i + 16)), c2);
}
sumf += (ggml_float)_mm512_reduce_add_ps(c1);
sumf += (ggml_float)_mm512_reduce_add_ps(c2);
#undef LOAD
#elif defined(__AVX2__) || defined(__AVX__)
#if defined(__AVX2__)
#define LOAD(p) _mm256_castsi256_ps(_mm256_slli_epi32(_mm256_cvtepu16_epi32(_mm_loadu_si128((const __m128i *)(p))), 16))
#else
#define LOAD(p) _mm256_castsi256_ps(_mm256_insertf128_si256(_mm256_castsi128_si256(_mm_slli_epi32(_mm_cvtepu16_epi32(_mm_loadu_si128((const __m128i *)(p))), 16)), (_mm_slli_epi32(_mm_cvtepu16_epi32(_mm_bsrli_si128(_mm_loadu_si128((const __m128i *)(p)), 8)), 16)), 1))
#endif
__m256 c1 = _mm256_setzero_ps();
__m256 c2 = _mm256_setzero_ps();
__m256 c3 = _mm256_setzero_ps();
__m256 c4 = _mm256_setzero_ps();
for (; i + 32 <= n; i += 32) {
c1 = _mm256_add_ps(_mm256_mul_ps(LOAD(x + i), LOAD(y + i)), c1);
c2 = _mm256_add_ps(_mm256_mul_ps(LOAD(x + i + 8), LOAD(y + i + 8)), c2);
c3 = _mm256_add_ps(_mm256_mul_ps(LOAD(x + i + 16), LOAD(y + i + 16)), c3);
c4 = _mm256_add_ps(_mm256_mul_ps(LOAD(x + i + 24), LOAD(y + i + 24)), c4);
}
__m128 g;
c1 = _mm256_add_ps(_mm256_add_ps(c1, c3),
_mm256_add_ps(c2, c4));
g = _mm_add_ps(_mm256_extractf128_ps(c1, 1),
_mm256_castps256_ps128(c1));
g = _mm_add_ps(g, _mm_movehl_ps(g, g));
g = _mm_add_ss(g, _mm_movehdup_ps(g));
sumf += (ggml_float)_mm_cvtss_f32(g);
#undef LOAD
#endif
for (; i < n; ++i) {
sumf += (ggml_float)(GGML_BF16_TO_FP32(x[i]) *
GGML_BF16_TO_FP32(y[i]));
}
*s = sumf;
} | O3 | c | ggml_vec_dot_bf16:
pushq %rax
cmpl $0x1, 0x18(%rsp)
jne 0x21e14
cmpl $0x20, %edi
jge 0x21d07
vxorps %xmm1, %xmm1, %xmm1
xorl %eax, %eax
vxorps %xmm0, %xmm0, %xmm0
jmp 0x21d7b
movl %edi, %edx
movl %edi, %eax
andl $0x7fffffe0, %eax # imm = 0x7FFFFFE0
vxorps %xmm0, %xmm0, %xmm0
movl $0x20, %r8d
vxorps %xmm1, %xmm1, %xmm1
vpmovzxwd -0x40(%rcx,%r8,2), %zmm2
vpslld $0x10, %zmm2, %zmm2
vpmovzxwd -0x40(%r9,%r8,2), %zmm3
vpslld $0x10, %zmm3, %zmm3
vmulps %zmm3, %zmm2, %zmm2
vaddps %zmm2, %zmm1, %zmm1
vpmovzxwd -0x20(%rcx,%r8,2), %zmm2
vpmovzxwd -0x20(%r9,%r8,2), %zmm3
vpslld $0x10, %zmm2, %zmm2
vpslld $0x10, %zmm3, %zmm3
vmulps %zmm3, %zmm2, %zmm2
vaddps %zmm2, %zmm0, %zmm0
addq $0x20, %r8
cmpq %rdx, %r8
jbe 0x21d1e
vextractf64x4 $0x1, %zmm1, %ymm2
vaddps %zmm2, %zmm1, %zmm1
vextractf128 $0x1, %ymm1, %xmm2
vaddps %xmm2, %xmm1, %xmm1
vshufpd $0x1, %xmm1, %xmm1, %xmm2 # xmm2 = xmm1[1,0]
vaddps %xmm2, %xmm1, %xmm1
vhaddps %xmm1, %xmm1, %xmm1
vcvtss2sd %xmm1, %xmm1, %xmm1
vextractf64x4 $0x1, %zmm0, %ymm2
vaddps %zmm2, %zmm0, %zmm0
vextractf128 $0x1, %ymm0, %xmm2
vaddps %xmm2, %xmm0, %xmm0
vshufpd $0x1, %xmm0, %xmm0, %xmm2 # xmm2 = xmm0[1,0]
vaddps %xmm2, %xmm0, %xmm0
vhaddps %xmm0, %xmm0, %xmm0
vxorpd %xmm2, %xmm2, %xmm2
vaddsd %xmm2, %xmm1, %xmm1
vcvtss2sd %xmm0, %xmm0, %xmm0
vaddsd %xmm0, %xmm1, %xmm0
cmpl %edi, %eax
jge 0x21e07
movl %eax, %eax
movzwl (%rcx,%rax,2), %edx
shll $0x10, %edx
vmovd %edx, %xmm1
movzwl (%r9,%rax,2), %edx
shll $0x10, %edx
vmovd %edx, %xmm2
vmulss %xmm2, %xmm1, %xmm1
vcvtss2sd %xmm1, %xmm1, %xmm1
vaddsd %xmm1, %xmm0, %xmm0
incq %rax
cmpl %edi, %eax
jl 0x21ddd
vcvtsd2ss %xmm0, %xmm0, %xmm0
vmovss %xmm0, (%rsi)
popq %rax
vzeroupper
retq
leaq 0x14e1b(%rip), %rdi # 0x36c36
leaq 0x14a48(%rip), %rsi # 0x3686a
leaq 0x14f04(%rip), %rcx # 0x36d2d
movl $0x574, %edx # imm = 0x574
callq 0x83b0
| ggml_vec_dot_bf16:
push rax
cmp [rsp+8+arg_8], 1
jnz loc_21E14
cmp edi, 20h ; ' '
jge short loc_21D07
vxorps xmm1, xmm1, xmm1
xor eax, eax
vxorps xmm0, xmm0, xmm0
jmp short loc_21D7B
loc_21D07:
mov edx, edi
mov eax, edi
and eax, 7FFFFFE0h
vxorps xmm0, xmm0, xmm0
mov r8d, 20h ; ' '
vxorps xmm1, xmm1, xmm1
loc_21D1E:
vpmovzxwd zmm2, ymmword ptr [rcx+r8*2-40h]
vpslld zmm2, zmm2, 10h
vpmovzxwd zmm3, ymmword ptr [r9+r8*2-40h]
vpslld zmm3, zmm3, 10h
vmulps zmm2, zmm2, zmm3
vaddps zmm1, zmm1, zmm2
vpmovzxwd zmm2, ymmword ptr [rcx+r8*2-20h]
vpmovzxwd zmm3, ymmword ptr [r9+r8*2-20h]
vpslld zmm2, zmm2, 10h
vpslld zmm3, zmm3, 10h
vmulps zmm2, zmm2, zmm3
vaddps zmm0, zmm0, zmm2
add r8, 20h ; ' '
cmp r8, rdx
jbe short loc_21D1E
loc_21D7B:
vextractf64x4 ymm2, zmm1, 1
vaddps zmm1, zmm1, zmm2
vextractf128 xmm2, ymm1, 1
vaddps xmm1, xmm1, xmm2
vshufpd xmm2, xmm1, xmm1, 1
vaddps xmm1, xmm1, xmm2
vhaddps xmm1, xmm1, xmm1
vcvtss2sd xmm1, xmm1, xmm1
vextractf64x4 ymm2, zmm0, 1
vaddps zmm0, zmm0, zmm2
vextractf128 xmm2, ymm0, 1
vaddps xmm0, xmm0, xmm2
vshufpd xmm2, xmm0, xmm0, 1
vaddps xmm0, xmm0, xmm2
vhaddps xmm0, xmm0, xmm0
vxorpd xmm2, xmm2, xmm2
vaddsd xmm1, xmm1, xmm2
vcvtss2sd xmm0, xmm0, xmm0
vaddsd xmm0, xmm1, xmm0
cmp eax, edi
jge short loc_21E07
mov eax, eax
loc_21DDD:
movzx edx, word ptr [rcx+rax*2]
shl edx, 10h
vmovd xmm1, edx
movzx edx, word ptr [r9+rax*2]
shl edx, 10h
vmovd xmm2, edx
vmulss xmm1, xmm1, xmm2
vcvtss2sd xmm1, xmm1, xmm1
vaddsd xmm0, xmm0, xmm1
inc rax
cmp eax, edi
jl short loc_21DDD
loc_21E07:
vcvtsd2ss xmm0, xmm0, xmm0
vmovss dword ptr [rsi], xmm0
pop rax
vzeroupper
retn
loc_21E14:
lea rdi, aNrc1; "nrc == 1"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidGgmlVecDot_1; "void ggml_vec_dot_bf16(int, float *rest"...
mov edx, 574h
call ___assert_fail
| void __spoils<rdx,rcx,r8,r9,r10,r11,xmm0,xmm4,xmm5> ggml_vec_dot_bf16(
int a1,
long long _RSI,
__m128 _XMM0,
__m128 _XMM1,
long long a5,
long long _RCX,
long long a7,
long long _R9,
int a9,
int a10)
{
long long v13; // rax
if ( a10 != 1 )
__assert_fail(
"nrc == 1",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
1396LL,
"void ggml_vec_dot_bf16(int, float *restrict, size_t, ggml_bf16_t *restrict, size_t, ggml_bf16_t *restrict, size_t, int)");
if ( a1 >= 32 )
{
LODWORD(v13) = a1 & 0x7FFFFFE0;
__asm { vxorps xmm0, xmm0, xmm0 }
_R8 = 32LL;
__asm { vxorps xmm1, xmm1, xmm1 }
do
{
__asm
{
vpmovzxwd zmm2, ymmword ptr [rcx+r8*2-40h]
vpslld zmm2, zmm2, 10h
vpmovzxwd zmm3, ymmword ptr [r9+r8*2-40h]
vpslld zmm3, zmm3, 10h
vmulps zmm2, zmm2, zmm3
vaddps zmm1, zmm1, zmm2
vpmovzxwd zmm2, ymmword ptr [rcx+r8*2-20h]
vpmovzxwd zmm3, ymmword ptr [r9+r8*2-20h]
vpslld zmm2, zmm2, 10h
vpslld zmm3, zmm3, 10h
vmulps zmm2, zmm2, zmm3
vaddps zmm0, zmm0, zmm2
}
_R8 += 32LL;
}
while ( _R8 <= (unsigned int)a1 );
}
else
{
__asm { vxorps xmm1, xmm1, xmm1 }
LODWORD(v13) = 0;
__asm { vxorps xmm0, xmm0, xmm0 }
}
__asm
{
vextractf64x4 ymm2, zmm1, 1
vaddps zmm1, zmm1, zmm2
vextractf128 xmm2, ymm1, 1
vaddps xmm1, xmm1, xmm2
vshufpd xmm2, xmm1, xmm1, 1
vaddps xmm1, xmm1, xmm2
vhaddps xmm1, xmm1, xmm1
vcvtss2sd xmm1, xmm1, xmm1
vextractf64x4 ymm2, zmm0, 1
vaddps zmm0, zmm0, zmm2
vextractf128 xmm2, ymm0, 1
vaddps xmm0, xmm0, xmm2
vshufpd xmm2, xmm0, xmm0, 1
vaddps xmm0, xmm0, xmm2
vhaddps xmm0, xmm0, xmm0
vxorpd xmm2, xmm2, xmm2
vaddsd xmm1, xmm1, xmm2
vcvtss2sd xmm0, xmm0, xmm0
vaddsd xmm0, xmm1, xmm0
}
if ( (int)v13 < a1 )
{
v13 = (unsigned int)v13;
do
{
_EDX = *(unsigned __int16 *)(_RCX + 2 * v13) << 16;
__asm { vmovd xmm1, edx }
_EDX = *(unsigned __int16 *)(_R9 + 2 * v13) << 16;
__asm
{
vmovd xmm2, edx
vmulss xmm1, xmm1, xmm2
vcvtss2sd xmm1, xmm1, xmm1
vaddsd xmm0, xmm0, xmm1
}
++v13;
}
while ( (int)v13 < a1 );
}
__asm
{
vcvtsd2ss xmm0, xmm0, xmm0
vmovss dword ptr [rsi], xmm0
vzeroupper
}
}
| ggml_vec_dot_bf16:
PUSH RAX
CMP dword ptr [RSP + 0x18],0x1
JNZ 0x00121e14
CMP EDI,0x20
JGE 0x00121d07
VXORPS XMM1,XMM1,XMM1
XOR EAX,EAX
VXORPS XMM0,XMM0,XMM0
JMP 0x00121d7b
LAB_00121d07:
MOV EDX,EDI
MOV EAX,EDI
AND EAX,0x7fffffe0
VXORPS XMM0,XMM0,XMM0
MOV R8D,0x20
VXORPS XMM1,XMM1,XMM1
LAB_00121d1e:
VPMOVZXWD ZMM2,ymmword ptr [RCX + R8*0x2 + -0x40]
VPSLLD ZMM2,ZMM2,0x10
VPMOVZXWD ZMM3,ymmword ptr [R9 + R8*0x2 + -0x40]
VPSLLD ZMM3,ZMM3,0x10
VMULPS ZMM2,ZMM2,ZMM3
VADDPS ZMM1,ZMM1,ZMM2
VPMOVZXWD ZMM2,ymmword ptr [RCX + R8*0x2 + -0x20]
VPMOVZXWD ZMM3,ymmword ptr [R9 + R8*0x2 + -0x20]
VPSLLD ZMM2,ZMM2,0x10
VPSLLD ZMM3,ZMM3,0x10
VMULPS ZMM2,ZMM2,ZMM3
VADDPS ZMM0,ZMM0,ZMM2
ADD R8,0x20
CMP R8,RDX
JBE 0x00121d1e
LAB_00121d7b:
VEXTRACTF64x4 YMM2,ZMM1,0x1
VADDPS ZMM1,ZMM1,ZMM2
VEXTRACTF128 XMM2,YMM1,0x1
VADDPS XMM1,XMM1,XMM2
VSHUFPD XMM2,XMM1,XMM1,0x1
VADDPS XMM1,XMM1,XMM2
VHADDPS XMM1,XMM1,XMM1
VCVTSS2SD XMM1,XMM1,XMM1
VEXTRACTF64x4 YMM2,ZMM0,0x1
VADDPS ZMM0,ZMM0,ZMM2
VEXTRACTF128 XMM2,YMM0,0x1
VADDPS XMM0,XMM0,XMM2
VSHUFPD XMM2,XMM0,XMM0,0x1
VADDPS XMM0,XMM0,XMM2
VHADDPS XMM0,XMM0,XMM0
VXORPD XMM2,XMM2,XMM2
VADDSD XMM1,XMM1,XMM2
VCVTSS2SD XMM0,XMM0,XMM0
VADDSD XMM0,XMM1,XMM0
CMP EAX,EDI
JGE 0x00121e07
MOV EAX,EAX
LAB_00121ddd:
MOVZX EDX,word ptr [RCX + RAX*0x2]
SHL EDX,0x10
VMOVD XMM1,EDX
MOVZX EDX,word ptr [R9 + RAX*0x2]
SHL EDX,0x10
VMOVD XMM2,EDX
VMULSS XMM1,XMM1,XMM2
VCVTSS2SD XMM1,XMM1,XMM1
VADDSD XMM0,XMM0,XMM1
INC RAX
CMP EAX,EDI
JL 0x00121ddd
LAB_00121e07:
VCVTSD2SS XMM0,XMM0,XMM0
VMOVSS dword ptr [RSI],XMM0
POP RAX
VZEROUPPER
RET
LAB_00121e14:
LEA RDI,[0x136c36]
LEA RSI,[0x13686a]
LEA RCX,[0x136d2d]
MOV EDX,0x574
CALL 0x001083b0
|
int8
ggml_vec_dot_bf16(uint param_1,float *param_2,int8 param_3,long param_4,int8 param_5,
long param_6,int8 param_7,int param_8)
{
int1 auVar1 [16];
float fVar2;
uint uVar3;
int8 in_RAX;
ulong uVar4;
int1 auVar5 [32];
int1 auVar6 [64];
int1 auVar7 [64];
int1 auVar8 [16];
int1 auVar9 [16];
int1 auVar10 [64];
int1 auVar11 [16];
int1 auVar12 [16];
int1 auVar13 [64];
if (param_8 != 1) {
/* WARNING: Subroutine does not return */
__assert_fail("nrc == 1",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c"
,0x574,
"void ggml_vec_dot_bf16(int, float *restrict, size_t, ggml_bf16_t *restrict, size_t, ggml_bf16_t *restrict, size_t, int)"
);
}
if ((int)param_1 < 0x20) {
auVar13 = ZEXT864(0);
uVar3 = 0;
auVar10 = ZEXT864(0);
}
else {
uVar3 = param_1 & 0x7fffffe0;
auVar10 = ZEXT864(0);
uVar4 = 0x20;
auVar13 = ZEXT864(0);
do {
auVar6 = vpmovzxwd_avx512f(*(int1 (*) [32])(param_4 + -0x40 + uVar4 * 2));
auVar6 = vpslld_avx512f(auVar6,0x10);
auVar7 = vpmovzxwd_avx512f(*(int1 (*) [32])(param_6 + -0x40 + uVar4 * 2));
auVar7 = vpslld_avx512f(auVar7,0x10);
auVar6 = vmulps_avx512f(auVar6,auVar7);
auVar13 = vaddps_avx512f(auVar13,auVar6);
auVar6 = vpmovzxwd_avx512f(*(int1 (*) [32])(param_4 + -0x20 + uVar4 * 2));
auVar7 = vpmovzxwd_avx512f(*(int1 (*) [32])(param_6 + -0x20 + uVar4 * 2));
auVar6 = vpslld_avx512f(auVar6,0x10);
auVar7 = vpslld_avx512f(auVar7,0x10);
auVar6 = vmulps_avx512f(auVar6,auVar7);
auVar10 = vaddps_avx512f(auVar10,auVar6);
uVar4 = uVar4 + 0x20;
} while (uVar4 <= param_1);
}
auVar5 = vextractf64x4_avx512f(auVar13,1);
auVar13 = vaddps_avx512f(auVar13,ZEXT3264(auVar5));
auVar11._0_4_ = auVar13._0_4_ + auVar13._16_4_;
auVar11._4_4_ = auVar13._4_4_ + auVar13._20_4_;
auVar11._8_4_ = auVar13._8_4_ + auVar13._24_4_;
auVar11._12_4_ = auVar13._12_4_ + auVar13._28_4_;
auVar1 = vshufpd_avx(auVar11,auVar11,1);
auVar12._0_4_ = auVar11._0_4_ + auVar1._0_4_;
auVar12._4_4_ = auVar11._4_4_ + auVar1._4_4_;
auVar12._8_4_ = auVar11._8_4_ + auVar1._8_4_;
auVar12._12_4_ = auVar11._12_4_ + auVar1._12_4_;
auVar1 = vhaddps_avx(auVar12,auVar12);
auVar5 = vextractf64x4_avx512f(auVar10,1);
auVar13 = vaddps_avx512f(auVar10,ZEXT3264(auVar5));
auVar8._0_4_ = auVar13._0_4_ + auVar13._16_4_;
auVar8._4_4_ = auVar13._4_4_ + auVar13._20_4_;
auVar8._8_4_ = auVar13._8_4_ + auVar13._24_4_;
auVar8._12_4_ = auVar13._12_4_ + auVar13._28_4_;
auVar11 = vshufpd_avx(auVar8,auVar8,1);
auVar9._0_4_ = auVar8._0_4_ + auVar11._0_4_;
auVar9._4_4_ = auVar8._4_4_ + auVar11._4_4_;
auVar9._8_4_ = auVar8._8_4_ + auVar11._8_4_;
auVar9._12_4_ = auVar8._12_4_ + auVar11._12_4_;
auVar11 = vhaddps_avx(auVar9,auVar9);
fVar2 = auVar1._0_4_ + 0.0 + auVar11._0_4_;
if ((int)uVar3 < (int)param_1) {
uVar4 = (ulong)uVar3;
do {
fVar2 = fVar2 + (float)((uint)*(ushort *)(param_4 + uVar4 * 2) << 0x10) *
(float)((uint)*(ushort *)(param_6 + uVar4 * 2) << 0x10);
uVar4 = uVar4 + 1;
} while ((int)uVar4 < (int)param_1);
}
*param_2 = fVar2;
return in_RAX;
}
|
|
5,862 | js_create_from_ctor | bluesky950520[P]quickjs/quickjs.c | static JSValue js_create_from_ctor(JSContext *ctx, JSValue ctor,
int class_id)
{
JSValue proto, obj;
JSContext *realm;
if (JS_IsUndefined(ctor)) {
proto = js_dup(ctx->class_proto[class_id]);
} else {
proto = JS_GetProperty(ctx, ctor, JS_ATOM_prototype);
if (JS_IsException(proto))
return proto;
if (!JS_IsObject(proto)) {
JS_FreeValue(ctx, proto);
realm = JS_GetFunctionRealm(ctx, ctor);
if (!realm)
return JS_EXCEPTION;
proto = js_dup(realm->class_proto[class_id]);
}
}
obj = JS_NewObjectProtoClass(ctx, proto, class_id);
JS_FreeValue(ctx, proto);
return obj;
} | O2 | c | js_create_from_ctor:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r12
movq %rdi, %rbx
cmpl $0x3, %r12d
jne 0x34042
movq 0x40(%rbx), %rax
movslq %ebp, %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %r15
movq 0x8(%rax,%rcx), %r14
cmpl $-0xa, %r14d
jbe 0x340b2
incl (%r15)
jmp 0x340b2
movq %rsi, %r13
pushq $0x3c
popq %rcx
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1ebf3
movq %rax, %r15
movq %rdx, %r14
cmpl $-0x1, %r14d
je 0x340b2
cmpl $0x6, %r14d
jne 0x34077
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %r15, %rcx
andq %rax, %rcx
jmp 0x340e9
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1bbce
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x4c883
testq %rax, %rax
je 0x34101
movq 0x40(%rax), %rax
movslq %ebp, %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %r15
movq 0x8(%rax,%rcx), %r14
cmpl $-0x9, %r14d
jae 0x3403d
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x1ec19
movq %rax, %r12
movq %rdx, %r13
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1bbce
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %r12, %rcx
movq %r12, %r15
movq %r13, %r14
movl %r15d, %eax
orq %rcx, %rax
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x6
popq %r14
xorl %r15d, %r15d
xorl %ecx, %ecx
jmp 0x340e9
| js_create_from_ctor:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ebp, ecx
mov r12, rdx
mov rbx, rdi
cmp r12d, 3
jnz short loc_34042
mov rax, [rbx+40h]
movsxd rcx, ebp
shl rcx, 4
mov r15, [rax+rcx]
mov r14, [rax+rcx+8]
cmp r14d, 0FFFFFFF6h
jbe short loc_340B2
loc_3403D:
inc dword ptr [r15]
jmp short loc_340B2
loc_34042:
mov r13, rsi
push 3Ch ; '<'
pop rcx
mov rdi, rbx
mov rdx, r12
call JS_GetProperty
mov r15, rax
mov r14, rdx
cmp r14d, 0FFFFFFFFh
jz short loc_340B2
cmp r14d, 6
jnz short loc_34077
mov rax, 0FFFFFFFF00000000h
mov rcx, r15
and rcx, rax
jmp short loc_340E9
loc_34077:
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call JS_FreeValue
mov rdi, rbx
mov rsi, r13
mov rdx, r12
call JS_GetFunctionRealm
test rax, rax
jz short loc_34101
mov rax, [rax+40h]
movsxd rcx, ebp
shl rcx, 4
mov r15, [rax+rcx]
mov r14, [rax+rcx+8]
cmp r14d, 0FFFFFFF7h
jnb short loc_3403D
loc_340B2:
mov rdi, rbx
mov rsi, r15
mov rdx, r14
mov ecx, ebp
call JS_NewObjectProtoClass
mov r12, rax
mov r13, rdx
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call JS_FreeValue
mov rcx, 0FFFFFFFF00000000h
and rcx, r12
mov r15, r12
mov r14, r13
loc_340E9:
mov eax, r15d
or rax, rcx
mov rdx, r14
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_34101:
push 6
pop r14
xor r15d, r15d
xor ecx, ecx
jmp short loc_340E9
| unsigned long long js_create_from_ctor(long long a1, long long a2, long long a3, signed int a4)
{
long long v6; // rax
long long v7; // rcx
_DWORD *v8; // r15
long long v9; // r14
long long Property; // rax
long long v11; // rdx
unsigned long long v12; // rcx
long long FunctionRealm; // rax
long long v14; // rax
long long v15; // rcx
long long v16; // r12
if ( (_DWORD)a3 == 3 )
{
v6 = *(_QWORD *)(a1 + 64);
v7 = 16LL * a4;
v8 = *(_DWORD **)(v6 + v7);
v9 = *(_QWORD *)(v6 + v7 + 8);
if ( (unsigned int)v9 <= 0xFFFFFFF6 )
{
LABEL_9:
v16 = JS_NewObjectProtoClass(a1, (long long)v8, v9, a4);
JS_FreeValue(a1, (long long)v8, v9);
v12 = v16 & 0xFFFFFFFF00000000LL;
LODWORD(v8) = v16;
return v12 | (unsigned int)v8;
}
LABEL_3:
++*v8;
goto LABEL_9;
}
Property = JS_GetProperty(a1, a2, a3, 60);
v8 = (_DWORD *)Property;
v9 = v11;
if ( (_DWORD)v11 == -1 )
goto LABEL_9;
if ( (_DWORD)v11 != 6 )
{
JS_FreeValue(a1, Property, v11);
FunctionRealm = JS_GetFunctionRealm(a1, a2, a3);
if ( !FunctionRealm )
{
LODWORD(v8) = 0;
v12 = 0LL;
return v12 | (unsigned int)v8;
}
v14 = *(_QWORD *)(FunctionRealm + 64);
v15 = 16LL * a4;
v8 = *(_DWORD **)(v14 + v15);
v9 = *(_QWORD *)(v14 + v15 + 8);
if ( (unsigned int)v9 < 0xFFFFFFF7 )
goto LABEL_9;
goto LABEL_3;
}
v12 = Property & 0xFFFFFFFF00000000LL;
return v12 | (unsigned int)v8;
}
| js_create_from_ctor:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV EBP,ECX
MOV R12,RDX
MOV RBX,RDI
CMP R12D,0x3
JNZ 0x00134042
MOV RAX,qword ptr [RBX + 0x40]
MOVSXD RCX,EBP
SHL RCX,0x4
MOV R15,qword ptr [RAX + RCX*0x1]
MOV R14,qword ptr [RAX + RCX*0x1 + 0x8]
CMP R14D,-0xa
JBE 0x001340b2
LAB_0013403d:
INC dword ptr [R15]
JMP 0x001340b2
LAB_00134042:
MOV R13,RSI
PUSH 0x3c
POP RCX
MOV RDI,RBX
MOV RDX,R12
CALL 0x0011ebf3
MOV R15,RAX
MOV R14,RDX
CMP R14D,-0x1
JZ 0x001340b2
CMP R14D,0x6
JNZ 0x00134077
MOV RAX,-0x100000000
MOV RCX,R15
AND RCX,RAX
JMP 0x001340e9
LAB_00134077:
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x0011bbce
MOV RDI,RBX
MOV RSI,R13
MOV RDX,R12
CALL 0x0014c883
TEST RAX,RAX
JZ 0x00134101
MOV RAX,qword ptr [RAX + 0x40]
MOVSXD RCX,EBP
SHL RCX,0x4
MOV R15,qword ptr [RAX + RCX*0x1]
MOV R14,qword ptr [RAX + RCX*0x1 + 0x8]
CMP R14D,-0x9
JNC 0x0013403d
LAB_001340b2:
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
MOV ECX,EBP
CALL 0x0011ec19
MOV R12,RAX
MOV R13,RDX
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x0011bbce
MOV RCX,-0x100000000
AND RCX,R12
MOV R15,R12
MOV R14,R13
LAB_001340e9:
MOV EAX,R15D
OR RAX,RCX
MOV RDX,R14
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00134101:
PUSH 0x6
POP R14
XOR R15D,R15D
XOR ECX,ECX
JMP 0x001340e9
|
int1 [16] js_create_from_ctor(long param_1,int8 param_2,int8 param_3,int param_4)
{
int *piVar1;
int1 auVar2 [16];
long lVar3;
ulong uVar4;
uint uVar5;
int8 uVar6;
int8 uVar7;
int1 auVar8 [16];
int1 auVar9 [16];
if ((int)param_3 == 3) {
piVar1 = *(int **)(*(long *)(param_1 + 0x40) + (long)param_4 * 0x10);
uVar6 = *(int8 *)(*(long *)(param_1 + 0x40) + 8 + (long)param_4 * 0x10);
uVar5 = (uint)uVar6;
joined_r0x001340b0:
auVar2._8_8_ = uVar6;
auVar2._0_8_ = piVar1;
auVar8._8_8_ = uVar6;
auVar8._0_8_ = piVar1;
if (0xfffffff6 < uVar5) {
*piVar1 = *piVar1 + 1;
auVar8 = auVar2;
}
}
else {
auVar8 = JS_GetProperty(param_1,param_2,param_3,0x3c);
if (auVar8._8_4_ != -1) {
if (auVar8._8_4_ == 6) {
uVar4 = auVar8._0_8_ & 0xffffffff00000000;
goto LAB_001340e9;
}
JS_FreeValue(param_1,auVar8._0_8_,auVar8._8_8_);
lVar3 = JS_GetFunctionRealm(param_1,param_2,param_3);
if (lVar3 == 0) {
auVar8 = ZEXT816(6) << 0x40;
uVar4 = 0;
goto LAB_001340e9;
}
piVar1 = *(int **)(*(long *)(lVar3 + 0x40) + (long)param_4 * 0x10);
uVar6 = *(int8 *)(*(long *)(lVar3 + 0x40) + 8 + (long)param_4 * 0x10);
uVar5 = (uint)uVar6;
goto joined_r0x001340b0;
}
}
uVar6 = auVar8._8_8_;
uVar7 = auVar8._0_8_;
auVar8 = JS_NewObjectProtoClass(param_1,uVar7,uVar6,param_4);
JS_FreeValue(param_1,uVar7,uVar6);
uVar4 = auVar8._0_8_ & 0xffffffff00000000;
LAB_001340e9:
auVar9._0_8_ = auVar8._0_8_ & 0xffffffff | uVar4;
auVar9._8_8_ = auVar8._8_8_;
return auVar9;
}
|
|
5,863 | harvest_pins | eloqsql/mysys/lf_alloc-pin.c | static int harvest_pins(LF_PINS *el, struct st_harvester *hv)
{
int i;
LF_PINS *el_end= el+MY_MIN(hv->npins, LF_DYNARRAY_LEVEL_LENGTH);
for (; el < el_end; el++)
{
for (i= 0; i < LF_PINBOX_PINS; i++)
{
void *p= el->pin[i];
if (p)
*hv->granary++= p;
}
}
/*
hv->npins may become negative below, but it means that
we're on the last dynarray page and harvest_pins() won't be
called again. We don't bother to make hv->npins() correct
(that is 0) in this case.
*/
hv->npins-= LF_DYNARRAY_LEVEL_LENGTH;
return 0;
} | O3 | c | harvest_pins:
movl 0x8(%rsi), %eax
movl $0x100, %ecx # imm = 0x100
cmpl %ecx, %eax
cmovll %eax, %ecx
testl %eax, %eax
jle 0xa5ac9
pushq %rbp
movq %rsp, %rbp
movslq %ecx, %rax
imulq $0x78, %rax, %rax
addq %rdi, %rax
xorl %ecx, %ecx
movq (%rdi,%rcx,8), %rdx
testq %rdx, %rdx
je 0xa5ab3
movq (%rsi), %r8
leaq 0x8(%r8), %r9
movq %r9, (%rsi)
movq %rdx, (%r8)
incq %rcx
cmpq $0x4, %rcx
jne 0xa5a9d
addq $0x78, %rdi
cmpq %rax, %rdi
jb 0xa5a9b
movl 0x8(%rsi), %eax
popq %rbp
addl $0xffffff00, %eax # imm = 0xFFFFFF00
movl %eax, 0x8(%rsi)
xorl %eax, %eax
retq
| harvest_pins:
mov eax, [rsi+8]
mov ecx, 100h
cmp eax, ecx
cmovl ecx, eax
test eax, eax
jle short loc_A5AC9
push rbp
mov rbp, rsp
movsxd rax, ecx
imul rax, 78h ; 'x'
add rax, rdi
loc_A5A9B:
xor ecx, ecx
loc_A5A9D:
mov rdx, [rdi+rcx*8]
test rdx, rdx
jz short loc_A5AB3
mov r8, [rsi]
lea r9, [r8+8]
mov [rsi], r9
mov [r8], rdx
loc_A5AB3:
inc rcx
cmp rcx, 4
jnz short loc_A5A9D
add rdi, 78h ; 'x'
cmp rdi, rax
jb short loc_A5A9B
mov eax, [rsi+8]
pop rbp
loc_A5AC9:
add eax, 0FFFFFF00h
mov [rsi+8], eax
xor eax, eax
retn
| long long harvest_pins(unsigned long long a1, long long a2)
{
int v2; // eax
int v3; // ecx
unsigned long long v4; // rax
long long i; // rcx
long long v6; // rdx
_QWORD *v7; // r8
v2 = *(_DWORD *)(a2 + 8);
v3 = 256;
if ( v2 < 256 )
v3 = *(_DWORD *)(a2 + 8);
if ( v2 > 0 )
{
v4 = a1 + 120LL * v3;
do
{
for ( i = 0LL; i != 4; ++i )
{
v6 = *(_QWORD *)(a1 + 8 * i);
if ( v6 )
{
v7 = *(_QWORD **)a2;
*(_QWORD *)a2 += 8LL;
*v7 = v6;
}
}
a1 += 120LL;
}
while ( a1 < v4 );
v2 = *(_DWORD *)(a2 + 8);
}
*(_DWORD *)(a2 + 8) = v2 - 256;
return 0LL;
}
| harvest_pins:
MOV EAX,dword ptr [RSI + 0x8]
MOV ECX,0x100
CMP EAX,ECX
CMOVL ECX,EAX
TEST EAX,EAX
JLE 0x001a5ac9
PUSH RBP
MOV RBP,RSP
MOVSXD RAX,ECX
IMUL RAX,RAX,0x78
ADD RAX,RDI
LAB_001a5a9b:
XOR ECX,ECX
LAB_001a5a9d:
MOV RDX,qword ptr [RDI + RCX*0x8]
TEST RDX,RDX
JZ 0x001a5ab3
MOV R8,qword ptr [RSI]
LEA R9,[R8 + 0x8]
MOV qword ptr [RSI],R9
MOV qword ptr [R8],RDX
LAB_001a5ab3:
INC RCX
CMP RCX,0x4
JNZ 0x001a5a9d
ADD RDI,0x78
CMP RDI,RAX
JC 0x001a5a9b
MOV EAX,dword ptr [RSI + 0x8]
POP RBP
LAB_001a5ac9:
ADD EAX,0xffffff00
MOV dword ptr [RSI + 0x8],EAX
XOR EAX,EAX
RET
|
int8 harvest_pins(ulong param_1,long *param_2)
{
long lVar1;
long *plVar2;
int iVar3;
ulong uVar4;
int iVar5;
long lVar6;
iVar3 = (int)param_2[1];
iVar5 = 0x100;
if (iVar3 < 0x100) {
iVar5 = iVar3;
}
if (0 < iVar3) {
uVar4 = (long)iVar5 * 0x78 + param_1;
do {
lVar6 = 0;
do {
lVar1 = *(long *)(param_1 + lVar6 * 8);
if (lVar1 != 0) {
plVar2 = (long *)*param_2;
*param_2 = (long)(plVar2 + 1);
*plVar2 = lVar1;
}
lVar6 = lVar6 + 1;
} while (lVar6 != 4);
param_1 = param_1 + 0x78;
} while (param_1 < uVar4);
iVar3 = (int)param_2[1];
}
*(int *)(param_2 + 1) = iVar3 + -0x100;
return 0;
}
|
|
5,864 | ggml_acc_impl | ngxson[P]ggml-easy/ggml/src/ggml.c | static struct ggml_tensor * ggml_acc_impl(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b,
size_t nb1,
size_t nb2,
size_t nb3,
size_t offset,
bool inplace) {
GGML_ASSERT(ggml_nelements(b) <= ggml_nelements(a));
GGML_ASSERT(ggml_is_contiguous(a));
GGML_ASSERT(a->type == GGML_TYPE_F32);
GGML_ASSERT(b->type == GGML_TYPE_F32);
struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);
int32_t params[] = { nb1, nb2, nb3, offset, inplace ? 1 : 0 };
ggml_set_op_params(result, params, sizeof(params));
result->op = GGML_OP_ACC;
result->src[0] = a;
result->src[1] = b;
return result;
} | O0 | c | ggml_acc_impl:
subq $0x68, %rsp
movb 0x78(%rsp), %al
movq 0x70(%rsp), %r10
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
andb $0x1, %al
movb %al, 0x37(%rsp)
movq 0x50(%rsp), %rdi
callq 0x43dc0
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rdi
callq 0x43dc0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jle 0x4b1c8
leaq 0x69409(%rip), %rdi # 0xb45b7
movl $0x7a9, %esi # imm = 0x7A9
leaq 0x69448(%rip), %rdx # 0xb4602
leaq 0x6b702(%rip), %rcx # 0xb68c3
movb $0x0, %al
callq 0x46780
movq 0x58(%rsp), %rdi
callq 0x40fb0
testb $0x1, %al
jne 0x4b1f7
leaq 0x693da(%rip), %rdi # 0xb45b7
movl $0x7aa, %esi # imm = 0x7AA
leaq 0x69419(%rip), %rdx # 0xb4602
leaq 0x69744(%rip), %rcx # 0xb4934
movb $0x0, %al
callq 0x46780
movq 0x58(%rsp), %rax
cmpl $0x0, (%rax)
je 0x4b222
leaq 0x693af(%rip), %rdi # 0xb45b7
movl $0x7ab, %esi # imm = 0x7AB
leaq 0x693ee(%rip), %rdx # 0xb4602
leaq 0x69b5a(%rip), %rcx # 0xb4d75
movb $0x0, %al
callq 0x46780
movq 0x50(%rsp), %rax
cmpl $0x0, (%rax)
je 0x4b24d
leaq 0x69384(%rip), %rdi # 0xb45b7
movl $0x7ac, %esi # imm = 0x7AC
leaq 0x693c3(%rip), %rdx # 0xb4602
leaq 0x6b6a4(%rip), %rcx # 0xb68ea
movb $0x0, %al
callq 0x46780
testb $0x1, 0x37(%rsp)
je 0x4b269
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x408f0
movq %rax, (%rsp)
jmp 0x4b27c
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x43c20
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rax
movl %eax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movl %eax, 0x14(%rsp)
movq 0x38(%rsp), %rax
movl %eax, 0x18(%rsp)
movq 0x70(%rsp), %rax
movl %eax, 0x1c(%rsp)
movb 0x37(%rsp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x14, %edx
callq 0x4c4d0
movq 0x28(%rsp), %rax
movl $0x4, 0x50(%rax)
movq 0x58(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x98(%rax)
movq 0x50(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0xa0(%rax)
movq 0x28(%rsp), %rax
addq $0x68, %rsp
retq
nopw (%rax,%rax)
| ggml_acc_impl:
sub rsp, 68h
mov al, [rsp+68h+arg_8]
mov r10, [rsp+68h+arg_0]
mov [rsp+68h+var_8], rdi
mov [rsp+68h+var_10], rsi
mov [rsp+68h+var_18], rdx
mov [rsp+68h+var_20], rcx
mov [rsp+68h+var_28], r8
mov [rsp+68h+var_30], r9
and al, 1
mov [rsp+68h+var_31], al
mov rdi, [rsp+68h+var_18]
call _ggml_nelements
mov [rsp+68h+var_60], rax
mov rdi, [rsp+68h+var_10]
call _ggml_nelements
mov rcx, rax
mov rax, [rsp+68h+var_60]
cmp rax, rcx
jle short loc_4B1C8
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov esi, 7A9h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlNelementsB; "ggml_nelements(b) <= ggml_nelements(a)"
mov al, 0
call _ggml_abort
loc_4B1C8:
mov rdi, [rsp+68h+var_10]
call _ggml_is_contiguous
test al, 1
jnz short loc_4B1F7
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov esi, 7AAh
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlIsContiguo_4; "ggml_is_contiguous(a)"
mov al, 0
call _ggml_abort
loc_4B1F7:
mov rax, [rsp+68h+var_10]
cmp dword ptr [rax], 0
jz short loc_4B222
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov esi, 7ABh
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aATypeGgmlTypeF; "a->type == GGML_TYPE_F32"
mov al, 0
call _ggml_abort
loc_4B222:
mov rax, [rsp+68h+var_18]
cmp dword ptr [rax], 0
jz short loc_4B24D
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov esi, 7ACh
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aBTypeGgmlTypeF; "b->type == GGML_TYPE_F32"
mov al, 0
call _ggml_abort
loc_4B24D:
test [rsp+68h+var_31], 1
jz short loc_4B269
mov rdi, [rsp+68h+var_8]
mov rsi, [rsp+68h+var_10]
call _ggml_view_tensor
mov [rsp+68h+var_68], rax
jmp short loc_4B27C
loc_4B269:
mov rdi, [rsp+68h+var_8]
mov rsi, [rsp+68h+var_10]
call _ggml_dup_tensor
mov [rsp+68h+var_68], rax
loc_4B27C:
mov rax, [rsp+68h+var_68]
mov [rsp+68h+var_40], rax
mov rax, [rsp+68h+var_20]
mov [rsp+68h+var_58], eax
mov rax, [rsp+68h+var_28]
mov [rsp+68h+var_54], eax
mov rax, [rsp+68h+var_30]
mov [rsp+68h+var_50], eax
mov rax, [rsp+68h+arg_0]
mov [rsp+68h+var_4C], eax
mov dl, [rsp+68h+var_31]
xor eax, eax
mov ecx, 1
test dl, 1
cmovnz eax, ecx
mov [rsp+68h+var_48], eax
mov rdi, [rsp+68h+var_40]
lea rsi, [rsp+68h+var_58]
mov edx, 14h
call ggml_set_op_params
mov rax, [rsp+68h+var_40]
mov dword ptr [rax+50h], 4
mov rcx, [rsp+68h+var_10]
mov rax, [rsp+68h+var_40]
mov [rax+98h], rcx
mov rcx, [rsp+68h+var_18]
mov rax, [rsp+68h+var_40]
mov [rax+0A0h], rcx
mov rax, [rsp+68h+var_40]
add rsp, 68h
retn
| long long ggml_acc_impl(
long long a1,
unsigned int *a2,
_QWORD *a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14,
long long a15,
char a16)
{
double v16; // xmm4_8
double v17; // xmm5_8
long long v19; // [rsp+0h] [rbp-68h]
long long v20; // [rsp+8h] [rbp-60h]
_DWORD v21[6]; // [rsp+10h] [rbp-58h] BYREF
long long v22; // [rsp+28h] [rbp-40h]
char v23; // [rsp+37h] [rbp-31h]
long long v24; // [rsp+38h] [rbp-30h]
long long v25; // [rsp+40h] [rbp-28h]
long long v26; // [rsp+48h] [rbp-20h]
_DWORD *v27; // [rsp+50h] [rbp-18h]
unsigned int *v28; // [rsp+58h] [rbp-10h]
long long v29; // [rsp+60h] [rbp-8h]
v29 = a1;
v28 = a2;
v27 = a3;
v26 = a4;
v25 = a5;
v24 = a6;
v23 = a16 & 1;
v20 = ggml_nelements(a3);
if ( v20 > ggml_nelements(a2) )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c",
1961,
(long long)"GGML_ASSERT(%s) failed",
"ggml_nelements(b) <= ggml_nelements(a)");
if ( (ggml_is_contiguous((long long)v28) & 1) == 0 )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c",
1962,
(long long)"GGML_ASSERT(%s) failed",
"ggml_is_contiguous(a)");
if ( *v28 )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c",
1963,
(long long)"GGML_ASSERT(%s) failed",
"a->type == GGML_TYPE_F32");
if ( *v27 )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c",
1964,
(long long)"GGML_ASSERT(%s) failed",
"b->type == GGML_TYPE_F32");
if ( (v23 & 1) != 0 )
v19 = (long long)ggml_view_tensor(v29, (long long)v28, a7, a8, a9, a10, v16, v17, a13, a14);
else
v19 = ggml_dup_tensor(v29, v28);
v22 = v19;
v21[0] = v26;
v21[1] = v25;
v21[2] = v24;
v21[3] = a15;
v21[4] = (v23 & 1) != 0;
ggml_set_op_params(v19, v21, 20LL);
*(_DWORD *)(v22 + 80) = 4;
*(_QWORD *)(v22 + 152) = v28;
*(_QWORD *)(v22 + 160) = v27;
return v22;
}
| ggml_acc_impl:
SUB RSP,0x68
MOV AL,byte ptr [RSP + 0x78]
MOV R10,qword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0x60],RDI
MOV qword ptr [RSP + 0x58],RSI
MOV qword ptr [RSP + 0x50],RDX
MOV qword ptr [RSP + 0x48],RCX
MOV qword ptr [RSP + 0x40],R8
MOV qword ptr [RSP + 0x38],R9
AND AL,0x1
MOV byte ptr [RSP + 0x37],AL
MOV RDI,qword ptr [RSP + 0x50]
CALL 0x00143dc0
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x00143dc0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
CMP RAX,RCX
JLE 0x0014b1c8
LEA RDI,[0x1b45b7]
MOV ESI,0x7a9
LEA RDX,[0x1b4602]
LEA RCX,[0x1b68c3]
MOV AL,0x0
CALL 0x00146780
LAB_0014b1c8:
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x00140fb0
TEST AL,0x1
JNZ 0x0014b1f7
LEA RDI,[0x1b45b7]
MOV ESI,0x7aa
LEA RDX,[0x1b4602]
LEA RCX,[0x1b4934]
MOV AL,0x0
CALL 0x00146780
LAB_0014b1f7:
MOV RAX,qword ptr [RSP + 0x58]
CMP dword ptr [RAX],0x0
JZ 0x0014b222
LEA RDI,[0x1b45b7]
MOV ESI,0x7ab
LEA RDX,[0x1b4602]
LEA RCX,[0x1b4d75]
MOV AL,0x0
CALL 0x00146780
LAB_0014b222:
MOV RAX,qword ptr [RSP + 0x50]
CMP dword ptr [RAX],0x0
JZ 0x0014b24d
LEA RDI,[0x1b45b7]
MOV ESI,0x7ac
LEA RDX,[0x1b4602]
LEA RCX,[0x1b68ea]
MOV AL,0x0
CALL 0x00146780
LAB_0014b24d:
TEST byte ptr [RSP + 0x37],0x1
JZ 0x0014b269
MOV RDI,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RSP + 0x58]
CALL 0x001408f0
MOV qword ptr [RSP],RAX
JMP 0x0014b27c
LAB_0014b269:
MOV RDI,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RSP + 0x58]
CALL 0x00143c20
MOV qword ptr [RSP],RAX
LAB_0014b27c:
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x28],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV dword ptr [RSP + 0x10],EAX
MOV RAX,qword ptr [RSP + 0x40]
MOV dword ptr [RSP + 0x14],EAX
MOV RAX,qword ptr [RSP + 0x38]
MOV dword ptr [RSP + 0x18],EAX
MOV RAX,qword ptr [RSP + 0x70]
MOV dword ptr [RSP + 0x1c],EAX
MOV DL,byte ptr [RSP + 0x37]
XOR EAX,EAX
MOV ECX,0x1
TEST DL,0x1
CMOVNZ EAX,ECX
MOV dword ptr [RSP + 0x20],EAX
MOV RDI,qword ptr [RSP + 0x28]
LEA RSI,[RSP + 0x10]
MOV EDX,0x14
CALL 0x0014c4d0
MOV RAX,qword ptr [RSP + 0x28]
MOV dword ptr [RAX + 0x50],0x4
MOV RCX,qword ptr [RSP + 0x58]
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RAX + 0x98],RCX
MOV RCX,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RAX + 0xa0],RCX
MOV RAX,qword ptr [RSP + 0x28]
ADD RSP,0x68
RET
|
long ggml_acc_impl(int8 param_1,int *param_2,int *param_3,int8 param_4,
int8 param_5,int8 param_6,int4 param_7,byte param_8)
{
long lVar1;
long lVar2;
ulong uVar3;
long local_68;
int4 local_58;
int4 local_54;
int4 local_50;
int4 local_4c;
uint local_48;
long local_40;
byte local_31;
int8 local_30;
int8 local_28;
int8 local_20;
int *local_18;
int *local_10;
int8 local_8;
local_31 = param_8 & 1;
local_30 = param_6;
local_28 = param_5;
local_20 = param_4;
local_18 = param_3;
local_10 = param_2;
local_8 = param_1;
lVar1 = ggml_nelements(param_3);
lVar2 = ggml_nelements(local_10);
if (lVar2 < lVar1) {
ggml_abort("/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c",0x7a9,
"GGML_ASSERT(%s) failed","ggml_nelements(b) <= ggml_nelements(a)");
}
uVar3 = ggml_is_contiguous(local_10);
if ((uVar3 & 1) == 0) {
ggml_abort("/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c",0x7aa,
"GGML_ASSERT(%s) failed","ggml_is_contiguous(a)");
}
if (*local_10 != 0) {
ggml_abort("/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c",0x7ab,
"GGML_ASSERT(%s) failed","a->type == GGML_TYPE_F32");
}
if (*local_18 != 0) {
ggml_abort("/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c",0x7ac,
"GGML_ASSERT(%s) failed","b->type == GGML_TYPE_F32");
}
if ((local_31 & 1) == 0) {
local_68 = ggml_dup_tensor(local_8,local_10);
}
else {
local_68 = ggml_view_tensor(local_8,local_10);
}
local_40 = local_68;
local_58 = (int4)local_20;
local_54 = (int4)local_28;
local_50 = (int4)local_30;
local_4c = param_7;
local_48 = (uint)((local_31 & 1) != 0);
ggml_set_op_params(local_68,&local_58,0x14);
*(int4 *)(local_40 + 0x50) = 4;
*(int **)(local_40 + 0x98) = local_10;
*(int **)(local_40 + 0xa0) = local_18;
return local_40;
}
|
|
5,865 | ggml_acc_impl | ngxson[P]ggml-easy/ggml/src/ggml.c | static struct ggml_tensor * ggml_acc_impl(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b,
size_t nb1,
size_t nb2,
size_t nb3,
size_t offset,
bool inplace) {
GGML_ASSERT(ggml_nelements(b) <= ggml_nelements(a));
GGML_ASSERT(ggml_is_contiguous(a));
GGML_ASSERT(a->type == GGML_TYPE_F32);
GGML_ASSERT(b->type == GGML_TYPE_F32);
struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);
int32_t params[] = { nb1, nb2, nb3, offset, inplace ? 1 : 0 };
ggml_set_op_params(result, params, sizeof(params));
result->op = GGML_OP_ACC;
result->src[0] = a;
result->src[1] = b;
return result;
} | O1 | c | ggml_acc_impl:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq 0x18(%rdx), %rax
imulq 0x10(%rdx), %rax
imulq 0x20(%rdx), %rax
imulq 0x28(%rdx), %rax
movq 0x18(%rsi), %rcx
imulq 0x10(%rsi), %rcx
imulq 0x20(%rsi), %rcx
imulq 0x28(%rsi), %rcx
cmpq %rcx, %rax
jg 0x1a6ba
movq %r9, %r14
movq %r8, %r15
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %rbp
movq %rsi, %rdi
xorl %esi, %esi
callq 0x197ef
testb %al, %al
je 0x1a6d6
movl (%r13), %esi
testl %esi, %esi
jne 0x1a6f2
cmpl $0x0, (%rbx)
jne 0x1a70e
cmpb $0x0, 0x48(%rsp)
je 0x1a65a
movq %rbp, %rdi
movq %r13, %rsi
callq 0x16260
jmp 0x1a671
leaq 0x10(%r13), %rcx
movq %rbp, %rdi
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x19cd9
testq %rax, %rax
je 0x1a72a
movq 0x40(%rsp), %rcx
movzbl 0x48(%rsp), %edx
movl %r12d, 0x54(%rax)
movl %r15d, 0x58(%rax)
movl %r14d, 0x5c(%rax)
movl %ecx, 0x60(%rax)
movl %edx, 0x64(%rax)
movl $0x4, 0x50(%rax)
movq %r13, 0x98(%rax)
movq %rbx, 0xa0(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2ff4e(%rip), %rdi # 0x4a60f
leaq 0x2ff92(%rip), %rdx # 0x4a65a
leaq 0x320c9(%rip), %rcx # 0x4c798
movl $0x7a9, %esi # imm = 0x7A9
jmp 0x1a744
leaq 0x2ff32(%rip), %rdi # 0x4a60f
leaq 0x2ff76(%rip), %rdx # 0x4a65a
leaq 0x302a1(%rip), %rcx # 0x4a98c
movl $0x7aa, %esi # imm = 0x7AA
jmp 0x1a744
leaq 0x2ff16(%rip), %rdi # 0x4a60f
leaq 0x2ff5a(%rip), %rdx # 0x4a65a
leaq 0x30687(%rip), %rcx # 0x4ad8e
movl $0x7ab, %esi # imm = 0x7AB
jmp 0x1a744
leaq 0x2fefa(%rip), %rdi # 0x4a60f
leaq 0x2ff3e(%rip), %rdx # 0x4a65a
leaq 0x3209c(%rip), %rcx # 0x4c7bf
movl $0x7ac, %esi # imm = 0x7AC
jmp 0x1a744
leaq 0x320a7(%rip), %rdi # 0x4c7d8
leaq 0x2ff22(%rip), %rdx # 0x4a65a
leaq 0x320e9(%rip), %rcx # 0x4c828
movl $0x70, %esi
xorl %eax, %eax
callq 0x17c70
| ggml_acc_impl:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r12, rcx
mov rax, [rdx+18h]
imul rax, [rdx+10h]
imul rax, [rdx+20h]
imul rax, [rdx+28h]
mov rcx, [rsi+18h]
imul rcx, [rsi+10h]
imul rcx, [rsi+20h]
imul rcx, [rsi+28h]
cmp rax, rcx
jg loc_1A6BA
mov r14, r9
mov r15, r8
mov rbx, rdx
mov r13, rsi
mov rbp, rdi
mov rdi, rsi
xor esi, esi
call ggml_is_contiguous_n
test al, al
jz loc_1A6D6
mov esi, [r13+0]
test esi, esi
jnz loc_1A6F2
cmp dword ptr [rbx], 0
jnz loc_1A70E
cmp [rsp+38h+arg_8], 0
jz short loc_1A65A
mov rdi, rbp
mov rsi, r13
call _ggml_view_tensor
jmp short loc_1A671
loc_1A65A:
lea rcx, [r13+10h]
mov rdi, rbp
mov edx, 4
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
loc_1A671:
test rax, rax
jz loc_1A72A
mov rcx, [rsp+38h+arg_0]
movzx edx, [rsp+38h+arg_8]
mov [rax+54h], r12d
mov [rax+58h], r15d
mov [rax+5Ch], r14d
mov [rax+60h], ecx
mov [rax+64h], edx
mov dword ptr [rax+50h], 4
mov [rax+98h], r13
mov [rax+0A0h], rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1A6BA:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlNelementsB; "ggml_nelements(b) <= ggml_nelements(a)"
mov esi, 7A9h
jmp short loc_1A744
loc_1A6D6:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlIsContiguo_4; "ggml_is_contiguous(a)"
mov esi, 7AAh
jmp short loc_1A744
loc_1A6F2:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aATypeGgmlTypeF; "a->type == GGML_TYPE_F32"
mov esi, 7ABh
jmp short loc_1A744
loc_1A70E:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aBTypeGgmlTypeF; "b->type == GGML_TYPE_F32"
mov esi, 7ACh
jmp short loc_1A744
loc_1A72A:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aTensorNull; "tensor != NULL"
mov esi, 70h ; 'p'
loc_1A744:
xor eax, eax
call _ggml_abort
| long long ggml_acc_impl(
long long a1,
long long a2,
long long a3,
int a4,
int a5,
int a6,
long long a7,
unsigned __int8 a8)
{
long long result; // rax
const char *v13; // rdi
const char *v14; // rcx
int v15; // esi
if ( *(_QWORD *)(a3 + 40) * *(_QWORD *)(a3 + 32) * *(_QWORD *)(a3 + 16) * *(_QWORD *)(a3 + 24) > *(_QWORD *)(a2 + 40)
* *(_QWORD *)(a2 + 32)
* *(_QWORD *)(a2 + 16)
* *(_QWORD *)(a2 + 24) )
{
v13 = "/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c";
v14 = "ggml_nelements(b) <= ggml_nelements(a)";
v15 = 1961;
goto LABEL_15;
}
if ( !(unsigned __int8)ggml_is_contiguous_n((unsigned int *)a2, 0) )
{
v13 = "/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c";
v14 = "ggml_is_contiguous(a)";
v15 = 1962;
goto LABEL_15;
}
if ( *(_DWORD *)a2 )
{
v13 = "/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c";
v14 = "a->type == GGML_TYPE_F32";
v15 = 1963;
goto LABEL_15;
}
if ( *(_DWORD *)a3 )
{
v13 = "/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c";
v14 = "b->type == GGML_TYPE_F32";
v15 = 1964;
goto LABEL_15;
}
if ( a8 )
result = ggml_view_tensor(a1, a2);
else
result = ggml_new_tensor_impl(a1, 0, 4, (_QWORD *)(a2 + 16), 0LL, 0LL);
if ( !result )
{
v13 = "/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml-impl.h";
v14 = "tensor != NULL";
v15 = 112;
LABEL_15:
ggml_abort((_DWORD)v13, v15, (unsigned int)"GGML_ASSERT(%s) failed", (_DWORD)v14, a5, a6);
}
*(_DWORD *)(result + 84) = a4;
*(_DWORD *)(result + 88) = a5;
*(_DWORD *)(result + 92) = a6;
*(_DWORD *)(result + 96) = a7;
*(_DWORD *)(result + 100) = a8;
*(_DWORD *)(result + 80) = 4;
*(_QWORD *)(result + 152) = a2;
*(_QWORD *)(result + 160) = a3;
return result;
}
| ggml_acc_impl:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R12,RCX
MOV RAX,qword ptr [RDX + 0x18]
IMUL RAX,qword ptr [RDX + 0x10]
IMUL RAX,qword ptr [RDX + 0x20]
IMUL RAX,qword ptr [RDX + 0x28]
MOV RCX,qword ptr [RSI + 0x18]
IMUL RCX,qword ptr [RSI + 0x10]
IMUL RCX,qword ptr [RSI + 0x20]
IMUL RCX,qword ptr [RSI + 0x28]
CMP RAX,RCX
JG 0x0011a6ba
MOV R14,R9
MOV R15,R8
MOV RBX,RDX
MOV R13,RSI
MOV RBP,RDI
MOV RDI,RSI
XOR ESI,ESI
CALL 0x001197ef
TEST AL,AL
JZ 0x0011a6d6
MOV ESI,dword ptr [R13]
TEST ESI,ESI
JNZ 0x0011a6f2
CMP dword ptr [RBX],0x0
JNZ 0x0011a70e
CMP byte ptr [RSP + 0x48],0x0
JZ 0x0011a65a
MOV RDI,RBP
MOV RSI,R13
CALL 0x00116260
JMP 0x0011a671
LAB_0011a65a:
LEA RCX,[R13 + 0x10]
MOV RDI,RBP
MOV EDX,0x4
XOR R8D,R8D
XOR R9D,R9D
CALL 0x00119cd9
LAB_0011a671:
TEST RAX,RAX
JZ 0x0011a72a
MOV RCX,qword ptr [RSP + 0x40]
MOVZX EDX,byte ptr [RSP + 0x48]
MOV dword ptr [RAX + 0x54],R12D
MOV dword ptr [RAX + 0x58],R15D
MOV dword ptr [RAX + 0x5c],R14D
MOV dword ptr [RAX + 0x60],ECX
MOV dword ptr [RAX + 0x64],EDX
MOV dword ptr [RAX + 0x50],0x4
MOV qword ptr [RAX + 0x98],R13
MOV qword ptr [RAX + 0xa0],RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0011a6ba:
LEA RDI,[0x14a60f]
LEA RDX,[0x14a65a]
LEA RCX,[0x14c798]
MOV ESI,0x7a9
JMP 0x0011a744
LAB_0011a6d6:
LEA RDI,[0x14a60f]
LEA RDX,[0x14a65a]
LEA RCX,[0x14a98c]
MOV ESI,0x7aa
JMP 0x0011a744
LAB_0011a6f2:
LEA RDI,[0x14a60f]
LEA RDX,[0x14a65a]
LEA RCX,[0x14ad8e]
MOV ESI,0x7ab
JMP 0x0011a744
LAB_0011a70e:
LEA RDI,[0x14a60f]
LEA RDX,[0x14a65a]
LEA RCX,[0x14c7bf]
MOV ESI,0x7ac
JMP 0x0011a744
LAB_0011a72a:
LEA RDI,[0x14c7d8]
LEA RDX,[0x14a65a]
LEA RCX,[0x14c828]
MOV ESI,0x70
LAB_0011a744:
XOR EAX,EAX
CALL 0x00117c70
|
void ggml_acc_impl(int8 param_1,int *param_2,int *param_3,int4 param_4,
int4 param_5,int4 param_6,int4 param_7,byte param_8)
{
char cVar1;
long lVar2;
long lVar3;
char *pcVar4;
int8 uVar5;
char *pcVar6;
lVar2 = *(long *)(param_3 + 6) * *(long *)(param_3 + 4) * *(long *)(param_3 + 8) *
*(long *)(param_3 + 10);
lVar3 = *(long *)(param_2 + 6) * *(long *)(param_2 + 4) * *(long *)(param_2 + 8) *
*(long *)(param_2 + 10);
if (lVar2 - lVar3 == 0 || lVar2 < lVar3) {
cVar1 = ggml_is_contiguous_n(param_2,0);
if (cVar1 == '\0') {
pcVar6 = "/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c";
pcVar4 = "ggml_is_contiguous(a)";
uVar5 = 0x7aa;
}
else if (*param_2 == 0) {
if (*param_3 == 0) {
if (param_8 == 0) {
lVar2 = ggml_new_tensor_impl(param_1,0,4,param_2 + 4,0,0);
}
else {
lVar2 = ggml_view_tensor(param_1,param_2);
}
if (lVar2 != 0) {
*(int4 *)(lVar2 + 0x54) = param_4;
*(int4 *)(lVar2 + 0x58) = param_5;
*(int4 *)(lVar2 + 0x5c) = param_6;
*(int4 *)(lVar2 + 0x60) = param_7;
*(uint *)(lVar2 + 100) = (uint)param_8;
*(int4 *)(lVar2 + 0x50) = 4;
*(int **)(lVar2 + 0x98) = param_2;
*(int **)(lVar2 + 0xa0) = param_3;
return;
}
pcVar6 = "/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml-impl.h";
pcVar4 = "tensor != NULL";
uVar5 = 0x70;
}
else {
pcVar6 = "/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c";
pcVar4 = "b->type == GGML_TYPE_F32";
uVar5 = 0x7ac;
}
}
else {
pcVar6 = "/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c";
pcVar4 = "a->type == GGML_TYPE_F32";
uVar5 = 0x7ab;
}
}
else {
pcVar6 = "/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c";
pcVar4 = "ggml_nelements(b) <= ggml_nelements(a)";
uVar5 = 0x7a9;
}
/* WARNING: Subroutine does not return */
ggml_abort(pcVar6,uVar5,"GGML_ASSERT(%s) failed",pcVar4);
}
|
|
5,866 | my_rw_tryrdlock | eloqsql/mysys/thr_rwlock.c | int my_rw_tryrdlock(my_rw_lock_t *rwp)
{
int res;
pthread_mutex_lock(&rwp->lock);
if ((rwp->state < 0 ) || rwp->waiters)
res= EBUSY; /* Can't get lock */
else
{
res=0;
rwp->state++;
}
pthread_mutex_unlock(&rwp->lock);
return(res);
} | O3 | c | my_rw_tryrdlock:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x2a220
movl 0x88(%rbx), %eax
movl $0x10, %r14d
testl %eax, %eax
js 0xaaa69
cmpl $0x0, 0x8c(%rbx)
jne 0xaaa69
incl %eax
movl %eax, 0x88(%rbx)
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x2a1e0
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
| my_rw_tryrdlock:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
call _pthread_mutex_lock
mov eax, [rbx+88h]
mov r14d, 10h
test eax, eax
js short loc_AAA69
cmp dword ptr [rbx+8Ch], 0
jnz short loc_AAA69
inc eax
mov [rbx+88h], eax
xor r14d, r14d
loc_AAA69:
mov rdi, rbx
call _pthread_mutex_unlock
mov eax, r14d
pop rbx
pop r14
pop rbp
retn
| long long my_rw_tryrdlock(long long a1)
{
int v1; // eax
unsigned int v2; // r14d
pthread_mutex_lock(a1);
v1 = *(_DWORD *)(a1 + 136);
v2 = 16;
if ( v1 >= 0 && !*(_DWORD *)(a1 + 140) )
{
*(_DWORD *)(a1 + 136) = v1 + 1;
v2 = 0;
}
pthread_mutex_unlock(a1);
return v2;
}
| my_rw_tryrdlock:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
CALL 0x0012a220
MOV EAX,dword ptr [RBX + 0x88]
MOV R14D,0x10
TEST EAX,EAX
JS 0x001aaa69
CMP dword ptr [RBX + 0x8c],0x0
JNZ 0x001aaa69
INC EAX
MOV dword ptr [RBX + 0x88],EAX
XOR R14D,R14D
LAB_001aaa69:
MOV RDI,RBX
CALL 0x0012a1e0
MOV EAX,R14D
POP RBX
POP R14
POP RBP
RET
|
int8 my_rw_tryrdlock(pthread_mutex_t *param_1)
{
int8 uVar1;
pthread_mutex_lock(param_1);
uVar1 = 0x10;
if ((-1 < *(int *)((long)param_1 + 0x88)) && (*(int *)((long)param_1 + 0x8c) == 0)) {
*(int *)((long)param_1 + 0x88) = *(int *)((long)param_1 + 0x88) + 1;
uVar1 = 0;
}
pthread_mutex_unlock(param_1);
return uVar1;
}
|
|
5,867 | my_open_parent_dir_nosymlinks | eloqsql/mysys/my_symlink.c | const char *my_open_parent_dir_nosymlinks(const char *pathname, int *pdfd)
{
char buf[FN_REFLEN + 1];
char *s= buf, *e= buf+1, *end= strnmov(buf, pathname, sizeof(buf));
int fd, dfd= -1;
if (*end)
{
errno= ENAMETOOLONG;
return NULL;
}
if (*s != '/') /* not an absolute path */
{
errno= ENOENT;
return NULL;
}
for (;;)
{
if (*e == '/') /* '//' in the path */
{
errno= ENOENT;
goto err;
}
while (*e && *e != '/')
e++;
*e= 0;
if (!memcmp(s, ".", 2) || !memcmp(s, "..", 3))
{
errno= ENOENT;
goto err;
}
if (++e >= end)
{
*pdfd= dfd;
return pathname + (s - buf);
}
fd = openat(dfd, s, O_NOFOLLOW | O_PATH | O_CLOEXEC);
if (fd < 0)
goto err;
if (dfd >= 0)
close(dfd);
dfd= fd;
s= e;
}
err:
if (dfd >= 0)
close(dfd);
return NULL;
} | O0 | c | my_open_parent_dir_nosymlinks:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp # imm = 0x260
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x220(%rbp)
movq %rsi, -0x228(%rbp)
leaq -0x210(%rbp), %rax
movq %rax, -0x230(%rbp)
leaq -0x210(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x238(%rbp)
leaq -0x210(%rbp), %rdi
movq -0x220(%rbp), %rsi
movl $0x201, %edx # imm = 0x201
callq 0x159f50
movq %rax, -0x240(%rbp)
movl $0xffffffff, -0x248(%rbp) # imm = 0xFFFFFFFF
movq -0x240(%rbp), %rax
cmpb $0x0, (%rax)
je 0xfdbe6
callq 0x2a750
movl $0x24, (%rax)
movq $0x0, -0x218(%rbp)
jmp 0xfdd9a
movq -0x230(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0xfdc10
callq 0x2a750
movl $0x2, (%rax)
movq $0x0, -0x218(%rbp)
jmp 0xfdd9a
jmp 0xfdc12
movq -0x238(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0xfdc31
callq 0x2a750
movl $0x2, (%rax)
jmp 0xfdd7b
jmp 0xfdc33
movq -0x238(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x249(%rbp)
je 0xfdc60
movq -0x238(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
setne %al
movb %al, -0x249(%rbp)
movb -0x249(%rbp), %al
testb $0x1, %al
jne 0xfdc6c
jmp 0xfdc80
movq -0x238(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x238(%rbp)
jmp 0xfdc33
movq -0x238(%rbp), %rax
movb $0x0, (%rax)
movq -0x230(%rbp), %rax
movw (%rax), %ax
subw $0x2e, %ax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0xfdcc0
movq -0x230(%rbp), %rdi
leaq 0x61c58(%rip), %rsi # 0x15f909
movl $0x3, %edx
callq 0x2a840
cmpl $0x0, %eax
jne 0xfdcd0
callq 0x2a750
movl $0x2, (%rax)
jmp 0xfdd7b
movq -0x238(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x238(%rbp)
cmpq -0x240(%rbp), %rax
jb 0xfdd1e
movl -0x248(%rbp), %ecx
movq -0x228(%rbp), %rax
movl %ecx, (%rax)
movq -0x220(%rbp), %rax
movq -0x230(%rbp), %rcx
leaq -0x210(%rbp), %rdx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x218(%rbp)
jmp 0xfdd9a
movl -0x248(%rbp), %edi
movq -0x230(%rbp), %rsi
movl $0x2a0000, %edx # imm = 0x2A0000
movb $0x0, %al
callq 0x2a530
movl %eax, -0x244(%rbp)
cmpl $0x0, -0x244(%rbp)
jge 0xfdd48
jmp 0xfdd7b
cmpl $0x0, -0x248(%rbp)
jl 0xfdd5c
movl -0x248(%rbp), %edi
callq 0x2a1b0
movl -0x244(%rbp), %eax
movl %eax, -0x248(%rbp)
movq -0x238(%rbp), %rax
movq %rax, -0x230(%rbp)
jmp 0xfdc12
cmpl $0x0, -0x248(%rbp)
jl 0xfdd8f
movl -0x248(%rbp), %edi
callq 0x2a1b0
movq $0x0, -0x218(%rbp)
movq -0x218(%rbp), %rax
movq %rax, -0x258(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xfddca
movq -0x258(%rbp), %rax
addq $0x260, %rsp # imm = 0x260
popq %rbp
retq
callq 0x2a250
nop
| my_open_parent_dir_nosymlinks:
push rbp
mov rbp, rsp
sub rsp, 260h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_220], rdi
mov [rbp+var_228], rsi
lea rax, [rbp+var_210]
mov [rbp+var_230], rax
lea rax, [rbp+var_210]
add rax, 1
mov [rbp+var_238], rax
lea rdi, [rbp+var_210]
mov rsi, [rbp+var_220]
mov edx, 201h
call strnmov
mov [rbp+var_240], rax
mov [rbp+var_248], 0FFFFFFFFh
mov rax, [rbp+var_240]
cmp byte ptr [rax], 0
jz short loc_FDBE6
call ___errno_location
mov dword ptr [rax], 24h ; '$'
mov [rbp+var_218], 0
jmp loc_FDD9A
loc_FDBE6:
mov rax, [rbp+var_230]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
jz short loc_FDC10
call ___errno_location
mov dword ptr [rax], 2
mov [rbp+var_218], 0
jmp loc_FDD9A
loc_FDC10:
jmp short $+2
loc_FDC12:
mov rax, [rbp+var_238]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
jnz short loc_FDC31
call ___errno_location
mov dword ptr [rax], 2
jmp loc_FDD7B
loc_FDC31:
jmp short $+2
loc_FDC33:
mov rax, [rbp+var_238]
movsx ecx, byte ptr [rax]
xor eax, eax
cmp ecx, 0
mov [rbp+var_249], al
jz short loc_FDC60
mov rax, [rbp+var_238]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
setnz al
mov [rbp+var_249], al
loc_FDC60:
mov al, [rbp+var_249]
test al, 1
jnz short loc_FDC6C
jmp short loc_FDC80
loc_FDC6C:
mov rax, [rbp+var_238]
add rax, 1
mov [rbp+var_238], rax
jmp short loc_FDC33
loc_FDC80:
mov rax, [rbp+var_238]
mov byte ptr [rax], 0
mov rax, [rbp+var_230]
mov ax, [rax]
sub ax, 2Eh ; '.'
setnz al
movzx eax, al
cmp eax, 0
jz short loc_FDCC0
mov rdi, [rbp+var_230]
lea rsi, asc_15F909; ".."
mov edx, 3
call _memcmp
cmp eax, 0
jnz short loc_FDCD0
loc_FDCC0:
call ___errno_location
mov dword ptr [rax], 2
jmp loc_FDD7B
loc_FDCD0:
mov rax, [rbp+var_238]
add rax, 1
mov [rbp+var_238], rax
cmp rax, [rbp+var_240]
jb short loc_FDD1E
mov ecx, [rbp+var_248]
mov rax, [rbp+var_228]
mov [rax], ecx
mov rax, [rbp+var_220]
mov rcx, [rbp+var_230]
lea rdx, [rbp+var_210]
sub rcx, rdx
add rax, rcx
mov [rbp+var_218], rax
jmp short loc_FDD9A
loc_FDD1E:
mov edi, [rbp+var_248]
mov rsi, [rbp+var_230]
mov edx, offset bigtens
mov al, 0
call _openat64
mov [rbp+var_244], eax
cmp [rbp+var_244], 0
jge short loc_FDD48
jmp short loc_FDD7B
loc_FDD48:
cmp [rbp+var_248], 0
jl short loc_FDD5C
mov edi, [rbp+var_248]
call _close
loc_FDD5C:
mov eax, [rbp+var_244]
mov [rbp+var_248], eax
mov rax, [rbp+var_238]
mov [rbp+var_230], rax
jmp loc_FDC12
loc_FDD7B:
cmp [rbp+var_248], 0
jl short loc_FDD8F
mov edi, [rbp+var_248]
call _close
loc_FDD8F:
mov [rbp+var_218], 0
loc_FDD9A:
mov rax, [rbp+var_218]
mov [rbp+var_258], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_FDDCA
mov rax, [rbp+var_258]
add rsp, 260h
pop rbp
retn
loc_FDDCA:
call ___stack_chk_fail
| long long my_open_parent_dir_nosymlinks(long long a1, int *a2)
{
long long v2; // rcx
bool v4; // [rsp+17h] [rbp-249h]
int v5; // [rsp+18h] [rbp-248h]
int v6; // [rsp+1Ch] [rbp-244h]
const char *v7; // [rsp+20h] [rbp-240h]
const char *v8; // [rsp+28h] [rbp-238h]
const char *v9; // [rsp+30h] [rbp-230h]
char v11; // [rsp+50h] [rbp-210h] BYREF
_BYTE v12[527]; // [rsp+51h] [rbp-20Fh] BYREF
*(_QWORD *)&v12[519] = __readfsqword(0x28u);
v9 = &v11;
v8 = v12;
v7 = (const char *)strnmov(&v11, a1, 513LL);
v5 = -1;
if ( *v7 )
{
*(_DWORD *)__errno_location() = 36;
return 0LL;
}
else if ( v11 == 47 )
{
while ( *v8 != 47 )
{
while ( 1 )
{
v2 = (unsigned int)*v8;
v4 = 0;
if ( *v8 )
v4 = *v8 != 47;
if ( !v4 )
break;
++v8;
}
*v8 = 0;
if ( *(_WORD *)v9 == 46 || !(unsigned int)strcmp(v9, "..") )
break;
if ( ++v8 >= v7 )
{
*a2 = v5;
return v9 - &v11 + a1;
}
v6 = openat64((unsigned int)v5, v9, &bigtens, v2);
if ( v6 < 0 )
goto LABEL_20;
if ( v5 >= 0 )
close((unsigned int)v5);
v5 = v6;
v9 = v8;
}
*(_DWORD *)__errno_location() = 2;
LABEL_20:
if ( v5 >= 0 )
close((unsigned int)v5);
return 0LL;
}
else
{
*(_DWORD *)__errno_location() = 2;
return 0LL;
}
}
| my_open_parent_dir_nosymlinks:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x260
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x220],RDI
MOV qword ptr [RBP + -0x228],RSI
LEA RAX,[RBP + -0x210]
MOV qword ptr [RBP + -0x230],RAX
LEA RAX,[RBP + -0x210]
ADD RAX,0x1
MOV qword ptr [RBP + -0x238],RAX
LEA RDI,[RBP + -0x210]
MOV RSI,qword ptr [RBP + -0x220]
MOV EDX,0x201
CALL 0x00259f50
MOV qword ptr [RBP + -0x240],RAX
MOV dword ptr [RBP + -0x248],0xffffffff
MOV RAX,qword ptr [RBP + -0x240]
CMP byte ptr [RAX],0x0
JZ 0x001fdbe6
CALL 0x0012a750
MOV dword ptr [RAX],0x24
MOV qword ptr [RBP + -0x218],0x0
JMP 0x001fdd9a
LAB_001fdbe6:
MOV RAX,qword ptr [RBP + -0x230]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
JZ 0x001fdc10
CALL 0x0012a750
MOV dword ptr [RAX],0x2
MOV qword ptr [RBP + -0x218],0x0
JMP 0x001fdd9a
LAB_001fdc10:
JMP 0x001fdc12
LAB_001fdc12:
MOV RAX,qword ptr [RBP + -0x238]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
JNZ 0x001fdc31
CALL 0x0012a750
MOV dword ptr [RAX],0x2
JMP 0x001fdd7b
LAB_001fdc31:
JMP 0x001fdc33
LAB_001fdc33:
MOV RAX,qword ptr [RBP + -0x238]
MOVSX ECX,byte ptr [RAX]
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0x249],AL
JZ 0x001fdc60
MOV RAX,qword ptr [RBP + -0x238]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
SETNZ AL
MOV byte ptr [RBP + -0x249],AL
LAB_001fdc60:
MOV AL,byte ptr [RBP + -0x249]
TEST AL,0x1
JNZ 0x001fdc6c
JMP 0x001fdc80
LAB_001fdc6c:
MOV RAX,qword ptr [RBP + -0x238]
ADD RAX,0x1
MOV qword ptr [RBP + -0x238],RAX
JMP 0x001fdc33
LAB_001fdc80:
MOV RAX,qword ptr [RBP + -0x238]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x230]
MOV AX,word ptr [RAX]
SUB AX,0x2e
SETNZ AL
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x001fdcc0
MOV RDI,qword ptr [RBP + -0x230]
LEA RSI,[0x25f909]
MOV EDX,0x3
CALL 0x0012a840
CMP EAX,0x0
JNZ 0x001fdcd0
LAB_001fdcc0:
CALL 0x0012a750
MOV dword ptr [RAX],0x2
JMP 0x001fdd7b
LAB_001fdcd0:
MOV RAX,qword ptr [RBP + -0x238]
ADD RAX,0x1
MOV qword ptr [RBP + -0x238],RAX
CMP RAX,qword ptr [RBP + -0x240]
JC 0x001fdd1e
MOV ECX,dword ptr [RBP + -0x248]
MOV RAX,qword ptr [RBP + -0x228]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x220]
MOV RCX,qword ptr [RBP + -0x230]
LEA RDX,[RBP + -0x210]
SUB RCX,RDX
ADD RAX,RCX
MOV qword ptr [RBP + -0x218],RAX
JMP 0x001fdd9a
LAB_001fdd1e:
MOV EDI,dword ptr [RBP + -0x248]
MOV RSI,qword ptr [RBP + -0x230]
MOV EDX,0x2a0000
MOV AL,0x0
CALL 0x0012a530
MOV dword ptr [RBP + -0x244],EAX
CMP dword ptr [RBP + -0x244],0x0
JGE 0x001fdd48
JMP 0x001fdd7b
LAB_001fdd48:
CMP dword ptr [RBP + -0x248],0x0
JL 0x001fdd5c
MOV EDI,dword ptr [RBP + -0x248]
CALL 0x0012a1b0
LAB_001fdd5c:
MOV EAX,dword ptr [RBP + -0x244]
MOV dword ptr [RBP + -0x248],EAX
MOV RAX,qword ptr [RBP + -0x238]
MOV qword ptr [RBP + -0x230],RAX
JMP 0x001fdc12
LAB_001fdd7b:
CMP dword ptr [RBP + -0x248],0x0
JL 0x001fdd8f
MOV EDI,dword ptr [RBP + -0x248]
CALL 0x0012a1b0
LAB_001fdd8f:
MOV qword ptr [RBP + -0x218],0x0
LAB_001fdd9a:
MOV RAX,qword ptr [RBP + -0x218]
MOV qword ptr [RBP + -0x258],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001fddca
MOV RAX,qword ptr [RBP + -0x258]
ADD RSP,0x260
POP RBP
RET
LAB_001fddca:
CALL 0x0012a250
|
long my_open_parent_dir_nosymlinks(long param_1,int *param_2)
{
int iVar1;
short *psVar2;
int *piVar3;
long in_FS_OFFSET;
bool bVar4;
int local_250;
short *local_240;
short *local_238;
long local_220;
int1 local_218 [520];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_238 = (short *)local_218;
local_240 = (short *)(local_218 + 1);
psVar2 = (short *)strnmov(local_218,param_1,0x201);
local_250 = -1;
if ((char)*psVar2 == '\0') {
iVar1 = local_250;
if (local_218[0] == '/') {
while (local_250 = iVar1, (char)*local_240 != '/') {
while( true ) {
bVar4 = false;
if ((char)*local_240 != '\0') {
bVar4 = (char)*local_240 != '/';
}
if (!bVar4) break;
local_240 = (short *)((long)local_240 + 1);
}
*(char *)local_240 = '\0';
if ((*local_238 == 0x2e) || (iVar1 = memcmp(local_238,&DAT_0025f909,3), iVar1 == 0)) {
piVar3 = __errno_location();
*piVar3 = 2;
goto LAB_001fdd7b;
}
local_240 = (short *)((long)local_240 + 1);
if (psVar2 <= local_240) {
*param_2 = local_250;
local_220 = (long)local_238 + (param_1 - (long)local_218);
goto LAB_001fdd9a;
}
iVar1 = openat64(local_250,(char *)local_238,0x2a0000);
if (iVar1 < 0) goto LAB_001fdd7b;
local_238 = local_240;
if (-1 < local_250) {
close(local_250);
}
}
piVar3 = __errno_location();
*piVar3 = 2;
LAB_001fdd7b:
if (-1 < local_250) {
close(local_250);
}
local_220 = 0;
}
else {
piVar3 = __errno_location();
*piVar3 = 2;
local_220 = 0;
}
}
else {
piVar3 = __errno_location();
*piVar3 = 0x24;
local_220 = 0;
}
LAB_001fdd9a:
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_220;
}
|
|
5,868 | my_open_parent_dir_nosymlinks | eloqsql/mysys/my_symlink.c | const char *my_open_parent_dir_nosymlinks(const char *pathname, int *pdfd)
{
char buf[FN_REFLEN + 1];
char *s= buf, *e= buf+1, *end= strnmov(buf, pathname, sizeof(buf));
int fd, dfd= -1;
if (*end)
{
errno= ENAMETOOLONG;
return NULL;
}
if (*s != '/') /* not an absolute path */
{
errno= ENOENT;
return NULL;
}
for (;;)
{
if (*e == '/') /* '//' in the path */
{
errno= ENOENT;
goto err;
}
while (*e && *e != '/')
e++;
*e= 0;
if (!memcmp(s, ".", 2) || !memcmp(s, "..", 3))
{
errno= ENOENT;
goto err;
}
if (++e >= end)
{
*pdfd= dfd;
return pathname + (s - buf);
}
fd = openat(dfd, s, O_NOFOLLOW | O_PATH | O_CLOEXEC);
if (fd < 0)
goto err;
if (dfd >= 0)
close(dfd);
dfd= fd;
s= e;
}
err:
if (dfd >= 0)
close(dfd);
return NULL;
} | O3 | c | my_open_parent_dir_nosymlinks:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
leaq -0x240(%rbp), %r15
movl $0x201, %edx # imm = 0x201
movq %r15, %rdi
movq %rbx, %rsi
callq 0xdfcb4
cmpb $0x0, (%rax)
je 0xa81f3
callq 0x2a7a0
movl $0x24, (%rax)
jmp 0xa82ca
cmpb $0x2f, -0x240(%rbp)
jne 0xa829f
movq %rax, %r12
movq %r14, -0x248(%rbp)
movb -0x23f(%rbp), %al
movl $0xffffffff, %r13d # imm = 0xFFFFFFFF
cmpb $0x2f, %al
je 0xa82af
leaq -0x23f(%rbp), %rcx
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
movq %r15, %rsi
incq %rcx
movq %rcx, %r15
testb %al, %al
je 0xa8248
movzbl %al, %eax
cmpl $0x2f, %eax
je 0xa8248
movb (%r15), %al
incq %r15
jmp 0xa8234
movb $0x0, -0x1(%r15)
cmpw $0x2e, (%rsi)
je 0xa82ac
movzwl (%rsi), %eax
xorl $0x2e2e, %eax # imm = 0x2E2E
movzbl 0x2(%rsi), %ecx
orw %ax, %cx
je 0xa82ac
cmpq %r12, %r15
jae 0xa82f0
movl %r14d, %edi
movl $0x2a0000, %edx # imm = 0x2A0000
xorl %eax, %eax
callq 0x2a570
testl %eax, %eax
js 0xa82bd
movl %eax, %r13d
testl %r14d, %r14d
js 0xa8290
movl %r14d, %edi
callq 0x2a190
movb (%r15), %al
movl %r13d, %r14d
movq %r15, %rcx
cmpb $0x2f, %al
jne 0xa822b
jmp 0xa82af
callq 0x2a7a0
movl $0x2, (%rax)
jmp 0xa82ca
movl %r14d, %r13d
callq 0x2a7a0
movl $0x2, (%rax)
movl %r13d, %r14d
testl %r14d, %r14d
js 0xa82ca
movl %r14d, %edi
callq 0x2a190
xorl %ebx, %ebx
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0xa8309
movq %rbx, %rax
addq $0x228, %rsp # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x248(%rbp), %rax
movl %r14d, (%rax)
leaq -0x240(%rbp), %rax
subq %rax, %rsi
addq %rsi, %rbx
jmp 0xa82cc
callq 0x2a240
nop
| my_open_parent_dir_nosymlinks:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 228h
mov r14, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
lea r15, [rbp+var_240]
mov edx, 201h
mov rdi, r15
mov rsi, rbx
call strnmov
cmp byte ptr [rax], 0
jz short loc_A81F3
call ___errno_location
mov dword ptr [rax], 24h ; '$'
jmp loc_A82CA
loc_A81F3:
cmp [rbp+var_240], 2Fh ; '/'
jnz loc_A829F
mov r12, rax
mov [rbp+var_248], r14
mov al, [rbp+var_23F]
mov r13d, 0FFFFFFFFh
cmp al, 2Fh ; '/'
jz loc_A82AF
lea rcx, [rbp+var_23F]
mov r14d, 0FFFFFFFFh
loc_A822B:
mov rsi, r15
inc rcx
mov r15, rcx
loc_A8234:
test al, al
jz short loc_A8248
movzx eax, al
cmp eax, 2Fh ; '/'
jz short loc_A8248
mov al, [r15]
inc r15
jmp short loc_A8234
loc_A8248:
mov byte ptr [r15-1], 0
cmp word ptr [rsi], 2Eh ; '.'
jz short loc_A82AC
movzx eax, word ptr [rsi]
xor eax, 2E2Eh
movzx ecx, byte ptr [rsi+2]
or cx, ax
jz short loc_A82AC
cmp r15, r12
jnb loc_A82F0
mov edi, r14d
mov edx, offset unk_2A0000
xor eax, eax
call _openat64
test eax, eax
js short loc_A82BD
mov r13d, eax
test r14d, r14d
js short loc_A8290
mov edi, r14d
call _close
loc_A8290:
mov al, [r15]
mov r14d, r13d
mov rcx, r15
cmp al, 2Fh ; '/'
jnz short loc_A822B
jmp short loc_A82AF
loc_A829F:
call ___errno_location
mov dword ptr [rax], 2
jmp short loc_A82CA
loc_A82AC:
mov r13d, r14d
loc_A82AF:
call ___errno_location
mov dword ptr [rax], 2
mov r14d, r13d
loc_A82BD:
test r14d, r14d
js short loc_A82CA
mov edi, r14d
call _close
loc_A82CA:
xor ebx, ebx
loc_A82CC:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_A8309
mov rax, rbx
add rsp, 228h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_A82F0:
mov rax, [rbp+var_248]
mov [rax], r14d
lea rax, [rbp+var_240]
sub rsi, rax
add rbx, rsi
jmp short loc_A82CC
loc_A8309:
call ___stack_chk_fail
| long long my_open_parent_dir_nosymlinks(long long a1, unsigned int *a2)
{
char *v3; // r15
char *v4; // rdi
char *v5; // rax
char *v6; // r12
char v7; // al
int v8; // r13d
char *v9; // rcx
unsigned int v10; // r14d
char *v11; // rsi
long long v12; // rcx
int v13; // eax
unsigned int *v16; // [rsp+8h] [rbp-248h]
char v17; // [rsp+10h] [rbp-240h] BYREF
char v18; // [rsp+11h] [rbp-23Fh] BYREF
unsigned long long v19; // [rsp+220h] [rbp-30h]
v19 = __readfsqword(0x28u);
v3 = &v17;
v4 = &v17;
v5 = (char *)strnmov(&v17, a1, 513LL);
if ( *v5 )
{
*(_DWORD *)__errno_location(&v17) = 36;
return 0LL;
}
if ( v17 != 47 )
{
*(_DWORD *)__errno_location(&v17) = 2;
return 0LL;
}
v6 = v5;
v16 = a2;
v7 = v18;
v8 = -1;
if ( v18 == 47 )
{
LABEL_20:
*(_DWORD *)__errno_location(v4) = 2;
v10 = v8;
LABEL_21:
if ( (v10 & 0x80000000) == 0 )
close(v10);
return 0LL;
}
v9 = &v18;
v10 = -1;
while ( 1 )
{
v11 = v3;
v3 = v9 + 1;
while ( v7 && v7 != 47 )
v7 = *v3++;
*(v3 - 1) = 0;
if ( *(_WORD *)v11 == 46 || (v12 = (unsigned __int8)v11[2], LOWORD(v12) = *(_WORD *)v11 ^ 0x2E2E | v12, !(_WORD)v12) )
{
v8 = v10;
goto LABEL_20;
}
if ( v3 >= v6 )
break;
v4 = (char *)v10;
v13 = openat64(v10, v11, &unk_2A0000, v12);
if ( v13 < 0 )
goto LABEL_21;
v8 = v13;
if ( (v10 & 0x80000000) == 0 )
{
v4 = (char *)v10;
close(v10);
}
v7 = *v3;
v10 = v8;
v9 = v3;
if ( *v3 == 47 )
goto LABEL_20;
}
*v16 = v10;
return v11 - &v17 + a1;
}
| my_open_parent_dir_nosymlinks:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x228
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
LEA R15,[RBP + -0x240]
MOV EDX,0x201
MOV RDI,R15
MOV RSI,RBX
CALL 0x001dfcb4
CMP byte ptr [RAX],0x0
JZ 0x001a81f3
CALL 0x0012a7a0
MOV dword ptr [RAX],0x24
JMP 0x001a82ca
LAB_001a81f3:
CMP byte ptr [RBP + -0x240],0x2f
JNZ 0x001a829f
MOV R12,RAX
MOV qword ptr [RBP + -0x248],R14
MOV AL,byte ptr [RBP + -0x23f]
MOV R13D,0xffffffff
CMP AL,0x2f
JZ 0x001a82af
LEA RCX,[RBP + -0x23f]
MOV R14D,0xffffffff
LAB_001a822b:
MOV RSI,R15
INC RCX
MOV R15,RCX
LAB_001a8234:
TEST AL,AL
JZ 0x001a8248
MOVZX EAX,AL
CMP EAX,0x2f
JZ 0x001a8248
MOV AL,byte ptr [R15]
INC R15
JMP 0x001a8234
LAB_001a8248:
MOV byte ptr [R15 + -0x1],0x0
CMP word ptr [RSI],0x2e
JZ 0x001a82ac
MOVZX EAX,word ptr [RSI]
XOR EAX,0x2e2e
MOVZX ECX,byte ptr [RSI + 0x2]
OR CX,AX
JZ 0x001a82ac
CMP R15,R12
JNC 0x001a82f0
MOV EDI,R14D
MOV EDX,0x2a0000
XOR EAX,EAX
CALL 0x0012a570
TEST EAX,EAX
JS 0x001a82bd
MOV R13D,EAX
TEST R14D,R14D
JS 0x001a8290
MOV EDI,R14D
CALL 0x0012a190
LAB_001a8290:
MOV AL,byte ptr [R15]
MOV R14D,R13D
MOV RCX,R15
CMP AL,0x2f
JNZ 0x001a822b
JMP 0x001a82af
LAB_001a829f:
CALL 0x0012a7a0
MOV dword ptr [RAX],0x2
JMP 0x001a82ca
LAB_001a82ac:
MOV R13D,R14D
LAB_001a82af:
CALL 0x0012a7a0
MOV dword ptr [RAX],0x2
MOV R14D,R13D
LAB_001a82bd:
TEST R14D,R14D
JS 0x001a82ca
MOV EDI,R14D
CALL 0x0012a190
LAB_001a82ca:
XOR EBX,EBX
LAB_001a82cc:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001a8309
MOV RAX,RBX
ADD RSP,0x228
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001a82f0:
MOV RAX,qword ptr [RBP + -0x248]
MOV dword ptr [RAX],R14D
LEA RAX,[RBP + -0x240]
SUB RSI,RAX
ADD RBX,RSI
JMP 0x001a82cc
LAB_001a8309:
CALL 0x0012a240
|
long my_open_parent_dir_nosymlinks(long param_1,int *param_2)
{
short *psVar1;
int iVar2;
short *psVar3;
int *piVar4;
long lVar5;
int __fd;
short *psVar6;
short *__file;
long in_FS_OFFSET;
int1 local_248 [2];
int1 local_246 [526];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
psVar3 = (short *)strnmov(local_248,param_1,0x201);
if ((char)*psVar3 == '\0') {
if (local_248[0] == '/') {
__fd = -1;
if (local_248[1] != '/') {
psVar1 = (short *)(local_248 + 1);
__file = (short *)local_248;
__fd = -1;
do {
while ((psVar6 = (short *)((long)psVar1 + 1), local_248[1] != '\0' &&
(local_248[1] != '/'))) {
psVar1 = psVar6;
local_248[1] = *(char *)psVar6;
}
*(char *)psVar1 = '\0';
if ((*__file == 0x2e) || ((char)__file[1] == '\0' && *__file == 0x2e2e)) break;
if (psVar3 <= psVar6) {
*param_2 = __fd;
lVar5 = (long)__file + (param_1 - (long)local_248);
goto LAB_001a82cc;
}
iVar2 = openat64(__fd,(char *)__file,0x2a0000);
if (iVar2 < 0) goto LAB_001a82bd;
if (-1 < __fd) {
close(__fd);
}
local_248[1] = *(char *)psVar6;
__fd = iVar2;
psVar1 = psVar6;
__file = psVar6;
} while (local_248[1] != '/');
}
piVar4 = __errno_location();
*piVar4 = 2;
LAB_001a82bd:
if (-1 < __fd) {
close(__fd);
}
}
else {
piVar4 = __errno_location();
*piVar4 = 2;
}
}
else {
piVar4 = __errno_location();
*piVar4 = 0x24;
}
lVar5 = 0;
LAB_001a82cc:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return lVar5;
}
|
|
5,869 | common_kv_cache_dump_view(llama_kv_cache_view const&, int) | monkey531[P]llama/common/common.cpp | void common_kv_cache_dump_view(const llama_kv_cache_view & view, int row_size) {
static const char slot_chars[] = ".123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+";
printf("=== Dumping KV cache. total cells %d, max sequences per cell %d, populated cells %d, total tokens in cache %d, largest empty slot=%d @ %d",
view.n_cells, view.n_seq_max, view.used_cells, view.token_count, view.max_contiguous, view.max_contiguous_idx);
llama_kv_cache_view_cell * c_curr = view.cells;
llama_seq_id * cs_curr = view.cells_sequences;
for (int i = 0; i < view.n_cells; i++, c_curr++, cs_curr += view.n_seq_max) {
if (i % row_size == 0) {
printf("\n%5d: ", i);
}
int seq_count = 0;
for (int j = 0; j < view.n_seq_max; j++) {
if (cs_curr[j] >= 0) { seq_count++; }
}
putchar(slot_chars[std::min(sizeof(slot_chars) - 2, size_t(seq_count))]);
}
printf("\n=== Done dumping\n");
} | O3 | cpp | common_kv_cache_dump_view(llama_kv_cache_view const&, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl (%rdi), %esi
movl 0x4(%rdi), %edx
movl 0xc(%rdi), %ecx
movl 0x8(%rdi), %r8d
movl 0x10(%rdi), %r9d
movl 0x14(%rdi), %eax
movl %eax, (%rsp)
leaq 0x79ede(%rip), %rdi # 0x114a68
xorl %eax, %eax
callq 0x1d080
cmpl $0x0, (%r14)
jle 0x9ac07
movq 0x20(%r14), %r12
movl $0x3e, %r13d
leaq 0x7c3e8(%rip), %r15 # 0x116f90
xorl %ebp, %ebp
movl %ebp, %eax
cltd
idivl %ebx
testl %edx, %edx
jne 0x9abc3
leaq 0x79f38(%rip), %rdi # 0x114af2
movl %ebp, %esi
xorl %eax, %eax
callq 0x1d080
movslq 0x4(%r14), %rcx
testq %rcx, %rcx
jle 0x9abe5
xorl %edx, %edx
xorl %eax, %eax
movl (%r12,%rdx,4), %esi
notl %esi
shrl $0x1f, %esi
addl %esi, %eax
incq %rdx
cmpq %rdx, %rcx
jne 0x9abd0
jmp 0x9abe7
xorl %eax, %eax
cmpl $0x3e, %eax
cmovael %r13d, %eax
movsbl (%rax,%r15), %edi
callq 0x1e140
incl %ebp
movslq 0x4(%r14), %rax
leaq (%r12,%rax,4), %r12
cmpl (%r14), %ebp
jl 0x9abaa
leaq 0x7c370(%rip), %rdi # 0x116f7e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1e310
| _Z25common_kv_cache_dump_viewRK19llama_kv_cache_viewi:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ebx, esi
mov r14, rdi
mov esi, [rdi]
mov edx, [rdi+4]
mov ecx, [rdi+0Ch]
mov r8d, [rdi+8]
mov r9d, [rdi+10h]
mov eax, [rdi+14h]
mov [rsp+38h+var_38], eax
lea rdi, aDumpingKvCache; "=== Dumping KV cache. total cells %d, m"...
xor eax, eax
call _printf
cmp dword ptr [r14], 0
jle short loc_9AC07
mov r12, [r14+20h]
mov r13d, 3Eh ; '>'
lea r15, _ZZ25common_kv_cache_dump_viewRK19llama_kv_cache_viewiE10slot_chars; ".123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabc"...
xor ebp, ebp
loc_9ABAA:
mov eax, ebp
cdq
idiv ebx
test edx, edx
jnz short loc_9ABC3
lea rdi, a5d; "\n%5d: "
mov esi, ebp
xor eax, eax
call _printf
loc_9ABC3:
movsxd rcx, dword ptr [r14+4]
test rcx, rcx
jle short loc_9ABE5
xor edx, edx
xor eax, eax
loc_9ABD0:
mov esi, [r12+rdx*4]
not esi
shr esi, 1Fh
add eax, esi
inc rdx
cmp rcx, rdx
jnz short loc_9ABD0
jmp short loc_9ABE7
loc_9ABE5:
xor eax, eax
loc_9ABE7:
cmp eax, 3Eh ; '>'
cmovnb eax, r13d
movsx edi, byte ptr [rax+r15]
call _putchar
inc ebp
movsxd rax, dword ptr [r14+4]
lea r12, [r12+rax*4]
cmp ebp, [r14]
jl short loc_9ABAA
loc_9AC07:
lea rdi, aDoneDumping; "\n=== Done dumping"
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _puts
| long long common_kv_cache_dump_view(long long a1, int a2)
{
long long v2; // r12
int v3; // ebp
long long v4; // rcx
long long v5; // rdx
long long v6; // rax
printf(
"=== Dumping KV cache. total cells %d, max sequences per cell %d, populated cells %d, total tokens in cache %d, large"
"st empty slot=%d @ %d",
*(_DWORD *)a1,
*(_DWORD *)(a1 + 4),
*(_DWORD *)(a1 + 12),
*(_DWORD *)(a1 + 8),
*(_DWORD *)(a1 + 16),
*(_DWORD *)(a1 + 20));
if ( *(int *)a1 > 0 )
{
v2 = *(_QWORD *)(a1 + 32);
v3 = 0;
do
{
if ( !(v3 % a2) )
printf("\n%5d: ", v3);
v4 = *(int *)(a1 + 4);
if ( v4 <= 0 )
{
v6 = 0LL;
}
else
{
v5 = 0LL;
LODWORD(v6) = 0;
do
v6 = (*(_DWORD *)(v2 + 4 * v5++) >= 0) + (unsigned int)v6;
while ( v4 != v5 );
}
if ( (unsigned int)v6 >= 0x3E )
v6 = 62LL;
putchar((unsigned int)common_kv_cache_dump_view(llama_kv_cache_view const&,int)::slot_chars[v6]);
++v3;
v2 += 4LL * *(int *)(a1 + 4);
}
while ( v3 < *(_DWORD *)a1 );
}
return puts("\n=== Done dumping");
}
| common_kv_cache_dump_view:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV EBX,ESI
MOV R14,RDI
MOV ESI,dword ptr [RDI]
MOV EDX,dword ptr [RDI + 0x4]
MOV ECX,dword ptr [RDI + 0xc]
MOV R8D,dword ptr [RDI + 0x8]
MOV R9D,dword ptr [RDI + 0x10]
MOV EAX,dword ptr [RDI + 0x14]
MOV dword ptr [RSP],EAX
LEA RDI,[0x214a68]
XOR EAX,EAX
CALL 0x0011d080
CMP dword ptr [R14],0x0
JLE 0x0019ac07
MOV R12,qword ptr [R14 + 0x20]
MOV R13D,0x3e
LEA R15,[0x216f90]
XOR EBP,EBP
LAB_0019abaa:
MOV EAX,EBP
CDQ
IDIV EBX
TEST EDX,EDX
JNZ 0x0019abc3
LEA RDI,[0x214af2]
MOV ESI,EBP
XOR EAX,EAX
CALL 0x0011d080
LAB_0019abc3:
MOVSXD RCX,dword ptr [R14 + 0x4]
TEST RCX,RCX
JLE 0x0019abe5
XOR EDX,EDX
XOR EAX,EAX
LAB_0019abd0:
MOV ESI,dword ptr [R12 + RDX*0x4]
NOT ESI
SHR ESI,0x1f
ADD EAX,ESI
INC RDX
CMP RCX,RDX
JNZ 0x0019abd0
JMP 0x0019abe7
LAB_0019abe5:
XOR EAX,EAX
LAB_0019abe7:
CMP EAX,0x3e
CMOVNC EAX,R13D
MOVSX EDI,byte ptr [RAX + R15*0x1]
CALL 0x0011e140
INC EBP
MOVSXD RAX,dword ptr [R14 + 0x4]
LEA R12,[R12 + RAX*0x4]
CMP EBP,dword ptr [R14]
JL 0x0019abaa
LAB_0019ac07:
LEA RDI,[0x216f7e]
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0011e310
|
/* common_kv_cache_dump_view(llama_kv_cache_view const&, int) */
void common_kv_cache_dump_view(llama_kv_cache_view *param_1,int param_2)
{
uint uVar1;
int8 in_RAX;
ulong uVar2;
long lVar3;
uint uVar4;
long lVar5;
printf("=== Dumping KV cache. total cells %d, max sequences per cell %d, populated cells %d, total tokens in cache %d, largest empty slot=%d @ %d"
,(ulong)*(uint *)param_1,(ulong)*(uint *)(param_1 + 4),(ulong)*(uint *)(param_1 + 0xc),
(ulong)*(uint *)(param_1 + 8),(ulong)*(uint *)(param_1 + 0x10),
CONCAT44((int)((ulong)in_RAX >> 0x20),*(int4 *)(param_1 + 0x14)));
if (0 < *(int *)param_1) {
lVar5 = *(long *)(param_1 + 0x20);
uVar4 = 0;
do {
if ((int)uVar4 % param_2 == 0) {
printf("\n%5d: ",(ulong)uVar4);
}
if ((long)*(int *)(param_1 + 4) < 1) {
uVar1 = 0;
}
else {
lVar3 = 0;
uVar1 = 0;
do {
uVar1 = uVar1 - ((int)~*(uint *)(lVar5 + lVar3 * 4) >> 0x1f);
lVar3 = lVar3 + 1;
} while (*(int *)(param_1 + 4) != lVar3);
}
uVar2 = (ulong)uVar1;
if (0x3d < uVar1) {
uVar2 = 0x3e;
}
putchar((int)".123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+"[uVar2]);
uVar4 = uVar4 + 1;
lVar5 = lVar5 + (long)*(int *)(param_1 + 4) * 4;
} while ((int)uVar4 < *(int *)param_1);
}
puts("\n=== Done dumping");
return;
}
|
|
5,870 | mi_store_blob_length | eloqsql/storage/myisam/mi_dynrec.c | void _mi_store_blob_length(uchar *pos,uint pack_length,uint length)
{
switch (pack_length) {
case 1:
*pos= (uchar) length;
break;
case 2:
int2store(pos,length);
break;
case 3:
int3store(pos,length);
break;
case 4:
int4store(pos,length);
default:
break;
}
return;
} | O0 | c | mi_store_blob_length:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x3, %eax
ja 0xacb8a
movq -0x28(%rbp), %rax
leaq 0xadb63(%rip), %rcx # 0x15a67c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl -0x10(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
jmp 0xacb8c
jmp 0xacb31
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %eax
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, (%rax)
jmp 0xacb8c
jmp 0xacb4a
movl -0x10(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movl -0x10(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x10(%rbp), %eax
shrl $0x10, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x2(%rax)
jmp 0xacb8c
jmp 0xacb77
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0xacb8a
jmp 0xacb8c
popq %rbp
retq
nop
| _mi_store_blob_length:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_10], edx
mov eax, [rbp+var_C]
dec eax; switch 4 cases
mov ecx, eax
mov [rbp+var_28], rcx
sub eax, 3
ja short def_ACB20; jumptable 00000000000ACB20 default case
mov rax, [rbp+var_28]
lea rcx, jpt_ACB20
movsxd rax, ds:(jpt_ACB20 - 15A67Ch)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_ACB22:
mov eax, [rbp+var_10]; jumptable 00000000000ACB20 case 1
mov cl, al
mov rax, [rbp+var_8]
mov [rax], cl
jmp short loc_ACB8C
loc_ACB2F:
jmp short $+2; jumptable 00000000000ACB20 case 2
loc_ACB31:
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
mov eax, [rbp+var_10]
mov cx, ax
mov rax, [rbp+var_18]
mov [rax], cx
jmp short loc_ACB8C
loc_ACB48:
jmp short $+2; jumptable 00000000000ACB20 case 3
loc_ACB4A:
mov eax, [rbp+var_10]
mov cl, al
mov rax, [rbp+var_8]
mov [rax], cl
mov eax, [rbp+var_10]
shr eax, 8
mov cl, al
mov rax, [rbp+var_8]
mov [rax+1], cl
mov eax, [rbp+var_10]
shr eax, 10h
mov cl, al
mov rax, [rbp+var_8]
mov [rax+2], cl
jmp short loc_ACB8C
loc_ACB75:
jmp short $+2; jumptable 00000000000ACB20 case 4
loc_ACB77:
mov rax, [rbp+var_8]
mov [rbp+var_20], rax
mov ecx, [rbp+var_10]
mov rax, [rbp+var_20]
mov [rax], ecx
jmp short $+2; jumptable 00000000000ACB20 default case
def_ACB20:
jmp short $+2; jumptable 00000000000ACB20 default case
loc_ACB8C:
pop rbp
retn
| unsigned long long mi_store_blob_length(_BYTE *a1, int a2, int a3)
{
unsigned long long result; // rax
result = (unsigned int)(a2 - 1);
switch ( a2 )
{
case 1:
result = (unsigned long long)a1;
*a1 = a3;
break;
case 2:
result = (unsigned long long)a1;
*(_WORD *)a1 = a3;
break;
case 3:
*(_WORD *)a1 = a3;
result = (unsigned long long)a1;
a1[2] = BYTE2(a3);
break;
case 4:
result = (unsigned long long)a1;
*(_DWORD *)a1 = a3;
break;
default:
return result;
}
return result;
}
| _mi_store_blob_length:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV dword ptr [RBP + -0x10],EDX
MOV EAX,dword ptr [RBP + -0xc]
DEC EAX
MOV ECX,EAX
MOV qword ptr [RBP + -0x28],RCX
SUB EAX,0x3
JA 0x001acb8a
MOV RAX,qword ptr [RBP + -0x28]
LEA RCX,[0x25a67c]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
MOV EAX,dword ptr [RBP + -0x10]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX],CL
JMP 0x001acb8c
caseD_2:
JMP 0x001acb31
LAB_001acb31:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
MOV EAX,dword ptr [RBP + -0x10]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x18]
MOV word ptr [RAX],CX
JMP 0x001acb8c
caseD_3:
JMP 0x001acb4a
LAB_001acb4a:
MOV EAX,dword ptr [RBP + -0x10]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX],CL
MOV EAX,dword ptr [RBP + -0x10]
SHR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x1],CL
MOV EAX,dword ptr [RBP + -0x10]
SHR EAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x2],CL
JMP 0x001acb8c
caseD_4:
JMP 0x001acb77
LAB_001acb77:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RAX
MOV ECX,dword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],ECX
JMP 0x001acb8a
LAB_001acb8a:
JMP 0x001acb8c
default:
POP RBP
RET
|
void _mi_store_blob_length(int4 *param_1,int4 param_2,int4 param_3)
{
switch(param_2) {
case 1:
*(char *)param_1 = (char)param_3;
break;
case 2:
*(short *)param_1 = (short)param_3;
break;
case 3:
*(char *)param_1 = (char)param_3;
*(char *)((long)param_1 + 1) = (char)((uint)param_3 >> 8);
*(char *)((long)param_1 + 2) = (char)((uint)param_3 >> 0x10);
break;
case 4:
*param_1 = param_3;
}
return;
}
|
|
5,871 | minja::Parser::parseNumber(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&) | monkey531[P]llama/common/minja.hpp | json parseNumber(CharIterator& it, const CharIterator& end) {
auto before = it;
consumeSpaces();
auto start = it;
bool hasDecimal = false;
bool hasExponent = false;
if (it != end && (*it == '-' || *it == '+')) ++it;
while (it != end) {
if (std::isdigit(*it)) {
++it;
} else if (*it == '.') {
if (hasDecimal) throw std::runtime_error("Multiple decimal points");
hasDecimal = true;
++it;
} else if (it != start && (*it == 'e' || *it == 'E')) {
if (hasExponent) throw std::runtime_error("Multiple exponents");
hasExponent = true;
++it;
} else {
break;
}
}
if (start == it) {
it = before;
return json(); // No valid characters found
}
std::string str(start, it);
try {
return json::parse(str);
} catch (json::parse_error& e) {
throw std::runtime_error("Failed to parse number: '" + str + "' (" + std::string(e.what()) + ")");
return json();
}
} | O1 | cpp | minja::Parser::parseNumber(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdx), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsi), %rbp
movq 0x20(%rsi), %r13
cmpq %rbp, %r13
je 0x90925
movq %rsi, %r12
movsbl (%r13), %edi
callq 0x1b0c0
testl %eax, %eax
je 0x90925
incq %r13
movq %r13, 0x20(%r12)
cmpq %rbp, %r13
jne 0x9090a
movq (%r14), %rsi
cmpq %rsi, (%r15)
je 0x90941
movzbl (%rsi), %eax
cmpl $0x2d, %eax
je 0x9093a
cmpl $0x2b, %eax
jne 0x90941
leaq 0x1(%rsi), %rax
movq %rax, (%r14)
movq (%r14), %rdx
cmpq (%r15), %rdx
je 0x90991
xorl %eax, %eax
xorl %ecx, %ecx
movsbl (%rdx), %edi
leal -0x30(%rdi), %r8d
cmpl $0xa, %r8d
jb 0x90986
movzbl %dil, %edi
cmpl $0x2e, %edi
jne 0x9096e
testb $0x1, %al
movb $0x1, %al
je 0x90986
jmp 0x90a44
cmpq %rsi, %rdx
je 0x90991
orl $0x20, %edi
cmpl $0x65, %edi
jne 0x90991
testb $0x1, %cl
movb $0x1, %cl
jne 0x90a62
incq %rdx
movq %rdx, (%r14)
cmpq (%r15), %rdx
jne 0x9094d
cmpq %rsi, %rdx
je 0x90a02
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x10(%rsp), %rdi
callq 0x74a60
xorps %xmm0, %xmm0
leaq 0x70(%rsp), %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x912da
movq 0x80(%rsp), %rax
testq %rax, %rax
je 0x909e9
leaq 0x70(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x90a2f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1b910
jmp 0x90a2f
movq 0x8(%rsp), %rax
movq %rax, (%r14)
movb $0x0, (%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5cc1e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5cc1e
movq %rbx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x1b460
movq %rax, %rbx
leaq 0x65baa(%rip), %rsi # 0xf6602
movq %rax, %rdi
callq 0x1b340
jmp 0x90a7e
movl $0x10, %edi
callq 0x1b460
movq %rax, %rbx
leaq 0x65ba4(%rip), %rsi # 0xf661a
movq %rax, %rdi
callq 0x1b340
movq 0xa2563(%rip), %rsi # 0x132fe8
movq 0xa24cc(%rip), %rdx # 0x132f58
movq %rbx, %rdi
callq 0x1bfb0
jmp 0x90cf4
movq %rdx, %rbx
movq %rax, %r14
movq 0x80(%rsp), %rax
testq %rax, %rax
je 0x90abb
leaq 0x70(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
cmpl $0x1, %ebx
jne 0x90cd9
movq %r14, %rdi
callq 0x1b3a0
movq %rax, %r14
movl $0x10, %edi
callq 0x1b460
movq %rax, %rbx
leaq 0x65b4a(%rip), %rsi # 0xf662d
leaq 0xb8(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x5981d
leaq 0x65b4b(%rip), %rsi # 0xf6647
leaq 0xb8(%rsp), %rdi
callq 0x1c1a0
leaq 0x40(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x90b2c
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x90b39
movq %rdx, 0x30(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x40(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x38(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
leaq 0x98(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0x2291a
leaq 0xd8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x98(%rsp), %rdx
callq 0x7d503
leaq 0x6a083(%rip), %rsi # 0xfac13
leaq 0xd8(%rsp), %rdi
callq 0x1c1a0
leaq 0x60(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x90bbf
movups (%rcx), %xmm0
movups %xmm0, (%r13)
jmp 0x90bcc
movq %rdx, 0x50(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x60(%rsp)
movq 0x8(%rax), %rdx
leaq 0x50(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x1beb0
xorl %ebp, %ebp
movq 0xa23ec(%rip), %rsi # 0x132fe8
movq 0xa2355(%rip), %rdx # 0x132f58
movq %rbx, %rdi
callq 0x1bfb0
movq %rax, %r14
movq 0x50(%rsp), %rdi
cmpq %r13, %rdi
je 0x90c2d
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1b910
jmp 0x90c2d
movq %rax, %r14
movb $0x1, %bpl
leaq 0xe8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x90c56
movq 0xe8(%rsp), %rsi
incq %rsi
callq 0x1b910
jmp 0x90c56
movq %rax, %r14
movb $0x1, %bpl
leaq 0xa8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x90c7f
movq 0xa8(%rsp), %rsi
incq %rsi
callq 0x1b910
jmp 0x90c7f
movq %rax, %r14
movb $0x1, %bpl
movq 0x30(%rsp), %rdi
cmpq %r12, %rdi
je 0x90c9e
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1b910
jmp 0x90c9e
movq %rax, %r14
movb $0x1, %bpl
leaq 0xc8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x90cc7
movq 0xc8(%rsp), %rsi
incq %rsi
callq 0x1b910
jmp 0x90cc7
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x90cd4
movq %rbx, %rdi
callq 0x1b6a0
callq 0x1bee0
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x90d0e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1b910
jmp 0x90d0e
jmp 0x90cf4
movq %rax, %rdi
callq 0x24da5
movq %rax, %r14
jmp 0x90d0e
jmp 0x90d03
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b6a0
movq %r14, %rdi
callq 0x1c030
| _ZN5minja6Parser11parseNumberERN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEERKSB_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0F8h
mov r15, rcx
mov r14, rdx
mov rbx, rdi
mov rax, [rdx]
mov [rsp+128h+var_120], rax
mov rbp, [rsi+18h]
mov r13, [rsi+20h]
cmp r13, rbp
jz short loc_90925
mov r12, rsi
loc_9090A:
movsx edi, byte ptr [r13+0]
call _isspace
test eax, eax
jz short loc_90925
inc r13
mov [r12+20h], r13
cmp r13, rbp
jnz short loc_9090A
loc_90925:
mov rsi, [r14]
cmp [r15], rsi
jz short loc_90941
movzx eax, byte ptr [rsi]
cmp eax, 2Dh ; '-'
jz short loc_9093A
cmp eax, 2Bh ; '+'
jnz short loc_90941
loc_9093A:
lea rax, [rsi+1]
mov [r14], rax
loc_90941:
mov rdx, [r14]
cmp rdx, [r15]
jz short loc_90991
xor eax, eax
xor ecx, ecx
loc_9094D:
movsx edi, byte ptr [rdx]
lea r8d, [rdi-30h]
cmp r8d, 0Ah
jb short loc_90986
movzx edi, dil
cmp edi, 2Eh ; '.'
jnz short loc_9096E
test al, 1
mov al, 1
jz short loc_90986
jmp loc_90A44
loc_9096E:
cmp rdx, rsi
jz short loc_90991
or edi, 20h
cmp edi, 65h ; 'e'
jnz short loc_90991
test cl, 1
mov cl, 1
jnz loc_90A62
loc_90986:
inc rdx
mov [r14], rdx
cmp rdx, [r15]
jnz short loc_9094D
loc_90991:
cmp rdx, rsi
jz short loc_90A02
lea r15, [rsp+128h+var_108]
mov [r15-10h], r15
lea rdi, [rsp+128h+var_118]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIN9__gnu_cxx17__normal_iteratorIPKcS4_EEEEvT_SB_St20forward_iterator_tag; std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::forward_iterator_tag)
xorps xmm0, xmm0
lea rdx, [rsp+128h+var_B8]
movaps xmmword ptr [rdx+10h], xmm0
movaps xmmword ptr [rdx], xmm0
lea rsi, [rsp+128h+var_118]
mov rdi, rbx
mov ecx, 1
xor r8d, r8d
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5parseIRS9_EESD_OT_St8functionIFbiNS0_6detail13parse_event_tERSD_EEbb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::parse<std::string&>(std::string&,std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&)>,bool,bool)
mov rax, [rsp+128h+var_A8]
test rax, rax
jz short loc_909E9
lea rdi, [rsp+128h+var_B8]
mov rsi, rdi
mov edx, 3
call rax
loc_909E9:
mov rdi, [rsp+128h+var_118]; void *
cmp rdi, r15
jz short loc_90A2F
mov rsi, [rsp+128h+var_108]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_90A2F
loc_90A02:
mov rax, [rsp+128h+var_120]
mov [r14], rax
mov byte ptr [rbx], 0
mov qword ptr [rbx+8], 0
mov rdi, rbx
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
loc_90A2F:
mov rax, rbx
add rsp, 0F8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_90A44:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aMultipleDecima; "Multiple decimal points"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short loc_90A7E
loc_90A62:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aMultipleExpone; "Multiple exponents"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
loc_90A7E:
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp loc_90CF4
mov rbx, rdx
mov r14, rax
mov rax, [rsp+128h+var_A8]
test rax, rax
jz short loc_90ABB
lea rdi, [rsp+128h+var_B8]
mov rsi, rdi
mov edx, 3
call rax
loc_90ABB:
cmp ebx, 1
jnz loc_90CD9
mov rdi, r14; void *
call ___cxa_begin_catch
mov r14, rax
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aFailedToParseN; "Failed to parse number: '"
lea rdi, [rsp+128h+var_70]
lea rdx, [rsp+128h+var_118]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
lea rsi, asc_F6647; "' ("
lea rdi, [rsp+128h+var_70]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea r12, [rsp+128h+var_E8]
mov [r12-10h], r12
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jnz short loc_90B2C
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r12], xmm0
jmp short loc_90B39
loc_90B2C:
mov [rsp+128h+var_F8], rdx
mov rdx, [rcx]
mov [rsp+128h+var_E8], rdx
loc_90B39:
mov rdx, [rax+8]
mov [rsp+128h+var_F0], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rax, [r14]
mov rdi, r14
call qword ptr [rax+10h]
lea rdi, [rsp+128h+var_90]
lea rdx, [rsp+128h+var_121]
mov rsi, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rdi, [rsp+128h+var_50]
lea rsi, [rsp+128h+var_F8]
lea rdx, [rsp+128h+var_90]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
lea rsi, a09401910201912+51h; ")"
lea rdi, [rsp+128h+var_50]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea r13, [rsp+128h+var_C8]
mov [r13-10h], r13
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jnz short loc_90BBF
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r13+0], xmm0
jmp short loc_90BCC
loc_90BBF:
mov [rsp+128h+var_D8], rdx
mov rdx, [rcx]
mov [rsp+128h+var_C8], rdx
loc_90BCC:
mov rdx, [rax+8]
lea rsi, [rsp+128h+var_D8]
mov [rsi+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov bpl, 1
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
mov rdi, [rsp+128h+var_D8]; void *
cmp rdi, r13
jz short loc_90C2D
mov rsi, [rsp+128h+var_C8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_90C2D
mov r14, rax
mov bpl, 1
loc_90C2D:
lea rax, [rsp+128h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_90C56
mov rsi, [rsp+128h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_90C56
mov r14, rax
mov bpl, 1
loc_90C56:
lea rax, [rsp+128h+var_80]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_90C7F
mov rsi, [rsp+128h+var_80]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_90C7F
mov r14, rax
mov bpl, 1
loc_90C7F:
mov rdi, [rsp+128h+var_F8]; void *
cmp rdi, r12
jz short loc_90C9E
mov rsi, [rsp+128h+var_E8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_90C9E
mov r14, rax
mov bpl, 1
loc_90C9E:
lea rax, [rsp+128h+var_60]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_90CC7
mov rsi, [rsp+128h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_90CC7
mov r14, rax
mov bpl, 1
loc_90CC7:
test bpl, bpl
jz short loc_90CD4
mov rdi, rbx; void *
call ___cxa_free_exception
loc_90CD4:
call ___cxa_end_catch
loc_90CD9:
mov rdi, [rsp+128h+var_118]; void *
cmp rdi, r15
jz short loc_90D0E
mov rsi, [rsp+128h+var_108]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_90D0E
jmp short $+2
loc_90CF4:
mov rdi, rax
call __clang_call_terminate
mov r14, rax
jmp short loc_90D0E
jmp short $+2
loc_90D03:
mov r14, rax
mov rdi, rbx; void *
call ___cxa_free_exception
loc_90D0E:
mov rdi, r14
call __Unwind_Resume
| long long minja::Parser::parseNumber(long long a1, long long a2, char **a3, char **a4)
{
char *v7; // rbp
char *i; // r13
char *v9; // rsi
int v10; // eax
char *v11; // rdx
char v12; // al
char v13; // cl
int v14; // edi
bool v15; // zf
std::runtime_error *exception; // rbx
char *v18; // [rsp+8h] [rbp-120h]
void *v19[2]; // [rsp+10h] [rbp-118h] BYREF
_QWORD v20[2]; // [rsp+20h] [rbp-108h] BYREF
__int128 v21; // [rsp+70h] [rbp-B8h] BYREF
__int128 v22; // [rsp+80h] [rbp-A8h]
v18 = *a3;
v7 = *(char **)(a2 + 24);
for ( i = *(char **)(a2 + 32); i != v7; *(_QWORD *)(a2 + 32) = ++i )
{
if ( !(unsigned int)isspace((unsigned int)*i) )
break;
}
v9 = *a3;
if ( *a4 != *a3 )
{
v10 = (unsigned __int8)*v9;
if ( v10 == 45 || v10 == 43 )
*a3 = v9 + 1;
}
v11 = *a3;
if ( *a3 != *a4 )
{
v12 = 0;
v13 = 0;
do
{
v14 = *v11;
if ( (unsigned int)(v14 - 48) >= 0xA )
{
if ( (unsigned __int8)v14 == 46 )
{
v15 = (v12 & 1) == 0;
v12 = 1;
if ( !v15 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Multiple decimal points");
goto LABEL_26;
}
}
else
{
if ( v11 == v9 || ((unsigned __int8)v14 | 0x20) != 0x65 )
break;
v15 = (v13 & 1) == 0;
v13 = 1;
if ( !v15 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Multiple exponents");
LABEL_26:
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
}
}
*a3 = ++v11;
}
while ( v11 != *a4 );
}
if ( v11 == v9 )
{
*a3 = v18;
*(_BYTE *)a1 = 0;
*(_QWORD *)(a1 + 8) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)a1);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)a1);
}
else
{
v19[0] = v20;
std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(v19, v9, (long long)v11);
v22 = 0LL;
v21 = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::parse<std::string&>(
a1,
v19,
&v21,
1LL,
0LL);
if ( (_QWORD)v22 )
((void ( *)(__int128 *, __int128 *, long long))v22)(&v21, &v21, 3LL);
if ( v19[0] != v20 )
operator delete(v19[0], v20[0] + 1LL);
}
return a1;
}
| parseNumber:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xf8
MOV R15,RCX
MOV R14,RDX
MOV RBX,RDI
MOV RAX,qword ptr [RDX]
MOV qword ptr [RSP + 0x8],RAX
MOV RBP,qword ptr [RSI + 0x18]
MOV R13,qword ptr [RSI + 0x20]
CMP R13,RBP
JZ 0x00190925
MOV R12,RSI
LAB_0019090a:
MOVSX EDI,byte ptr [R13]
CALL 0x0011b0c0
TEST EAX,EAX
JZ 0x00190925
INC R13
MOV qword ptr [R12 + 0x20],R13
CMP R13,RBP
JNZ 0x0019090a
LAB_00190925:
MOV RSI,qword ptr [R14]
CMP qword ptr [R15],RSI
JZ 0x00190941
MOVZX EAX,byte ptr [RSI]
CMP EAX,0x2d
JZ 0x0019093a
CMP EAX,0x2b
JNZ 0x00190941
LAB_0019093a:
LEA RAX,[RSI + 0x1]
MOV qword ptr [R14],RAX
LAB_00190941:
MOV RDX,qword ptr [R14]
CMP RDX,qword ptr [R15]
JZ 0x00190991
XOR EAX,EAX
XOR ECX,ECX
LAB_0019094d:
MOVSX EDI,byte ptr [RDX]
LEA R8D,[RDI + -0x30]
CMP R8D,0xa
JC 0x00190986
MOVZX EDI,DIL
CMP EDI,0x2e
JNZ 0x0019096e
TEST AL,0x1
MOV AL,0x1
JZ 0x00190986
JMP 0x00190a44
LAB_0019096e:
CMP RDX,RSI
JZ 0x00190991
OR EDI,0x20
CMP EDI,0x65
JNZ 0x00190991
TEST CL,0x1
MOV CL,0x1
JNZ 0x00190a62
LAB_00190986:
INC RDX
MOV qword ptr [R14],RDX
CMP RDX,qword ptr [R15]
JNZ 0x0019094d
LAB_00190991:
CMP RDX,RSI
JZ 0x00190a02
LEA R15,[RSP + 0x20]
MOV qword ptr [R15 + -0x10],R15
LAB_0019099f:
LEA RDI,[RSP + 0x10]
CALL 0x00174a60
XORPS XMM0,XMM0
LEA RDX,[RSP + 0x70]
MOVAPS xmmword ptr [RDX + 0x10],XMM0
MOVAPS xmmword ptr [RDX],XMM0
LAB_001909b8:
LEA RSI,[RSP + 0x10]
MOV RDI,RBX
MOV ECX,0x1
XOR R8D,R8D
CALL 0x001912da
MOV RAX,qword ptr [RSP + 0x80]
TEST RAX,RAX
JZ 0x001909e9
LAB_001909da:
LEA RDI,[RSP + 0x70]
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_001909e9:
MOV RDI,qword ptr [RSP + 0x10]
CMP RDI,R15
JZ 0x00190a2f
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
CALL 0x0011b910
JMP 0x00190a2f
LAB_00190a02:
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [R14],RAX
MOV byte ptr [RBX],0x0
MOV qword ptr [RBX + 0x8],0x0
MOV RDI,RBX
MOV ESI,0x1
CALL 0x0015cc1e
MOV RDI,RBX
MOV ESI,0x1
CALL 0x0015cc1e
LAB_00190a2f:
MOV RAX,RBX
ADD RSP,0xf8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00190a44:
MOV EDI,0x10
CALL 0x0011b460
MOV RBX,RAX
LAB_00190a51:
LEA RSI,[0x1f6602]
MOV RDI,RAX
CALL 0x0011b340
LAB_00190a60:
JMP 0x00190a7e
LAB_00190a62:
MOV EDI,0x10
CALL 0x0011b460
MOV RBX,RAX
LAB_00190a6f:
LEA RSI,[0x1f661a]
MOV RDI,RAX
CALL 0x0011b340
LAB_00190a7e:
MOV RSI,qword ptr [0x00232fe8]
MOV RDX,qword ptr [0x00232f58]
MOV RDI,RBX
CALL 0x0011bfb0
|
/* minja::Parser::parseNumber(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::string >&,
__gnu_cxx::__normal_iterator<char const*, std::__cxx11::string > const&) */
__normal_iterator *
minja::Parser::parseNumber(__normal_iterator *param_1,__normal_iterator *param_2)
{
byte bVar1;
long lVar2;
char *pcVar3;
byte *pbVar4;
bool bVar5;
bool bVar6;
bool bVar7;
int iVar8;
runtime_error *this;
bool bVar9;
int8 *in_RCX;
long *in_RDX;
byte *pbVar10;
char *pcVar11;
long *local_118 [2];
long local_108 [10];
int8 local_b8;
int8 uStack_b0;
code *local_a8;
int8 uStack_a0;
lVar2 = *in_RDX;
pcVar3 = *(char **)(param_2 + 0x18);
pcVar11 = *(char **)(param_2 + 0x20);
while ((pcVar11 != pcVar3 && (iVar8 = isspace((int)*pcVar11), iVar8 != 0))) {
pcVar11 = pcVar11 + 1;
*(char **)(param_2 + 0x20) = pcVar11;
}
pbVar4 = (byte *)*in_RDX;
if (((byte *)*in_RCX != pbVar4) && ((*pbVar4 == 0x2d || (*pbVar4 == 0x2b)))) {
*in_RDX = (long)(pbVar4 + 1);
}
pbVar10 = (byte *)*in_RDX;
if (pbVar10 != (byte *)*in_RCX) {
bVar7 = false;
bVar9 = false;
do {
bVar1 = *pbVar10;
bVar5 = bVar7;
bVar6 = bVar9;
if (9 < (int)(char)bVar1 - 0x30U) {
if (bVar1 == 0x2e) {
bVar5 = true;
if (bVar7) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00190a51 to 00190a5f has its CatchHandler @ 00190d03 */
std::runtime_error::runtime_error(this,"Multiple decimal points");
LAB_00190a7e:
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_00232fe8,PTR__runtime_error_00232f58);
}
}
else {
if ((pbVar10 == pbVar4) || ((bVar1 | 0x20) != 0x65)) break;
bVar6 = true;
if (bVar9) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00190a6f to 00190a7d has its CatchHandler @ 00190d01 */
std::runtime_error::runtime_error(this,"Multiple exponents");
goto LAB_00190a7e;
}
}
}
bVar9 = bVar6;
bVar7 = bVar5;
pbVar10 = pbVar10 + 1;
*in_RDX = (long)pbVar10;
} while (pbVar10 != (byte *)*in_RCX);
}
if (pbVar10 == pbVar4) {
*in_RDX = lVar2;
*param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(param_1,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(param_1,0));
}
else {
/* try { // try from 0019099f to 001909a8 has its CatchHandler @ 00190cfc */
local_118[0] = local_108;
std::__cxx11::string::
_M_construct<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>(local_118);
local_a8 = (code *)0x0;
uStack_a0 = 0;
local_b8 = 0;
uStack_b0 = 0;
/* try { // try from 001909b8 to 001909cc has its CatchHandler @ 00190a99 */
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::parse<std::__cxx11::string&>
((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)param_1,local_118,&local_b8,1,0);
if (local_a8 != (code *)0x0) {
/* try { // try from 001909da to 001909e8 has its CatchHandler @ 00190a94 */
(*local_a8)(&local_b8,&local_b8,3);
}
if (local_118[0] != local_108) {
operator_delete(local_118[0],local_108[0] + 1);
}
}
return param_1;
}
|
|
5,872 | sp_get_geometry_mbr | eloqsql/storage/maria/ma_sp_key.c | static int sp_get_geometry_mbr(uchar *(*wkb), uchar *end, uint n_dims,
double *mbr, int top)
{
int res;
uchar byte_order;
uint wkb_type;
byte_order = *(*wkb);
++(*wkb);
wkb_type = uint4korr((*wkb));
(*wkb) += 4;
switch ((enum wkbType) wkb_type)
{
case wkbPoint:
res = sp_get_point_mbr(wkb, end, n_dims, byte_order, mbr);
break;
case wkbLineString:
res = sp_get_linestring_mbr(wkb, end, n_dims, byte_order, mbr);
break;
case wkbPolygon:
res = sp_get_polygon_mbr(wkb, end, n_dims, byte_order, mbr);
break;
case wkbMultiPoint:
{
uint n_items;
n_items = uint4korr((*wkb));
(*wkb) += 4;
for (; n_items > 0; --n_items)
{
byte_order = *(*wkb);
++(*wkb);
(*wkb) += 4;
if (sp_get_point_mbr(wkb, end, n_dims, byte_order, mbr))
return -1;
}
res = 0;
break;
}
case wkbMultiLineString:
{
uint n_items;
n_items = uint4korr((*wkb));
(*wkb) += 4;
for (; n_items > 0; --n_items)
{
byte_order = *(*wkb);
++(*wkb);
(*wkb) += 4;
if (sp_get_linestring_mbr(wkb, end, n_dims, byte_order, mbr))
return -1;
}
res = 0;
break;
}
case wkbMultiPolygon:
{
uint n_items;
n_items = uint4korr((*wkb));
(*wkb) += 4;
for (; n_items > 0; --n_items)
{
byte_order = *(*wkb);
++(*wkb);
(*wkb) += 4;
if (sp_get_polygon_mbr(wkb, end, n_dims, byte_order, mbr))
return -1;
}
res = 0;
break;
}
case wkbGeometryCollection:
{
uint n_items;
if (!top)
return -1;
n_items = uint4korr((*wkb));
(*wkb) += 4;
for (; n_items > 0; --n_items)
{
if (sp_get_geometry_mbr(wkb, end, n_dims, mbr, 0))
return -1;
}
res = 0;
break;
}
default:
res = -1;
}
return res;
} | O0 | c | sp_get_geometry_mbr:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0x31(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
incq %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
movl -0x38(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x50(%rbp)
subl $0x6, %eax
ja 0x854f7
movq -0x50(%rbp), %rax
leaq 0xdddc7(%rip), %rcx # 0x163044
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movb -0x31(%rbp), %al
movq -0x28(%rbp), %r8
movzbl %al, %ecx
callq 0x85510
movl %eax, -0x30(%rbp)
jmp 0x854fe
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movb -0x31(%rbp), %al
movq -0x28(%rbp), %r8
movzbl %al, %ecx
callq 0x85550
movl %eax, -0x30(%rbp)
jmp 0x854fe
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movb -0x31(%rbp), %al
movq -0x28(%rbp), %r8
movzbl %al, %ecx
callq 0x855e0
movl %eax, -0x30(%rbp)
jmp 0x854fe
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
cmpl $0x0, -0x3c(%rbp)
jbe 0x8536c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0x31(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movb -0x31(%rbp), %al
movq -0x28(%rbp), %r8
movzbl %al, %ecx
callq 0x85510
cmpl $0x0, %eax
je 0x8535f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x85504
jmp 0x85361
movl -0x3c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x85306
movl $0x0, -0x30(%rbp)
jmp 0x854fe
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
cmpl $0x0, -0x40(%rbp)
jbe 0x853f8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0x31(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movb -0x31(%rbp), %al
movq -0x28(%rbp), %r8
movzbl %al, %ecx
callq 0x85550
cmpl $0x0, %eax
je 0x853eb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x85504
jmp 0x853ed
movl -0x40(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x85392
movl $0x0, -0x30(%rbp)
jmp 0x854fe
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
cmpl $0x0, -0x44(%rbp)
jbe 0x85484
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0x31(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movb -0x31(%rbp), %al
movq -0x28(%rbp), %r8
movzbl %al, %ecx
callq 0x855e0
cmpl $0x0, %eax
je 0x85477
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x85504
jmp 0x85479
movl -0x44(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x8541e
movl $0x0, -0x30(%rbp)
jmp 0x854fe
cmpl $0x0, -0x2c(%rbp)
jne 0x8549c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x85504
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
cmpl $0x0, -0x48(%rbp)
jbe 0x854ee
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
xorl %r8d, %r8d
callq 0x85210
cmpl $0x0, %eax
je 0x854e1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x85504
jmp 0x854e3
movl -0x48(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x854b6
movl $0x0, -0x30(%rbp)
jmp 0x854fe
movl $0xffffffff, -0x30(%rbp) # imm = 0xFFFFFFFF
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
| sp_get_geometry_mbr:
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_28], rcx
mov [rbp+var_2C], r8d
mov rax, [rbp+var_10]
mov rax, [rax]
mov al, [rax]
mov [rbp+var_31], al
mov rax, [rbp+var_10]
mov rcx, [rax]
inc rcx
mov [rax], rcx
mov rax, [rbp+var_10]
mov rax, [rax]
mov eax, [rax]
mov [rbp+var_38], eax
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 4
mov [rax], rcx
mov eax, [rbp+var_38]
dec eax; switch 7 cases
mov ecx, eax
mov [rbp+var_50], rcx
sub eax, 6
ja def_85284; jumptable 0000000000085284 default case
mov rax, [rbp+var_50]
lea rcx, jpt_85284
movsxd rax, ds:(jpt_85284 - 163044h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_85286:
mov rdi, [rbp+var_10]; jumptable 0000000000085284 case 1
mov rsi, [rbp+var_18]
mov edx, [rbp+var_1C]
mov al, [rbp+var_31]
mov r8, [rbp+var_28]
movzx ecx, al
call sp_get_point_mbr
mov [rbp+var_30], eax
jmp loc_854FE
loc_852A8:
mov rdi, [rbp+var_10]; jumptable 0000000000085284 case 2
mov rsi, [rbp+var_18]
mov edx, [rbp+var_1C]
mov al, [rbp+var_31]
mov r8, [rbp+var_28]
movzx ecx, al
call sp_get_linestring_mbr
mov [rbp+var_30], eax
jmp loc_854FE
loc_852CA:
mov rdi, [rbp+var_10]; jumptable 0000000000085284 case 3
mov rsi, [rbp+var_18]
mov edx, [rbp+var_1C]
mov al, [rbp+var_31]
mov r8, [rbp+var_28]
movzx ecx, al
call sp_get_polygon_mbr
mov [rbp+var_30], eax
jmp loc_854FE
loc_852EC:
mov rax, [rbp+var_10]; jumptable 0000000000085284 case 4
mov rax, [rax]
mov eax, [rax]
mov [rbp+var_3C], eax
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 4
mov [rax], rcx
loc_85306:
cmp [rbp+var_3C], 0
jbe short loc_8536C
mov rax, [rbp+var_10]
mov rax, [rax]
mov al, [rax]
mov [rbp+var_31], al
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 1
mov [rax], rcx
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 4
mov [rax], rcx
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov edx, [rbp+var_1C]
mov al, [rbp+var_31]
mov r8, [rbp+var_28]
movzx ecx, al
call sp_get_point_mbr
cmp eax, 0
jz short loc_8535F
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_85504
loc_8535F:
jmp short $+2
loc_85361:
mov eax, [rbp+var_3C]
add eax, 0FFFFFFFFh
mov [rbp+var_3C], eax
jmp short loc_85306
loc_8536C:
mov [rbp+var_30], 0
jmp loc_854FE
loc_85378:
mov rax, [rbp+var_10]; jumptable 0000000000085284 case 5
mov rax, [rax]
mov eax, [rax]
mov [rbp+var_40], eax
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 4
mov [rax], rcx
loc_85392:
cmp [rbp+var_40], 0
jbe short loc_853F8
mov rax, [rbp+var_10]
mov rax, [rax]
mov al, [rax]
mov [rbp+var_31], al
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 1
mov [rax], rcx
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 4
mov [rax], rcx
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov edx, [rbp+var_1C]
mov al, [rbp+var_31]
mov r8, [rbp+var_28]
movzx ecx, al
call sp_get_linestring_mbr
cmp eax, 0
jz short loc_853EB
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_85504
loc_853EB:
jmp short $+2
loc_853ED:
mov eax, [rbp+var_40]
add eax, 0FFFFFFFFh
mov [rbp+var_40], eax
jmp short loc_85392
loc_853F8:
mov [rbp+var_30], 0
jmp loc_854FE
loc_85404:
mov rax, [rbp+var_10]; jumptable 0000000000085284 case 6
mov rax, [rax]
mov eax, [rax]
mov [rbp+var_44], eax
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 4
mov [rax], rcx
loc_8541E:
cmp [rbp+var_44], 0
jbe short loc_85484
mov rax, [rbp+var_10]
mov rax, [rax]
mov al, [rax]
mov [rbp+var_31], al
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 1
mov [rax], rcx
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 4
mov [rax], rcx
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov edx, [rbp+var_1C]
mov al, [rbp+var_31]
mov r8, [rbp+var_28]
movzx ecx, al
call sp_get_polygon_mbr
cmp eax, 0
jz short loc_85477
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_85504
loc_85477:
jmp short $+2
loc_85479:
mov eax, [rbp+var_44]
add eax, 0FFFFFFFFh
mov [rbp+var_44], eax
jmp short loc_8541E
loc_85484:
mov [rbp+var_30], 0
jmp short loc_854FE
loc_8548D:
cmp [rbp+var_2C], 0; jumptable 0000000000085284 case 7
jnz short loc_8549C
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_85504
loc_8549C:
mov rax, [rbp+var_10]
mov rax, [rax]
mov eax, [rax]
mov [rbp+var_48], eax
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 4
mov [rax], rcx
loc_854B6:
cmp [rbp+var_48], 0
jbe short loc_854EE
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov edx, [rbp+var_1C]
mov rcx, [rbp+var_28]
xor r8d, r8d
call sp_get_geometry_mbr
cmp eax, 0
jz short loc_854E1
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_85504
loc_854E1:
jmp short $+2
loc_854E3:
mov eax, [rbp+var_48]
add eax, 0FFFFFFFFh
mov [rbp+var_48], eax
jmp short loc_854B6
loc_854EE:
mov [rbp+var_30], 0
jmp short loc_854FE
def_85284:
mov [rbp+var_30], 0FFFFFFFFh; jumptable 0000000000085284 default case
loc_854FE:
mov eax, [rbp+var_30]
mov [rbp+var_4], eax
loc_85504:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
| long long sp_get_geometry_mbr(unsigned __int8 **a1, long long a2, unsigned int a3, long long a4, int a5)
{
int v6; // [rsp+8h] [rbp-48h]
int v7; // [rsp+Ch] [rbp-44h]
int v8; // [rsp+10h] [rbp-40h]
int v9; // [rsp+14h] [rbp-3Ch]
int v10; // [rsp+18h] [rbp-38h]
unsigned __int8 v11; // [rsp+1Fh] [rbp-31h]
unsigned __int8 v12; // [rsp+1Fh] [rbp-31h]
unsigned __int8 v13; // [rsp+1Fh] [rbp-31h]
unsigned __int8 v14; // [rsp+1Fh] [rbp-31h]
v11 = *(*a1)++;
v10 = *(_DWORD *)*a1;
*a1 += 4;
switch ( v10 )
{
case 1:
return (unsigned int)sp_get_point_mbr(a1, a2, a3, v11, a4);
case 2:
return (unsigned int)sp_get_linestring_mbr(a1, a2, a3, v11, a4);
case 3:
return (unsigned int)sp_get_polygon_mbr(a1, a2, a3, v11, a4);
case 4:
v9 = *(_DWORD *)*a1;
*a1 += 4;
while ( 2 )
{
if ( !v9 )
return 0;
v12 = *(*a1)++;
*a1 += 4;
if ( !(unsigned int)sp_get_point_mbr(a1, a2, a3, v12, a4) )
{
--v9;
continue;
}
return (unsigned int)-1;
}
case 5:
v8 = *(_DWORD *)*a1;
*a1 += 4;
while ( 2 )
{
if ( !v8 )
return 0;
v13 = *(*a1)++;
*a1 += 4;
if ( !(unsigned int)sp_get_linestring_mbr(a1, a2, a3, v13, a4) )
{
--v8;
continue;
}
return (unsigned int)-1;
}
case 6:
v7 = *(_DWORD *)*a1;
*a1 += 4;
while ( 2 )
{
if ( !v7 )
return 0;
v14 = *(*a1)++;
*a1 += 4;
if ( !(unsigned int)sp_get_polygon_mbr(a1, a2, a3, v14, a4) )
{
--v7;
continue;
}
break;
}
return (unsigned int)-1;
case 7:
if ( !a5 )
return (unsigned int)-1;
v6 = *(_DWORD *)*a1;
*a1 += 4;
break;
default:
return (unsigned int)-1;
}
while ( v6 )
{
if ( (unsigned int)sp_get_geometry_mbr(a1, a2, a3, a4, 0LL) )
return (unsigned int)-1;
--v6;
}
return 0;
}
| sp_get_geometry_mbr:
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 qword ptr [RBP + -0x28],RCX
MOV dword ptr [RBP + -0x2c],R8D
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x31],AL
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
INC RCX
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x38],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x4
MOV qword ptr [RAX],RCX
MOV EAX,dword ptr [RBP + -0x38]
DEC EAX
MOV ECX,EAX
MOV qword ptr [RBP + -0x50],RCX
SUB EAX,0x6
JA 0x001854f7
MOV RAX,qword ptr [RBP + -0x50]
LEA RCX,[0x263044]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
MOV AL,byte ptr [RBP + -0x31]
MOV R8,qword ptr [RBP + -0x28]
MOVZX ECX,AL
CALL 0x00185510
MOV dword ptr [RBP + -0x30],EAX
JMP 0x001854fe
caseD_2:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
MOV AL,byte ptr [RBP + -0x31]
MOV R8,qword ptr [RBP + -0x28]
MOVZX ECX,AL
CALL 0x00185550
MOV dword ptr [RBP + -0x30],EAX
JMP 0x001854fe
caseD_3:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
MOV AL,byte ptr [RBP + -0x31]
MOV R8,qword ptr [RBP + -0x28]
MOVZX ECX,AL
CALL 0x001855e0
MOV dword ptr [RBP + -0x30],EAX
JMP 0x001854fe
caseD_4:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x3c],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x4
MOV qword ptr [RAX],RCX
LAB_00185306:
CMP dword ptr [RBP + -0x3c],0x0
JBE 0x0018536c
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x31],AL
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x1
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x4
MOV qword ptr [RAX],RCX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
MOV AL,byte ptr [RBP + -0x31]
MOV R8,qword ptr [RBP + -0x28]
MOVZX ECX,AL
CALL 0x00185510
CMP EAX,0x0
JZ 0x0018535f
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00185504
LAB_0018535f:
JMP 0x00185361
LAB_00185361:
MOV EAX,dword ptr [RBP + -0x3c]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x00185306
LAB_0018536c:
MOV dword ptr [RBP + -0x30],0x0
JMP 0x001854fe
caseD_5:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x40],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x4
MOV qword ptr [RAX],RCX
LAB_00185392:
CMP dword ptr [RBP + -0x40],0x0
JBE 0x001853f8
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x31],AL
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x1
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x4
MOV qword ptr [RAX],RCX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
MOV AL,byte ptr [RBP + -0x31]
MOV R8,qword ptr [RBP + -0x28]
MOVZX ECX,AL
CALL 0x00185550
CMP EAX,0x0
JZ 0x001853eb
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00185504
LAB_001853eb:
JMP 0x001853ed
LAB_001853ed:
MOV EAX,dword ptr [RBP + -0x40]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x40],EAX
JMP 0x00185392
LAB_001853f8:
MOV dword ptr [RBP + -0x30],0x0
JMP 0x001854fe
caseD_6:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x44],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x4
MOV qword ptr [RAX],RCX
LAB_0018541e:
CMP dword ptr [RBP + -0x44],0x0
JBE 0x00185484
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x31],AL
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x1
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x4
MOV qword ptr [RAX],RCX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
MOV AL,byte ptr [RBP + -0x31]
MOV R8,qword ptr [RBP + -0x28]
MOVZX ECX,AL
CALL 0x001855e0
CMP EAX,0x0
JZ 0x00185477
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00185504
LAB_00185477:
JMP 0x00185479
LAB_00185479:
MOV EAX,dword ptr [RBP + -0x44]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x44],EAX
JMP 0x0018541e
LAB_00185484:
MOV dword ptr [RBP + -0x30],0x0
JMP 0x001854fe
caseD_7:
CMP dword ptr [RBP + -0x2c],0x0
JNZ 0x0018549c
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00185504
LAB_0018549c:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x48],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x4
MOV qword ptr [RAX],RCX
LAB_001854b6:
CMP dword ptr [RBP + -0x48],0x0
JBE 0x001854ee
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x28]
XOR R8D,R8D
CALL 0x00185210
CMP EAX,0x0
JZ 0x001854e1
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00185504
LAB_001854e1:
JMP 0x001854e3
LAB_001854e3:
MOV EAX,dword ptr [RBP + -0x48]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x48],EAX
JMP 0x001854b6
LAB_001854ee:
MOV dword ptr [RBP + -0x30],0x0
JMP 0x001854fe
default:
MOV dword ptr [RBP + -0x30],0xffffffff
LAB_001854fe:
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x4],EAX
LAB_00185504:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
int4
sp_get_geometry_mbr(long *param_1,int8 param_2,int4 param_3,int8 param_4,
int param_5)
{
int1 uVar1;
int4 uVar2;
int iVar3;
int local_50;
int local_4c;
int local_48;
int local_44;
int4 local_38;
uVar1 = *(int1 *)*param_1;
*param_1 = *param_1 + 1;
uVar2 = *(int4 *)*param_1;
*param_1 = *param_1 + 4;
switch(uVar2) {
case 1:
local_38 = sp_get_point_mbr(param_1,param_2,param_3,uVar1,param_4);
break;
case 2:
local_38 = sp_get_linestring_mbr(param_1,param_2,param_3,uVar1,param_4);
break;
case 3:
local_38 = sp_get_polygon_mbr(param_1,param_2,param_3,uVar1,param_4);
break;
case 4:
local_44 = *(int *)*param_1;
*param_1 = *param_1 + 4;
for (; local_44 != 0; local_44 = local_44 + -1) {
uVar1 = *(int1 *)*param_1;
*param_1 = *param_1 + 1;
*param_1 = *param_1 + 4;
iVar3 = sp_get_point_mbr(param_1,param_2,param_3,uVar1,param_4);
if (iVar3 != 0) {
return 0xffffffff;
}
}
local_38 = 0;
break;
case 5:
local_48 = *(int *)*param_1;
*param_1 = *param_1 + 4;
for (; local_48 != 0; local_48 = local_48 + -1) {
uVar1 = *(int1 *)*param_1;
*param_1 = *param_1 + 1;
*param_1 = *param_1 + 4;
iVar3 = sp_get_linestring_mbr(param_1,param_2,param_3,uVar1,param_4);
if (iVar3 != 0) {
return 0xffffffff;
}
}
local_38 = 0;
break;
case 6:
local_4c = *(int *)*param_1;
*param_1 = *param_1 + 4;
for (; local_4c != 0; local_4c = local_4c + -1) {
uVar1 = *(int1 *)*param_1;
*param_1 = *param_1 + 1;
*param_1 = *param_1 + 4;
iVar3 = sp_get_polygon_mbr(param_1,param_2,param_3,uVar1,param_4);
if (iVar3 != 0) {
return 0xffffffff;
}
}
local_38 = 0;
break;
case 7:
if (param_5 == 0) {
return 0xffffffff;
}
local_50 = *(int *)*param_1;
*param_1 = *param_1 + 4;
for (; local_50 != 0; local_50 = local_50 + -1) {
iVar3 = sp_get_geometry_mbr(param_1,param_2,param_3,param_4,0);
if (iVar3 != 0) {
return 0xffffffff;
}
}
local_38 = 0;
break;
default:
local_38 = 0xffffffff;
}
return local_38;
}
|
|
5,873 | _gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>> 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>>>>::find<char const (&) [5], 0>(char const (&) [5]) | hkr04[P]cpp-mcp/common/json.hpp | iterator find(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
return it;
}
}
return Container::end();
} | O0 | cpp | _gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>> 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>>>>::find<char const (&) [5], 0>(char const (&) [5]):
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x9f80
movq %rax, 0x30(%rsp)
movq 0x10(%rsp), %rdi
callq 0x9fb0
movq %rax, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x9fe0
testb $0x1, %al
jne 0x4c9c6
jmp 0x4ca06
movq 0x10(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x11ad0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x20(%rsp), %rdx
callq 0x4ca20
testb $0x1, %al
jne 0x4c9f6
jmp 0x4c9f8
jmp 0x4ca15
jmp 0x4c9fa
leaq 0x30(%rsp), %rdi
callq 0xa060
jmp 0x4c9a2
movq 0x10(%rsp), %rdi
callq 0x9fb0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA5_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_:
sub rsp, 38h
mov [rsp+38h+var_10], rdi
mov [rsp+38h+var_18], rsi
mov rdi, [rsp+38h+var_10]
mov [rsp+38h+var_28], rdi
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE5beginEv; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::begin(void)
mov [rsp+38h+var_8], rax
loc_4C9A2:
mov rdi, [rsp+38h+var_28]
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE3endEv; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::end(void)
mov [rsp+38h+var_20], rax
lea rdi, [rsp+38h+var_8]
lea rsi, [rsp+38h+var_20]
call _ZN9__gnu_cxxneIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEEbRKNS_17__normal_iteratorIT_T0_EESR_; __gnu_cxx::operator!=<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>(__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>> const&,__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>> const&)
test al, 1
jnz short loc_4C9C6
jmp short loc_4CA06
loc_4C9C6:
mov rax, [rsp+38h+var_28]
add rax, 18h
mov [rsp+38h+var_30], rax
lea rdi, [rsp+38h+var_8]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEptEv; __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::operator->(void)
mov rdi, [rsp+38h+var_30]
mov rsi, rax
mov rdx, [rsp+38h+var_18]
call _ZNKSt8equal_toIvEclIRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA5_KcEEDTeqclsr3stdE7forwardIT_Efp_Eclsr3stdE7forwardIT0_Efp0_EEOSD_OSE_
test al, 1
jnz short loc_4C9F6
jmp short loc_4C9F8
loc_4C9F6:
jmp short loc_4CA15
loc_4C9F8:
jmp short $+2
loc_4C9FA:
lea rdi, [rsp+38h+var_8]
call _ZN9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEppEv; __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::operator++(void)
jmp short loc_4C9A2
loc_4CA06:
mov rdi, [rsp+38h+var_28]
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE3endEv; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::end(void)
mov [rsp+38h+var_8], rax
loc_4CA15:
mov rax, [rsp+38h+var_8]
add rsp, 38h
retn
| long long ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA5_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_(
long long a1,
long long a2)
{
long long v2; // rax
long long v4; // [rsp+18h] [rbp-20h] BYREF
long long v5; // [rsp+20h] [rbp-18h]
long long v6; // [rsp+28h] [rbp-10h]
long long i; // [rsp+30h] [rbp-8h] BYREF
v6 = a1;
v5 = a2;
for ( i = std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::begin(a1);
;
__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::operator++(&i) )
{
v4 = std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::end(a1);
if ( !__gnu_cxx::operator!=<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>(
(long long)&i,
(long long)&v4) )
break;
v2 = __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::operator->((long long)&i);
if ( (std::equal_to<void>::operator()<std::string const&,char const(&)[5]>(a1 + 24, v2, v5) & 1) != 0 )
return i;
}
return std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::end(a1);
}
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA5_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RDI
MOV qword ptr [RSP + 0x20],RSI
MOV RDI,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x10],RDI
CALL 0x00109f80
MOV qword ptr [RSP + 0x30],RAX
LAB_0014c9a2:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x00109fb0
MOV qword ptr [RSP + 0x18],RAX
LEA RDI,[RSP + 0x30]
LEA RSI,[RSP + 0x18]
CALL 0x00109fe0
TEST AL,0x1
JNZ 0x0014c9c6
JMP 0x0014ca06
LAB_0014c9c6:
MOV RAX,qword ptr [RSP + 0x10]
ADD RAX,0x18
MOV qword ptr [RSP + 0x8],RAX
LEA RDI,[RSP + 0x30]
CALL 0x00111ad0
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,RAX
MOV RDX,qword ptr [RSP + 0x20]
CALL 0x0014ca20
TEST AL,0x1
JNZ 0x0014c9f6
JMP 0x0014c9f8
LAB_0014c9f6:
JMP 0x0014ca15
LAB_0014c9f8:
JMP 0x0014c9fa
LAB_0014c9fa:
LEA RDI,[RSP + 0x30]
CALL 0x0010a060
JMP 0x0014c9a2
LAB_0014ca06:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x00109fb0
MOV qword ptr [RSP + 0x30],RAX
LAB_0014ca15:
MOV RAX,qword ptr [RSP + 0x30]
ADD RSP,0x38
RET
|
int8
_ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA5_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_
(vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*param_1,char *param_2)
{
bool bVar1;
string *psVar2;
ulong uVar3;
int8 uVar4;
int8 local_20;
char *local_18;
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*local_10;
int8 local_8;
local_18 = param_2;
local_10 = param_1;
local_8 = std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::begin(param_1);
while( true ) {
local_20 = std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::end(param_1);
bVar1 = __gnu_cxx::operator!=((__normal_iterator *)&local_8,(__normal_iterator *)&local_20);
if (!bVar1) {
uVar4 = std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::end(param_1);
return uVar4;
}
psVar2 = (string *)
__gnu_cxx::
__normal_iterator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>*,std::vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>>
::operator->((__normal_iterator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>*,std::vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>>
*)&local_8);
uVar3 = std::equal_to<void>::operator()((equal_to<void> *)(param_1 + 0x18),psVar2,local_18);
if ((uVar3 & 1) != 0) break;
__gnu_cxx::
__normal_iterator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>*,std::vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>>
::operator++((__normal_iterator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>*,std::vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>>
*)&local_8);
}
return local_8;
}
|
|
5,874 | _gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>> 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>>>>::find<char const (&) [5], 0>(char const (&) [5]) | hkr04[P]cpp-mcp/common/json.hpp | iterator find(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
return it;
}
}
return Container::end();
} | O2 | cpp | _gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>> 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>>>>::find<char const (&) [5], 0>(char const (&) [5]):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %r14
movq 0x8(%r15), %rax
cmpq %rax, %r14
je 0x189cf
movq %r14, %rdi
movq %rbx, %rsi
callq 0xaabd
testb %al, %al
jne 0x189cc
addq $0x30, %r14
jmp 0x189ae
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA7_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_:
push r15
push r14
push rbx
mov rbx, rsi
mov r15, rdi
mov r14, [rdi]
loc_189AE:
mov rax, [r15+8]
cmp r14, rax
jz short loc_189CF
mov rdi, r14
mov rsi, rbx
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jnz short loc_189CC
add r14, 30h ; '0'
jmp short loc_189AE
loc_189CC:
mov rax, r14
loc_189CF:
pop rbx
pop r14
pop r15
retn
| long long ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA7_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_(
long long *a1)
{
long long i; // r14
long long result; // rax
for ( i = *a1; ; i += 48LL )
{
result = a1[1];
if ( i == result )
break;
if ( std::operator==<char>(i) )
return i;
}
return result;
}
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA7_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R15,RDI
MOV R14,qword ptr [RDI]
LAB_001189ae:
MOV RAX,qword ptr [R15 + 0x8]
CMP R14,RAX
JZ 0x001189cf
MOV RDI,R14
MOV RSI,RBX
CALL 0x0010aabd
TEST AL,AL
JNZ 0x001189cc
ADD R14,0x30
JMP 0x001189ae
LAB_001189cc:
MOV RAX,R14
LAB_001189cf:
POP RBX
POP R14
POP R15
RET
|
string * _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA7_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_
(int8 *param_1,char *param_2)
{
bool bVar1;
string *psVar2;
string *psVar3;
psVar3 = (string *)*param_1;
while ((psVar2 = (string *)param_1[1], psVar3 != (string *)param_1[1] &&
(bVar1 = std::operator==(psVar3,param_2), psVar2 = psVar3, !bVar1))) {
psVar3 = psVar3 + 0x30;
}
return psVar2;
}
|
|
5,875 | ft_init_stopwords | eloqsql/storage/myisam/ft_stopwords.c | int ft_init_stopwords()
{
DBUG_ENTER("ft_init_stopwords");
if (!stopwords3)
{
if (!(stopwords3=(TREE *)my_malloc(mi_key_memory_ft_stopwords,
sizeof(TREE), MYF(0))))
DBUG_RETURN(-1);
init_tree(stopwords3,0,0,sizeof(FT_STOPWORD),(qsort_cmp2)&FT_STOPWORD_cmp,
(ft_stopword_file ? (tree_element_free)&FT_STOPWORD_free : 0),
NULL, MYF(0));
/*
Stopword engine currently does not support tricky
character sets UCS2, UTF16, UTF32.
Use latin1 to compare stopwords in case of these character sets.
It's also fine to use latin1 with the built-in stopwords.
*/
ft_stopword_cs= default_charset_info->mbminlen == 1 ?
default_charset_info : &my_charset_latin1;
}
if (ft_stopword_file)
{
File fd;
size_t len;
uchar *buffer, *start, *end;
FT_WORD w;
int error=-1;
if (!*ft_stopword_file)
DBUG_RETURN(0);
if ((fd=my_open(ft_stopword_file, O_RDONLY, MYF(MY_WME))) == -1)
DBUG_RETURN(-1);
len=(size_t)my_seek(fd, 0L, MY_SEEK_END, MYF(0));
my_seek(fd, 0L, MY_SEEK_SET, MYF(0));
if (!(start= buffer= my_malloc(mi_key_memory_ft_stopwords, len+1,
MYF(MY_WME))))
goto err0;
len=my_read(fd, buffer, len, MYF(MY_WME));
end=start+len;
while (ft_simple_get_word(ft_stopword_cs, &start, end, &w, TRUE))
{
if (ft_add_stopword(my_strndup(mi_key_memory_ft_stopwords,
(char*) w.pos, w.len, MYF(0))))
goto err1;
}
error=0;
err1:
my_free(buffer);
err0:
my_close(fd, MYF(MY_WME));
DBUG_RETURN(error);
}
else
{
/* compatibility mode: to be removed */
char **sws=(char **)ft_precompiled_stopwords;
for (;*sws;sws++)
{
if (ft_add_stopword(*sws))
DBUG_RETURN(-1);
}
ft_stopword_file="(built-in)"; /* for SHOW VARIABLES */
}
DBUG_RETURN(0);
} | O0 | c | ft_init_stopwords:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
cmpq $0x0, 0xbdc830(%rip) # 0xc7a200
jne 0x9da91
leaq 0xbdc86f(%rip), %rax # 0xc7a24c
movl (%rax), %edi
movl $0x298, %esi # imm = 0x298
xorl %eax, %eax
movl %eax, %edx
callq 0xf37f0
movq %rax, 0xbdc80c(%rip) # 0xc7a200
cmpq $0x0, %rax
jne 0x9da08
jmp 0x9d9fc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9dc3b
movq 0xbdc7f1(%rip), %rdi # 0xc7a200
leaq 0xbdc7e2(%rip), %rax # 0xc7a1f8
movq (%rax), %rcx
xorl %eax, %eax
movl %eax, %r9d
leaq 0x27b(%rip), %rax # 0x9dca0
cmpq $0x0, %rcx
cmovneq %rax, %r9
xorl %eax, %eax
movl %eax, %edx
movl $0x10, %ecx
leaq 0x213(%rip), %r8 # 0x9dc50
movq %rdx, %rsi
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0xfa350
leaq 0x221ebb(%rip), %rax # 0x2bf918
movq (%rax), %rax
cmpl $0x1, 0x98(%rax)
jne 0x9da79
leaq 0x221ea8(%rip), %rax # 0x2bf918
movq (%rax), %rax
movq %rax, -0x58(%rbp)
jmp 0x9da86
leaq 0x2c86d0(%rip), %rax # 0x366150
movq %rax, -0x58(%rbp)
jmp 0x9da86
movq -0x58(%rbp), %rax
movq %rax, 0xbdc777(%rip) # 0xc7a208
leaq 0xbdc760(%rip), %rax # 0xc7a1f8
cmpq $0x0, (%rax)
je 0x9dbe0
movl $0xffffffff, -0x44(%rbp) # imm = 0xFFFFFFFF
leaq 0xbdc748(%rip), %rax # 0xc7a1f8
movq (%rax), %rax
cmpb $0x0, (%rax)
jne 0x9dac6
jmp 0x9daba
movl $0x0, -0x4(%rbp)
jmp 0x9dc3b
leaq 0xbdc72b(%rip), %rax # 0xc7a1f8
movq (%rax), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0xf4200
movl %eax, -0x8(%rbp)
cmpl $-0x1, %eax
jne 0x9daf2
jmp 0x9dae6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9dc3b
movl -0x8(%rbp), %edi
xorl %eax, %eax
movl %eax, %ecx
movl $0x2, %edx
movq %rcx, %rsi
callq 0xf4c30
movq %rax, -0x10(%rbp)
movl -0x8(%rbp), %edi
xorl %eax, %eax
movl %eax, %ecx
xorl %edx, %edx
movq %rcx, %rsi
callq 0xf4c30
leaq 0xbdc72a(%rip), %rax # 0xc7a24c
movl (%rax), %edi
movq -0x10(%rbp), %rsi
addq $0x1, %rsi
movl $0x10, %edx
callq 0xf37f0
movq %rax, -0x18(%rbp)
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x9db49
jmp 0x9dbcb
movl -0x8(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl $0x10, %ecx
callq 0xf4a10
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0xbdc693(%rip), %rdi # 0xc7a208
movq -0x28(%rbp), %rdx
leaq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rcx
movl $0x1, %r8d
callq 0xa2050
cmpb $0x0, %al
je 0x9dbbb
leaq 0xbdc6b5(%rip), %rax # 0xc7a24c
movl (%rax), %edi
movq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0xf3ce0
movq %rax, %rdi
callq 0x9dcd0
cmpl $0x0, %eax
je 0x9dbb9
jmp 0x9dbc2
jmp 0x9db6e
movl $0x0, -0x44(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf3b70
movl -0x8(%rbp), %edi
movl $0x10, %esi
callq 0xf4490
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9dc3b
leaq 0x220619(%rip), %rax # 0x2be200
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
cmpq $0x0, (%rax)
je 0x9dc21
movq -0x50(%rbp), %rax
movq (%rax), %rdi
callq 0x9dcd0
cmpl $0x0, %eax
je 0x9dc11
jmp 0x9dc08
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9dc3b
jmp 0x9dc13
movq -0x50(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x50(%rbp)
jmp 0x9dbeb
leaq 0xbdc5d0(%rip), %rax # 0xc7a1f8
leaq 0xb5953(%rip), %rcx # 0x153582
movq %rcx, (%rax)
jmp 0x9dc34
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ft_init_stopwords:
push rbp
mov rbp, rsp
sub rsp, 70h
cmp cs:stopwords3, 0
jnz loc_9DA91
lea rax, mi_key_memory_ft_stopwords
mov edi, [rax]
mov esi, 298h
xor eax, eax
mov edx, eax
call my_malloc
mov cs:stopwords3, rax
cmp rax, 0
jnz short loc_9DA08
jmp short $+2
loc_9D9FC:
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_9DC3B
loc_9DA08:
mov rdi, cs:stopwords3
lea rax, ft_stopword_file
mov rcx, [rax]
xor eax, eax
mov r9d, eax
lea rax, FT_STOPWORD_free
cmp rcx, 0
cmovnz r9, rax
xor eax, eax
mov edx, eax
mov ecx, 10h
lea r8, FT_STOPWORD_cmp
mov rsi, rdx
mov [rsp+70h+var_70], 0
mov [rsp+70h+var_68], 0
call init_tree
lea rax, default_charset_info
mov rax, [rax]
cmp dword ptr [rax+98h], 1
jnz short loc_9DA79
lea rax, default_charset_info
mov rax, [rax]
mov [rbp+var_58], rax
jmp short loc_9DA86
loc_9DA79:
lea rax, my_charset_latin1
mov [rbp+var_58], rax
jmp short $+2
loc_9DA86:
mov rax, [rbp+var_58]
mov cs:ft_stopword_cs, rax
loc_9DA91:
lea rax, ft_stopword_file
cmp qword ptr [rax], 0
jz loc_9DBE0
mov [rbp+var_44], 0FFFFFFFFh
lea rax, ft_stopword_file
mov rax, [rax]
cmp byte ptr [rax], 0
jnz short loc_9DAC6
jmp short $+2
loc_9DABA:
mov [rbp+var_4], 0
jmp loc_9DC3B
loc_9DAC6:
lea rax, ft_stopword_file
mov rdi, [rax]
xor esi, esi
mov edx, 10h
call my_open
mov [rbp+var_8], eax
cmp eax, 0FFFFFFFFh
jnz short loc_9DAF2
jmp short $+2
loc_9DAE6:
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_9DC3B
loc_9DAF2:
mov edi, [rbp+var_8]
xor eax, eax
mov ecx, eax
mov edx, 2
mov rsi, rcx
call my_seek
mov [rbp+var_10], rax
mov edi, [rbp+var_8]
xor eax, eax
mov ecx, eax
xor edx, edx
mov rsi, rcx
call my_seek
lea rax, mi_key_memory_ft_stopwords
mov edi, [rax]
mov rsi, [rbp+var_10]
add rsi, 1
mov edx, 10h
call my_malloc
mov [rbp+var_18], rax
mov [rbp+var_20], rax
cmp rax, 0
jnz short loc_9DB49
jmp loc_9DBCB
loc_9DB49:
mov edi, [rbp+var_8]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_10]
mov ecx, 10h
call my_read
mov [rbp+var_10], rax
mov rax, [rbp+var_20]
add rax, [rbp+var_10]
mov [rbp+var_28], rax
loc_9DB6E:
mov rdi, cs:ft_stopword_cs
mov rdx, [rbp+var_28]
lea rsi, [rbp+var_20]
lea rcx, [rbp+var_40]
mov r8d, 1
call ft_simple_get_word
cmp al, 0
jz short loc_9DBBB
lea rax, mi_key_memory_ft_stopwords
mov edi, [rax]
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_30]
xor eax, eax
mov ecx, eax
call my_strndup
mov rdi, rax
call ft_add_stopword
cmp eax, 0
jz short loc_9DBB9
jmp short loc_9DBC2
loc_9DBB9:
jmp short loc_9DB6E
loc_9DBBB:
mov [rbp+var_44], 0
loc_9DBC2:
mov rdi, [rbp+var_18]
call my_free
loc_9DBCB:
mov edi, [rbp+var_8]
mov esi, 10h
call my_close
mov eax, [rbp+var_44]
mov [rbp+var_4], eax
jmp short loc_9DC3B
loc_9DBE0:
lea rax, ft_precompiled_stopwords
mov [rbp+var_50], rax
loc_9DBEB:
mov rax, [rbp+var_50]
cmp qword ptr [rax], 0
jz short loc_9DC21
mov rax, [rbp+var_50]
mov rdi, [rax]
call ft_add_stopword
cmp eax, 0
jz short loc_9DC11
jmp short $+2
loc_9DC08:
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_9DC3B
loc_9DC11:
jmp short $+2
loc_9DC13:
mov rax, [rbp+var_50]
add rax, 8
mov [rbp+var_50], rax
jmp short loc_9DBEB
loc_9DC21:
lea rax, ft_stopword_file
lea rcx, aBuiltIn; "(built-in)"
mov [rax], rcx
jmp short $+2
loc_9DC34:
mov [rbp+var_4], 0
loc_9DC3B:
mov eax, [rbp+var_4]
add rsp, 70h
pop rbp
retn
| long long ft_init_stopwords()
{
long long ( *v0)(); // r9
long long v1; // rax
void *v3; // [rsp+18h] [rbp-58h]
char **i; // [rsp+20h] [rbp-50h]
unsigned int v5; // [rsp+2Ch] [rbp-44h]
_QWORD v6[3]; // [rsp+30h] [rbp-40h] BYREF
long long v7; // [rsp+48h] [rbp-28h]
long long v8; // [rsp+50h] [rbp-20h] BYREF
long long v9; // [rsp+58h] [rbp-18h]
long long v10; // [rsp+60h] [rbp-10h]
unsigned int v11; // [rsp+68h] [rbp-8h]
if ( !stopwords3 )
{
stopwords3 = my_malloc(mi_key_memory_ft_stopwords, 664LL, 0LL);
if ( !stopwords3 )
return (unsigned int)-1;
LODWORD(v0) = 0;
if ( ft_stopword_file )
v0 = FT_STOPWORD_free;
init_tree(stopwords3, 0, 0, 16, (unsigned int)FT_STOPWORD_cmp, (_DWORD)v0, 0LL, 0LL);
if ( *((_DWORD *)default_charset_info + 38) == 1 )
v3 = default_charset_info;
else
v3 = &my_charset_latin1;
ft_stopword_cs = (long long)v3;
}
if ( ft_stopword_file )
{
v5 = -1;
if ( *ft_stopword_file )
{
v11 = my_open(ft_stopword_file, 0LL, 16LL);
if ( v11 == -1 )
{
return (unsigned int)-1;
}
else
{
v10 = my_seek(v11, 0LL, 2LL, 0LL);
my_seek(v11, 0LL, 0LL, 0LL);
v9 = my_malloc(mi_key_memory_ft_stopwords, v10 + 1, 16LL);
v8 = v9;
if ( v9 )
{
v10 = my_read(v11, v9, v10, 16LL);
v7 = v10 + v8;
while ( (unsigned __int8)ft_simple_get_word(ft_stopword_cs, &v8, v7, v6, 1LL) )
{
v1 = my_strndup(mi_key_memory_ft_stopwords, v6[0], v6[2], 0LL);
if ( (unsigned int)ft_add_stopword(v1) )
goto LABEL_21;
}
v5 = 0;
LABEL_21:
my_free(v9);
}
my_close(v11, 16LL);
return v5;
}
}
else
{
return 0;
}
}
else
{
for ( i = &ft_precompiled_stopwords; *i; ++i )
{
if ( (unsigned int)ft_add_stopword(*i) )
return (unsigned int)-1;
}
ft_stopword_file = "(built-in)";
return 0;
}
}
| ft_init_stopwords:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
CMP qword ptr [0x00d7a200],0x0
JNZ 0x0019da91
LEA RAX,[0xd7a24c]
MOV EDI,dword ptr [RAX]
MOV ESI,0x298
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001f37f0
MOV qword ptr [0x00d7a200],RAX
CMP RAX,0x0
JNZ 0x0019da08
JMP 0x0019d9fc
LAB_0019d9fc:
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x0019dc3b
LAB_0019da08:
MOV RDI,qword ptr [0x00d7a200]
LEA RAX,[0xd7a1f8]
MOV RCX,qword ptr [RAX]
XOR EAX,EAX
MOV R9D,EAX
LEA RAX,[0x19dca0]
CMP RCX,0x0
CMOVNZ R9,RAX
XOR EAX,EAX
MOV EDX,EAX
MOV ECX,0x10
LEA R8,[0x19dc50]
MOV RSI,RDX
MOV qword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],0x0
CALL 0x001fa350
LEA RAX,[0x3bf918]
MOV RAX,qword ptr [RAX]
CMP dword ptr [RAX + 0x98],0x1
JNZ 0x0019da79
LEA RAX,[0x3bf918]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x58],RAX
JMP 0x0019da86
LAB_0019da79:
LEA RAX,[0x466150]
MOV qword ptr [RBP + -0x58],RAX
JMP 0x0019da86
LAB_0019da86:
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [0x00d7a208],RAX
LAB_0019da91:
LEA RAX,[0xd7a1f8]
CMP qword ptr [RAX],0x0
JZ 0x0019dbe0
MOV dword ptr [RBP + -0x44],0xffffffff
LEA RAX,[0xd7a1f8]
MOV RAX,qword ptr [RAX]
CMP byte ptr [RAX],0x0
JNZ 0x0019dac6
JMP 0x0019daba
LAB_0019daba:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0019dc3b
LAB_0019dac6:
LEA RAX,[0xd7a1f8]
MOV RDI,qword ptr [RAX]
XOR ESI,ESI
MOV EDX,0x10
CALL 0x001f4200
MOV dword ptr [RBP + -0x8],EAX
CMP EAX,-0x1
JNZ 0x0019daf2
JMP 0x0019dae6
LAB_0019dae6:
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x0019dc3b
LAB_0019daf2:
MOV EDI,dword ptr [RBP + -0x8]
XOR EAX,EAX
MOV ECX,EAX
MOV EDX,0x2
MOV RSI,RCX
CALL 0x001f4c30
MOV qword ptr [RBP + -0x10],RAX
MOV EDI,dword ptr [RBP + -0x8]
XOR EAX,EAX
MOV ECX,EAX
XOR EDX,EDX
MOV RSI,RCX
CALL 0x001f4c30
LEA RAX,[0xd7a24c]
MOV EDI,dword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x1
MOV EDX,0x10
CALL 0x001f37f0
MOV qword ptr [RBP + -0x18],RAX
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JNZ 0x0019db49
JMP 0x0019dbcb
LAB_0019db49:
MOV EDI,dword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,0x10
CALL 0x001f4a10
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RAX
LAB_0019db6e:
MOV RDI,qword ptr [0x00d7a208]
MOV RDX,qword ptr [RBP + -0x28]
LEA RSI,[RBP + -0x20]
LEA RCX,[RBP + -0x40]
MOV R8D,0x1
CALL 0x001a2050
CMP AL,0x0
JZ 0x0019dbbb
LEA RAX,[0xd7a24c]
MOV EDI,dword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x30]
XOR EAX,EAX
MOV ECX,EAX
CALL 0x001f3ce0
MOV RDI,RAX
CALL 0x0019dcd0
CMP EAX,0x0
JZ 0x0019dbb9
JMP 0x0019dbc2
LAB_0019dbb9:
JMP 0x0019db6e
LAB_0019dbbb:
MOV dword ptr [RBP + -0x44],0x0
LAB_0019dbc2:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001f3b70
LAB_0019dbcb:
MOV EDI,dword ptr [RBP + -0x8]
MOV ESI,0x10
CALL 0x001f4490
MOV EAX,dword ptr [RBP + -0x44]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0019dc3b
LAB_0019dbe0:
LEA RAX,[0x3be200]
MOV qword ptr [RBP + -0x50],RAX
LAB_0019dbeb:
MOV RAX,qword ptr [RBP + -0x50]
CMP qword ptr [RAX],0x0
JZ 0x0019dc21
MOV RAX,qword ptr [RBP + -0x50]
MOV RDI,qword ptr [RAX]
CALL 0x0019dcd0
CMP EAX,0x0
JZ 0x0019dc11
JMP 0x0019dc08
LAB_0019dc08:
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x0019dc3b
LAB_0019dc11:
JMP 0x0019dc13
LAB_0019dc13:
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x8
MOV qword ptr [RBP + -0x50],RAX
JMP 0x0019dbeb
LAB_0019dc21:
LEA RAX,[0xd7a1f8]
LEA RCX,[0x253582]
MOV qword ptr [RAX],RCX
JMP 0x0019dc34
LAB_0019dc34:
MOV dword ptr [RBP + -0x4],0x0
LAB_0019dc3b:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x70
POP RBP
RET
|
int4 ft_init_stopwords(void)
{
char cVar1;
int iVar2;
int8 uVar3;
code *pcVar4;
int4 *local_60;
int **local_58;
int4 local_4c;
int8 local_48 [2];
int8 local_38;
long local_30;
long local_28;
long local_20;
long local_18;
int local_10;
int4 local_c;
if (stopwords3 == 0) {
stopwords3 = my_malloc(mi_key_memory_ft_stopwords,0x298,0);
if (stopwords3 == 0) {
return 0xffffffff;
}
pcVar4 = (code *)0x0;
if (ft_stopword_file != (char *)0x0) {
pcVar4 = FT_STOPWORD_free;
}
init_tree(stopwords3,0,0,0x10,FT_STOPWORD_cmp,pcVar4,0,0);
if (*(int *)(default_charset_info + 0x98) == 1) {
local_60 = (int4 *)default_charset_info;
}
else {
local_60 = &my_charset_latin1;
}
ft_stopword_cs = local_60;
}
if (ft_stopword_file == (char *)0x0) {
for (local_58 = &ft_precompiled_stopwords; *local_58 != (int *)0x0;
local_58 = local_58 + 1) {
iVar2 = ft_add_stopword(*local_58);
if (iVar2 != 0) {
return 0xffffffff;
}
}
ft_stopword_file = "(built-in)";
local_c = 0;
}
else {
local_4c = 0xffffffff;
if (*ft_stopword_file == '\0') {
local_c = 0;
}
else {
local_10 = my_open(ft_stopword_file,0,0x10);
if (local_10 == -1) {
local_c = 0xffffffff;
}
else {
local_18 = my_seek(local_10,0,2);
my_seek(local_10,0,0);
local_28 = my_malloc(mi_key_memory_ft_stopwords,local_18 + 1,0x10);
local_20 = local_28;
if (local_28 != 0) {
local_18 = my_read(local_10,local_28,local_18,0x10);
local_30 = local_28 + local_18;
do {
cVar1 = ft_simple_get_word(ft_stopword_cs,&local_28,local_30,local_48,1);
if (cVar1 == '\0') {
local_4c = 0;
break;
}
uVar3 = my_strndup(mi_key_memory_ft_stopwords,local_48[0],local_38,0);
iVar2 = ft_add_stopword(uVar3);
} while (iVar2 == 0);
my_free(local_20);
}
my_close(local_10,0x10);
local_c = local_4c;
}
}
}
return local_c;
}
|
|
5,876 | my_register_filename | eloqsql/mysys/my_open.c | File my_register_filename(File fd, const char *FileName, enum file_type
type_of_file, uint error_message_number, myf MyFlags)
{
DBUG_ENTER("my_register_filename");
if ((int) fd >= MY_FILE_MIN)
{
my_atomic_add32_explicit(&my_file_opened, 1, MY_MEMORY_ORDER_RELAXED);
if ((uint) fd >= my_file_limit || (MyFlags & MY_NO_REGISTER))
DBUG_RETURN(fd);
my_file_info[fd].name = my_strdup(key_memory_my_file_info, FileName, MyFlags);
statistic_increment(my_file_total_opened,&THR_LOCK_open);
my_file_info[fd].type = type_of_file;
DBUG_PRINT("exit",("fd: %d",fd));
DBUG_RETURN(fd);
}
my_errno= errno;
DBUG_PRINT("error",("Got error %d on open", my_errno));
if (MyFlags & (MY_FFNF | MY_FAE | MY_WME))
{
if (my_errno == EMFILE)
error_message_number= EE_OUT_OF_FILERESOURCES;
my_error(error_message_number,
MYF(ME_BELL | (MyFlags & (ME_NOTE | ME_ERROR_LOG))),
FileName, my_errno);
}
DBUG_RETURN(-1);
} | O3 | c | my_register_filename:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rsi, %r15
testl %edi, %edi
js 0x625c9
movl %edi, %ebx
leaq 0x35c6a9(%rip), %rax # 0x3bec14
lock
incl (%rax)
testl $0x2004, %r14d # imm = 0x2004
jne 0x62618
leaq 0x2db40e(%rip), %rax # 0x33d990
cmpl %ebx, (%rax)
jbe 0x62618
movl %edx, %r13d
leaq 0x35cbb0(%rip), %rax # 0x3bf144
movl (%rax), %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x621a8
leaq 0x2db3f0(%rip), %rcx # 0x33d998
movq (%rcx), %rdx
movl %ebx, %esi
shlq $0x4, %rsi
movq %rax, (%rdx,%rsi)
leaq 0x35c644(%rip), %rax # 0x3bec00
incq (%rax)
movq (%rcx), %rax
movl %r13d, 0x8(%rax,%rsi)
jmp 0x62618
movl %ecx, %r12d
callq 0x36a30
movl (%rax), %ebx
callq 0x6337a
movl %ebx, (%rax)
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
testb $0x19, %r14b
je 0x62618
callq 0x6337a
cmpl $0x18, (%rax)
movl $0x17, %eax
cmovel %eax, %r12d
andl $0x440, %r14d # imm = 0x440
orq $0x4, %r14
callq 0x6337a
movl (%rax), %ecx
movl %r12d, %edi
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x5e6bb
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_register_filename:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, r8
mov r15, rsi
test edi, edi
js short loc_625C9
mov ebx, edi
lea rax, my_file_opened
lock inc dword ptr [rax]
test r14d, 2004h
jnz loc_62618
lea rax, my_file_limit
cmp [rax], ebx
jbe loc_62618
mov r13d, edx
lea rax, key_memory_my_file_info
mov edi, [rax]
mov rsi, r15
mov rdx, r14
call my_strdup
lea rcx, my_file_info
mov rdx, [rcx]
mov esi, ebx
shl rsi, 4
mov [rdx+rsi], rax
lea rax, my_file_total_opened
inc qword ptr [rax]
mov rax, [rcx]
mov [rax+rsi+8], r13d
jmp short loc_62618
loc_625C9:
mov r12d, ecx
call ___errno_location
mov ebx, [rax]
call _my_thread_var
mov [rax], ebx
mov ebx, 0FFFFFFFFh
test r14b, 19h
jz short loc_62618
call _my_thread_var
cmp dword ptr [rax], 18h
mov eax, 17h
cmovz r12d, eax
and r14d, 440h
or r14, 4
call _my_thread_var
mov ecx, [rax]
mov edi, r12d
mov rsi, r14
mov rdx, r15
xor eax, eax
call my_error
loc_62618:
mov eax, ebx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_register_filename(long long a1, long long a2, int a3, unsigned int a4, __int16 a5)
{
unsigned int v6; // ebx
long long v8; // rax
long long v9; // rsi
int v11; // ebx
unsigned int *v12; // rax
if ( (int)a1 < 0 )
{
v11 = *(_DWORD *)__errno_location(a1);
*(_DWORD *)my_thread_var(a1) = v11;
v6 = -1;
if ( (a5 & 0x19) != 0 )
{
if ( *(_DWORD *)my_thread_var(a1) == 24 )
a4 = 23;
v12 = (unsigned int *)my_thread_var(a1);
my_error(a4, a5 & 0x440 | 4LL, a2, *v12);
}
}
else
{
v6 = a1;
_InterlockedIncrement(my_file_opened);
if ( (a5 & 0x2004) == 0 && my_file_limit > (unsigned int)a1 )
{
v8 = my_strdup(key_memory_my_file_info, a2, a5);
v9 = 16LL * (unsigned int)a1;
*(_QWORD *)((char *)my_file_info + v9) = v8;
++my_file_total_opened;
*(_DWORD *)((char *)my_file_info + v9 + 8) = a3;
}
}
return v6;
}
| my_register_filename:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,R8
MOV R15,RSI
TEST EDI,EDI
JS 0x001625c9
MOV EBX,EDI
LEA RAX,[0x4bec14]
INC.LOCK dword ptr [RAX]
TEST R14D,0x2004
JNZ 0x00162618
LEA RAX,[0x43d990]
CMP dword ptr [RAX],EBX
JBE 0x00162618
MOV R13D,EDX
LEA RAX,[0x4bf144]
MOV EDI,dword ptr [RAX]
MOV RSI,R15
MOV RDX,R14
CALL 0x001621a8
LEA RCX,[0x43d998]
MOV RDX,qword ptr [RCX]
MOV ESI,EBX
SHL RSI,0x4
MOV qword ptr [RDX + RSI*0x1],RAX
LEA RAX,[0x4bec00]
INC qword ptr [RAX]
MOV RAX,qword ptr [RCX]
MOV dword ptr [RAX + RSI*0x1 + 0x8],R13D
JMP 0x00162618
LAB_001625c9:
MOV R12D,ECX
CALL 0x00136a30
MOV EBX,dword ptr [RAX]
CALL 0x0016337a
MOV dword ptr [RAX],EBX
MOV EBX,0xffffffff
TEST R14B,0x19
JZ 0x00162618
CALL 0x0016337a
CMP dword ptr [RAX],0x18
MOV EAX,0x17
CMOVZ R12D,EAX
AND R14D,0x440
OR R14,0x4
CALL 0x0016337a
MOV ECX,dword ptr [RAX]
MOV EDI,R12D
MOV RSI,R14
MOV RDX,R15
XOR EAX,EAX
CALL 0x0015e6bb
LAB_00162618:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
uint my_register_filename
(uint param_1,int8 param_2,int4 param_3,int4 param_4,ulong param_5)
{
int iVar1;
int8 uVar2;
int *piVar3;
int4 *puVar4;
if ((int)param_1 < 0) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar3 = (int *)_my_thread_var();
*piVar3 = iVar1;
param_1 = 0xffffffff;
if ((param_5 & 0x19) != 0) {
piVar3 = (int *)_my_thread_var();
if (*piVar3 == 0x18) {
param_4 = 0x17;
}
puVar4 = (int4 *)_my_thread_var();
my_error(param_4,(uint)param_5 & 0x440 | 4,param_2,*puVar4);
}
}
else {
LOCK();
my_file_opened = my_file_opened + 1;
UNLOCK();
if (((param_5 & 0x2004) == 0) && (param_1 < my_file_limit)) {
uVar2 = my_strdup(key_memory_my_file_info,param_2,param_5);
*(int8 *)(my_file_info + (ulong)param_1 * 0x10) = uVar2;
my_file_total_opened = my_file_total_opened + 1;
*(int4 *)(my_file_info + (ulong)param_1 * 0x10 + 8) = param_3;
}
}
return param_1;
}
|
|
5,877 | mz_zip_writer_compute_padding_needed_for_file_alignment | 7CodeWizard[P]stablediffusion/thirdparty/miniz.h | static mz_uint
mz_zip_writer_compute_padding_needed_for_file_alignment(mz_zip_archive *pZip) {
mz_uint32 n;
if (!pZip->m_file_offset_alignment)
return 0;
n = (mz_uint32)(pZip->m_archive_size & (pZip->m_file_offset_alignment - 1));
return (mz_uint)((pZip->m_file_offset_alignment - n) &
(pZip->m_file_offset_alignment - 1));
} | O2 | c | mz_zip_writer_compute_padding_needed_for_file_alignment:
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x620cd
leal -0x1(%rax), %ecx
movl (%rdi), %edx
andl %ecx, %edx
subl %edx, %eax
andl %ecx, %eax
retq
xorl %eax, %eax
retq
| mz_zip_writer_compute_padding_needed_for_file_alignment:
mov rax, [rdi+20h]
test rax, rax
jz short loc_620CD
lea ecx, [rax-1]
mov edx, [rdi]
and edx, ecx
sub eax, edx
and eax, ecx
retn
loc_620CD:
xor eax, eax
retn
| long long mz_zip_writer_compute_padding_needed_for_file_alignment(long long a1)
{
long long v1; // rax
v1 = *(_QWORD *)(a1 + 32);
if ( v1 )
return ((_DWORD)v1 - 1) & ((unsigned int)v1 - (((_DWORD)v1 - 1) & *(_DWORD *)a1));
else
return 0LL;
}
| mz_zip_writer_compute_padding_needed_for_file_alignment:
MOV RAX,qword ptr [RDI + 0x20]
TEST RAX,RAX
JZ 0x001620cd
LEA ECX,[RAX + -0x1]
MOV EDX,dword ptr [RDI]
AND EDX,ECX
SUB EAX,EDX
AND EAX,ECX
RET
LAB_001620cd:
XOR EAX,EAX
RET
|
uint mz_zip_writer_compute_padding_needed_for_file_alignment(uint *param_1)
{
int iVar1;
uint uVar2;
if (*(long *)(param_1 + 8) != 0) {
iVar1 = (int)*(long *)(param_1 + 8);
uVar2 = iVar1 - 1;
return iVar1 - (*param_1 & uVar2) & uVar2;
}
return 0;
}
|
|
5,878 | 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>>>>>::get_token_string() const | monkey531[P]llama/common/./json.hpp | std::string get_token_string() const
{
// escape control characters
std::string result;
for (const auto c : token_string)
{
if (static_cast<unsigned char>(c) <= '\x1F')
{
// escape control characters
std::array<char, 9> cs{{}};
static_cast<void>((std::snprintf)(cs.data(), cs.size(), "<U+%.4X>", static_cast<unsigned char>(c))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
result += cs.data();
}
else
{
// add character as is
result.push_back(static_cast<std::string::value_type>(c));
}
}
return result;
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<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>>>>>::get_token_string() const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x38(%rsi), %r13
movq 0x40(%rsi), %rbp
cmpq %rbp, %r13
je 0x3325b
leaq 0x830c0(%rip), %r14 # 0xb62cc
leaq 0x8(%rsp), %r15
movzbl (%r13), %ecx
cmpl $0x1f, %ecx
ja 0x33248
movb $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movl $0x9, %esi
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19ab0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19d30
jmp 0x33253
movsbl %cl, %esi
movq %rbx, %rdi
callq 0x195d0
incq %r13
cmpq %rbp, %r13
jne 0x33211
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3326f
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x33286
movq (%r12), %rsi
incq %rsi
callq 0x196d0
movq %r14, %rdi
callq 0x19c00
| _ZNK8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE16get_token_stringEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
lea r12, [rdi+10h]
mov [rdi], r12
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov r13, [rsi+38h]
mov rbp, [rsi+40h]
cmp r13, rbp
jz short loc_3325B
lea r14, aU4x; "<U+%.4X>"
lea r15, [rsp+48h+var_40]
loc_33211:
movzx ecx, byte ptr [r13+0]
cmp ecx, 1Fh
ja short loc_33248
mov [rsp+48h+var_38], 0
mov [rsp+48h+var_40], 0
mov esi, 9
mov rdi, r15
mov rdx, r14
xor eax, eax
call _snprintf
mov rdi, rbx
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
jmp short loc_33253
loc_33248:
movsx esi, cl
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
loc_33253:
inc r13
cmp r13, rbp
jnz short loc_33211
loc_3325B:
mov rax, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short $+2
loc_3326F:
mov r14, rax
mov rdi, [rbx]; void *
cmp rdi, r12
jz short loc_33286
mov rsi, [r12]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_33286:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get_token_string(
long long a1,
long long a2)
{
unsigned __int8 *v2; // r13
unsigned __int8 *i; // rbp
unsigned int v4; // ecx
long long v6; // [rsp+8h] [rbp-40h] BYREF
char v7; // [rsp+10h] [rbp-38h]
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v2 = *(unsigned __int8 **)(a2 + 56);
for ( i = *(unsigned __int8 **)(a2 + 64); v2 != i; ++v2 )
{
v4 = *v2;
if ( v4 > 0x1F )
{
std::string::push_back(a1, (unsigned int)(char)v4);
}
else
{
v7 = 0;
v6 = 0LL;
snprintf(&v6, 9LL, "<U+%.4X>", v4);
std::string::append(a1, &v6);
}
}
return a1;
}
| get_token_string:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
LEA R12,[RDI + 0x10]
MOV qword ptr [RDI],R12
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
MOV R13,qword ptr [RSI + 0x38]
MOV RBP,qword ptr [RSI + 0x40]
CMP R13,RBP
JZ 0x0013325b
LEA R14,[0x1b62cc]
LEA R15,[RSP + 0x8]
LAB_00133211:
MOVZX ECX,byte ptr [R13]
CMP ECX,0x1f
JA 0x00133248
MOV byte ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x8],0x0
MOV ESI,0x9
MOV RDI,R15
MOV RDX,R14
XOR EAX,EAX
CALL 0x00119ab0
LAB_0013323b:
MOV RDI,RBX
MOV RSI,R15
CALL 0x00119d30
JMP 0x00133253
LAB_00133248:
MOVSX ESI,CL
MOV RDI,RBX
CALL 0x001195d0
LAB_00133253:
INC R13
CMP R13,RBP
JNZ 0x00133211
LAB_0013325b:
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<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 > > >::get_token_string() const */
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::__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>>>
::get_token_string(void)
{
byte *pbVar1;
long in_RSI;
long *in_RDI;
byte *pbVar2;
char local_40 [16];
*in_RDI = (long)(in_RDI + 2);
in_RDI[1] = 0;
*(int1 *)(in_RDI + 2) = 0;
pbVar2 = *(byte **)(in_RSI + 0x38);
pbVar1 = *(byte **)(in_RSI + 0x40);
if (pbVar2 != pbVar1) {
do {
if (*pbVar2 < 0x20) {
local_40[8] = 0;
local_40[0] = '\0';
local_40[1] = '\0';
local_40[2] = '\0';
local_40[3] = '\0';
local_40[4] = '\0';
local_40[5] = '\0';
local_40[6] = '\0';
local_40[7] = '\0';
snprintf(local_40,9,"<U+%.4X>");
/* try { // try from 0013323b to 00133245 has its CatchHandler @ 0013326f */
std::__cxx11::string::append((char *)in_RDI);
}
else {
/* try { // try from 00133248 to 00133252 has its CatchHandler @ 0013326d */
std::__cxx11::string::push_back((char)in_RDI);
}
pbVar2 = pbVar2 + 1;
} while (pbVar2 != pbVar1);
}
return;
}
|
|
5,879 | my_char_weight_put | eloqsql/strings/ctype-uca.c | static my_bool
my_char_weight_put(MY_UCA_WEIGHT_LEVEL *dst,
uint16 *to, size_t to_length, size_t *nweights,
my_wc_t *str, size_t len)
{
size_t count;
int rc= FALSE;
if (!to_length)
{
*nweights= 0;
return len > 0;
}
to_length--; /* Without trailing zero */
for (count= 0; len; )
{
size_t chlen;
const uint16 *from= NULL;
uint16 implicit_weights[3];
for (chlen= len; chlen > 1; chlen--)
{
const MY_CONTRACTION *cnt;
if (chlen <= MY_UCA_MAX_CONTRACTION &&
(cnt= my_uca_contraction_find(&dst->contractions, str, chlen)))
{
from= cnt->weight;
str+= chlen;
len-= chlen;
break;
}
}
if (!from)
{
from= my_char_weight_addr(dst, *str);
if (!from)
{
from= implicit_weights;
my_uca_implicit_weight_put(implicit_weights, *str, dst->levelno);
}
str++;
len--;
}
for ( ; from && *from && count < to_length; )
{
*to++= *from++;
count++;
}
if (count == to_length && from && * from)
rc= TRUE; /* All weights did not fit */
}
*to= 0;
*nweights= count;
return rc;
} | O0 | c | my_char_weight_put:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movl $0x0, -0x44(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x574de
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
cmpq $0x0, -0x38(%rbp)
seta %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x1(%rbp)
jmp 0x5767d
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x40(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x57663
movq $0x0, -0x58(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x1, -0x50(%rbp)
jbe 0x57577
cmpq $0x6, -0x50(%rbp)
ja 0x57567
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movq -0x30(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x57930
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0x57567
movq -0x68(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
shlq $0x3, %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x50(%rbp), %rcx
movq -0x38(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0x57577
jmp 0x57569
movq -0x50(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x5750d
cmpq $0x0, -0x58(%rbp)
jne 0x575d2
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rax
movl %eax, %esi
callq 0x54c50
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
jne 0x575ba
leaq -0x5e(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x5e(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x30(%rax), %edx
callq 0x57250
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x575d4
xorl %eax, %eax
cmpq $0x0, -0x58(%rbp)
movb %al, -0x69(%rbp)
je 0x575ff
movq -0x58(%rbp), %rax
movzwl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x69(%rbp)
je 0x575ff
movq -0x40(%rbp), %rax
cmpq -0x20(%rbp), %rax
setb %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x57608
jmp 0x5763a
movq -0x58(%rbp), %rax
movq %rax, %rcx
addq $0x2, %rcx
movq %rcx, -0x58(%rbp)
movw (%rax), %cx
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x2, %rdx
movq %rdx, -0x18(%rbp)
movw %cx, (%rax)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x575d4
movq -0x40(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x5765e
cmpq $0x0, -0x58(%rbp)
je 0x5765e
movq -0x58(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x0, %eax
je 0x5765e
movl $0x1, -0x44(%rbp)
jmp 0x574f2
movq -0x18(%rbp), %rax
movw $0x0, (%rax)
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl -0x44(%rbp), %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_char_weight_put:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_38], r9
mov [rbp+var_44], 0
cmp [rbp+var_20], 0
jnz short loc_574DE
mov rax, [rbp+var_28]
mov qword ptr [rax], 0
cmp [rbp+var_38], 0
setnbe al
and al, 1
movzx eax, al
mov [rbp+var_1], al
jmp loc_5767D
loc_574DE:
mov rax, [rbp+var_20]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_20], rax
mov [rbp+var_40], 0
loc_574F2:
cmp [rbp+var_38], 0
jz loc_57663
mov [rbp+var_58], 0
mov rax, [rbp+var_38]
mov [rbp+var_50], rax
loc_5750D:
cmp [rbp+var_50], 1
jbe short loc_57577
cmp [rbp+var_50], 6
ja short loc_57567
mov rdi, [rbp+var_10]
add rdi, 18h
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_50]
call my_uca_contraction_find
mov [rbp+var_68], rax
cmp rax, 0
jz short loc_57567
mov rax, [rbp+var_68]
add rax, 30h ; '0'
mov [rbp+var_58], rax
mov rax, [rbp+var_50]
shl rax, 3
add rax, [rbp+var_30]
mov [rbp+var_30], rax
mov rcx, [rbp+var_50]
mov rax, [rbp+var_38]
sub rax, rcx
mov [rbp+var_38], rax
jmp short loc_57577
loc_57567:
jmp short $+2
loc_57569:
mov rax, [rbp+var_50]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_50], rax
jmp short loc_5750D
loc_57577:
cmp [rbp+var_58], 0
jnz short loc_575D2
mov rdi, [rbp+var_10]
mov rax, [rbp+var_30]
mov rax, [rax]
mov esi, eax
call my_char_weight_addr
mov [rbp+var_58], rax
cmp [rbp+var_58], 0
jnz short loc_575BA
lea rax, [rbp+var_5E]
mov [rbp+var_58], rax
lea rdi, [rbp+var_5E]
mov rax, [rbp+var_30]
mov rsi, [rax]
mov rax, [rbp+var_10]
mov edx, [rax+30h]
call my_uca_implicit_weight_put
loc_575BA:
mov rax, [rbp+var_30]
add rax, 8
mov [rbp+var_30], rax
mov rax, [rbp+var_38]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_38], rax
loc_575D2:
jmp short $+2
loc_575D4:
xor eax, eax
cmp [rbp+var_58], 0
mov [rbp+var_69], al
jz short loc_575FF
mov rax, [rbp+var_58]
movzx ecx, word ptr [rax]
xor eax, eax
cmp ecx, 0
mov [rbp+var_69], al
jz short loc_575FF
mov rax, [rbp+var_40]
cmp rax, [rbp+var_20]
setb al
mov [rbp+var_69], al
loc_575FF:
mov al, [rbp+var_69]
test al, 1
jnz short loc_57608
jmp short loc_5763A
loc_57608:
mov rax, [rbp+var_58]
mov rcx, rax
add rcx, 2
mov [rbp+var_58], rcx
mov cx, [rax]
mov rax, [rbp+var_18]
mov rdx, rax
add rdx, 2
mov [rbp+var_18], rdx
mov [rax], cx
mov rax, [rbp+var_40]
add rax, 1
mov [rbp+var_40], rax
jmp short loc_575D4
loc_5763A:
mov rax, [rbp+var_40]
cmp rax, [rbp+var_20]
jnz short loc_5765E
cmp [rbp+var_58], 0
jz short loc_5765E
mov rax, [rbp+var_58]
movzx eax, word ptr [rax]
cmp eax, 0
jz short loc_5765E
mov [rbp+var_44], 1
loc_5765E:
jmp loc_574F2
loc_57663:
mov rax, [rbp+var_18]
mov word ptr [rax], 0
mov rcx, [rbp+var_40]
mov rax, [rbp+var_28]
mov [rax], rcx
mov eax, [rbp+var_44]
mov [rbp+var_1], al
loc_5767D:
mov al, [rbp+var_1]
add rsp, 70h
pop rbp
retn
| bool my_char_weight_put(
_QWORD *a1,
_WORD *a2,
unsigned long long a3,
unsigned long long *a4,
unsigned long long *a5,
unsigned long long a6)
{
__int16 *v6; // rax
__int16 v7; // cx
_WORD *v8; // rax
bool v10; // [rsp+7h] [rbp-69h]
long long v11; // [rsp+8h] [rbp-68h]
_WORD v12[3]; // [rsp+12h] [rbp-5Eh] BYREF
__int16 *v13; // [rsp+18h] [rbp-58h]
unsigned long long i; // [rsp+20h] [rbp-50h]
int v15; // [rsp+2Ch] [rbp-44h]
unsigned long long v16; // [rsp+30h] [rbp-40h]
unsigned long long v17; // [rsp+38h] [rbp-38h]
unsigned long long *v18; // [rsp+40h] [rbp-30h]
unsigned long long *v19; // [rsp+48h] [rbp-28h]
unsigned long long v20; // [rsp+50h] [rbp-20h]
_WORD *v21; // [rsp+58h] [rbp-18h]
_QWORD *v22; // [rsp+60h] [rbp-10h]
v22 = a1;
v21 = a2;
v20 = a3;
v19 = a4;
v18 = a5;
v17 = a6;
v15 = 0;
if ( a3 )
{
--v20;
v16 = 0LL;
while ( v17 )
{
v13 = 0LL;
for ( i = v17; i > 1; --i )
{
if ( i <= 6 )
{
v11 = my_uca_contraction_find(v22 + 3, v18, i);
if ( v11 )
{
v13 = (__int16 *)(v11 + 48);
v18 += i;
v17 -= i;
break;
}
}
}
if ( !v13 )
{
v13 = (__int16 *)my_char_weight_addr(v22, *v18);
if ( !v13 )
{
v13 = v12;
my_uca_implicit_weight_put(v12, *v18, *((_DWORD *)v22 + 12));
}
++v18;
--v17;
}
while ( 1 )
{
v10 = 0;
if ( v13 )
{
v10 = 0;
if ( *v13 )
v10 = v16 < v20;
}
if ( !v10 )
break;
v6 = v13++;
v7 = *v6;
v8 = v21++;
*v8 = v7;
++v16;
}
if ( v16 == v20 && v13 && *v13 )
v15 = 1;
}
*v21 = 0;
*v19 = v16;
return v15;
}
else
{
*v19 = 0LL;
return v17 != 0;
}
}
| my_char_weight_put:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
MOV dword ptr [RBP + -0x44],0x0
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x001574de
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],0x0
CMP qword ptr [RBP + -0x38],0x0
SETA AL
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x1],AL
JMP 0x0015767d
LAB_001574de:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x20],RAX
MOV qword ptr [RBP + -0x40],0x0
LAB_001574f2:
CMP qword ptr [RBP + -0x38],0x0
JZ 0x00157663
MOV qword ptr [RBP + -0x58],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x50],RAX
LAB_0015750d:
CMP qword ptr [RBP + -0x50],0x1
JBE 0x00157577
CMP qword ptr [RBP + -0x50],0x6
JA 0x00157567
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x18
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x50]
CALL 0x00157930
MOV qword ptr [RBP + -0x68],RAX
CMP RAX,0x0
JZ 0x00157567
MOV RAX,qword ptr [RBP + -0x68]
ADD RAX,0x30
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x50]
SHL RAX,0x3
ADD RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x30],RAX
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x38]
SUB RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
JMP 0x00157577
LAB_00157567:
JMP 0x00157569
LAB_00157569:
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x50],RAX
JMP 0x0015750d
LAB_00157577:
CMP qword ptr [RBP + -0x58],0x0
JNZ 0x001575d2
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV ESI,EAX
CALL 0x00154c50
MOV qword ptr [RBP + -0x58],RAX
CMP qword ptr [RBP + -0x58],0x0
JNZ 0x001575ba
LEA RAX,[RBP + -0x5e]
MOV qword ptr [RBP + -0x58],RAX
LEA RDI,[RBP + -0x5e]
MOV RAX,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX + 0x30]
CALL 0x00157250
LAB_001575ba:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x8
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x38],RAX
LAB_001575d2:
JMP 0x001575d4
LAB_001575d4:
XOR EAX,EAX
CMP qword ptr [RBP + -0x58],0x0
MOV byte ptr [RBP + -0x69],AL
JZ 0x001575ff
MOV RAX,qword ptr [RBP + -0x58]
MOVZX ECX,word ptr [RAX]
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0x69],AL
JZ 0x001575ff
MOV RAX,qword ptr [RBP + -0x40]
CMP RAX,qword ptr [RBP + -0x20]
SETC AL
MOV byte ptr [RBP + -0x69],AL
LAB_001575ff:
MOV AL,byte ptr [RBP + -0x69]
TEST AL,0x1
JNZ 0x00157608
JMP 0x0015763a
LAB_00157608:
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,RAX
ADD RCX,0x2
MOV qword ptr [RBP + -0x58],RCX
MOV CX,word ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,RAX
ADD RDX,0x2
MOV qword ptr [RBP + -0x18],RDX
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x1
MOV qword ptr [RBP + -0x40],RAX
JMP 0x001575d4
LAB_0015763a:
MOV RAX,qword ptr [RBP + -0x40]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x0015765e
CMP qword ptr [RBP + -0x58],0x0
JZ 0x0015765e
MOV RAX,qword ptr [RBP + -0x58]
MOVZX EAX,word ptr [RAX]
CMP EAX,0x0
JZ 0x0015765e
MOV dword ptr [RBP + -0x44],0x1
LAB_0015765e:
JMP 0x001574f2
LAB_00157663:
MOV RAX,qword ptr [RBP + -0x18]
MOV word ptr [RAX],0x0
MOV RCX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
MOV EAX,dword ptr [RBP + -0x44]
MOV byte ptr [RBP + -0x1],AL
LAB_0015767d:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x70
POP RBP
RET
|
int8
my_char_weight_put(long param_1,short *param_2,long param_3,ulong *param_4,ulong *param_5,
ulong param_6)
{
long lVar1;
ulong uVar2;
bool bVar3;
short local_66 [3];
short *local_60;
ulong local_58;
uint local_4c;
ulong local_48;
ulong local_40;
ulong *local_38;
ulong *local_30;
ulong local_28;
short *local_20;
long local_18;
int1 local_9;
local_4c = 0;
if (param_3 == 0) {
*param_4 = 0;
local_9 = param_6 != 0;
uVar2 = 0;
}
else {
local_28 = param_3 - 1;
local_48 = 0;
local_40 = param_6;
local_38 = param_5;
local_30 = param_4;
local_20 = param_2;
local_18 = param_1;
while (local_40 != 0) {
local_60 = (short *)0x0;
for (local_58 = local_40; 1 < local_58; local_58 = local_58 - 1) {
if ((local_58 < 7) &&
(lVar1 = my_uca_contraction_find(local_18 + 0x18,local_38,local_58), lVar1 != 0)) {
local_60 = (short *)(lVar1 + 0x30);
local_38 = local_38 + local_58;
local_40 = local_40 - local_58;
break;
}
}
if (local_60 == (short *)0x0) {
local_60 = (short *)my_char_weight_addr(local_18,*local_38 & 0xffffffff);
if (local_60 == (short *)0x0) {
local_60 = local_66;
my_uca_implicit_weight_put(local_66,*local_38,*(int4 *)(local_18 + 0x30));
}
local_38 = local_38 + 1;
local_40 = local_40 - 1;
}
while( true ) {
bVar3 = false;
if ((local_60 != (short *)0x0) && (bVar3 = false, *local_60 != 0)) {
bVar3 = local_48 < local_28;
}
if (!bVar3) break;
*local_20 = *local_60;
local_48 = local_48 + 1;
local_60 = local_60 + 1;
local_20 = local_20 + 1;
}
if (((local_48 == local_28) && (local_60 != (short *)0x0)) && (*local_60 != 0)) {
local_4c = 1;
}
}
*local_20 = 0;
*local_30 = local_48;
uVar2 = (ulong)local_4c;
local_9 = (int1)local_4c;
}
return CONCAT71((int7)(uVar2 >> 8),local_9);
}
|
|
5,880 | nglog::tools::InitializeLoggingUtilities(char const*) | ng-log[P]ng-log/src/utilities.cc | void InitializeLoggingUtilities(const char* argv0) {
CHECK(!IsLoggingInitialized()) << "You called InitializeLogging() twice!";
g_program_invocation_short_name = const_basename(argv0);
#ifdef HAVE_STACKTRACE
InstallFailureFunction(&DumpStackTraceAndExit);
#endif
} | O0 | cpp | nglog::tools::InitializeLoggingUtilities(char const*):
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
callq 0x4c550
xorb $-0x1, %al
xorb $-0x1, %al
movb $0x0, -0x71(%rbp)
testb $0x1, %al
jne 0x4c6e2
jmp 0x4c75f
leaq 0x38e5(%rip), %rsi # 0x4ffce
leaq -0x70(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movl $0x12b, %edx # imm = 0x12B
callq 0x15010
movq -0x98(%rbp), %rdi
movb $0x1, -0x71(%rbp)
callq 0x10b40
movq %rax, -0x90(%rbp)
jmp 0x4c717
movq -0x90(%rbp), %rdi
leaq 0x38f2(%rip), %rsi # 0x50017
callq 0x96e0
movq %rax, -0xa0(%rbp)
jmp 0x4c733
movq -0xa0(%rbp), %rdi
leaq 0x38fd(%rip), %rsi # 0x5003e
callq 0x96e0
movq %rax, -0xa8(%rbp)
jmp 0x4c74f
movq -0xa8(%rbp), %rsi
leaq -0x9(%rbp), %rdi
callq 0x1a380
testb $0x1, -0x71(%rbp)
jne 0x4c767
jmp 0x4c787
leaq -0x70(%rbp), %rdi
callq 0x15080
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
testb $0x1, -0x71(%rbp)
jne 0x4c7ac
jmp 0x4c7b7
movq -0x8(%rbp), %rdi
callq 0x4c590
movq %rax, 0x36621(%rip) # 0x82db8
leaq 0x32(%rip), %rdi # 0x4c7d0
callq 0x11b30
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x70(%rbp), %rdi
callq 0x15080
jmp 0x4c7b7
jmp 0x4c7b9
movq -0x80(%rbp), %rdi
callq 0x9cc0
movq %rax, %rdi
callq 0xc110
nopw (%rax,%rax)
| _ZN5nglog5tools26InitializeLoggingUtilitiesEPKc:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov [rbp+var_8], rdi
call _ZN5nglog20IsLoggingInitializedEv; nglog::IsLoggingInitialized(void)
xor al, 0FFh
xor al, 0FFh
mov [rbp+var_71], 0
test al, 1
jnz short loc_4C6E2
jmp short loc_4C75F
loc_4C6E2:
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
lea rdi, [rbp+var_70]; this
mov [rbp+var_98], rdi
mov edx, 12Bh; int
call _ZN5nglog15LogMessageFatalC2EPKci; nglog::LogMessageFatal::LogMessageFatal(char const*,int)
mov rdi, [rbp+var_98]; this
mov [rbp+var_71], 1
call _ZN5nglog10LogMessage6streamEv; nglog::LogMessage::stream(void)
mov [rbp+var_90], rax
jmp short $+2
loc_4C717:
mov rdi, [rbp+var_90]
lea rsi, aCheckFailedIsl; "Check failed: !IsLoggingInitialized() "
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rbp+var_A0], rax
jmp short $+2
loc_4C733:
mov rdi, [rbp+var_A0]
lea rsi, aYouCalledIniti; "You called InitializeLogging() twice!"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rbp+var_A8], rax
jmp short $+2
loc_4C74F:
mov rsi, [rbp+var_A8]; void (*)(void)
lea rdi, [rbp+var_9]
call _ZNK5nglog8internal17LogMessageVoidifyanERSo; nglog::internal::LogMessageVoidify::operator&(std::ostream &)
loc_4C75F:
test [rbp+var_71], 1
jnz short loc_4C767
jmp short loc_4C787
loc_4C767:
lea rdi, [rbp+var_70]; this
call _ZN5nglog15LogMessageFatalD2Ev; nglog::LogMessageFatal::~LogMessageFatal()
mov rcx, rax
mov eax, edx
mov [rbp+var_80], rcx
mov [rbp+var_84], eax
test [rbp+var_71], 1
jnz short loc_4C7AC
jmp short loc_4C7B7
loc_4C787:
mov rdi, [rbp+var_8]; this
call _ZN5nglog5tools14const_basenameEPKc; nglog::tools::const_basename(char const*)
mov cs:_ZN5nglogL31g_program_invocation_short_nameE, rax; nglog::g_program_invocation_short_name
lea rdi, _ZN5nglogL21DumpStackTraceAndExitEv; this
call _ZN5nglog22InstallFailureFunctionEPFvvE; nglog::InstallFailureFunction(void (*)(void))
add rsp, 0B0h
pop rbp
retn
loc_4C7AC:
lea rdi, [rbp+var_70]; this
call _ZN5nglog15LogMessageFatalD2Ev; nglog::LogMessageFatal::~LogMessageFatal()
jmp short $+2
loc_4C7B7:
jmp short $+2
loc_4C7B9:
mov rdi, [rbp+var_80]
call __Unwind_Resume
mov rdi, rax
call __clang_call_terminate
| long long nglog::tools::InitializeLoggingUtilities(nglog::tools *this, char *a2)
{
long long v3; // [rsp+10h] [rbp-A0h]
long long v4; // [rsp+20h] [rbp-90h]
char v5; // [rsp+3Fh] [rbp-71h]
nglog::LogDestination *v6[12]; // [rsp+40h] [rbp-70h] BYREF
nglog::tools *v7; // [rsp+A8h] [rbp-8h]
v7 = this;
v5 = 0;
if ( nglog::IsLoggingInitialized(this) )
{
nglog::LogMessageFatal::LogMessageFatal(
v6,
(std::this_thread *)"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/utilities.cc",
0x12Bu);
v5 = 1;
v4 = nglog::LogMessage::stream((nglog::LogMessage *)v6);
v3 = std::operator<<<std::char_traits<char>>(v4, "Check failed: !IsLoggingInitialized() ");
a2 = (char *)std::operator<<<std::char_traits<char>>(v3, "You called InitializeLogging() twice!");
nglog::internal::LogMessageVoidify::operator&();
}
if ( (v5 & 1) != 0 )
nglog::LogMessageFatal::~LogMessageFatal(v6);
nglog::g_program_invocation_short_name = (long long)nglog::tools::const_basename(v7, a2);
return nglog::InstallFailureFunction((nglog *)nglog::DumpStackTraceAndExit, (void (*)(void))a2);
}
| InitializeLoggingUtilities:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV qword ptr [RBP + -0x8],RDI
CALL 0x0014c550
XOR AL,0xff
XOR AL,0xff
MOV byte ptr [RBP + -0x71],0x0
TEST AL,0x1
JNZ 0x0014c6e2
JMP 0x0014c75f
LAB_0014c6e2:
LEA RSI,[0x14ffce]
LEA RDI,[RBP + -0x70]
MOV qword ptr [RBP + -0x98],RDI
MOV EDX,0x12b
CALL 0x00115010
MOV RDI,qword ptr [RBP + -0x98]
MOV byte ptr [RBP + -0x71],0x1
LAB_0014c709:
CALL 0x00110b40
MOV qword ptr [RBP + -0x90],RAX
JMP 0x0014c717
LAB_0014c717:
MOV RDI,qword ptr [RBP + -0x90]
LEA RSI,[0x150017]
CALL 0x001096e0
MOV qword ptr [RBP + -0xa0],RAX
JMP 0x0014c733
LAB_0014c733:
MOV RDI,qword ptr [RBP + -0xa0]
LEA RSI,[0x15003e]
CALL 0x001096e0
LAB_0014c746:
MOV qword ptr [RBP + -0xa8],RAX
JMP 0x0014c74f
LAB_0014c74f:
MOV RSI,qword ptr [RBP + -0xa8]
LEA RDI,[RBP + -0x9]
CALL 0x0011a380
LAB_0014c75f:
TEST byte ptr [RBP + -0x71],0x1
JNZ 0x0014c767
JMP 0x0014c787
LAB_0014c767:
LEA RDI,[RBP + -0x70]
CALL 0x00115080
LAB_0014c770:
MOV RCX,RAX
MOV EAX,EDX
MOV qword ptr [RBP + -0x80],RCX
MOV dword ptr [RBP + -0x84],EAX
TEST byte ptr [RBP + -0x71],0x1
JNZ 0x0014c7ac
JMP 0x0014c7b7
LAB_0014c787:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0014c590
MOV qword ptr [0x00182db8],RAX
LEA RDI,[0x14c7d0]
CALL 0x00111b30
ADD RSP,0xb0
POP RBP
RET
LAB_0014c7ac:
LEA RDI,[RBP + -0x70]
CALL 0x00115080
LAB_0014c7b5:
JMP 0x0014c7b7
LAB_0014c7b7:
JMP 0x0014c7b9
LAB_0014c7b9:
MOV RDI,qword ptr [RBP + -0x80]
CALL 0x00109cc0
|
/* nglog::tools::InitializeLoggingUtilities(char const*) */
void nglog::tools::InitializeLoggingUtilities(char *param_1)
{
byte bVar1;
ostream *poVar2;
int8 uVar3;
bool bVar4;
LogMessageFatal local_78 [103];
LogMessageVoidify local_11;
char *local_10;
local_10 = param_1;
bVar1 = IsLoggingInitialized();
bVar4 = (bVar1 & 1) != 0;
if (bVar4) {
LogMessageFatal::LogMessageFatal
(local_78,"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/utilities.cc",
299);
/* try { // try from 0014c709 to 0014c745 has its CatchHandler @ 0014c770 */
poVar2 = (ostream *)LogMessage::stream((LogMessage *)local_78);
poVar2 = std::operator<<(poVar2,"Check failed: !IsLoggingInitialized() ");
poVar2 = std::operator<<(poVar2,"You called InitializeLogging() twice!");
internal::LogMessageVoidify::operator&(&local_11,poVar2);
uVar3 = LogMessageFatal::~LogMessageFatal(local_78);
/* catch(type#1 @ 00000000) { ... } // from try @ 0014c709 with catch @ 0014c770
*/
if (bVar4) {
/* try { // try from 0014c7ac to 0014c7b4 has its CatchHandler @ 0014c7c2 */
LogMessageFatal::~LogMessageFatal(local_78);
}
/* WARNING: Subroutine does not return */
_Unwind_Resume(uVar3);
}
g_program_invocation_short_name = const_basename(local_10);
InstallFailureFunction(DumpStackTraceAndExit);
return;
}
|
|
5,881 | reinit_queue | eloqsql/mysys/queues.c | int reinit_queue(QUEUE *queue, uint max_elements, uint offset_to_key,
my_bool max_at_top, int (*compare) (void *, uchar *, uchar *),
void *first_cmp_arg, uint offset_to_queue_pos,
uint auto_extent)
{
DBUG_ENTER("reinit_queue");
queue->elements= 0;
queue->compare= compare;
queue->first_cmp_arg= first_cmp_arg;
queue->offset_to_key= offset_to_key;
queue->offset_to_queue_pos= offset_to_queue_pos;
queue->auto_extent= auto_extent;
queue_set_max_at_top(queue, max_at_top);
DBUG_RETURN(resize_queue(queue, max_elements));
} | O3 | c | reinit_queue:
pushq %rbp
movq %rsp, %rbp
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %r10d
movl $0x0, 0x10(%rdi)
movq %r8, 0x28(%rdi)
movq %r9, 0x8(%rdi)
movl %edx, 0x18(%rdi)
movl %r10d, 0x1c(%rdi)
movl %eax, 0x20(%rdi)
xorl %eax, %eax
negb %cl
sbbl %eax, %eax
orl $0x1, %eax
movl %eax, 0x24(%rdi)
popq %rbp
jmp 0xa20a9
| reinit_queue:
push rbp
mov rbp, rsp
mov eax, [rbp+arg_8]
mov r10d, [rbp+arg_0]
mov dword ptr [rdi+10h], 0
mov [rdi+28h], r8
mov [rdi+8], r9
mov [rdi+18h], edx
mov [rdi+1Ch], r10d
mov [rdi+20h], eax
xor eax, eax
neg cl
sbb eax, eax
or eax, 1
mov [rdi+24h], eax
pop rbp
jmp $+5
| long long reinit_queue(long long a1, long long a2, long long a3, long long a4, long long a5, long long a6, int a7, int a8)
{
*(_DWORD *)(a1 + 16) = 0;
*(_QWORD *)(a1 + 40) = a5;
*(_QWORD *)(a1 + 8) = a6;
*(_DWORD *)(a1 + 24) = a3;
*(_DWORD *)(a1 + 28) = a7;
*(_DWORD *)(a1 + 32) = a8;
LOBYTE(a4) = -(char)a4;
*(_DWORD *)(a1 + 36) = (_BYTE)a4 != 0 ? -1 : 1;
return resize_queue(a1, a2, a3, a4);
}
| reinit_queue:
PUSH RBP
MOV RBP,RSP
MOV EAX,dword ptr [RBP + 0x18]
MOV R10D,dword ptr [RBP + 0x10]
MOV dword ptr [RDI + 0x10],0x0
MOV qword ptr [RDI + 0x28],R8
MOV qword ptr [RDI + 0x8],R9
MOV dword ptr [RDI + 0x18],EDX
MOV dword ptr [RDI + 0x1c],R10D
MOV dword ptr [RDI + 0x20],EAX
XOR EAX,EAX
NEG CL
SBB EAX,EAX
OR EAX,0x1
MOV dword ptr [RDI + 0x24],EAX
POP RBP
JMP 0x001a20a9
|
void reinit_queue(long param_1,int8 param_2,int4 param_3,char param_4,int8 param_5
,int8 param_6,int4 param_7,int4 param_8)
{
*(int4 *)(param_1 + 0x10) = 0;
*(int8 *)(param_1 + 0x28) = param_5;
*(int8 *)(param_1 + 8) = param_6;
*(int4 *)(param_1 + 0x18) = param_3;
*(int4 *)(param_1 + 0x1c) = param_7;
*(int4 *)(param_1 + 0x20) = param_8;
*(uint *)(param_1 + 0x24) = -(uint)(param_4 != '\0') | 1;
resize_queue();
return;
}
|
|
5,882 | google::protobuf::FieldOptions* google::protobuf::Arena::CreateMaybeMessage<google::protobuf::FieldOptions>(google::protobuf::Arena*) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.pb.cc | PROTOBUF_NOINLINE ::PROTOBUF_NAMESPACE_ID::FieldOptions*
Arena::CreateMaybeMessage< ::PROTOBUF_NAMESPACE_ID::FieldOptions >(Arena* arena) {
return Arena::CreateMessageInternal< ::PROTOBUF_NAMESPACE_ID::FieldOptions >(arena);
} | O0 | cpp | google::protobuf::FieldOptions* google::protobuf::Arena::CreateMaybeMessage<google::protobuf::FieldOptions>(google::protobuf::Arena*):
subq $0xb8, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0xd24cf
movl $0x58, %edi
callq 0x13450
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
xorl %edx, %edx
movl %edx, %esi
callq 0xc1d30
jmp 0xd24c0
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x13400
movq 0x38(%rsp), %rdi
callq 0x13750
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
jmp 0xd2683
movq 0x20(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq %rax, 0x98(%rsp)
movq $0x58, 0x90(%rsp)
movq $0x8, 0x88(%rsp)
movq $0x0, 0x80(%rsp)
leaq 0x1a6ccb(%rip), %rax # 0x2791e0
movq %rax, 0x78(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x80(%rsp)
jne 0xd255e
movq 0x8(%rsp), %rdi
movq 0x90(%rsp), %rsi
movq 0x88(%rsp), %rdx
movq 0x78(%rsp), %rcx
callq 0xdf5f0
movq %rax, 0xa0(%rsp)
jmp 0xd2663
cmpq $0x8, 0x88(%rsp)
ja 0xd25c2
movq 0x90(%rsp), %rdi
callq 0xdf6a0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x78(%rsp), %rdx
callq 0x1816c0
movq %rax, 0x68(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x68(%rsp), %rcx
movq 0x70(%rsp), %rax
movq %rcx, (%rax)
movq 0x80(%rsp), %rcx
movq 0x70(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x68(%rsp), %rax
movq %rax, 0xa0(%rsp)
jmp 0xd2663
movq 0x8(%rsp), %rdi
movq 0x90(%rsp), %rsi
addq 0x88(%rsp), %rsi
subq $0x8, %rsi
movq 0x78(%rsp), %rdx
callq 0x1816c0
movq %rax, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x58(%rsp), %rcx
movq 0x88(%rsp), %rax
movq %rcx, 0xb0(%rsp)
movq %rax, 0xa8(%rsp)
movq 0xb0(%rsp), %rax
addq 0xa8(%rsp), %rax
subq $0x1, %rax
movq 0xa8(%rsp), %rcx
xorq $-0x1, %rcx
addq $0x1, %rcx
andq %rcx, %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rcx
movq 0x60(%rsp), %rax
movq %rcx, (%rax)
movq 0x80(%rsp), %rcx
movq 0x60(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x50(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq (%rsp), %rax
movq 0xa0(%rsp), %rdi
movq %rax, 0x40(%rsp)
leaq 0x40(%rsp), %rsi
callq 0xe3db0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
addq $0xb8, %rsp
retq
| _ZN6google8protobuf5Arena18CreateMaybeMessageINS0_12FieldOptionsEJEEEPT_PS1_DpOT0_:
sub rsp, 0B8h
mov [rsp+0B8h+var_A0], rdi
mov rax, [rsp+0B8h+var_A0]
mov [rsp+0B8h+var_98], rax
cmp [rsp+0B8h+var_98], 0
jnz short loc_D24CF
mov edi, 58h ; 'X'; unsigned __int64
call __Znwm; operator new(ulong)
mov rdi, rax; this
mov rax, rdi
mov [rsp+0B8h+var_A8], rax
xor edx, edx; bool
mov esi, edx; google::protobuf::Arena *
call _ZN6google8protobuf12FieldOptionsC2EPNS0_5ArenaEb; google::protobuf::FieldOptions::FieldOptions(google::protobuf::Arena *,bool)
jmp short loc_D24C0
mov rdi, [rsp+arg_8]; void *
mov rcx, rax
mov eax, edx
mov [rsp+arg_30], rcx
mov [rsp+arg_2C], eax
call __ZdlPv; operator delete(void *)
mov rdi, [rsp+arg_30]
call __Unwind_Resume
loc_D24C0:
mov rax, [rsp+0B8h+var_A8]
mov [rsp+0B8h+var_90], rax
jmp loc_D2683
loc_D24CF:
mov rax, [rsp+0B8h+var_98]
mov [rsp+0B8h+var_70], rax
mov rax, [rsp+0B8h+var_70]
mov [rsp+0B8h+var_B8], rax
mov [rsp+0B8h+var_20], rax
mov [rsp+0B8h+var_28], 58h ; 'X'
mov [rsp+0B8h+var_30], 8
mov [rsp+0B8h+var_38], 0
lea rax, _ZTIN6google8protobuf12FieldOptionsE; `typeinfo for'google::protobuf::FieldOptions
mov [rsp+0B8h+var_40], rax
mov rax, [rsp+0B8h+var_20]
mov [rsp+0B8h+var_B0], rax
cmp [rsp+0B8h+var_38], 0
jnz short loc_D255E
mov rdi, [rsp+0B8h+var_B0]; this
mov rsi, [rsp+0B8h+var_28]; unsigned __int64
mov rdx, [rsp+0B8h+var_30]; unsigned __int64
mov rcx, [rsp+0B8h+var_40]; type_info *
call _ZN6google8protobuf5Arena23AllocateAlignedWithHookEmmPKSt9type_info; google::protobuf::Arena::AllocateAlignedWithHook(ulong,ulong,std::type_info const*)
mov [rsp+0B8h+var_18], rax
jmp loc_D2663
loc_D255E:
cmp [rsp+0B8h+var_30], 8
ja short loc_D25C2
mov rdi, [rsp+0B8h+var_28]; this
call _ZN6google8protobuf8internal10AlignUpTo8Em; google::protobuf::internal::AlignUpTo8(ulong)
mov rdi, [rsp+0B8h+var_B0]; this
mov rsi, rax; unsigned __int64
mov rdx, [rsp+0B8h+var_40]; type_info *
call _ZN6google8protobuf5Arena26AllocateAlignedWithCleanupEmPKSt9type_info; google::protobuf::Arena::AllocateAlignedWithCleanup(ulong,std::type_info const*)
mov [rsp+0B8h+var_50], rax
mov [rsp+0B8h+var_48], rdx
mov rcx, [rsp+0B8h+var_50]
mov rax, [rsp+0B8h+var_48]
mov [rax], rcx
mov rcx, [rsp+0B8h+var_38]
mov rax, [rsp+0B8h+var_48]
mov [rax+8], rcx
mov rax, [rsp+0B8h+var_50]
mov [rsp+0B8h+var_18], rax
jmp loc_D2663
loc_D25C2:
mov rdi, [rsp+0B8h+var_B0]; this
mov rsi, [rsp+0B8h+var_28]
add rsi, [rsp+0B8h+var_30]
sub rsi, 8; unsigned __int64
mov rdx, [rsp+0B8h+var_40]; type_info *
call _ZN6google8protobuf5Arena26AllocateAlignedWithCleanupEmPKSt9type_info; google::protobuf::Arena::AllocateAlignedWithCleanup(ulong,std::type_info const*)
mov [rsp+0B8h+var_60], rax
mov [rsp+0B8h+var_58], rdx
mov rcx, [rsp+0B8h+var_60]
mov rax, [rsp+0B8h+var_30]
mov [rsp+0B8h+var_8], rcx
mov [rsp+0B8h+var_10], rax
mov rax, [rsp+0B8h+var_8]
add rax, [rsp+0B8h+var_10]
sub rax, 1
mov rcx, [rsp+0B8h+var_10]
xor rcx, 0FFFFFFFFFFFFFFFFh
add rcx, 1
and rax, rcx
mov [rsp+0B8h+var_68], rax
mov rcx, [rsp+0B8h+var_68]
mov rax, [rsp+0B8h+var_58]
mov [rax], rcx
mov rcx, [rsp+0B8h+var_38]
mov rax, [rsp+0B8h+var_58]
mov [rax+8], rcx
mov rax, [rsp+0B8h+var_68]
mov [rsp+0B8h+var_18], rax
loc_D2663:
mov rax, [rsp+0B8h+var_B8]
mov rdi, [rsp+0B8h+var_18]
mov [rsp+0B8h+var_78], rax
lea rsi, [rsp+0B8h+var_78]
call _ZN6google8protobuf5Arena14InternalHelperINS0_12FieldOptionsEE9ConstructIJPS1_EEEPS3_PvDpOT_; google::protobuf::Arena::InternalHelper<google::protobuf::FieldOptions>::Construct<google::protobuf::Arena*>(void *,google::protobuf::Arena* &&)
mov [rsp+0B8h+var_90], rax
loc_D2683:
mov rax, [rsp+0B8h+var_90]
add rsp, 0B8h
retn
| google::protobuf::FieldOptions * google::protobuf::Arena::CreateMaybeMessage<google::protobuf::FieldOptions>(
google::protobuf::Arena *a1)
{
google::protobuf::FieldOptions *v2; // [rsp+10h] [rbp-A8h]
_QWORD v4[12]; // [rsp+40h] [rbp-78h] BYREF
long long AlignedWithHook; // [rsp+A0h] [rbp-18h]
if ( a1 )
{
v4[1] = a1;
v4[11] = a1;
v4[10] = 88LL;
v4[9] = 8LL;
v4[8] = 0LL;
v4[7] = &`typeinfo for'google::protobuf::FieldOptions;
AlignedWithHook = google::protobuf::Arena::AllocateAlignedWithHook(
a1,
0x58uLL,
8uLL,
(const type_info *)&`typeinfo for'google::protobuf::FieldOptions);
v4[0] = a1;
return (google::protobuf::FieldOptions *)google::protobuf::Arena::InternalHelper<google::protobuf::FieldOptions>::Construct<google::protobuf::Arena*>(
AlignedWithHook,
v4);
}
else
{
v2 = (google::protobuf::FieldOptions *)operator new(0x58uLL);
google::protobuf::FieldOptions::FieldOptions(v2, 0LL, 0);
return v2;
}
}
| CreateMaybeMessage<google::protobuf::FieldOptions>:
SUB RSP,0xb8
MOV qword ptr [RSP + 0x18],RDI
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x20],RAX
CMP qword ptr [RSP + 0x20],0x0
JNZ 0x001d24cf
MOV EDI,0x58
CALL 0x00113450
MOV RDI,RAX
MOV RAX,RDI
MOV qword ptr [RSP + 0x10],RAX
LAB_001d2493:
XOR EDX,EDX
MOV ESI,EDX
CALL 0x001c1d30
LAB_001d249c:
JMP 0x001d24c0
LAB_001d24c0:
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x28],RAX
JMP 0x001d2683
LAB_001d24cf:
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x48],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x98],RAX
MOV qword ptr [RSP + 0x90],0x58
MOV qword ptr [RSP + 0x88],0x8
MOV qword ptr [RSP + 0x80],0x0
LEA RAX,[0x3791e0]
MOV qword ptr [RSP + 0x78],RAX
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x80],0x0
JNZ 0x001d255e
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x90]
MOV RDX,qword ptr [RSP + 0x88]
MOV RCX,qword ptr [RSP + 0x78]
CALL 0x001df5f0
MOV qword ptr [RSP + 0xa0],RAX
JMP 0x001d2663
LAB_001d255e:
CMP qword ptr [RSP + 0x88],0x8
JA 0x001d25c2
MOV RDI,qword ptr [RSP + 0x90]
CALL 0x001df6a0
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,RAX
MOV RDX,qword ptr [RSP + 0x78]
CALL 0x002816c0
MOV qword ptr [RSP + 0x68],RAX
MOV qword ptr [RSP + 0x70],RDX
MOV RCX,qword ptr [RSP + 0x68]
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x80]
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0xa0],RAX
JMP 0x001d2663
LAB_001d25c2:
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x90]
ADD RSI,qword ptr [RSP + 0x88]
SUB RSI,0x8
MOV RDX,qword ptr [RSP + 0x78]
CALL 0x002816c0
MOV qword ptr [RSP + 0x58],RAX
MOV qword ptr [RSP + 0x60],RDX
MOV RCX,qword ptr [RSP + 0x58]
MOV RAX,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0xb0],RCX
MOV qword ptr [RSP + 0xa8],RAX
MOV RAX,qword ptr [RSP + 0xb0]
ADD RAX,qword ptr [RSP + 0xa8]
SUB RAX,0x1
MOV RCX,qword ptr [RSP + 0xa8]
XOR RCX,-0x1
ADD RCX,0x1
AND RAX,RCX
MOV qword ptr [RSP + 0x50],RAX
MOV RCX,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x80]
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0xa0],RAX
LAB_001d2663:
MOV RAX,qword ptr [RSP]
MOV RDI,qword ptr [RSP + 0xa0]
MOV qword ptr [RSP + 0x40],RAX
LEA RSI,[RSP + 0x40]
CALL 0x001e3db0
MOV qword ptr [RSP + 0x28],RAX
LAB_001d2683:
MOV RAX,qword ptr [RSP + 0x28]
ADD RSP,0xb8
RET
|
/* WARNING: Removing unreachable block (ram,0x001d255e) */
/* WARNING: Removing unreachable block (ram,0x001d2569) */
/* WARNING: Removing unreachable block (ram,0x001d25c2) */
/* google::protobuf::FieldOptions*
google::protobuf::Arena::CreateMaybeMessage<google::protobuf::FieldOptions>(google::protobuf::Arena*)
*/
FieldOptions *
google::protobuf::Arena::CreateMaybeMessage<google::protobuf::FieldOptions>(Arena *param_1)
{
FieldOptions *local_90;
Arena *local_78;
Arena *local_70;
pointer_____offset_0x10___ *local_40;
int8 local_38;
int8 local_30;
int8 local_28;
Arena *local_20;
void *local_18;
if (param_1 == (Arena *)0x0) {
local_90 = (FieldOptions *)operator_new(0x58);
/* try { // try from 001d2493 to 001d249b has its CatchHandler @ 001d249e */
FieldOptions::FieldOptions(local_90,(Arena *)0x0,false);
}
else {
local_28 = 0x58;
local_30 = 8;
local_38 = 0;
local_40 = &FieldOptions::typeinfo;
local_70 = param_1;
local_20 = param_1;
local_18 = (void *)AllocateAlignedWithHook(param_1,0x58,8,(type_info *)&FieldOptions::typeinfo);
local_78 = param_1;
local_90 = InternalHelper<google::protobuf::FieldOptions>::Construct<google::protobuf::Arena*>
(local_18,&local_78);
}
return local_90;
}
|
|
5,883 | fn_same | eloqsql/mysys/mf_same.c | char * fn_same(char *to, const char *name, int flag)
{
char dev[FN_REFLEN];
const char *ext;
size_t dev_length;
DBUG_ENTER("fn_same");
DBUG_PRINT("enter",("to: %s name: %s flag: %d",to,name,flag));
if ((ext=strrchr(name+dirname_part(dev, name, &dev_length),FN_EXTCHAR)) == 0)
ext="";
DBUG_RETURN(fn_format(to,to,dev,ext,flag));
} | O3 | c | fn_same:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x220, %rsp # imm = 0x220
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq %fs:0x28, %rax
movq %rax, -0x28(%rbp)
leaq -0x230(%rbp), %r12
leaq -0x238(%rbp), %rdx
movq %r12, %rdi
callq 0xb0181
addq %rax, %r14
movq %r14, %rdi
movl $0x2e, %esi
callq 0x2a830
testq %rax, %rax
leaq 0x33615(%rip), %rcx # 0xfc374
cmovneq %rax, %rcx
movq %r15, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl %ebx, %r8d
callq 0xb02b0
movq %fs:0x28, %rcx
cmpq -0x28(%rbp), %rcx
jne 0xc8d93
addq $0x220, %rsp # imm = 0x220
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x2a280
| fn_same:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 220h
mov ebx, edx
mov r14, rsi
mov r15, rdi
mov rax, fs:28h
mov [rbp+var_28], rax
lea r12, [rbp+var_230]
lea rdx, [rbp+var_238]
mov rdi, r12
call dirname_part
add r14, rax
mov rdi, r14
mov esi, 2Eh ; '.'
call _strrchr
test rax, rax
lea rcx, aTotalKeyblocks+30h; ""
cmovnz rcx, rax
mov rdi, r15
mov rsi, r15
mov rdx, r12
mov r8d, ebx
call fn_format
mov rcx, fs:28h
cmp rcx, [rbp+var_28]
jnz short loc_C8D93
add rsp, 220h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_C8D93:
call ___stack_chk_fail
| _BYTE * fn_same(_BYTE *a1, _BYTE *a2, __int16 a3)
{
long long v4; // rax
long long v5; // rax
char *v6; // rcx
long long v8; // [rsp+8h] [rbp-238h] BYREF
_BYTE v9[520]; // [rsp+10h] [rbp-230h] BYREF
unsigned long long v10; // [rsp+218h] [rbp-28h]
v10 = __readfsqword(0x28u);
v4 = dirname_part((long long)v9, a2, &v8);
v5 = strrchr(&a2[v4], 46LL);
v6 = "";
if ( v5 )
v6 = (char *)v5;
return fn_format(a1, a1, (long long)v9, v6, a3);
}
| fn_same:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x220
MOV EBX,EDX
MOV R14,RSI
MOV R15,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
LEA R12,[RBP + -0x230]
LEA RDX,[RBP + -0x238]
MOV RDI,R12
CALL 0x001b0181
ADD R14,RAX
MOV RDI,R14
MOV ESI,0x2e
CALL 0x0012a830
TEST RAX,RAX
LEA RCX,[0x1fc374]
CMOVNZ RCX,RAX
MOV RDI,R15
MOV RSI,R15
MOV RDX,R12
MOV R8D,EBX
CALL 0x001b02b0
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x28]
JNZ 0x001c8d93
ADD RSP,0x220
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001c8d93:
CALL 0x0012a280
|
void fn_same(int8 param_1,long param_2,int4 param_3)
{
long lVar1;
char *pcVar2;
char *pcVar3;
long in_FS_OFFSET;
int1 local_240 [8];
int1 local_238 [520];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
lVar1 = dirname_part(local_238,param_2,local_240);
pcVar2 = strrchr((char *)(param_2 + lVar1),0x2e);
pcVar3 = "";
if (pcVar2 != (char *)0x0) {
pcVar3 = pcVar2;
}
fn_format(param_1,param_1,local_238,pcVar3,param_3);
if (*(long *)(in_FS_OFFSET + 0x28) == local_30) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
5,884 | ma_multi_malloc | eloqsql/libmariadb/libmariadb/ma_alloc.c | void *ma_multi_malloc(myf myFlags, ...)
{
va_list args;
char **ptr,*start,*res;
size_t tot_length,length;
va_start(args,myFlags);
tot_length=0;
while ((ptr=va_arg(args, char **)))
{
length=va_arg(args, size_t);
tot_length+=ALIGN_SIZE(length);
}
va_end(args);
if (!(start=(char *)malloc(tot_length)))
return 0;
va_start(args,myFlags);
res=start;
while ((ptr=va_arg(args, char **)))
{
*ptr=res;
length=va_arg(args,size_t);
res+=ALIGN_SIZE(length);
}
va_end(args);
return start;
} | O0 | c | ma_multi_malloc:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
testb %al, %al
je 0x89891
movaps %xmm0, -0xe0(%rbp)
movaps %xmm1, -0xd0(%rbp)
movaps %xmm2, -0xc0(%rbp)
movaps %xmm3, -0xb0(%rbp)
movaps %xmm4, -0xa0(%rbp)
movaps %xmm5, -0x90(%rbp)
movaps %xmm6, -0x80(%rbp)
movaps %xmm7, -0x70(%rbp)
movq %r9, -0xe8(%rbp)
movq %r8, -0xf0(%rbp)
movq %rcx, -0xf8(%rbp)
movq %rdx, -0x100(%rbp)
movq %rsi, -0x108(%rbp)
movl %edi, -0xc(%rbp)
leaq -0x30(%rbp), %rax
leaq -0x110(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq $0x0, -0x50(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x120(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x114(%rbp)
cmpl $0x28, %eax
ja 0x8991e
movq -0x120(%rbp), %rcx
movl -0x114(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x128(%rbp)
jmp 0x8993b
movq -0x120(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x128(%rbp)
movq -0x128(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x899d6
leaq -0x30(%rbp), %rax
movq %rax, -0x138(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x12c(%rbp)
cmpl $0x28, %eax
ja 0x8998e
movq -0x138(%rbp), %rcx
movl -0x12c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x140(%rbp)
jmp 0x899ab
movq -0x138(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x140(%rbp)
movq -0x140(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $0x8, %rax
subq $0x1, %rax
andq $-0x8, %rax
addq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x898e3
leaq -0x30(%rbp), %rax
movq -0x50(%rbp), %rdi
callq 0x60aa0
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x899fa
movq $0x0, -0x8(%rbp)
jmp 0x89b30
leaq -0x30(%rbp), %rax
leaq -0x110(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x150(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x144(%rbp)
cmpl $0x28, %eax
ja 0x89a61
movq -0x150(%rbp), %rcx
movl -0x144(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x158(%rbp)
jmp 0x89a7e
movq -0x150(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x158(%rbp)
movq -0x158(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x89b24
movq -0x48(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
leaq -0x30(%rbp), %rax
movq %rax, -0x168(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x15c(%rbp)
cmpl $0x28, %eax
ja 0x89adc
movq -0x168(%rbp), %rcx
movl -0x15c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x170(%rbp)
jmp 0x89af9
movq -0x168(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x170(%rbp)
movq -0x170(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $0x8, %rax
subq $0x1, %rax
andq $-0x8, %rax
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x89a26
leaq -0x30(%rbp), %rax
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x170, %rsp # imm = 0x170
popq %rbp
retq
nopl (%rax)
| ma_multi_malloc:
push rbp
mov rbp, rsp
sub rsp, 170h
test al, al
jz short loc_89891
movaps [rbp+var_E0], xmm0
movaps [rbp+var_D0], xmm1
movaps [rbp+var_C0], xmm2
movaps [rbp+var_B0], xmm3
movaps [rbp+var_A0], xmm4
movaps [rbp+var_90], xmm5
movaps [rbp+var_80], xmm6
movaps [rbp+var_70], xmm7
loc_89891:
mov [rbp+var_E8], r9
mov [rbp+var_F0], r8
mov [rbp+var_F8], rcx
mov [rbp+var_100], rdx
mov [rbp+var_108], rsi
mov [rbp+var_C], edi
lea rax, [rbp+var_30]
lea rcx, [rbp+var_110]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 8
mov [rbp+var_50], 0
loc_898E3:
lea rax, [rbp+var_30]
mov [rbp+var_120], rax
mov eax, [rbp+var_30]
mov [rbp+var_114], eax
cmp eax, 28h ; '('
ja short loc_8991E
mov rcx, [rbp+var_120]
mov edx, [rbp+var_114]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_128], rax
jmp short loc_8993B
loc_8991E:
mov rcx, [rbp+var_120]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_128], rax
loc_8993B:
mov rax, [rbp+var_128]
mov rax, [rax]
mov [rbp+var_38], rax
cmp rax, 0
jz loc_899D6
lea rax, [rbp+var_30]
mov [rbp+var_138], rax
mov eax, [rbp+var_30]
mov [rbp+var_12C], eax
cmp eax, 28h ; '('
ja short loc_8998E
mov rcx, [rbp+var_138]
mov edx, [rbp+var_12C]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_140], rax
jmp short loc_899AB
loc_8998E:
mov rcx, [rbp+var_138]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_140], rax
loc_899AB:
mov rax, [rbp+var_140]
mov rax, [rax]
mov [rbp+var_58], rax
mov rax, [rbp+var_58]
add rax, 8
sub rax, 1
and rax, 0FFFFFFFFFFFFFFF8h
add rax, [rbp+var_50]
mov [rbp+var_50], rax
jmp loc_898E3
loc_899D6:
lea rax, [rbp+var_30]
mov rdi, [rbp+var_50]
call _malloc
mov [rbp+var_40], rax
cmp rax, 0
jnz short loc_899FA
mov [rbp+var_8], 0
jmp loc_89B30
loc_899FA:
lea rax, [rbp+var_30]
lea rcx, [rbp+var_110]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 8
mov rax, [rbp+var_40]
mov [rbp+var_48], rax
loc_89A26:
lea rax, [rbp+var_30]
mov [rbp+var_150], rax
mov eax, [rbp+var_30]
mov [rbp+var_144], eax
cmp eax, 28h ; '('
ja short loc_89A61
mov rcx, [rbp+var_150]
mov edx, [rbp+var_144]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_158], rax
jmp short loc_89A7E
loc_89A61:
mov rcx, [rbp+var_150]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_158], rax
loc_89A7E:
mov rax, [rbp+var_158]
mov rax, [rax]
mov [rbp+var_38], rax
cmp rax, 0
jz loc_89B24
mov rcx, [rbp+var_48]
mov rax, [rbp+var_38]
mov [rax], rcx
lea rax, [rbp+var_30]
mov [rbp+var_168], rax
mov eax, [rbp+var_30]
mov [rbp+var_15C], eax
cmp eax, 28h ; '('
ja short loc_89ADC
mov rcx, [rbp+var_168]
mov edx, [rbp+var_15C]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_170], rax
jmp short loc_89AF9
loc_89ADC:
mov rcx, [rbp+var_168]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_170], rax
loc_89AF9:
mov rax, [rbp+var_170]
mov rax, [rax]
mov [rbp+var_58], rax
mov rax, [rbp+var_58]
add rax, 8
sub rax, 1
and rax, 0FFFFFFFFFFFFFFF8h
add rax, [rbp+var_48]
mov [rbp+var_48], rax
jmp loc_89A26
loc_89B24:
lea rax, [rbp+var_30]
mov rax, [rbp+var_40]
mov [rbp+var_8], rax
loc_89B30:
mov rax, [rbp+var_8]
add rsp, 170h
pop rbp
retn
| long long ma_multi_malloc(int a1, ...)
{
_QWORD *overflow_arg_area; // rax
_QWORD *v2; // rax
_QWORD *v3; // rax
_QWORD *v4; // rax
long long i; // [rsp+120h] [rbp-50h]
long long j; // [rsp+128h] [rbp-48h]
long long v8; // [rsp+130h] [rbp-40h]
va_list va; // [rsp+140h] [rbp-30h] BYREF
int v10; // [rsp+164h] [rbp-Ch]
va_start(va, a1);
v10 = a1;
for ( i = 0LL; ; i += (*v2 + 7LL) & 0xFFFFFFFFFFFFFFF8LL )
{
if ( va[0].gp_offset > 0x28 )
{
overflow_arg_area = va[0].overflow_arg_area;
va[0].overflow_arg_area = (char *)va[0].overflow_arg_area + 8;
}
else
{
overflow_arg_area = (char *)va[0].reg_save_area + (int)va[0].gp_offset;
va[0].gp_offset += 8;
}
if ( !*overflow_arg_area )
break;
if ( va[0].gp_offset > 0x28 )
{
v2 = va[0].overflow_arg_area;
va[0].overflow_arg_area = (char *)va[0].overflow_arg_area + 8;
}
else
{
v2 = (char *)va[0].reg_save_area + (int)va[0].gp_offset;
va[0].gp_offset += 8;
}
}
v8 = malloc(i);
if ( !v8 )
return 0LL;
va_end(va);
va_start(va, a1);
for ( j = v8; ; j += (*v4 + 7LL) & 0xFFFFFFFFFFFFFFF8LL )
{
if ( va[0].gp_offset > 0x28 )
{
v3 = va[0].overflow_arg_area;
va[0].overflow_arg_area = (char *)va[0].overflow_arg_area + 8;
}
else
{
v3 = (char *)va[0].reg_save_area + (int)va[0].gp_offset;
va[0].gp_offset += 8;
}
if ( !*v3 )
break;
*(_QWORD *)*v3 = j;
if ( va[0].gp_offset > 0x28 )
{
v4 = va[0].overflow_arg_area;
va[0].overflow_arg_area = (char *)va[0].overflow_arg_area + 8;
}
else
{
v4 = (char *)va[0].reg_save_area + (int)va[0].gp_offset;
va[0].gp_offset += 8;
}
}
return v8;
}
| ma_multi_malloc:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x170
TEST AL,AL
JZ 0x00189891
MOVAPS xmmword ptr [RBP + -0xe0],XMM0
MOVAPS xmmword ptr [RBP + -0xd0],XMM1
MOVAPS xmmword ptr [RBP + -0xc0],XMM2
MOVAPS xmmword ptr [RBP + -0xb0],XMM3
MOVAPS xmmword ptr [RBP + -0xa0],XMM4
MOVAPS xmmword ptr [RBP + -0x90],XMM5
MOVAPS xmmword ptr [RBP + -0x80],XMM6
MOVAPS xmmword ptr [RBP + -0x70],XMM7
LAB_00189891:
MOV qword ptr [RBP + -0xe8],R9
MOV qword ptr [RBP + -0xf0],R8
MOV qword ptr [RBP + -0xf8],RCX
MOV qword ptr [RBP + -0x100],RDX
MOV qword ptr [RBP + -0x108],RSI
MOV dword ptr [RBP + -0xc],EDI
LEA RAX,[RBP + -0x30]
LEA RCX,[RBP + -0x110]
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x8
MOV qword ptr [RBP + -0x50],0x0
LAB_001898e3:
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0x120],RAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x114],EAX
CMP EAX,0x28
JA 0x0018991e
MOV RCX,qword ptr [RBP + -0x120]
MOV EDX,dword ptr [RBP + -0x114]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x128],RAX
JMP 0x0018993b
LAB_0018991e:
MOV RCX,qword ptr [RBP + -0x120]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x128],RAX
LAB_0018993b:
MOV RAX,qword ptr [RBP + -0x128]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JZ 0x001899d6
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0x138],RAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x12c],EAX
CMP EAX,0x28
JA 0x0018998e
MOV RCX,qword ptr [RBP + -0x138]
MOV EDX,dword ptr [RBP + -0x12c]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x140],RAX
JMP 0x001899ab
LAB_0018998e:
MOV RCX,qword ptr [RBP + -0x138]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x140],RAX
LAB_001899ab:
MOV RAX,qword ptr [RBP + -0x140]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x8
SUB RAX,0x1
AND RAX,-0x8
ADD RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x001898e3
LAB_001899d6:
LEA RAX,[RBP + -0x30]
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x00160aa0
MOV qword ptr [RBP + -0x40],RAX
CMP RAX,0x0
JNZ 0x001899fa
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00189b30
LAB_001899fa:
LEA RAX,[RBP + -0x30]
LEA RCX,[RBP + -0x110]
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x8
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x48],RAX
LAB_00189a26:
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0x150],RAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x144],EAX
CMP EAX,0x28
JA 0x00189a61
MOV RCX,qword ptr [RBP + -0x150]
MOV EDX,dword ptr [RBP + -0x144]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x158],RAX
JMP 0x00189a7e
LAB_00189a61:
MOV RCX,qword ptr [RBP + -0x150]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x158],RAX
LAB_00189a7e:
MOV RAX,qword ptr [RBP + -0x158]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JZ 0x00189b24
MOV RCX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],RCX
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0x168],RAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x15c],EAX
CMP EAX,0x28
JA 0x00189adc
MOV RCX,qword ptr [RBP + -0x168]
MOV EDX,dword ptr [RBP + -0x15c]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x170],RAX
JMP 0x00189af9
LAB_00189adc:
MOV RCX,qword ptr [RBP + -0x168]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x170],RAX
LAB_00189af9:
MOV RAX,qword ptr [RBP + -0x170]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x8
SUB RAX,0x1
AND RAX,-0x8
ADD RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x00189a26
LAB_00189b24:
LEA RAX,[RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x8],RAX
LAB_00189b30:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x170
POP RBP
RET
|
/* WARNING: Restarted to delay deadcode elimination for space: stack */
void * ma_multi_malloc(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int4 param_9,int8 param_10,int8 param_11,int8 param_12
,int8 param_13,int8 param_14)
{
char in_AL;
long *local_178;
long *local_160;
long *local_148;
long *local_130;
long local_118 [4];
int8 local_f8;
int8 local_f0;
int8 local_e8;
int8 local_d8;
int8 local_c8;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
long local_60;
size_t local_58;
void *local_50;
long local_40;
uint local_38;
int4 local_34;
long *local_30;
long *local_28;
int4 local_14;
void *local_10;
if (in_AL != '\0') {
local_e8 = param_1;
local_d8 = param_2;
local_c8 = param_3;
local_b8 = param_4;
local_a8 = param_5;
local_98 = param_6;
local_88 = param_7;
local_78 = param_8;
}
local_28 = local_118;
local_30 = (long *)&stack0x00000008;
local_34 = 0x30;
local_38 = 8;
local_58 = 0;
while( true ) {
if (local_38 < 0x29) {
local_130 = (long *)((long)local_28 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_130 = local_30;
local_30 = local_30 + 1;
}
local_40 = *local_130;
if (local_40 == 0) break;
if (local_38 < 0x29) {
local_148 = (long *)((long)local_28 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_148 = local_30;
local_30 = local_30 + 1;
}
local_60 = *local_148;
local_58 = (local_60 + 7U & 0xfffffffffffffff8) + local_58;
}
local_118[1] = param_10;
local_118[2] = param_11;
local_118[3] = param_12;
local_f8 = param_13;
local_f0 = param_14;
local_14 = param_9;
local_10 = malloc(local_58);
if (local_10 == (void *)0x0) {
local_10 = (void *)0x0;
}
else {
local_30 = (long *)&stack0x00000008;
local_38 = 8;
local_50 = local_10;
while( true ) {
if (local_38 < 0x29) {
local_160 = (long *)((long)local_118 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_160 = local_30;
local_30 = local_30 + 1;
}
if ((int8 *)*local_160 == (int8 *)0x0) break;
*(int8 *)*local_160 = local_50;
if (local_38 < 0x29) {
local_178 = (long *)((long)local_118 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_178 = local_30;
local_30 = local_30 + 1;
}
local_50 = (void *)((*local_178 + 7U & 0xfffffffffffffff8) + (long)local_50);
}
}
return local_10;
}
|
|
5,885 | mju_printMatSparse | aimrt_mujoco_sim/_deps/mujoco-src/src/engine/engine_util_misc.c | void mju_printMatSparse(const mjtNum* mat, int nr,
const int* rownnz, const int* rowadr,
const int* colind) {
for (int r=0; r < nr; r++) {
for (int adr=rowadr[r]; adr < rowadr[r]+rownnz[r]; adr++) {
printf("(%d %d): %9.6f ", r, colind[adr], mat[adr]);
}
printf("\n");
}
printf("\n");
} | O0 | c | mju_printMatSparse:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x2db92e
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x18(%rsp), %rcx
movslq 0xc(%rsp), %rdx
movl (%rcx,%rdx,4), %ecx
movq 0x20(%rsp), %rdx
movslq 0xc(%rsp), %rsi
addl (%rdx,%rsi,4), %ecx
cmpl %ecx, %eax
jge 0x2db910
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rax
movslq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movq 0x30(%rsp), %rax
movslq 0x8(%rsp), %rcx
vmovsd (%rax,%rcx,8), %xmm0
leaq 0x24d60d(%rip), %rdi # 0x528f09
movb $0x1, %al
callq 0x4a900
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x2db8b3
leaq 0x24a947(%rip), %rdi # 0x52625e
movb $0x0, %al
callq 0x4a900
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2db894
leaq 0x24a929(%rip), %rdi # 0x52625e
movb $0x0, %al
callq 0x4a900
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
| mju_printMatSparse:
sub rsp, 38h
mov [rsp+38h+var_8], rdi
mov [rsp+38h+var_C], esi
mov [rsp+38h+var_18], rdx
mov [rsp+38h+var_20], rcx
mov [rsp+38h+var_28], r8
mov [rsp+38h+var_2C], 0
loc_2DB894:
mov eax, [rsp+38h+var_2C]
cmp eax, [rsp+38h+var_C]
jge loc_2DB92E
mov rax, [rsp+38h+var_20]
movsxd rcx, [rsp+38h+var_2C]
mov eax, [rax+rcx*4]
mov [rsp+38h+var_30], eax
loc_2DB8B3:
mov eax, [rsp+38h+var_30]
mov rcx, [rsp+38h+var_20]
movsxd rdx, [rsp+38h+var_2C]
mov ecx, [rcx+rdx*4]
mov rdx, [rsp+38h+var_18]
movsxd rsi, [rsp+38h+var_2C]
add ecx, [rdx+rsi*4]
cmp eax, ecx
jge short loc_2DB910
mov esi, [rsp+38h+var_2C]
mov rax, [rsp+38h+var_28]
movsxd rcx, [rsp+38h+var_30]
mov edx, [rax+rcx*4]
mov rax, [rsp+38h+var_8]
movsxd rcx, [rsp+38h+var_30]
vmovsd xmm0, qword ptr [rax+rcx*8]
lea rdi, aDD96f; "(%d %d): %9.6f "
mov al, 1
call _printf
mov eax, [rsp+38h+var_30]
add eax, 1
mov [rsp+38h+var_30], eax
jmp short loc_2DB8B3
loc_2DB910:
lea rdi, asc_52625E; "\n"
mov al, 0
call _printf
mov eax, [rsp+38h+var_2C]
add eax, 1
mov [rsp+38h+var_2C], eax
jmp loc_2DB894
loc_2DB92E:
lea rdi, asc_52625E; "\n"
mov al, 0
call _printf
add rsp, 38h
retn
| long long mju_printMatSparse(long long a1, int a2, long long a3, long long a4, long long a5)
{
int j; // [rsp+8h] [rbp-30h]
int i; // [rsp+Ch] [rbp-2Ch]
for ( i = 0; i < a2; ++i )
{
for ( j = *(_DWORD *)(a4 + 4LL * i); j < *(_DWORD *)(a3 + 4LL * i) + *(_DWORD *)(a4 + 4LL * i); ++j )
{
_RAX = a1;
_RCX = j;
__asm { vmovsd xmm0, qword ptr [rax+rcx*8] }
printf("(%d %d): %9.6f ", i, *(_DWORD *)(a5 + 4LL * j), *(double *)&_XMM0);
}
printf("\n");
}
return printf("\n");
}
| |||
5,886 | mju_printMatSparse | aimrt_mujoco_sim/_deps/mujoco-src/src/engine/engine_util_misc.c | void mju_printMatSparse(const mjtNum* mat, int nr,
const int* rownnz, const int* rowadr,
const int* colind) {
for (int r=0; r < nr; r++) {
for (int adr=rowadr[r]; adr < rowadr[r]+rownnz[r]; adr++) {
printf("(%d %d): %9.6f ", r, colind[adr], mat[adr]);
}
printf("\n");
}
printf("\n");
} | O3 | c | mju_printMatSparse:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
testl %esi, %esi
jle 0x9e953
movq %rdx, %r12
movl %esi, %eax
movq %rax, 0x10(%rsp)
xorl %r13d, %r13d
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %r14
movq 0x18(%rsp), %r15
cmpl $0x0, (%r12,%r13,4)
leaq 0x12fce8(%rip), %rbx # 0x1ce5ed
jle 0x9e93a
movslq (%rcx,%r13,4), %rbp
movl (%r14,%rbp,4), %edx
vmovsd (%r15,%rbp,8), %xmm0
movq %rbx, %rdi
movl %r13d, %esi
movb $0x1, %al
callq 0x2e3e0
incq %rbp
movq 0x8(%rsp), %rax
movslq (%rax,%r13,4), %rax
movslq (%r12,%r13,4), %rcx
addq %rax, %rcx
cmpq %rcx, %rbp
jl 0x9e90b
movl $0xa, %edi
callq 0x2e470
movq 0x8(%rsp), %rcx
incq %r13
cmpq 0x10(%rsp), %r13
jne 0x9e8f9
movl $0xa, %edi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2e470
| mju_printMatSparse:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov [rsp+58h+var_38], r8
mov [rsp+58h+var_40], rdi
test esi, esi
jle short loc_9E953
mov r12, rdx
mov eax, esi
mov [rsp+58h+var_48], rax
xor r13d, r13d
mov [rsp+58h+var_50], rcx
mov r14, [rsp+58h+var_38]
mov r15, [rsp+58h+var_40]
loc_9E8F9:
cmp dword ptr [r12+r13*4], 0
lea rbx, aDD96f; "(%d %d): %9.6f "
jle short loc_9E93A
movsxd rbp, dword ptr [rcx+r13*4]
loc_9E90B:
mov edx, [r14+rbp*4]
vmovsd xmm0, qword ptr [r15+rbp*8]
mov rdi, rbx
mov esi, r13d
mov al, 1
call _printf
inc rbp
mov rax, [rsp+58h+var_50]
movsxd rax, dword ptr [rax+r13*4]
movsxd rcx, dword ptr [r12+r13*4]
add rcx, rax
cmp rbp, rcx
jl short loc_9E90B
loc_9E93A:
mov edi, 0Ah
call _putchar
mov rcx, [rsp+58h+var_50]
inc r13
cmp r13, [rsp+58h+var_48]
jnz short loc_9E8F9
loc_9E953:
mov edi, 0Ah
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _putchar
| long long mju_printMatSparse(long long a1, int a2, long long a3, long long a4, long long a5)
{
long long v6; // r13
long long v11; // [rsp+8h] [rbp-50h]
if ( a2 > 0 )
{
v6 = 0LL;
v11 = a4;
_R15 = a1;
do
{
if ( *(int *)(a3 + 4 * v6) > 0 )
{
_RBP = *(int *)(a4 + 4 * v6);
do
{
__asm { vmovsd xmm0, qword ptr [r15+rbp*8] }
printf("(%d %d): %9.6f ", v6, *(_DWORD *)(a5 + 4 * _RBP++), *(double *)&_XMM0);
}
while ( _RBP < *(int *)(v11 + 4 * v6) + (long long)*(int *)(a3 + 4 * v6) );
}
putchar(10LL);
a4 = v11;
++v6;
}
while ( v6 != a2 );
}
return putchar(10LL);
}
| mju_printMatSparse:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],R8
MOV qword ptr [RSP + 0x18],RDI
TEST ESI,ESI
JLE 0x0019e953
MOV R12,RDX
MOV EAX,ESI
MOV qword ptr [RSP + 0x10],RAX
XOR R13D,R13D
MOV qword ptr [RSP + 0x8],RCX
MOV R14,qword ptr [RSP + 0x20]
MOV R15,qword ptr [RSP + 0x18]
LAB_0019e8f9:
CMP dword ptr [R12 + R13*0x4],0x0
LEA RBX,[0x2ce5ed]
JLE 0x0019e93a
MOVSXD RBP,dword ptr [RCX + R13*0x4]
LAB_0019e90b:
MOV EDX,dword ptr [R14 + RBP*0x4]
VMOVSD XMM0,qword ptr [R15 + RBP*0x8]
MOV RDI,RBX
MOV ESI,R13D
MOV AL,0x1
CALL 0x0012e3e0
INC RBP
MOV RAX,qword ptr [RSP + 0x8]
MOVSXD RAX,dword ptr [RAX + R13*0x4]
MOVSXD RCX,dword ptr [R12 + R13*0x4]
ADD RCX,RAX
CMP RBP,RCX
JL 0x0019e90b
LAB_0019e93a:
MOV EDI,0xa
CALL 0x0012e470
MOV RCX,qword ptr [RSP + 0x8]
INC R13
CMP R13,qword ptr [RSP + 0x10]
JNZ 0x0019e8f9
LAB_0019e953:
MOV EDI,0xa
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0012e470
|
void mju_printMatSparse(long param_1,uint param_2,long param_3,long param_4,long param_5)
{
long lVar1;
ulong uVar2;
if (0 < (int)param_2) {
uVar2 = 0;
do {
if (0 < *(int *)(param_3 + uVar2 * 4)) {
lVar1 = (long)*(int *)(param_4 + uVar2 * 4);
do {
printf("(%d %d): %9.6f ",*(int8 *)(param_1 + lVar1 * 8),uVar2 & 0xffffffff,
(ulong)*(uint *)(param_5 + lVar1 * 4));
lVar1 = lVar1 + 1;
} while (lVar1 < (long)*(int *)(param_3 + uVar2 * 4) + (long)*(int *)(param_4 + uVar2 * 4));
}
putchar(10);
uVar2 = uVar2 + 1;
} while (uVar2 != param_2);
}
putchar(10);
return;
}
|
|
5,887 | findPeaks::_peak_prominences(std::vector<double, std::allocator<double>> const&, std::vector<unsigned long, std::allocator<unsigned long>> const&, unsigned long) | giladroyz[P]FindPeaks/src/cpp/find_peaks.cpp | std::vector<lpr_peak_prominence_t> _peak_prominences(const std::vector<double> &x,
const std::vector<size_t> &peaks,
size_t wlen) {
std::vector<lpr_peak_prominence_t> prominences;
size_t i;
double left_min, right_min;
size_t peak, i_min, i_max;
size_t half_wlen = wlen / 2;
for (size_t peak_nr = 0; peak_nr < peaks.size(); peak_nr++) {
lpr_peak_prominence_t prominence;
peak = peaks[peak_nr];
i_min = 0;
i_max = x.size() - 1;
if (wlen >= 2) {
//Adjust window around the evaluated peak (within bounds);
//if wlen is even the resulting window length is is implicitly
//rounded to next odd integer
i_min = max_int(peak - half_wlen, i_min);
i_max = min_int(peak + half_wlen, i_max);
}
//Find the left base in interval [i_min, peak]
i = peak;
prominence.left_base = peak;
left_min = x[peak];
while (i_min <= i && x[i] <= x[peak]) {
if (x[i] < left_min) {
left_min = x[i];
prominence.left_base = i;
}
if (i == 0 && i_min == 0)
break;
i--;
}
//Find the right base in interval [peak, i_max]
i = peak;
prominence.right_base = peak;
right_min = x[peak];
while (i <= i_max && x[i] <= x[peak]) {
if (x[i] < right_min) {
right_min = x[i];
prominence.right_base = i;
}
i++;
}
prominence.prominence = x[peak] - max_double(left_min, right_min);
prominences.push_back(prominence);
}
return prominences;
} | O0 | cpp | findPeaks::_peak_prominences(std::vector<double, std::allocator<double>> const&, std::vector<unsigned long, std::allocator<unsigned long>> const&, unsigned long):
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x70a0
movq -0x20(%rbp), %rax
shrq %rax
movq %rax, -0x60(%rbp)
movq $0x0, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6e80
movq %rax, %rcx
movq -0xa8(%rbp), %rax
cmpq %rcx, %rax
jae 0x3eba
movq -0x18(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x7010
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6b40
subq $0x1, %rax
movq %rax, -0x58(%rbp)
cmpq $0x2, -0x20(%rbp)
jb 0x3c8d
movq -0x48(%rbp), %rdi
subq -0x60(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x3420
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
addq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x3450
movq %rax, -0x58(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x6d90
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x50(%rbp), %rcx
xorl %eax, %eax
cmpq -0x30(%rbp), %rcx
movb %al, -0xa9(%rbp)
ja 0x3d04
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x6d90
movsd (%rax), %xmm0
movsd %xmm0, -0xb8(%rbp)
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x6d90
movsd -0xb8(%rbp), %xmm1
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
setae %al
movb %al, -0xa9(%rbp)
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0x3d10
jmp 0x3d6b
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x6d90
movsd (%rax), %xmm1
movsd -0x38(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x3d4a
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x6d90
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x3d5a
cmpq $0x0, -0x50(%rbp)
jne 0x3d5a
jmp 0x3d6b
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x3cb3
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x6d90
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpq -0x58(%rbp), %rcx
movb %al, -0xb9(%rbp)
ja 0x3de2
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x6d90
movsd (%rax), %xmm0
movsd %xmm0, -0xc8(%rbp)
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x6d90
movsd -0xc8(%rbp), %xmm1
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
setae %al
movb %al, -0xb9(%rbp)
movb -0xb9(%rbp), %al
testb $0x1, %al
jne 0x3dee
jmp 0x3e39
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x6d90
movsd (%rax), %xmm1
movsd -0x40(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x3e28
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x6d90
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x3d91
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x6d90
movsd (%rax), %xmm0
movsd %xmm0, -0xd0(%rbp)
movsd -0x38(%rbp), %xmm0
movsd -0x40(%rbp), %xmm1
callq 0x3480
movq -0xa0(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0xd0(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x78(%rbp)
leaq -0x80(%rbp), %rsi
callq 0x70c0
jmp 0x3e87
jmp 0x3e89
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
jmp 0x3c08
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
callq 0x7130
jmp 0x3ee0
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x3ed0
movq -0xa0(%rbp), %rdi
callq 0x7130
movq -0x98(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x1140
nopl (%rax)
| _ZN9findPeaks17_peak_prominencesERKSt6vectorIdSaIdEERKS0_ImSaImEEm:
push rbp
mov rbp, rsp
sub rsp, 0D0h
mov [rbp+var_A0], rdi
mov rax, rdi
mov [rbp+var_98], rax
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_21], 0
call _ZNSt6vectorIN9findPeaks21lpr_peak_prominence_tESaIS1_EEC2Ev; std::vector<findPeaks::lpr_peak_prominence_t>::vector(void)
mov rax, [rbp+var_20]
shr rax, 1
mov [rbp+var_60], rax
mov [rbp+var_68], 0
loc_3C08:
mov rax, [rbp+var_68]
mov [rbp+var_A8], rax
mov rdi, [rbp+var_18]
call _ZNKSt6vectorImSaImEE4sizeEv; std::vector<ulong>::size(void)
mov rcx, rax
mov rax, [rbp+var_A8]
cmp rax, rcx
jnb loc_3EBA
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_68]
call _ZNKSt6vectorImSaImEEixEm; std::vector<ulong>::operator[](ulong)
mov rax, [rax]
mov [rbp+var_48], rax
mov [rbp+var_50], 0
mov rdi, [rbp+var_10]
call _ZNKSt6vectorIdSaIdEE4sizeEv; std::vector<double>::size(void)
sub rax, 1
mov [rbp+var_58], rax
cmp [rbp+var_20], 2
jb short loc_3C8D
mov rdi, [rbp+var_48]
sub rdi, [rbp+var_60]; this
mov rsi, [rbp+var_50]; unsigned __int64
call _ZN9findPeaks7max_intEmm; findPeaks::max_int(ulong,ulong)
mov [rbp+var_50], rax
mov rdi, [rbp+var_48]
add rdi, [rbp+var_60]; this
mov rsi, [rbp+var_58]; unsigned __int64
call _ZN9findPeaks7min_intEmm; findPeaks::min_int(ulong,ulong)
mov [rbp+var_58], rax
loc_3C8D:
mov rax, [rbp+var_48]
mov [rbp+var_30], rax
mov rax, [rbp+var_48]
mov [rbp+var_80], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_48]
call _ZNKSt6vectorIdSaIdEEixEm; std::vector<double>::operator[](ulong)
movsd xmm0, qword ptr [rax]
movsd [rbp+var_38], xmm0
loc_3CB3:
mov rcx, [rbp+var_50]
xor eax, eax
cmp rcx, [rbp+var_30]
mov [rbp+var_A9], al
ja short loc_3D04
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_30]
call _ZNKSt6vectorIdSaIdEEixEm; std::vector<double>::operator[](ulong)
movsd xmm0, qword ptr [rax]
movsd [rbp+var_B8], xmm0
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_48]
call _ZNKSt6vectorIdSaIdEEixEm; std::vector<double>::operator[](ulong)
movsd xmm1, [rbp+var_B8]
movsd xmm0, qword ptr [rax]
ucomisd xmm0, xmm1
setnb al
mov [rbp+var_A9], al
loc_3D04:
mov al, [rbp+var_A9]
test al, 1
jnz short loc_3D10
jmp short loc_3D6B
loc_3D10:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_30]
call _ZNKSt6vectorIdSaIdEEixEm; std::vector<double>::operator[](ulong)
movsd xmm1, qword ptr [rax]
movsd xmm0, [rbp+var_38]
ucomisd xmm0, xmm1
jbe short loc_3D4A
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_30]
call _ZNKSt6vectorIdSaIdEEixEm; std::vector<double>::operator[](ulong)
movsd xmm0, qword ptr [rax]
movsd [rbp+var_38], xmm0
mov rax, [rbp+var_30]
mov [rbp+var_80], rax
loc_3D4A:
cmp [rbp+var_30], 0
jnz short loc_3D5A
cmp [rbp+var_50], 0
jnz short loc_3D5A
jmp short loc_3D6B
loc_3D5A:
mov rax, [rbp+var_30]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_30], rax
jmp loc_3CB3
loc_3D6B:
mov rax, [rbp+var_48]
mov [rbp+var_30], rax
mov rax, [rbp+var_48]
mov [rbp+var_70], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_48]
call _ZNKSt6vectorIdSaIdEEixEm; std::vector<double>::operator[](ulong)
movsd xmm0, qword ptr [rax]
movsd [rbp+var_40], xmm0
loc_3D91:
mov rcx, [rbp+var_30]
xor eax, eax
cmp rcx, [rbp+var_58]
mov [rbp+var_B9], al
ja short loc_3DE2
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_30]
call _ZNKSt6vectorIdSaIdEEixEm; std::vector<double>::operator[](ulong)
movsd xmm0, qword ptr [rax]
movsd [rbp+var_C8], xmm0
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_48]
call _ZNKSt6vectorIdSaIdEEixEm; std::vector<double>::operator[](ulong)
movsd xmm1, [rbp+var_C8]
movsd xmm0, qword ptr [rax]
ucomisd xmm0, xmm1
setnb al
mov [rbp+var_B9], al
loc_3DE2:
mov al, [rbp+var_B9]
test al, 1
jnz short loc_3DEE
jmp short loc_3E39
loc_3DEE:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_30]
call _ZNKSt6vectorIdSaIdEEixEm; std::vector<double>::operator[](ulong)
movsd xmm1, qword ptr [rax]
movsd xmm0, [rbp+var_40]
ucomisd xmm0, xmm1
jbe short loc_3E28
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_30]
call _ZNKSt6vectorIdSaIdEEixEm; std::vector<double>::operator[](ulong)
movsd xmm0, qword ptr [rax]
movsd [rbp+var_40], xmm0
mov rax, [rbp+var_30]
mov [rbp+var_70], rax
loc_3E28:
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_30], rax
jmp loc_3D91
loc_3E39:
mov rdi, [rbp+var_10]; this
mov rsi, [rbp+var_48]
call _ZNKSt6vectorIdSaIdEEixEm; std::vector<double>::operator[](ulong)
movsd xmm0, qword ptr [rax]
movsd [rbp+var_D0], xmm0
movsd xmm0, [rbp+var_38]; double
movsd xmm1, [rbp+var_40]; double
call _ZN9findPeaks10max_doubleEdd; findPeaks::max_double(double,double)
mov rdi, [rbp+var_A0]
movaps xmm1, xmm0
movsd xmm0, [rbp+var_D0]
subsd xmm0, xmm1
movsd [rbp+var_78], xmm0
lea rsi, [rbp+var_80]
call _ZNSt6vectorIN9findPeaks21lpr_peak_prominence_tESaIS1_EE9push_backERKS1_; std::vector<findPeaks::lpr_peak_prominence_t>::push_back(findPeaks::lpr_peak_prominence_t const&)
jmp short $+2
loc_3E87:
jmp short $+2
loc_3E89:
mov rax, [rbp+var_68]
add rax, 1
mov [rbp+var_68], rax
jmp loc_3C08
mov rdi, [rbp+var_A0]
mov rcx, rax
mov eax, edx
mov [rbp+var_88], rcx
mov [rbp+var_8C], eax
call _ZNSt6vectorIN9findPeaks21lpr_peak_prominence_tESaIS1_EED2Ev; std::vector<findPeaks::lpr_peak_prominence_t>::~vector()
jmp short loc_3EE0
loc_3EBA:
mov [rbp+var_21], 1
test [rbp+var_21], 1
jnz short loc_3ED0
mov rdi, [rbp+var_A0]
call _ZNSt6vectorIN9findPeaks21lpr_peak_prominence_tESaIS1_EED2Ev; std::vector<findPeaks::lpr_peak_prominence_t>::~vector()
loc_3ED0:
mov rax, [rbp+var_98]
add rsp, 0D0h
pop rbp
retn
loc_3EE0:
mov rdi, [rbp+var_88]
call __Unwind_Resume
| long long findPeaks::_peak_prominences(long long a1, findPeaks *a2, long long a3, unsigned long long a4)
{
double *v4; // rax
double *v5; // rax
findPeaks *v6; // rdi
double v8; // [rsp+0h] [rbp-D0h]
double v9; // [rsp+8h] [rbp-C8h]
bool v10; // [rsp+17h] [rbp-B9h]
double v11; // [rsp+18h] [rbp-B8h]
bool v12; // [rsp+27h] [rbp-A9h]
unsigned long long v13; // [rsp+28h] [rbp-A8h]
_QWORD v16[2]; // [rsp+50h] [rbp-80h] BYREF
unsigned long long v17; // [rsp+60h] [rbp-70h]
unsigned long long i; // [rsp+68h] [rbp-68h]
unsigned long long v19; // [rsp+70h] [rbp-60h]
unsigned long long v20; // [rsp+78h] [rbp-58h]
unsigned long long v21; // [rsp+80h] [rbp-50h]
unsigned long long v22; // [rsp+88h] [rbp-48h]
double v23; // [rsp+90h] [rbp-40h]
double v24; // [rsp+98h] [rbp-38h]
unsigned long long v25; // [rsp+A0h] [rbp-30h]
char v26; // [rsp+AFh] [rbp-21h]
unsigned long long v27; // [rsp+B0h] [rbp-20h]
long long v28; // [rsp+B8h] [rbp-18h]
findPeaks *v29; // [rsp+C0h] [rbp-10h]
long long v30; // [rsp+C8h] [rbp-8h]
v30 = a1;
v29 = a2;
v28 = a3;
v27 = a4;
v26 = 0;
std::vector<findPeaks::lpr_peak_prominence_t>::vector();
v19 = v27 >> 1;
for ( i = 0LL; ; ++i )
{
v13 = i;
if ( v13 >= std::vector<unsigned long>::size(v28) )
break;
v22 = *(_QWORD *)std::vector<unsigned long>::operator[](v28, i);
v21 = 0LL;
v20 = std::vector<double>::size(v29) - 1;
if ( v27 >= 2 )
{
v21 = (unsigned long long)findPeaks::max_int((findPeaks *)(v22 - v19), v21);
v20 = (unsigned long long)findPeaks::min_int((findPeaks *)(v19 + v22), v20);
}
v25 = v22;
v16[0] = v22;
v24 = *(double *)std::vector<double>::operator[](v29, v22);
while ( 1 )
{
v12 = 0;
if ( v21 <= v25 )
{
v11 = *(double *)std::vector<double>::operator[](v29, v25);
v12 = *(double *)std::vector<double>::operator[](v29, v22) >= v11;
}
if ( !v12 )
break;
v4 = (double *)std::vector<double>::operator[](v29, v25);
if ( v24 > *v4 )
{
v24 = *(double *)std::vector<double>::operator[](v29, v25);
v16[0] = v25;
}
if ( !v25 && !v21 )
break;
--v25;
}
v25 = v22;
v17 = v22;
v23 = *(double *)std::vector<double>::operator[](v29, v22);
while ( 1 )
{
v10 = 0;
if ( v25 <= v20 )
{
v9 = *(double *)std::vector<double>::operator[](v29, v25);
v10 = *(double *)std::vector<double>::operator[](v29, v22) >= v9;
}
if ( !v10 )
break;
v5 = (double *)std::vector<double>::operator[](v29, v25);
if ( v23 > *v5 )
{
v23 = *(double *)std::vector<double>::operator[](v29, v25);
v17 = v25;
}
++v25;
}
v6 = v29;
v8 = *(double *)std::vector<double>::operator[](v29, v22);
*(double *)&v16[1] = v8 - findPeaks::max_double(v6, v24, v23);
std::vector<findPeaks::lpr_peak_prominence_t>::push_back(a1, v16);
}
return a1;
}
| _peak_prominences:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xd0
MOV qword ptr [RBP + -0xa0],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0x98],RAX
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV byte ptr [RBP + -0x21],0x0
CALL 0x001070a0
MOV RAX,qword ptr [RBP + -0x20]
SHR RAX,0x1
MOV qword ptr [RBP + -0x60],RAX
MOV qword ptr [RBP + -0x68],0x0
LAB_00103c08:
MOV RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RBP + -0xa8],RAX
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00106e80
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0xa8]
CMP RAX,RCX
JNC 0x00103eba
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x68]
CALL 0x00107010
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x48],RAX
MOV qword ptr [RBP + -0x50],0x0
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00106b40
SUB RAX,0x1
MOV qword ptr [RBP + -0x58],RAX
CMP qword ptr [RBP + -0x20],0x2
JC 0x00103c8d
MOV RDI,qword ptr [RBP + -0x48]
SUB RDI,qword ptr [RBP + -0x60]
MOV RSI,qword ptr [RBP + -0x50]
CALL 0x00103420
MOV qword ptr [RBP + -0x50],RAX
MOV RDI,qword ptr [RBP + -0x48]
ADD RDI,qword ptr [RBP + -0x60]
MOV RSI,qword ptr [RBP + -0x58]
CALL 0x00103450
MOV qword ptr [RBP + -0x58],RAX
LAB_00103c8d:
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x80],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x48]
CALL 0x00106d90
MOVSD XMM0,qword ptr [RAX]
MOVSD qword ptr [RBP + -0x38],XMM0
LAB_00103cb3:
MOV RCX,qword ptr [RBP + -0x50]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x30]
MOV byte ptr [RBP + -0xa9],AL
JA 0x00103d04
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x30]
CALL 0x00106d90
MOVSD XMM0,qword ptr [RAX]
MOVSD qword ptr [RBP + -0xb8],XMM0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x48]
CALL 0x00106d90
MOVSD XMM1,qword ptr [RBP + -0xb8]
MOVSD XMM0,qword ptr [RAX]
UCOMISD XMM0,XMM1
SETNC AL
MOV byte ptr [RBP + -0xa9],AL
LAB_00103d04:
MOV AL,byte ptr [RBP + -0xa9]
TEST AL,0x1
JNZ 0x00103d10
JMP 0x00103d6b
LAB_00103d10:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x30]
CALL 0x00106d90
MOVSD XMM1,qword ptr [RAX]
MOVSD XMM0,qword ptr [RBP + -0x38]
UCOMISD XMM0,XMM1
JBE 0x00103d4a
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x30]
CALL 0x00106d90
MOVSD XMM0,qword ptr [RAX]
MOVSD qword ptr [RBP + -0x38],XMM0
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x80],RAX
LAB_00103d4a:
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x00103d5a
CMP qword ptr [RBP + -0x50],0x0
JNZ 0x00103d5a
JMP 0x00103d6b
LAB_00103d5a:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x30],RAX
JMP 0x00103cb3
LAB_00103d6b:
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x70],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x48]
CALL 0x00106d90
MOVSD XMM0,qword ptr [RAX]
MOVSD qword ptr [RBP + -0x40],XMM0
LAB_00103d91:
MOV RCX,qword ptr [RBP + -0x30]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x58]
MOV byte ptr [RBP + -0xb9],AL
JA 0x00103de2
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x30]
CALL 0x00106d90
MOVSD XMM0,qword ptr [RAX]
MOVSD qword ptr [RBP + -0xc8],XMM0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x48]
CALL 0x00106d90
MOVSD XMM1,qword ptr [RBP + -0xc8]
MOVSD XMM0,qword ptr [RAX]
UCOMISD XMM0,XMM1
SETNC AL
MOV byte ptr [RBP + -0xb9],AL
LAB_00103de2:
MOV AL,byte ptr [RBP + -0xb9]
TEST AL,0x1
JNZ 0x00103dee
JMP 0x00103e39
LAB_00103dee:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x30]
CALL 0x00106d90
MOVSD XMM1,qword ptr [RAX]
MOVSD XMM0,qword ptr [RBP + -0x40]
UCOMISD XMM0,XMM1
JBE 0x00103e28
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x30]
CALL 0x00106d90
MOVSD XMM0,qword ptr [RAX]
MOVSD qword ptr [RBP + -0x40],XMM0
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x70],RAX
LAB_00103e28:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
JMP 0x00103d91
LAB_00103e39:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x48]
CALL 0x00106d90
MOVSD XMM0,qword ptr [RAX]
MOVSD qword ptr [RBP + -0xd0],XMM0
MOVSD XMM0,qword ptr [RBP + -0x38]
MOVSD XMM1,qword ptr [RBP + -0x40]
CALL 0x00103480
MOV RDI,qword ptr [RBP + -0xa0]
MOVAPS XMM1,XMM0
MOVSD XMM0,qword ptr [RBP + -0xd0]
SUBSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x78],XMM0
LAB_00103e7c:
LEA RSI,[RBP + -0x80]
CALL 0x001070c0
LAB_00103e85:
JMP 0x00103e87
LAB_00103e87:
JMP 0x00103e89
LAB_00103e89:
MOV RAX,qword ptr [RBP + -0x68]
ADD RAX,0x1
MOV qword ptr [RBP + -0x68],RAX
JMP 0x00103c08
LAB_00103eba:
MOV byte ptr [RBP + -0x21],0x1
TEST byte ptr [RBP + -0x21],0x1
JNZ 0x00103ed0
MOV RDI,qword ptr [RBP + -0xa0]
CALL 0x00107130
LAB_00103ed0:
MOV RAX,qword ptr [RBP + -0x98]
ADD RSP,0xd0
POP RBP
RET
|
/* WARNING: Removing unreachable block (ram,0x00103ec4) */
/* findPeaks::_peak_prominences(std::vector<double, std::allocator<double> > const&,
std::vector<unsigned long, std::allocator<unsigned long> > const&, unsigned long) */
findPeaks * __thiscall
findPeaks::_peak_prominences(findPeaks *this,vector *param_1,vector *param_2,ulong param_3)
{
double dVar1;
bool bVar2;
ulong uVar3;
ulong uVar4;
ulong *puVar5;
long lVar6;
double *pdVar7;
ulong local_88;
double local_80;
ulong local_78;
ulong local_70;
ulong local_68;
ulong local_60;
ulong local_58;
ulong local_50;
double local_48;
double local_40;
ulong local_38;
int1 local_29;
ulong local_28;
vector *local_20;
vector *local_18;
findPeaks *local_10;
local_29 = 0;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
local_10 = this;
std::vector<findPeaks::lpr_peak_prominence_t,std::allocator<findPeaks::lpr_peak_prominence_t>>::
vector((vector<findPeaks::lpr_peak_prominence_t,std::allocator<findPeaks::lpr_peak_prominence_t>>
*)this);
local_68 = local_28 >> 1;
local_70 = 0;
do {
uVar3 = local_70;
uVar4 = std::vector<unsigned_long,std::allocator<unsigned_long>>::size
((vector<unsigned_long,std::allocator<unsigned_long>> *)local_20);
if (uVar4 <= uVar3) {
return this;
}
puVar5 = (ulong *)std::vector<unsigned_long,std::allocator<unsigned_long>>::operator[]
((vector<unsigned_long,std::allocator<unsigned_long>> *)local_20,
local_70);
local_50 = *puVar5;
local_58 = 0;
lVar6 = std::vector<double,std::allocator<double>>::size
((vector<double,std::allocator<double>> *)local_18);
local_60 = lVar6 - 1;
if (1 < local_28) {
local_58 = max_int(local_50 - local_68,local_58);
local_60 = min_int(local_50 + local_68,local_60);
}
local_38 = local_50;
local_88 = local_50;
pdVar7 = (double *)
std::vector<double,std::allocator<double>>::operator[]
((vector<double,std::allocator<double>> *)local_18,local_50);
local_40 = *pdVar7;
while( true ) {
bVar2 = false;
if (local_58 <= local_38) {
pdVar7 = (double *)
std::vector<double,std::allocator<double>>::operator[]
((vector<double,std::allocator<double>> *)local_18,local_38);
dVar1 = *pdVar7;
pdVar7 = (double *)
std::vector<double,std::allocator<double>>::operator[]
((vector<double,std::allocator<double>> *)local_18,local_50);
bVar2 = dVar1 <= *pdVar7;
}
if (!bVar2) break;
pdVar7 = (double *)
std::vector<double,std::allocator<double>>::operator[]
((vector<double,std::allocator<double>> *)local_18,local_38);
if (*pdVar7 < local_40) {
pdVar7 = (double *)
std::vector<double,std::allocator<double>>::operator[]
((vector<double,std::allocator<double>> *)local_18,local_38);
local_40 = *pdVar7;
local_88 = local_38;
}
if ((local_38 == 0) && (local_58 == 0)) break;
local_38 = local_38 - 1;
}
local_38 = local_50;
local_78 = local_50;
pdVar7 = (double *)
std::vector<double,std::allocator<double>>::operator[]
((vector<double,std::allocator<double>> *)local_18,local_50);
local_48 = *pdVar7;
while( true ) {
bVar2 = false;
if (local_38 <= local_60) {
pdVar7 = (double *)
std::vector<double,std::allocator<double>>::operator[]
((vector<double,std::allocator<double>> *)local_18,local_38);
dVar1 = *pdVar7;
pdVar7 = (double *)
std::vector<double,std::allocator<double>>::operator[]
((vector<double,std::allocator<double>> *)local_18,local_50);
bVar2 = dVar1 <= *pdVar7;
}
if (!bVar2) break;
pdVar7 = (double *)
std::vector<double,std::allocator<double>>::operator[]
((vector<double,std::allocator<double>> *)local_18,local_38);
if (*pdVar7 < local_48) {
pdVar7 = (double *)
std::vector<double,std::allocator<double>>::operator[]
((vector<double,std::allocator<double>> *)local_18,local_38);
local_48 = *pdVar7;
local_78 = local_38;
}
local_38 = local_38 + 1;
}
pdVar7 = (double *)
std::vector<double,std::allocator<double>>::operator[]
((vector<double,std::allocator<double>> *)local_18,local_50);
dVar1 = *pdVar7;
local_80 = (double)max_double(local_40,local_48);
local_80 = dVar1 - local_80;
/* try { // try from 00103e7c to 00103e84 has its CatchHandler @ 00103e9a */
std::vector<findPeaks::lpr_peak_prominence_t,std::allocator<findPeaks::lpr_peak_prominence_t>>::
push_back((vector<findPeaks::lpr_peak_prominence_t,std::allocator<findPeaks::lpr_peak_prominence_t>>
*)this,(lpr_peak_prominence_t *)&local_88);
local_70 = local_70 + 1;
} while( true );
}
|
|
5,888 | ma_scramble_323 | eloqsql/libmariadb/libmariadb/ma_password.c | char *ma_scramble_323(char *to, const char *message, const char *password)
{
struct rand_struct rand_st;
ulong hash_pass[2], hash_message[2];
if (password && password[0])
{
char extra, *to_start=to;
const char *end_scramble323= message + SCRAMBLE_LENGTH_323;
ma_hash_password(hash_pass,password, (uint) strlen(password));
/* Don't use strlen, could be > SCRAMBLE_LENGTH_323 ! */
ma_hash_password(hash_message, message, SCRAMBLE_LENGTH_323);
ma_randominit(&rand_st, hash_pass[0] ^ hash_message[0],
hash_pass[1] ^ hash_message[1]);
for (; message < end_scramble323; message++)
*to++= (char) (floor(rnd(&rand_st) * 31) + 64);
extra=(char) (floor(rnd(&rand_st) * 31));
while (to_start != to)
*(to_start++)^= extra;
}
*to= 0;
return to;
} | O3 | c | ma_scramble_323:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
testq %rdx, %rdx
je 0x4406f
movq %rdx, %r15
cmpb $0x0, (%rdx)
je 0x4406f
movq %rsi, %r14
movq %r15, %rdi
callq 0x141c0
movl %eax, %edx
leaq -0x50(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x43cc0
leaq -0x40(%rbp), %r15
movl $0x8, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x43cc0
movq (%r15), %rsi
movq 0x8(%r15), %rcx
xorq (%r12), %rsi
xorq 0x8(%r12), %rcx
movabsq $0x400000011, %r12 # imm = 0x400000011
movq %rsi, %rax
mulq %r12
movq %rsi, %r13
subq %rdx, %r13
shrq %r13
addq %rdx, %r13
shrq $0x1d, %r13
movq %r13, %rax
shlq $0x1e, %rax
subq %rax, %r13
addq %rsi, %r13
movq %rcx, %rax
mulq %r12
movq %rcx, %rsi
subq %rdx, %rsi
shrq %rsi
addq %rdx, %rsi
shrq $0x1d, %rsi
movq %rsi, %rax
shlq $0x1e, %rax
subq %rax, %rsi
addq %rcx, %rsi
xorl %r15d, %r15d
leaq (,%r13,2), %rcx
addq %r13, %rcx
addq %rsi, %rcx
movq %rcx, %rax
mulq %r12
movq %rcx, %r13
subq %rdx, %r13
shrq %r13
addq %rdx, %r13
shrq $0x1d, %r13
movq %r13, %rax
shlq $0x1e, %rax
subq %rax, %r13
addq %rcx, %r13
leaq (%rsi,%r13), %r14
addq $0x21, %r14
xorps %xmm0, %xmm0
cvtsi2sd %r13d, %xmm0
divsd 0x2205(%rip), %xmm0 # 0x461c8
mulsd 0x2205(%rip), %xmm0 # 0x461d0
callq 0x147b0
addsd 0x2200(%rip), %xmm0 # 0x461d8
cvttsd2si %xmm0, %eax
movb %al, (%rbx,%r15)
movq %r14, %rax
mulq %r12
incq %r15
movq %r14, %rsi
subq %rdx, %rsi
shrq %rsi
addq %rdx, %rsi
shrq $0x1d, %rsi
movq %rsi, %rax
shlq $0x1e, %rax
subq %rax, %rsi
addq %r14, %rsi
cmpq $0x8, %r15
jne 0x43f7a
leal (%r13,%r13,2), %eax
addl %eax, %esi
leaq (%rsi,%rsi,4), %rax
shrq $0x20, %rax
movl %esi, %ecx
subl %eax, %ecx
shrl %ecx
addl %eax, %ecx
shrl $0x1d, %ecx
movl %ecx, %eax
shll $0x1e, %eax
subl %eax, %ecx
addl %esi, %ecx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
divsd 0x2186(%rip), %xmm0 # 0x461c8
mulsd 0x2186(%rip), %xmm0 # 0x461d0
callq 0x147b0
cvttsd2si %xmm0, %eax
movd %eax, %xmm0
punpcklbw %xmm0, %xmm0 # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0,4,5,6,7]
movq (%rbx), %xmm1
pxor %xmm0, %xmm1
movq %xmm1, (%rbx)
addq %r15, %rbx
movb $0x0, (%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| ma_scramble_323:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbx, rdi
test rdx, rdx
jz loc_4406F
mov r15, rdx
cmp byte ptr [rdx], 0
jz loc_4406F
mov r14, rsi
mov rdi, r15
call _strlen
mov edx, eax
lea r12, [rbp+var_50]
mov rdi, r12
mov rsi, r15
call ma_hash_password
lea r15, [rbp+var_40]
mov edx, 8
mov rdi, r15
mov rsi, r14
call ma_hash_password
mov rsi, [r15]
mov rcx, [r15+8]
xor rsi, [r12]
xor rcx, [r12+8]
mov r12, 400000011h
mov rax, rsi
mul r12
mov r13, rsi
sub r13, rdx
shr r13, 1
add r13, rdx
shr r13, 1Dh
mov rax, r13
shl rax, 1Eh
sub r13, rax
add r13, rsi
mov rax, rcx
mul r12
mov rsi, rcx
sub rsi, rdx
shr rsi, 1
add rsi, rdx
shr rsi, 1Dh
mov rax, rsi
shl rax, 1Eh
sub rsi, rax
add rsi, rcx
xor r15d, r15d
loc_43F7A:
lea rcx, ds:0[r13*2]
add rcx, r13
add rcx, rsi
mov rax, rcx
mul r12
mov r13, rcx
sub r13, rdx
shr r13, 1
add r13, rdx
shr r13, 1Dh
mov rax, r13
shl rax, 1Eh
sub r13, rax
add r13, rcx
lea r14, [rsi+r13]
add r14, 21h ; '!'
xorps xmm0, xmm0
cvtsi2sd xmm0, r13d
divsd xmm0, cs:qword_461C8
mulsd xmm0, cs:qword_461D0
call _floor
addsd xmm0, cs:qword_461D8
cvttsd2si eax, xmm0
mov [rbx+r15], al
mov rax, r14
mul r12
inc r15
mov rsi, r14
sub rsi, rdx
shr rsi, 1
add rsi, rdx
shr rsi, 1Dh
mov rax, rsi
shl rax, 1Eh
sub rsi, rax
add rsi, r14
cmp r15, 8
jnz loc_43F7A
lea eax, [r13+r13*2+0]
add esi, eax
lea rax, [rsi+rsi*4]
shr rax, 20h
mov ecx, esi
sub ecx, eax
shr ecx, 1
add ecx, eax
shr ecx, 1Dh
mov eax, ecx
shl eax, 1Eh
sub ecx, eax
add ecx, esi
xorps xmm0, xmm0
cvtsi2sd xmm0, ecx
divsd xmm0, cs:qword_461C8
mulsd xmm0, cs:qword_461D0
call _floor
cvttsd2si eax, xmm0
movd xmm0, eax
punpcklbw xmm0, xmm0
pshuflw xmm0, xmm0, 0
movq xmm1, qword ptr [rbx]
pxor xmm1, xmm0
movq qword ptr [rbx], xmm1
add rbx, r15
loc_4406F:
mov byte ptr [rbx], 0
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| __m128i * ma_scramble_323(__m128i *a1, unsigned __int8 *a2, unsigned __int8 *a3)
{
__m128i *v3; // rbx
unsigned int v5; // eax
unsigned long long v6; // r13
unsigned long long v7; // rsi
long long i; // r15
__m128i v9; // xmm0
long long v11[2]; // [rsp+0h] [rbp-50h] BYREF
long long v12[8]; // [rsp+10h] [rbp-40h] BYREF
v3 = a1;
if ( a3 && *a3 )
{
v5 = strlen(a3);
ma_hash_password(v11, a3, v5);
ma_hash_password(v12, a2, 8LL);
v6 = (v11[0] ^ v12[0]) % 0x3FFFFFFFuLL;
v7 = (v11[1] ^ v12[1]) % 0x3FFFFFFFuLL;
for ( i = 0LL; i != 8; ++i )
{
v6 = (v7 + 3 * v6) % 0x3FFFFFFF;
a1->m128i_i8[i] = (int)(floor((double)(int)v6 / 1073741823.0 * 31.0) + 64.0);
v7 = (v7 + v6 + 33) % 0x3FFFFFFF;
}
v9 = _mm_cvtsi32_si128((int)floor((double)((3 * (int)v6 + (int)v7) % 0x3FFFFFFFu) / 1073741823.0 * 31.0));
a1->m128i_i64[0] = _mm_xor_si128(_mm_loadl_epi64(a1), _mm_shufflelo_epi16(_mm_unpacklo_epi8(v9, v9), 0)).m128i_u64[0];
v3 = (__m128i *)&a1->m128i_u64[1];
}
v3->m128i_i8[0] = 0;
return v3;
}
| ma_scramble_323:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
TEST RDX,RDX
JZ 0x0014406f
MOV R15,RDX
CMP byte ptr [RDX],0x0
JZ 0x0014406f
MOV R14,RSI
MOV RDI,R15
CALL 0x001141c0
MOV EDX,EAX
LEA R12,[RBP + -0x50]
MOV RDI,R12
MOV RSI,R15
CALL 0x00143cc0
LEA R15,[RBP + -0x40]
MOV EDX,0x8
MOV RDI,R15
MOV RSI,R14
CALL 0x00143cc0
MOV RSI,qword ptr [R15]
MOV RCX,qword ptr [R15 + 0x8]
XOR RSI,qword ptr [R12]
XOR RCX,qword ptr [R12 + 0x8]
MOV R12,0x400000011
MOV RAX,RSI
MUL R12
MOV R13,RSI
SUB R13,RDX
SHR R13,0x1
ADD R13,RDX
SHR R13,0x1d
MOV RAX,R13
SHL RAX,0x1e
SUB R13,RAX
ADD R13,RSI
MOV RAX,RCX
MUL R12
MOV RSI,RCX
SUB RSI,RDX
SHR RSI,0x1
ADD RSI,RDX
SHR RSI,0x1d
MOV RAX,RSI
SHL RAX,0x1e
SUB RSI,RAX
ADD RSI,RCX
XOR R15D,R15D
LAB_00143f7a:
LEA RCX,[R13*0x2]
ADD RCX,R13
ADD RCX,RSI
MOV RAX,RCX
MUL R12
MOV R13,RCX
SUB R13,RDX
SHR R13,0x1
ADD R13,RDX
SHR R13,0x1d
MOV RAX,R13
SHL RAX,0x1e
SUB R13,RAX
ADD R13,RCX
LEA R14,[RSI + R13*0x1]
ADD R14,0x21
XORPS XMM0,XMM0
CVTSI2SD XMM0,R13D
DIVSD XMM0,qword ptr [0x001461c8]
MULSD XMM0,qword ptr [0x001461d0]
CALL 0x001147b0
ADDSD XMM0,qword ptr [0x001461d8]
CVTTSD2SI EAX,XMM0
MOV byte ptr [RBX + R15*0x1],AL
MOV RAX,R14
MUL R12
INC R15
MOV RSI,R14
SUB RSI,RDX
SHR RSI,0x1
ADD RSI,RDX
SHR RSI,0x1d
MOV RAX,RSI
SHL RAX,0x1e
SUB RSI,RAX
ADD RSI,R14
CMP R15,0x8
JNZ 0x00143f7a
LEA EAX,[R13 + R13*0x2]
ADD ESI,EAX
LEA RAX,[RSI + RSI*0x4]
SHR RAX,0x20
MOV ECX,ESI
SUB ECX,EAX
SHR ECX,0x1
ADD ECX,EAX
SHR ECX,0x1d
MOV EAX,ECX
SHL EAX,0x1e
SUB ECX,EAX
ADD ECX,ESI
XORPS XMM0,XMM0
CVTSI2SD XMM0,ECX
DIVSD XMM0,qword ptr [0x001461c8]
MULSD XMM0,qword ptr [0x001461d0]
CALL 0x001147b0
CVTTSD2SI EAX,XMM0
MOVD XMM0,EAX
PUNPCKLBW XMM0,XMM0
PSHUFLW XMM0,XMM0,0x0
MOVQ XMM1,qword ptr [RBX]
PXOR XMM1,XMM0
MOVQ qword ptr [RBX],XMM1
ADD RBX,R15
LAB_0014406f:
MOV byte ptr [RBX],0x0
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
ulong * ma_scramble_323(ulong *param_1,int8 param_2,char *param_3)
{
int iVar1;
size_t sVar2;
ulong uVar3;
ulong uVar4;
long lVar5;
int1 uVar8;
int1 uVar9;
int1 uVar10;
double dVar6;
int1 auVar7 [16];
ulong local_58;
ulong local_50;
ulong local_48;
ulong local_40;
if ((param_3 != (char *)0x0) && (*param_3 != '\0')) {
sVar2 = strlen(param_3);
ma_hash_password(&local_58,param_3,sVar2 & 0xffffffff);
ma_hash_password(&local_48,param_2,8);
uVar4 = (local_48 ^ local_58) % 0x3fffffff;
uVar3 = (local_40 ^ local_50) % 0x3fffffff;
lVar5 = 0;
do {
uVar4 = (uVar4 * 3 + uVar3) % 0x3fffffff;
dVar6 = floor(((double)(int)uVar4 / _DAT_001461c8) * _DAT_001461d0);
*(char *)((long)param_1 + lVar5) = (char)(int)(dVar6 + _DAT_001461d8);
lVar5 = lVar5 + 1;
uVar3 = (uVar3 + uVar4 + 0x21) % 0x3fffffff;
} while (lVar5 != 8);
dVar6 = floor(((double)((uint)((int)uVar3 + (int)uVar4 * 3) % 0x3fffffff) / _DAT_001461c8) *
_DAT_001461d0);
iVar1 = (int)dVar6;
uVar10 = (int1)((uint)iVar1 >> 0x18);
uVar9 = (int1)((uint)iVar1 >> 0x10);
uVar8 = (int1)((uint)iVar1 >> 8);
auVar7._4_4_ = (int)(CONCAT35(CONCAT21(CONCAT11(uVar10,uVar10),uVar9),CONCAT14(uVar9,iVar1)) >>
0x20);
auVar7[3] = uVar8;
auVar7[2] = uVar8;
auVar7[0] = (int1)iVar1;
auVar7[1] = auVar7[0];
auVar7._8_8_ = 0;
auVar7 = pshuflw(auVar7,auVar7,0);
*param_1 = *param_1 ^ auVar7._0_8_;
param_1 = param_1 + 1;
}
*(int1 *)param_1 = 0;
return param_1;
}
|
|
5,889 | JS_ToInt32Free | bluesky950520[P]quickjs/quickjs.c | static int JS_ToInt32Free(JSContext *ctx, int32_t *pres, JSValue val)
{
uint32_t tag;
int32_t ret;
redo:
tag = JS_VALUE_GET_NORM_TAG(val);
switch(tag) {
case JS_TAG_INT:
case JS_TAG_BOOL:
case JS_TAG_NULL:
case JS_TAG_UNDEFINED:
ret = JS_VALUE_GET_INT(val);
break;
case JS_TAG_FLOAT64:
{
JSFloat64Union u;
double d;
int e;
d = JS_VALUE_GET_FLOAT64(val);
u.d = d;
/* we avoid doing fmod(x, 2^32) */
e = (u.u64 >> 52) & 0x7ff;
if (likely(e <= (1023 + 30))) {
/* fast case */
ret = (int32_t)d;
} else if (e <= (1023 + 30 + 53)) {
uint64_t v;
/* remainder modulo 2^32 */
v = (u.u64 & (((uint64_t)1 << 52) - 1)) | ((uint64_t)1 << 52);
v = v << ((e - 1023) - 52 + 32);
ret = v >> 32;
/* take the sign into account */
if (u.u64 >> 63)
if (ret != INT32_MIN)
ret = -ret;
} else {
ret = 0; /* also handles NaN and +inf */
}
}
break;
default:
val = JS_ToNumberFree(ctx, val);
if (JS_IsException(val)) {
*pres = 0;
return -1;
}
goto redo;
}
*pres = ret;
return 0;
} | O1 | c | JS_ToInt32Free:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
cmpl $0x4, %ecx
jb 0x26de7
cmpl $0x7, %ecx
je 0x26df4
movq %r14, %rdi
movq %rax, %rsi
movq %rcx, %rdx
xorl %ecx, %ecx
callq 0x41f0c
movq %rdx, %rcx
cmpl $0x6, %ecx
jne 0x26dbe
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
jmp 0x26deb
xorl %edx, %edx
movl %eax, %ebp
movl %ebp, (%rbx)
movl %edx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rcx
shrq $0x34, %rcx
andl $0x7ff, %ecx # imm = 0x7FF
cmpl $0x41d, %ecx # imm = 0x41D
ja 0x26e16
movq %rax, %xmm0
cvttsd2si %xmm0, %ebp
xorl %edx, %edx
jmp 0x26deb
xorl %edx, %edx
cmpl $0x452, %ecx # imm = 0x452
ja 0x26e57
movabsq $0xfffffffffffff, %rsi # imm = 0xFFFFFFFFFFFFF
movq %rax, %rdi
andq %rsi, %rdi
addq %rdi, %rsi
incq %rsi
addb $-0x13, %cl
shlq %cl, %rsi
shrq $0x20, %rsi
movl %esi, %ebp
negl %ebp
movl $0x80000000, %ecx # imm = 0x80000000
cmpq %rcx, %rsi
cmovel %esi, %ebp
testq %rax, %rax
cmovnsl %esi, %ebp
jmp 0x26deb
xorl %ebp, %ebp
jmp 0x26deb
| JS_ToInt32Free:
push rbp
push r14
push rbx
mov rax, rdx
mov rbx, rsi
mov r14, rdi
xor ebp, ebp
loc_26DBE:
cmp ecx, 4
jb short loc_26DE7
cmp ecx, 7
jz short loc_26DF4
mov rdi, r14
mov rsi, rax
mov rdx, rcx
xor ecx, ecx
call JS_ToNumberHintFree
mov rcx, rdx
cmp ecx, 6
jnz short loc_26DBE
mov edx, 0FFFFFFFFh
jmp short loc_26DEB
loc_26DE7:
xor edx, edx
mov ebp, eax
loc_26DEB:
mov [rbx], ebp
mov eax, edx
pop rbx
pop r14
pop rbp
retn
loc_26DF4:
mov rcx, rax
shr rcx, 34h
and ecx, 7FFh
cmp ecx, 41Dh
ja short loc_26E16
movq xmm0, rax
cvttsd2si ebp, xmm0
xor edx, edx
jmp short loc_26DEB
loc_26E16:
xor edx, edx
cmp ecx, 452h
ja short loc_26E57
mov rsi, 0FFFFFFFFFFFFFh
mov rdi, rax
and rdi, rsi
add rsi, rdi
inc rsi
add cl, 0EDh
shl rsi, cl
shr rsi, 20h
mov ebp, esi
neg ebp
mov ecx, 80000000h
cmp rsi, rcx
cmovz ebp, esi
test rax, rax
cmovns ebp, esi
jmp short loc_26DEB
loc_26E57:
xor ebp, ebp
jmp short loc_26DEB
| long long JS_ToInt32Free(long long a1, int *a2, unsigned long long a3, long long a4)
{
int v5; // ebp
long long v6; // rdx
unsigned int v7; // edx
long long v9; // rcx
v5 = 0;
while ( 1 )
{
if ( (unsigned int)a4 < 4 )
{
v7 = 0;
v5 = a3;
goto LABEL_7;
}
if ( (_DWORD)a4 == 7 )
break;
*(double *)&a3 = COERCE_DOUBLE(JS_ToNumberHintFree(a1, a3, a4, 0LL));
a4 = v6;
if ( (_DWORD)v6 == 6 )
{
v7 = -1;
goto LABEL_7;
}
}
v9 = (a3 >> 52) & 0x7FF;
if ( (unsigned int)v9 > 0x41D )
{
v7 = 0;
if ( (unsigned int)v9 > 0x452 )
{
v5 = 0;
}
else
{
v5 = -(((a3 & 0xFFFFFFFFFFFFFLL) + 0x10000000000000LL) << ((unsigned __int8)(a3 >> 52) - 19) >> 32);
if ( ((a3 & 0xFFFFFFFFFFFFFLL) + 0x10000000000000LL) << ((unsigned __int8)(a3 >> 52) - 19) >> 32 == 0x80000000 )
v5 = 0x80000000;
if ( (a3 & 0x8000000000000000LL) == 0LL )
v5 = ((a3 & 0xFFFFFFFFFFFFFLL) + 0x10000000000000LL) << ((unsigned __int8)(a3 >> 52) - 19) >> 32;
}
}
else
{
v5 = (int)*(double *)&a3;
v7 = 0;
}
LABEL_7:
*a2 = v5;
return v7;
}
| JS_ToInt32Free:
PUSH RBP
PUSH R14
PUSH RBX
MOV RAX,RDX
MOV RBX,RSI
MOV R14,RDI
XOR EBP,EBP
LAB_00126dbe:
CMP ECX,0x4
JC 0x00126de7
CMP ECX,0x7
JZ 0x00126df4
MOV RDI,R14
MOV RSI,RAX
MOV RDX,RCX
XOR ECX,ECX
CALL 0x00141f0c
MOV RCX,RDX
CMP ECX,0x6
JNZ 0x00126dbe
MOV EDX,0xffffffff
JMP 0x00126deb
LAB_00126de7:
XOR EDX,EDX
MOV EBP,EAX
LAB_00126deb:
MOV dword ptr [RBX],EBP
MOV EAX,EDX
POP RBX
POP R14
POP RBP
RET
LAB_00126df4:
MOV RCX,RAX
SHR RCX,0x34
AND ECX,0x7ff
CMP ECX,0x41d
JA 0x00126e16
MOVQ XMM0,RAX
CVTTSD2SI EBP,XMM0
XOR EDX,EDX
JMP 0x00126deb
LAB_00126e16:
XOR EDX,EDX
CMP ECX,0x452
JA 0x00126e57
MOV RSI,0xfffffffffffff
MOV RDI,RAX
AND RDI,RSI
ADD RSI,RDI
INC RSI
ADD CL,0xed
SHL RSI,CL
SHR RSI,0x20
MOV EBP,ESI
NEG EBP
MOV ECX,0x80000000
CMP RSI,RCX
CMOVZ EBP,ESI
TEST RAX,RAX
CMOVNS EBP,ESI
JMP 0x00126deb
LAB_00126e57:
XOR EBP,EBP
JMP 0x00126deb
|
int8 JS_ToInt32Free(int8 param_1,int *param_2,int8 param_3,int8 param_4)
{
double dVar1;
uint uVar2;
int8 uVar3;
int iVar4;
int iVar5;
ulong uVar6;
int1 auVar7 [16];
auVar7._8_8_ = param_4;
auVar7._0_8_ = param_3;
while( true ) {
dVar1 = auVar7._0_8_;
if (auVar7._8_4_ < 4) {
uVar3 = 0;
iVar4 = auVar7._0_4_;
goto LAB_00126deb;
}
if (auVar7._8_4_ == 7) break;
auVar7 = JS_ToNumberHintFree(param_1,dVar1,auVar7._8_8_,0);
if (auVar7._8_4_ == 6) {
uVar3 = 0xffffffff;
iVar4 = 0;
LAB_00126deb:
*param_2 = iVar4;
return uVar3;
}
}
uVar2 = auVar7._4_4_ >> 0x14 & 0x7ff;
if (uVar2 < 0x41e) {
uVar3 = 0;
iVar4 = (int)dVar1;
}
else {
uVar3 = 0;
if (uVar2 < 0x453) {
uVar6 = ((ulong)dVar1 & 0xfffffffffffff) + 0x10000000000000 << ((char)uVar2 - 0x13U & 0x3f);
iVar5 = (int)(uVar6 >> 0x20);
iVar4 = -iVar5;
if (uVar6 >> 0x20 == 0x80000000) {
iVar4 = iVar5;
}
if (-1 < (long)dVar1) {
iVar4 = iVar5;
}
}
else {
iVar4 = 0;
}
}
goto LAB_00126deb;
}
|
|
5,890 | JS_ToInt32Free | bluesky950520[P]quickjs/quickjs.c | static int JS_ToInt32Free(JSContext *ctx, int32_t *pres, JSValue val)
{
uint32_t tag;
int32_t ret;
redo:
tag = JS_VALUE_GET_NORM_TAG(val);
switch(tag) {
case JS_TAG_INT:
case JS_TAG_BOOL:
case JS_TAG_NULL:
case JS_TAG_UNDEFINED:
ret = JS_VALUE_GET_INT(val);
break;
case JS_TAG_FLOAT64:
{
JSFloat64Union u;
double d;
int e;
d = JS_VALUE_GET_FLOAT64(val);
u.d = d;
/* we avoid doing fmod(x, 2^32) */
e = (u.u64 >> 52) & 0x7ff;
if (likely(e <= (1023 + 30))) {
/* fast case */
ret = (int32_t)d;
} else if (e <= (1023 + 30 + 53)) {
uint64_t v;
/* remainder modulo 2^32 */
v = (u.u64 & (((uint64_t)1 << 52) - 1)) | ((uint64_t)1 << 52);
v = v << ((e - 1023) - 52 + 32);
ret = v >> 32;
/* take the sign into account */
if (u.u64 >> 63)
if (ret != INT32_MIN)
ret = -ret;
} else {
ret = 0; /* also handles NaN and +inf */
}
}
break;
default:
val = JS_ToNumberFree(ctx, val);
if (JS_IsException(val)) {
*pres = 0;
return -1;
}
goto redo;
}
*pres = ret;
return 0;
} | O2 | c | JS_ToInt32Free:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $-0x1
popq %rbp
cmpl $0x4, %ecx
jb 0x20ab6
cmpl $0x7, %ecx
je 0x20a98
movq %r14, %rdi
movq %rax, %rsi
movq %rcx, %rdx
callq 0x2d69a
movq %rdx, %rcx
cmpl $0x6, %ecx
jne 0x20a74
xorl %eax, %eax
jmp 0x20ab8
movq %rax, %rcx
shrq $0x34, %rcx
andl $0x7ff, %ecx # imm = 0x7FF
cmpl $0x41d, %ecx # imm = 0x41D
ja 0x20ac1
movq %rax, %xmm0
cvttsd2si %xmm0, %eax
xorl %ebp, %ebp
movl %eax, (%rbx)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
xorl %ebp, %ebp
cmpl $0x452, %ecx # imm = 0x452
ja 0x20a94
movabsq $0xfffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFF
movq %rax, %rsi
andq %rdx, %rsi
addq %rsi, %rdx
incq %rdx
addb $-0x13, %cl
shlq %cl, %rdx
shrq $0x20, %rdx
movl %edx, %ecx
negl %ecx
movl $0x80000000, %esi # imm = 0x80000000
cmpq %rsi, %rdx
cmovel %edx, %ecx
testq %rax, %rax
cmovnsl %edx, %ecx
movl %ecx, %eax
jmp 0x20ab8
| JS_ToInt32Free:
push rbp
push r14
push rbx
mov rax, rdx
mov rbx, rsi
mov r14, rdi
push 0FFFFFFFFFFFFFFFFh
pop rbp
loc_20A74:
cmp ecx, 4
jb short loc_20AB6
cmp ecx, 7
jz short loc_20A98
mov rdi, r14
mov rsi, rax
mov rdx, rcx
call JS_ToNumberFree
mov rcx, rdx
cmp ecx, 6
jnz short loc_20A74
loc_20A94:
xor eax, eax
jmp short loc_20AB8
loc_20A98:
mov rcx, rax
shr rcx, 34h
and ecx, 7FFh
cmp ecx, 41Dh
ja short loc_20AC1
movq xmm0, rax
cvttsd2si eax, xmm0
loc_20AB6:
xor ebp, ebp
loc_20AB8:
mov [rbx], eax
mov eax, ebp
pop rbx
pop r14
pop rbp
retn
loc_20AC1:
xor ebp, ebp
cmp ecx, 452h
ja short loc_20A94
mov rdx, 0FFFFFFFFFFFFFh
mov rsi, rax
and rsi, rdx
add rdx, rsi
inc rdx
add cl, 0EDh
shl rdx, cl
shr rdx, 20h
mov ecx, edx
neg ecx
mov esi, 80000000h
cmp rdx, rsi
cmovz ecx, edx
test rax, rax
cmovns ecx, edx
mov eax, ecx
jmp short loc_20AB8
| long long JS_ToInt32Free(long long a1, _DWORD *a2, unsigned long long a3, long long a4)
{
unsigned int v5; // ebp
long long v6; // rdx
long long v7; // rcx
unsigned int v9; // ecx
v5 = -1;
while ( 1 )
{
if ( (unsigned int)a4 < 4 )
goto LABEL_8;
if ( (_DWORD)a4 == 7 )
break;
*(double *)&a3 = COERCE_DOUBLE(JS_ToNumberFree(a1, a3, a4));
a4 = v6;
if ( (_DWORD)v6 == 6 )
goto LABEL_5;
}
v7 = (a3 >> 52) & 0x7FF;
if ( (unsigned int)v7 <= 0x41D )
{
LODWORD(a3) = (int)*(double *)&a3;
LABEL_8:
v5 = 0;
goto LABEL_9;
}
v5 = 0;
if ( (unsigned int)v7 > 0x452 )
{
LABEL_5:
LODWORD(a3) = 0;
goto LABEL_9;
}
v9 = -(((a3 & 0xFFFFFFFFFFFFFLL) + 0x10000000000000LL) << ((unsigned __int8)(a3 >> 52) - 19) >> 32);
if ( ((a3 & 0xFFFFFFFFFFFFFLL) + 0x10000000000000LL) << ((unsigned __int8)(a3 >> 52) - 19) >> 32 == 0x80000000 )
v9 = 0x80000000;
if ( (a3 & 0x8000000000000000LL) == 0LL )
v9 = ((a3 & 0xFFFFFFFFFFFFFLL) + 0x10000000000000LL) << ((unsigned __int8)(a3 >> 52) - 19) >> 32;
LODWORD(a3) = v9;
LABEL_9:
*a2 = a3;
return v5;
}
| JS_ToInt32Free:
PUSH RBP
PUSH R14
PUSH RBX
MOV RAX,RDX
MOV RBX,RSI
MOV R14,RDI
PUSH -0x1
POP RBP
LAB_00120a74:
CMP ECX,0x4
JC 0x00120ab6
CMP ECX,0x7
JZ 0x00120a98
MOV RDI,R14
MOV RSI,RAX
MOV RDX,RCX
CALL 0x0012d69a
MOV RCX,RDX
CMP ECX,0x6
JNZ 0x00120a74
LAB_00120a94:
XOR EAX,EAX
JMP 0x00120ab8
LAB_00120a98:
MOV RCX,RAX
SHR RCX,0x34
AND ECX,0x7ff
CMP ECX,0x41d
JA 0x00120ac1
MOVQ XMM0,RAX
CVTTSD2SI EAX,XMM0
LAB_00120ab6:
XOR EBP,EBP
LAB_00120ab8:
MOV dword ptr [RBX],EAX
MOV EAX,EBP
POP RBX
POP R14
POP RBP
RET
LAB_00120ac1:
XOR EBP,EBP
CMP ECX,0x452
JA 0x00120a94
MOV RDX,0xfffffffffffff
MOV RSI,RAX
AND RSI,RDX
ADD RDX,RSI
INC RDX
ADD CL,0xed
SHL RDX,CL
SHR RDX,0x20
MOV ECX,EDX
NEG ECX
MOV ESI,0x80000000
CMP RDX,RSI
CMOVZ ECX,EDX
TEST RAX,RAX
CMOVNS ECX,EDX
MOV EAX,ECX
JMP 0x00120ab8
|
int4 JS_ToInt32Free(int8 param_1,int *param_2,int8 param_3,int8 param_4)
{
int iVar1;
double dVar2;
uint uVar3;
int iVar4;
ulong uVar5;
int4 uVar6;
int1 auVar7 [16];
auVar7._8_8_ = param_4;
auVar7._0_8_ = param_3;
uVar6 = 0xffffffff;
do {
dVar2 = auVar7._0_8_;
if (auVar7._8_4_ < 4) {
LAB_00120ab6:
uVar6 = 0;
iVar1 = SUB84(dVar2,0);
goto LAB_00120ab8;
}
if (auVar7._8_4_ == 7) {
uVar3 = auVar7._4_4_ >> 0x14 & 0x7ff;
if (uVar3 < 0x41e) {
dVar2 = (double)(ulong)(uint)(int)dVar2;
goto LAB_00120ab6;
}
uVar6 = 0;
if (uVar3 < 0x453) {
uVar5 = ((ulong)dVar2 & 0xfffffffffffff) + 0x10000000000000 << ((char)uVar3 - 0x13U & 0x3f);
iVar4 = (int)(uVar5 >> 0x20);
iVar1 = -iVar4;
if (uVar5 >> 0x20 == 0x80000000) {
iVar1 = iVar4;
}
if (-1 < (long)dVar2) {
iVar1 = iVar4;
}
goto LAB_00120ab8;
}
goto LAB_00120a94;
}
auVar7 = JS_ToNumberFree(param_1,dVar2,auVar7._8_8_);
if (auVar7._8_4_ == 6) {
LAB_00120a94:
iVar1 = 0;
LAB_00120ab8:
*param_2 = iVar1;
return uVar6;
}
} while( true );
}
|
|
5,891 | JS_ToInt32Free | bluesky950520[P]quickjs/quickjs.c | static int JS_ToInt32Free(JSContext *ctx, int32_t *pres, JSValue val)
{
uint32_t tag;
int32_t ret;
redo:
tag = JS_VALUE_GET_NORM_TAG(val);
switch(tag) {
case JS_TAG_INT:
case JS_TAG_BOOL:
case JS_TAG_NULL:
case JS_TAG_UNDEFINED:
ret = JS_VALUE_GET_INT(val);
break;
case JS_TAG_FLOAT64:
{
JSFloat64Union u;
double d;
int e;
d = JS_VALUE_GET_FLOAT64(val);
u.d = d;
/* we avoid doing fmod(x, 2^32) */
e = (u.u64 >> 52) & 0x7ff;
if (likely(e <= (1023 + 30))) {
/* fast case */
ret = (int32_t)d;
} else if (e <= (1023 + 30 + 53)) {
uint64_t v;
/* remainder modulo 2^32 */
v = (u.u64 & (((uint64_t)1 << 52) - 1)) | ((uint64_t)1 << 52);
v = v << ((e - 1023) - 52 + 32);
ret = v >> 32;
/* take the sign into account */
if (u.u64 >> 63)
if (ret != INT32_MIN)
ret = -ret;
} else {
ret = 0; /* also handles NaN and +inf */
}
}
break;
default:
val = JS_ToNumberFree(ctx, val);
if (JS_IsException(val)) {
*pres = 0;
return -1;
}
goto redo;
}
*pres = ret;
return 0;
} | O3 | c | JS_ToInt32Free:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
cmpl $0x4, %ecx
jb 0x27440
cmpl $0x7, %ecx
je 0x2744d
movq %r14, %rdi
movq %rax, %rsi
movq %rcx, %rdx
xorl %ecx, %ecx
callq 0x43a59
movq %rdx, %rcx
cmpl $0x6, %ecx
jne 0x27417
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
jmp 0x27444
xorl %edx, %edx
movl %eax, %ebp
movl %ebp, (%rbx)
movl %edx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rcx
shrq $0x34, %rcx
andl $0x7ff, %ecx # imm = 0x7FF
cmpl $0x41d, %ecx # imm = 0x41D
ja 0x2746f
movq %rax, %xmm0
cvttsd2si %xmm0, %ebp
xorl %edx, %edx
jmp 0x27444
xorl %edx, %edx
cmpl $0x452, %ecx # imm = 0x452
ja 0x274b0
movabsq $0xfffffffffffff, %rsi # imm = 0xFFFFFFFFFFFFF
movq %rax, %rdi
andq %rsi, %rdi
addq %rdi, %rsi
incq %rsi
addb $-0x13, %cl
shlq %cl, %rsi
shrq $0x20, %rsi
movl %esi, %ebp
negl %ebp
movl $0x80000000, %ecx # imm = 0x80000000
cmpq %rcx, %rsi
cmovel %esi, %ebp
testq %rax, %rax
cmovnsl %esi, %ebp
jmp 0x27444
xorl %ebp, %ebp
jmp 0x27444
| JS_ToInt32Free:
push rbp
push r14
push rbx
mov rax, rdx
mov rbx, rsi
mov r14, rdi
xor ebp, ebp
loc_27417:
cmp ecx, 4
jb short loc_27440
cmp ecx, 7
jz short loc_2744D
mov rdi, r14
mov rsi, rax
mov rdx, rcx
xor ecx, ecx
call JS_ToNumberHintFree
mov rcx, rdx
cmp ecx, 6
jnz short loc_27417
mov edx, 0FFFFFFFFh
jmp short loc_27444
loc_27440:
xor edx, edx
mov ebp, eax
loc_27444:
mov [rbx], ebp
mov eax, edx
pop rbx
pop r14
pop rbp
retn
loc_2744D:
mov rcx, rax
shr rcx, 34h
and ecx, 7FFh
cmp ecx, 41Dh
ja short loc_2746F
movq xmm0, rax
cvttsd2si ebp, xmm0
xor edx, edx
jmp short loc_27444
loc_2746F:
xor edx, edx
cmp ecx, 452h
ja short loc_274B0
mov rsi, 0FFFFFFFFFFFFFh
mov rdi, rax
and rdi, rsi
add rsi, rdi
inc rsi
add cl, 0EDh
shl rsi, cl
shr rsi, 20h
mov ebp, esi
neg ebp
mov ecx, 80000000h
cmp rsi, rcx
cmovz ebp, esi
test rax, rax
cmovns ebp, esi
jmp short loc_27444
loc_274B0:
xor ebp, ebp
jmp short loc_27444
| long long JS_ToInt32Free(long long a1, int *a2, unsigned long long a3, long long a4)
{
int v5; // ebp
long long v6; // rdx
unsigned int v7; // edx
long long v9; // rcx
v5 = 0;
while ( 1 )
{
if ( (unsigned int)a4 < 4 )
{
v7 = 0;
v5 = a3;
goto LABEL_7;
}
if ( (_DWORD)a4 == 7 )
break;
*(double *)&a3 = COERCE_DOUBLE(JS_ToNumberHintFree(a1, a3, a4, 0LL));
a4 = v6;
if ( (_DWORD)v6 == 6 )
{
v7 = -1;
goto LABEL_7;
}
}
v9 = (a3 >> 52) & 0x7FF;
if ( (unsigned int)v9 > 0x41D )
{
v7 = 0;
if ( (unsigned int)v9 > 0x452 )
{
v5 = 0;
}
else
{
v5 = -(((a3 & 0xFFFFFFFFFFFFFLL) + 0x10000000000000LL) << ((unsigned __int8)(a3 >> 52) - 19) >> 32);
if ( ((a3 & 0xFFFFFFFFFFFFFLL) + 0x10000000000000LL) << ((unsigned __int8)(a3 >> 52) - 19) >> 32 == 0x80000000 )
v5 = 0x80000000;
if ( (a3 & 0x8000000000000000LL) == 0LL )
v5 = ((a3 & 0xFFFFFFFFFFFFFLL) + 0x10000000000000LL) << ((unsigned __int8)(a3 >> 52) - 19) >> 32;
}
}
else
{
v5 = (int)*(double *)&a3;
v7 = 0;
}
LABEL_7:
*a2 = v5;
return v7;
}
| JS_ToInt32Free:
PUSH RBP
PUSH R14
PUSH RBX
MOV RAX,RDX
MOV RBX,RSI
MOV R14,RDI
XOR EBP,EBP
LAB_00127417:
CMP ECX,0x4
JC 0x00127440
CMP ECX,0x7
JZ 0x0012744d
MOV RDI,R14
MOV RSI,RAX
MOV RDX,RCX
XOR ECX,ECX
CALL 0x00143a59
MOV RCX,RDX
CMP ECX,0x6
JNZ 0x00127417
MOV EDX,0xffffffff
JMP 0x00127444
LAB_00127440:
XOR EDX,EDX
MOV EBP,EAX
LAB_00127444:
MOV dword ptr [RBX],EBP
MOV EAX,EDX
POP RBX
POP R14
POP RBP
RET
LAB_0012744d:
MOV RCX,RAX
SHR RCX,0x34
AND ECX,0x7ff
CMP ECX,0x41d
JA 0x0012746f
MOVQ XMM0,RAX
CVTTSD2SI EBP,XMM0
XOR EDX,EDX
JMP 0x00127444
LAB_0012746f:
XOR EDX,EDX
CMP ECX,0x452
JA 0x001274b0
MOV RSI,0xfffffffffffff
MOV RDI,RAX
AND RDI,RSI
ADD RSI,RDI
INC RSI
ADD CL,0xed
SHL RSI,CL
SHR RSI,0x20
MOV EBP,ESI
NEG EBP
MOV ECX,0x80000000
CMP RSI,RCX
CMOVZ EBP,ESI
TEST RAX,RAX
CMOVNS EBP,ESI
JMP 0x00127444
LAB_001274b0:
XOR EBP,EBP
JMP 0x00127444
|
int8 JS_ToInt32Free(int8 param_1,int *param_2,int8 param_3,int8 param_4)
{
double dVar1;
uint uVar2;
int8 uVar3;
int iVar4;
int iVar5;
ulong uVar6;
int1 auVar7 [16];
auVar7._8_8_ = param_4;
auVar7._0_8_ = param_3;
while( true ) {
dVar1 = auVar7._0_8_;
if (auVar7._8_4_ < 4) {
uVar3 = 0;
iVar4 = auVar7._0_4_;
goto LAB_00127444;
}
if (auVar7._8_4_ == 7) break;
auVar7 = JS_ToNumberHintFree(param_1,dVar1,auVar7._8_8_,0);
if (auVar7._8_4_ == 6) {
uVar3 = 0xffffffff;
iVar4 = 0;
LAB_00127444:
*param_2 = iVar4;
return uVar3;
}
}
uVar2 = auVar7._4_4_ >> 0x14 & 0x7ff;
if (uVar2 < 0x41e) {
uVar3 = 0;
iVar4 = (int)dVar1;
}
else {
uVar3 = 0;
if (uVar2 < 0x453) {
uVar6 = ((ulong)dVar1 & 0xfffffffffffff) + 0x10000000000000 << ((char)uVar2 - 0x13U & 0x3f);
iVar5 = (int)(uVar6 >> 0x20);
iVar4 = -iVar5;
if (uVar6 >> 0x20 == 0x80000000) {
iVar4 = iVar5;
}
if (-1 < (long)dVar1) {
iVar4 = iVar5;
}
}
else {
iVar4 = 0;
}
}
goto LAB_00127444;
}
|
|
5,892 | LoadCodepoints | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rtext.c | int *LoadCodepoints(const char *text, int *count)
{
int textLength = TextLength(text);
int codepointSize = 0;
int codepointCount = 0;
// Allocate a big enough buffer to store as many codepoints as text bytes
int *codepoints = (int *)RL_CALLOC(textLength, sizeof(int));
for (int i = 0; i < textLength; codepointCount++)
{
codepoints[codepointCount] = GetCodepointNext(text + i, &codepointSize);
i += codepointSize;
}
// Re-allocate buffer to the actual number of codepoints loaded
codepoints = (int *)RL_REALLOC(codepoints, codepointCount*sizeof(int));
*count = codepointCount;
return codepoints;
} | O0 | c | LoadCodepoints:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe5fe0
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x14(%rbp), %rdi
movl $0x4, %esi
callq 0xa340
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xe79b0
movq -0x8(%rbp), %rdi
movslq -0x2c(%rbp), %rax
addq %rax, %rdi
leaq -0x18(%rbp), %rsi
callq 0xe6020
movl %eax, %edx
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xe7973
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
shlq $0x2, %rsi
callq 0xa950
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| LoadCodepoints:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rdi, [rbp+var_8]
call TextLength
mov [rbp+var_14], eax
mov [rbp+var_18], 0
mov [rbp+var_1C], 0
movsxd rdi, [rbp+var_14]
mov esi, 4
call _calloc
mov [rbp+var_28], rax
mov [rbp+var_2C], 0
loc_E7973:
mov eax, [rbp+var_2C]
cmp eax, [rbp+var_14]
jge short loc_E79B0
mov rdi, [rbp+var_8]
movsxd rax, [rbp+var_2C]
add rdi, rax
lea rsi, [rbp+var_18]
call GetCodepointNext
mov edx, eax
mov rax, [rbp+var_28]
movsxd rcx, [rbp+var_1C]
mov [rax+rcx*4], edx
mov eax, [rbp+var_18]
add eax, [rbp+var_2C]
mov [rbp+var_2C], eax
mov eax, [rbp+var_1C]
add eax, 1
mov [rbp+var_1C], eax
jmp short loc_E7973
loc_E79B0:
mov rdi, [rbp+var_28]
movsxd rsi, [rbp+var_1C]
shl rsi, 2
call _realloc
mov [rbp+var_28], rax
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_10]
mov [rax], ecx
mov rax, [rbp+var_28]
add rsp, 30h
pop rbp
retn
| long long LoadCodepoints(_BYTE *a1, _DWORD *a2)
{
long long result; // rax
int v3; // [rsp+4h] [rbp-2Ch]
long long v4; // [rsp+8h] [rbp-28h]
int v5; // [rsp+14h] [rbp-1Ch]
int v6; // [rsp+18h] [rbp-18h] BYREF
int v7; // [rsp+1Ch] [rbp-14h]
_DWORD *v8; // [rsp+20h] [rbp-10h]
_BYTE *v9; // [rsp+28h] [rbp-8h]
v9 = a1;
v8 = a2;
v7 = TextLength(a1);
v6 = 0;
v5 = 0;
v4 = calloc(v7, 4LL);
v3 = 0;
while ( v3 < v7 )
{
*(_DWORD *)(v4 + 4LL * v5) = GetCodepointNext(&v9[v3], &v6);
v3 += v6;
++v5;
}
result = realloc(v4, 4LL * v5);
*v8 = v5;
return result;
}
| LoadCodepoints:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001e5fe0
MOV dword ptr [RBP + -0x14],EAX
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x1c],0x0
MOVSXD RDI,dword ptr [RBP + -0x14]
MOV ESI,0x4
CALL 0x0010a340
MOV qword ptr [RBP + -0x28],RAX
MOV dword ptr [RBP + -0x2c],0x0
LAB_001e7973:
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,dword ptr [RBP + -0x14]
JGE 0x001e79b0
MOV RDI,qword ptr [RBP + -0x8]
MOVSXD RAX,dword ptr [RBP + -0x2c]
ADD RDI,RAX
LEA RSI,[RBP + -0x18]
CALL 0x001e6020
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOVSXD RCX,dword ptr [RBP + -0x1c]
MOV dword ptr [RAX + RCX*0x4],EDX
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x2c],EAX
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x001e7973
LAB_001e79b0:
MOV RDI,qword ptr [RBP + -0x28]
MOVSXD RSI,dword ptr [RBP + -0x1c]
SHL RSI,0x2
CALL 0x0010a950
MOV qword ptr [RBP + -0x28],RAX
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x28]
ADD RSP,0x30
POP RBP
RET
|
void * LoadCodepoints(long param_1,int *param_2)
{
int4 uVar1;
void *pvVar2;
int local_34;
int local_24;
int local_20;
int local_1c;
int *local_18;
long local_10;
local_18 = param_2;
local_10 = param_1;
local_1c = TextLength(param_1);
local_20 = 0;
local_24 = 0;
pvVar2 = calloc((long)local_1c,4);
for (local_34 = 0; local_34 < local_1c; local_34 = local_20 + local_34) {
uVar1 = GetCodepointNext(local_10 + local_34,&local_20);
*(int4 *)((long)pvVar2 + (long)local_24 * 4) = uVar1;
local_24 = local_24 + 1;
}
pvVar2 = realloc(pvVar2,(long)local_24 << 2);
*local_18 = local_24;
return pvVar2;
}
|
|
5,893 | LoadCodepoints | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rtext.c | int *LoadCodepoints(const char *text, int *count)
{
int textLength = TextLength(text);
int codepointSize = 0;
int codepointCount = 0;
// Allocate a big enough buffer to store as many codepoints as text bytes
int *codepoints = (int *)RL_CALLOC(textLength, sizeof(int));
for (int i = 0; i < textLength; codepointCount++)
{
codepoints[codepointCount] = GetCodepointNext(text + i, &codepointSize);
i += codepointSize;
}
// Re-allocate buffer to the actual number of codepoints loaded
codepoints = (int *)RL_REALLOC(codepoints, codepointCount*sizeof(int));
*count = codepointCount;
return codepoints;
} | O3 | c | LoadCodepoints:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
movl $0x0, %ebp
testq %rdi, %rdi
je 0x8613e
cmpb $0x0, (%r14)
movl $0x0, %ebp
je 0x8613e
xorl %ebp, %ebp
cmpb $0x0, 0x1(%r14,%rbp)
leaq 0x1(%rbp), %rbp
jne 0x86132
movl $0x0, 0xc(%rsp)
movslq %ebp, %r12
movl $0x4, %esi
movq %r12, %rdi
callq 0xa330
movq %rax, %r15
testl %r12d, %r12d
jle 0x86190
movq %rbx, 0x10(%rsp)
xorl %r13d, %r13d
leaq 0xc(%rsp), %r12
xorl %ebx, %ebx
movslq %ebx, %rbx
leaq (%r14,%rbx), %rdi
movq %r12, %rsi
callq 0x85040
movl %eax, (%r15,%r13,4)
addl 0xc(%rsp), %ebx
incq %r13
cmpl %ebp, %ebx
jl 0x8616d
movq 0x10(%rsp), %rbx
movl %r13d, %esi
shlq $0x2, %rsi
movq %r15, %rdi
callq 0xa940
movl %r13d, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| LoadCodepoints:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rsi
mov r14, rdi
xor r13d, r13d
mov ebp, 0
test rdi, rdi
jz short loc_8613E
cmp byte ptr [r14], 0
mov ebp, 0
jz short loc_8613E
xor ebp, ebp
loc_86132:
cmp byte ptr [r14+rbp+1], 0
lea rbp, [rbp+1]
jnz short loc_86132
loc_8613E:
mov [rsp+48h+var_3C], 0
movsxd r12, ebp
mov esi, 4
mov rdi, r12
call _calloc
mov r15, rax
test r12d, r12d
jle short loc_86190
mov [rsp+48h+var_38], rbx
xor r13d, r13d
lea r12, [rsp+48h+var_3C]
xor ebx, ebx
loc_8616D:
movsxd rbx, ebx
lea rdi, [r14+rbx]
mov rsi, r12
call GetCodepointNext
mov [r15+r13*4], eax
add ebx, [rsp+48h+var_3C]
inc r13
cmp ebx, ebp
jl short loc_8616D
mov rbx, [rsp+48h+var_38]
loc_86190:
mov esi, r13d
shl rsi, 2
mov rdi, r15
call _realloc
mov [rbx], r13d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long LoadCodepoints(_BYTE *a1, _DWORD *a2)
{
_DWORD *v2; // rbx
long long v3; // r13
long long v4; // rbp
long long v6; // r15
int v7; // ebx
long long result; // rax
int v9; // [rsp+Ch] [rbp-3Ch] BYREF
_DWORD *v10; // [rsp+10h] [rbp-38h]
v2 = a2;
LODWORD(v3) = 0;
LODWORD(v4) = 0;
if ( a1 )
{
LODWORD(v4) = 0;
if ( *a1 )
{
v4 = 0LL;
while ( a1[++v4] != 0 )
;
}
}
v9 = 0;
v6 = calloc((int)v4, 4LL);
if ( (int)v4 > 0 )
{
v10 = a2;
v3 = 0LL;
v7 = 0;
do
{
*(_DWORD *)(v6 + 4 * v3) = GetCodepointNext(&a1[v7], &v9);
v7 += v9;
++v3;
}
while ( v7 < (int)v4 );
v2 = v10;
}
result = realloc(v6, 4LL * (unsigned int)v3);
*v2 = v3;
return result;
}
| LoadCodepoints:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RSI
MOV R14,RDI
XOR R13D,R13D
MOV EBP,0x0
TEST RDI,RDI
JZ 0x0018613e
CMP byte ptr [R14],0x0
MOV EBP,0x0
JZ 0x0018613e
XOR EBP,EBP
LAB_00186132:
CMP byte ptr [R14 + RBP*0x1 + 0x1],0x0
LEA RBP,[RBP + 0x1]
JNZ 0x00186132
LAB_0018613e:
MOV dword ptr [RSP + 0xc],0x0
MOVSXD R12,EBP
MOV ESI,0x4
MOV RDI,R12
CALL 0x0010a330
MOV R15,RAX
TEST R12D,R12D
JLE 0x00186190
MOV qword ptr [RSP + 0x10],RBX
XOR R13D,R13D
LEA R12,[RSP + 0xc]
XOR EBX,EBX
LAB_0018616d:
MOVSXD RBX,EBX
LEA RDI,[R14 + RBX*0x1]
MOV RSI,R12
CALL 0x00185040
MOV dword ptr [R15 + R13*0x4],EAX
ADD EBX,dword ptr [RSP + 0xc]
INC R13
CMP EBX,EBP
JL 0x0018616d
MOV RBX,qword ptr [RSP + 0x10]
LAB_00186190:
MOV ESI,R13D
SHL RSI,0x2
MOV RDI,R15
CALL 0x0010a940
MOV dword ptr [RBX],R13D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void LoadCodepoints(char *param_1,int4 *param_2)
{
long lVar1;
int4 uVar2;
void *__ptr;
int iVar3;
int iVar4;
long lVar5;
ulong uVar6;
int local_3c;
int4 *local_38;
uVar6 = 0;
lVar5 = 0;
if ((param_1 != (char *)0x0) && (lVar5 = 0, *param_1 != '\0')) {
lVar5 = 0;
do {
lVar1 = lVar5 + 1;
lVar5 = lVar5 + 1;
} while (param_1[lVar1] != '\0');
}
local_3c = 0;
iVar4 = (int)lVar5;
__ptr = calloc((long)iVar4,4);
if (0 < iVar4) {
uVar6 = 0;
iVar3 = 0;
local_38 = param_2;
do {
uVar2 = GetCodepointNext(param_1 + iVar3,&local_3c);
*(int4 *)((long)__ptr + uVar6 * 4) = uVar2;
iVar3 = iVar3 + local_3c;
uVar6 = uVar6 + 1;
param_2 = local_38;
} while (iVar3 < iVar4);
}
realloc(__ptr,(uVar6 & 0xffffffff) << 2);
*param_2 = (int)uVar6;
return;
}
|
|
5,894 | trnman_free_trn | eloqsql/storage/maria/trnman.c | static void trnman_free_trn(TRN *trn)
{
/*
union is to solve strict aliasing issue.
without it gcc 3.4.3 doesn't notice that updating *(void **)&tmp
modifies the value of tmp.
*/
union { TRN *trn; void *v; } tmp;
DBUG_ASSERT(trn != &dummy_transaction_object);
mysql_mutex_lock(&trn->state_lock);
trn->short_id= 0;
mysql_mutex_unlock(&trn->state_lock);
tmp.trn= pool;
do
{
/*
without this volatile cast gcc-3.4.4 moves the assignment
down after the loop at -O2
*/
*(TRN * volatile *)&(trn->next)= tmp.trn;
} while (!my_atomic_casptr((void **)(char*)&pool, &tmp.v, trn));
} | O3 | c | trnman_free_trn:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
cmpq $0x0, 0x50(%rdi)
jne 0x5c326
movq %r14, %rdi
callq 0x291d0
movw $0x0, 0xac(%rbx)
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
jne 0x5c33c
movq %r14, %rdi
callq 0x291a0
movq 0x3a3116(%rip), %rax # 0x3ff428
movq %rax, 0x68(%rbx)
lock
cmpxchgq %rbx, 0x3a3109(%rip) # 0x3ff428
jne 0x5c312
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x7e4be(%rip), %rsi # 0xda7eb
movq %r14, %rdi
movl $0x22d, %edx # imm = 0x22D
callq 0x2ee6f
jmp 0x5c2f1
leaq 0x32ad0d(%rip), %rax # 0x387050
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x5c303
| trnman_free_trn:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
lea r14, [rdi+10h]
cmp qword ptr [rdi+50h], 0
jnz short loc_5C326
mov rdi, r14
call _pthread_mutex_lock
loc_5C2F1:
mov word ptr [rbx+0ACh], 0
mov rdi, [rbx+50h]
test rdi, rdi
jnz short loc_5C33C
loc_5C303:
mov rdi, r14
call _pthread_mutex_unlock
mov rax, cs:pool
loc_5C312:
mov [rbx+68h], rax
lock cmpxchg cs:pool, rbx
jnz short loc_5C312
pop rbx
pop r14
pop rbp
retn
loc_5C326:
lea rsi, aWorkspaceLlm4b_8; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r14
mov edx, 22Dh
call psi_mutex_lock
jmp short loc_5C2F1
loc_5C33C:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_5C303
| signed long long trnman_free_trn(signed long long a1)
{
signed long long result; // rax
signed long long v2; // rtt
if ( *(_QWORD *)(a1 + 80) )
psi_mutex_lock(a1 + 16, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c", 0x22Du);
else
pthread_mutex_lock(a1 + 16);
*(_WORD *)(a1 + 172) = 0;
if ( *(_QWORD *)(a1 + 80) )
PSI_server[44]();
pthread_mutex_unlock(a1 + 16);
result = pool;
do
{
*(_QWORD *)(a1 + 104) = result;
v2 = result;
result = _InterlockedCompareExchange64(&pool, a1, result);
}
while ( v2 != result );
return result;
}
| trnman_free_trn:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
LEA R14,[RDI + 0x10]
CMP qword ptr [RDI + 0x50],0x0
JNZ 0x0015c326
MOV RDI,R14
CALL 0x001291d0
LAB_0015c2f1:
MOV word ptr [RBX + 0xac],0x0
MOV RDI,qword ptr [RBX + 0x50]
TEST RDI,RDI
JNZ 0x0015c33c
LAB_0015c303:
MOV RDI,R14
CALL 0x001291a0
MOV RAX,qword ptr [0x004ff428]
LAB_0015c312:
MOV qword ptr [RBX + 0x68],RAX
CMPXCHG.LOCK qword ptr [0x004ff428],RBX
JNZ 0x0015c312
POP RBX
POP R14
POP RBP
RET
LAB_0015c326:
LEA RSI,[0x1da7eb]
MOV RDI,R14
MOV EDX,0x22d
CALL 0x0012ee6f
JMP 0x0015c2f1
LAB_0015c33c:
LEA RAX,[0x487050]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0015c303
|
void trnman_free_trn(long param_1)
{
pthread_mutex_t *__mutex;
long lVar1;
long lVar2;
bool bVar3;
__mutex = (pthread_mutex_t *)(param_1 + 0x10);
if (*(long *)(param_1 + 0x50) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c",0x22d);
}
*(int2 *)(param_1 + 0xac) = 0;
if (*(long *)(param_1 + 0x50) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
lVar2 = pool;
do {
*(long *)(param_1 + 0x68) = lVar2;
LOCK();
bVar3 = lVar2 != pool;
lVar1 = param_1;
if (bVar3) {
lVar2 = pool;
lVar1 = pool;
}
pool = lVar1;
UNLOCK();
} while (bVar3);
return;
}
|
|
5,895 | bitmap_test_and_set | eloqsql/mysys/my_bitmap.c | my_bool bitmap_test_and_set(MY_BITMAP *map, uint bitmap_bit)
{
my_bool res;
DBUG_ASSERT(map->bitmap);
DBUG_ASSERT(bitmap_bit < map->n_bits);
bitmap_lock(map);
res= bitmap_fast_test_and_set(map, bitmap_bit);
bitmap_unlock(map);
return res;
} | O3 | c | bitmap_test_and_set:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x9d2f1
cmpq $0x0, 0x40(%rdi)
jne 0x9d342
callq 0x29220
movl %r14d, %eax
andb $0x7, %r14b
movl $0x1, %r15d
movl %r14d, %ecx
shll %cl, %r15d
movq (%rbx), %rcx
shrl $0x3, %eax
movb (%rcx,%rax), %r14b
movl %r14d, %edx
orb %r15b, %dl
movb %dl, (%rcx,%rax)
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
je 0x9d331
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
jne 0x9d355
movq %rbx, %rdi
callq 0x291e0
andb %r15b, %r14b
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3f059(%rip), %rsi # 0xdc3a2
movl $0x81, %edx
callq 0x2eb8f
jmp 0x9d2f1
leaq 0x2e8cb4(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x9d329
| bitmap_test_and_set:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14d, esi
mov rbx, rdi
mov rdi, [rdi+10h]
test rdi, rdi
jz short loc_9D2F1
cmp qword ptr [rdi+40h], 0
jnz short loc_9D342
call _pthread_mutex_lock
loc_9D2F1:
mov eax, r14d
and r14b, 7
mov r15d, 1
mov ecx, r14d
shl r15d, cl
mov rcx, [rbx]
shr eax, 3
mov r14b, [rcx+rax]
mov edx, r14d
or dl, r15b
mov [rcx+rax], dl
mov rbx, [rbx+10h]
test rbx, rbx
jz short loc_9D331
mov rdi, [rbx+40h]
test rdi, rdi
jnz short loc_9D355
loc_9D329:
mov rdi, rbx
call _pthread_mutex_unlock
loc_9D331:
and r14b, r15b
mov eax, r14d
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_9D342:
lea rsi, aWorkspaceLlm4b_40; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 81h
call psi_mutex_lock
jmp short loc_9D2F1
loc_9D355:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_9D329
| long long bitmap_test_and_set(_QWORD *a1, unsigned int a2)
{
unsigned int v2; // r14d
long long v4; // rdi
int v5; // r15d
long long v6; // rax
long long v7; // rbx
long long v8; // rdi
v2 = a2;
v4 = a1[2];
if ( v4 )
{
if ( *(_QWORD *)(v4 + 64) )
psi_mutex_lock(v4, (long long)"/workspace/llm4binary/github2025/eloqsql/mysys/my_bitmap.c", 0x81u);
else
pthread_mutex_lock(v4);
}
v5 = 1 << (a2 & 7);
v6 = a2 >> 3;
LOBYTE(v2) = *(_BYTE *)(*a1 + v6);
*(_BYTE *)(*a1 + v6) = v5 | v2;
v7 = a1[2];
if ( v7 )
{
v8 = *(_QWORD *)(v7 + 64);
if ( v8 )
((void ( *)(long long))PSI_server[44])(v8);
pthread_mutex_unlock(v7);
}
LOBYTE(v2) = v5 & v2;
return v2;
}
| bitmap_test_and_set:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14D,ESI
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x10]
TEST RDI,RDI
JZ 0x0019d2f1
CMP qword ptr [RDI + 0x40],0x0
JNZ 0x0019d342
CALL 0x00129220
LAB_0019d2f1:
MOV EAX,R14D
AND R14B,0x7
MOV R15D,0x1
MOV ECX,R14D
SHL R15D,CL
MOV RCX,qword ptr [RBX]
SHR EAX,0x3
MOV R14B,byte ptr [RCX + RAX*0x1]
MOV EDX,R14D
OR DL,R15B
MOV byte ptr [RCX + RAX*0x1],DL
MOV RBX,qword ptr [RBX + 0x10]
TEST RBX,RBX
JZ 0x0019d331
MOV RDI,qword ptr [RBX + 0x40]
TEST RDI,RDI
JNZ 0x0019d355
LAB_0019d329:
MOV RDI,RBX
CALL 0x001291e0
LAB_0019d331:
AND R14B,R15B
MOV EAX,R14D
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0019d342:
LEA RSI,[0x1dc3a2]
MOV EDX,0x81
CALL 0x0012eb8f
JMP 0x0019d2f1
LAB_0019d355:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0019d329
|
int8 bitmap_test_and_set(long *param_1,uint param_2)
{
byte bVar1;
pthread_mutex_t *ppVar2;
byte bVar3;
ppVar2 = (pthread_mutex_t *)param_1[2];
if (ppVar2 != (pthread_mutex_t *)0x0) {
if (*(long *)((long)ppVar2 + 0x40) == 0) {
pthread_mutex_lock(ppVar2);
}
else {
psi_mutex_lock(ppVar2,"/workspace/llm4binary/github2025/eloqsql/mysys/my_bitmap.c",0x81);
}
}
bVar1 = *(byte *)(*param_1 + (ulong)(param_2 >> 3));
bVar3 = (byte)(1 << (sbyte)((ulong)param_2 & 0xffffffffffffff07));
*(byte *)(*param_1 + (ulong)(param_2 >> 3)) = bVar1 | bVar3;
ppVar2 = (pthread_mutex_t *)param_1[2];
if (ppVar2 != (pthread_mutex_t *)0x0) {
if (*(long *)((long)ppVar2 + 0x40) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(ppVar2);
}
return CONCAT71((int7)(((ulong)param_2 & 0xffffffffffffff07) >> 8),bVar1 & bVar3);
}
|
|
5,896 | mysql_stmt_free_result_cont | eloqsql/libmariadb/libmariadb/mariadb_async.c | int STDCALL
mysql_stmt_free_result_cont(my_bool *ret, MYSQL_STMT *stmt, int ready_status)
{
MK_ASYNC_CONT_BODY(
stmt->mysql,
TRUE,
r_my_bool)
} | O3 | c | mysql_stmt_free_result_cont:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rsi), %rax
movq 0x480(%rax), %rcx
movq 0x28(%rcx), %r15
cmpb $0x0, 0x15(%r15)
je 0x70be0
movb $0x1, 0x14(%r15)
movl %edx, 0x4(%r15)
leaq 0x38(%r15), %rdi
callq 0x71997
movb $0x0, 0x14(%r15)
testl %eax, %eax
jle 0x70c43
movl (%r15), %r15d
jmp 0x70cb9
movl $0x7de, 0x90(%rax) # imm = 0x7DE
movl $0x297, %edi # imm = 0x297
addq 0x38(%r14), %rdi
leaq 0x2fceb6(%rip), %rax # 0x36dab0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x3a1a0
movq 0x38(%r14), %rax
xorl %r15d, %r15d
movb %r15b, 0x29c(%rax)
movl $0x97, %edi
addq 0x38(%r14), %rdi
leaq 0x2fce9b(%rip), %rax # 0x36dac0
movq 0x70(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x3a1a0
movq 0x38(%r14), %rax
movb %r15b, 0x296(%rax)
movb $0x1, (%rbx)
jmp 0x70cb9
movb $0x0, 0x15(%r15)
js 0x70c50
movb 0x8(%r15), %al
jmp 0x70cb4
movq 0x38(%r14), %rax
movl $0x7d8, 0x90(%rax) # imm = 0x7D8
movl $0x297, %edi # imm = 0x297
addq 0x38(%r14), %rdi
leaq 0x2fce42(%rip), %rax # 0x36dab0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x3a1a0
movq 0x38(%r14), %rax
xorl %r15d, %r15d
movb %r15b, 0x29c(%rax)
movl $0x97, %edi
addq 0x38(%r14), %rdi
leaq 0x2fce27(%rip), %rax # 0x36dac0
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x3a1a0
movq 0x38(%r14), %rax
movb %r15b, 0x296(%rax)
movb $0x1, %al
movb %al, (%rbx)
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| mysql_stmt_free_result_cont:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov rax, [rsi+38h]
mov rcx, [rax+480h]
mov r15, [rcx+28h]
cmp byte ptr [r15+15h], 0
jz short loc_70BE0
mov byte ptr [r15+14h], 1
mov [r15+4], edx
lea rdi, [r15+38h]
call my_context_continue
mov byte ptr [r15+14h], 0
test eax, eax
jle short loc_70C43
mov r15d, [r15]
jmp loc_70CB9
loc_70BE0:
mov dword ptr [rax+90h], 7DEh
mov edi, 297h
add rdi, [r14+38h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [r14+38h]
xor r15d, r15d
mov [rax+29Ch], r15b
mov edi, 97h
add rdi, [r14+38h]
lea rax, client_errors
mov rsi, [rax+70h]
mov edx, 1FFh
call _strncpy
mov rax, [r14+38h]
mov [rax+296h], r15b
mov byte ptr [rbx], 1
jmp short loc_70CB9
loc_70C43:
mov byte ptr [r15+15h], 0
js short loc_70C50
mov al, [r15+8]
jmp short loc_70CB4
loc_70C50:
mov rax, [r14+38h]
mov dword ptr [rax+90h], 7D8h
mov edi, 297h
add rdi, [r14+38h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [r14+38h]
xor r15d, r15d
mov [rax+29Ch], r15b
mov edi, 97h
add rdi, [r14+38h]
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
mov rax, [r14+38h]
mov [rax+296h], r15b
mov al, 1
loc_70CB4:
mov [rbx], al
xor r15d, r15d
loc_70CB9:
mov eax, r15d
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long mysql_stmt_free_result_cont(char *a1, long long a2, unsigned int a3)
{
long long v3; // rax
unsigned int *v4; // r15
int v5; // eax
unsigned int v6; // r15d
char v7; // al
v3 = *(_QWORD *)(a2 + 56);
v4 = *(unsigned int **)(*(_QWORD *)(v3 + 1152) + 40LL);
if ( *((_BYTE *)v4 + 21) )
{
*((_BYTE *)v4 + 20) = 1;
v4[1] = a3;
v5 = my_context_continue(v4 + 14);
*((_BYTE *)v4 + 20) = 0;
if ( v5 <= 0 )
{
*((_BYTE *)v4 + 21) = 0;
if ( v5 < 0 )
{
*(_DWORD *)(*(_QWORD *)(a2 + 56) + 144LL) = 2008;
strncpy(*(_QWORD *)(a2 + 56) + 663LL, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 668LL) = 0;
strncpy(*(_QWORD *)(a2 + 56) + 151LL, client_errors[8], 511LL);
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 662LL) = 0;
v7 = 1;
}
else
{
v7 = *((_BYTE *)v4 + 8);
}
*a1 = v7;
return 0;
}
else
{
return *v4;
}
}
else
{
*(_DWORD *)(v3 + 144) = 2014;
strncpy(*(_QWORD *)(a2 + 56) + 663LL, SQLSTATE_UNKNOWN, 5LL);
v6 = 0;
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 668LL) = 0;
strncpy(*(_QWORD *)(a2 + 56) + 151LL, client_errors[14], 511LL);
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 662LL) = 0;
*a1 = 1;
}
return v6;
}
| mysql_stmt_free_result_cont:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RSI + 0x38]
MOV RCX,qword ptr [RAX + 0x480]
MOV R15,qword ptr [RCX + 0x28]
CMP byte ptr [R15 + 0x15],0x0
JZ 0x00170be0
MOV byte ptr [R15 + 0x14],0x1
MOV dword ptr [R15 + 0x4],EDX
LEA RDI,[R15 + 0x38]
CALL 0x00171997
MOV byte ptr [R15 + 0x14],0x0
TEST EAX,EAX
JLE 0x00170c43
MOV R15D,dword ptr [R15]
JMP 0x00170cb9
LAB_00170be0:
MOV dword ptr [RAX + 0x90],0x7de
MOV EDI,0x297
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x46dab0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x0013a1a0
MOV RAX,qword ptr [R14 + 0x38]
XOR R15D,R15D
MOV byte ptr [RAX + 0x29c],R15B
MOV EDI,0x97
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x46dac0]
MOV RSI,qword ptr [RAX + 0x70]
MOV EDX,0x1ff
CALL 0x0013a1a0
MOV RAX,qword ptr [R14 + 0x38]
MOV byte ptr [RAX + 0x296],R15B
MOV byte ptr [RBX],0x1
JMP 0x00170cb9
LAB_00170c43:
MOV byte ptr [R15 + 0x15],0x0
JS 0x00170c50
MOV AL,byte ptr [R15 + 0x8]
JMP 0x00170cb4
LAB_00170c50:
MOV RAX,qword ptr [R14 + 0x38]
MOV dword ptr [RAX + 0x90],0x7d8
MOV EDI,0x297
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x46dab0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x0013a1a0
MOV RAX,qword ptr [R14 + 0x38]
XOR R15D,R15D
MOV byte ptr [RAX + 0x29c],R15B
MOV EDI,0x97
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x46dac0]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x0013a1a0
MOV RAX,qword ptr [R14 + 0x38]
MOV byte ptr [RAX + 0x296],R15B
MOV AL,0x1
LAB_00170cb4:
MOV byte ptr [RBX],AL
XOR R15D,R15D
LAB_00170cb9:
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4 mysql_stmt_free_result_cont(int1 *param_1,long param_2,int4 param_3)
{
int4 *puVar1;
int1 uVar2;
int iVar3;
int4 uVar4;
puVar1 = *(int4 **)(*(long *)(*(long *)(param_2 + 0x38) + 0x480) + 0x28);
if (*(char *)((long)puVar1 + 0x15) == '\0') {
*(int4 *)(*(long *)(param_2 + 0x38) + 0x90) = 0x7de;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x297),SQLSTATE_UNKNOWN,5);
uVar4 = 0;
*(int1 *)(*(long *)(param_2 + 0x38) + 0x29c) = 0;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x97),
PTR_s_Commands_out_of_sync__you_can_t_r_0046db30,0x1ff);
*(int1 *)(*(long *)(param_2 + 0x38) + 0x296) = 0;
*param_1 = 1;
}
else {
*(int1 *)(puVar1 + 5) = 1;
puVar1[1] = param_3;
iVar3 = my_context_continue(puVar1 + 0xe);
*(int1 *)(puVar1 + 5) = 0;
if (iVar3 < 1) {
*(int1 *)((long)puVar1 + 0x15) = 0;
if (iVar3 < 0) {
*(int4 *)(*(long *)(param_2 + 0x38) + 0x90) = 0x7d8;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(*(long *)(param_2 + 0x38) + 0x29c) = 0;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x97),PTR_s_Client_run_out_of_memory_0046db00,
0x1ff);
*(int1 *)(*(long *)(param_2 + 0x38) + 0x296) = 0;
uVar2 = 1;
}
else {
uVar2 = *(int1 *)(puVar1 + 2);
}
*param_1 = uVar2;
uVar4 = 0;
}
else {
uVar4 = *puVar1;
}
}
return uVar4;
}
|
|
5,897 | lunasvg::SVGTextFragmentsBuilder::handleElement(lunasvg::SVGTextPositioningElement const*) | dmazzella[P]pylunasvg/lunasvg/source/svgtextelement.cpp | void SVGTextFragmentsBuilder::handleElement(const SVGTextPositioningElement* element)
{
const auto itemIndex = m_textPositions.size();
m_textPositions.emplace_back(element, m_text.length(), m_text.length());
for(const auto& child : element->children()) {
if(child->isTextNode()) {
handleText(toSVGTextNode(child.get()));
} else if(child->isTextPositioningElement()) {
handleElement(toSVGTextPositioningElement(child.get()));
}
}
auto& position = m_textPositions[itemIndex];
assert(position.node == element);
position.endOffset = m_text.length();
} | O0 | cpp | lunasvg::SVGTextFragmentsBuilder::handleElement(lunasvg::SVGTextPositioningElement const*):
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0x40, %rdi
callq 0x4fcc0
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq %rax, %rcx
addq $0x40, %rcx
movq %rcx, -0x58(%rbp)
movq (%rax), %rdi
callq 0x4fad0
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq (%rax), %rdi
callq 0x4fad0
movq -0x58(%rbp), %rdi
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq 0x4fcf0
movq -0x10(%rbp), %rdi
callq 0xe950
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0xe970
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0xe9a0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xe9d0
testb $0x1, %al
jne 0x4d608
jmp 0x4d693
leaq -0x38(%rbp), %rdi
callq 0xea00
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x1fc50
movq %rax, %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb $0x1, %al
jne 0x4d62d
jmp 0x4d64c
movq -0x48(%rbp), %rdi
callq 0xea60
movq %rax, %rdi
callq 0x4fd80
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x4e2d0
jmp 0x4d683
movq -0x48(%rbp), %rdi
callq 0x1fc50
movq %rax, %rdi
movq (%rdi), %rax
callq *0x38(%rax)
testb $0x1, %al
jne 0x4d664
jmp 0x4d681
movq -0x48(%rbp), %rdi
callq 0xea60
movq %rax, %rdi
callq 0x4f690
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x4d560
jmp 0x4d683
jmp 0x4d685
leaq -0x38(%rbp), %rdi
callq 0xea90
jmp 0x4d5f2
movq -0x60(%rbp), %rdi
addq $0x40, %rdi
movq -0x18(%rbp), %rsi
callq 0x4fde0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x4d6b7
jmp 0x4d6d6
leaq 0x3fecb(%rip), %rdi # 0x8d589
leaq 0x3fedd(%rip), %rsi # 0x8d5a2
movl $0x144, %edx # imm = 0x144
leaq 0x3ff31(%rip), %rcx # 0x8d602
callq 0xb210
movq -0x60(%rbp), %rax
movq (%rax), %rdi
callq 0x4fad0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZN7lunasvg23SVGTextFragmentsBuilder13handleElementEPKNS_25SVGTextPositioningElementE:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rdi, [rbp+var_8]
mov [rbp+var_60], rdi
add rdi, 40h ; '@'
call _ZNKSt6vectorIN7lunasvg15SVGTextPositionESaIS1_EE4sizeEv; std::vector<lunasvg::SVGTextPosition>::size(void)
mov rcx, rax
mov rax, [rbp+var_60]
mov [rbp+var_18], rcx
mov rcx, rax
add rcx, 40h ; '@'
mov [rbp+var_58], rcx
mov rdi, [rax]
call _ZNKSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEE6lengthEv; std::basic_string<char32_t>::length(void)
mov rcx, rax
mov rax, [rbp+var_60]
mov [rbp+var_20], rcx
mov rdi, [rax]
call _ZNKSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEE6lengthEv; std::basic_string<char32_t>::length(void)
mov rdi, [rbp+var_58]
mov [rbp+var_28], rax
lea rsi, [rbp+var_10]
lea rdx, [rbp+var_20]
lea rcx, [rbp+var_28]
call _ZNSt6vectorIN7lunasvg15SVGTextPositionESaIS1_EE12emplace_backIJRPKNS0_25SVGTextPositioningElementEmmEEERS1_DpOT_; std::vector<lunasvg::SVGTextPosition>::emplace_back<lunasvg::SVGTextPositioningElement const*&,ulong,ulong>(lunasvg::SVGTextPositioningElement const*&,ulong,ulong &&)
mov rdi, [rbp+var_10]
call _ZNK7lunasvg10SVGElement8childrenB5cxx11Ev; lunasvg::SVGElement::children(void)
mov [rbp+var_30], rax
mov rdi, [rbp+var_30]
call _ZNKSt7__cxx114listISt10unique_ptrIN7lunasvg7SVGNodeESt14default_deleteIS3_EESaIS6_EE5beginEv; std::list<std::unique_ptr<lunasvg::SVGNode>>::begin(void)
mov [rbp+var_38], rax
mov rdi, [rbp+var_30]
call _ZNKSt7__cxx114listISt10unique_ptrIN7lunasvg7SVGNodeESt14default_deleteIS3_EESaIS6_EE3endEv; std::list<std::unique_ptr<lunasvg::SVGNode>>::end(void)
mov [rbp+var_40], rax
loc_4D5F2:
lea rdi, [rbp+var_38]
lea rsi, [rbp+var_40]; lunasvg::SVGNode *
call _ZStneRKSt20_List_const_iteratorISt10unique_ptrIN7lunasvg7SVGNodeESt14default_deleteIS2_EEES8_; std::operator!=(std::_List_const_iterator<std::unique_ptr<lunasvg::SVGNode>> const&,std::_List_const_iterator<std::unique_ptr<lunasvg::SVGNode>> const&)
test al, 1
jnz short loc_4D608
jmp loc_4D693
loc_4D608:
lea rdi, [rbp+var_38]
call _ZNKSt20_List_const_iteratorISt10unique_ptrIN7lunasvg7SVGNodeESt14default_deleteIS2_EEEdeEv; std::_List_const_iterator<std::unique_ptr<lunasvg::SVGNode>>::operator*(void)
mov [rbp+var_48], rax
mov rdi, [rbp+var_48]
call _ZNKSt10unique_ptrIN7lunasvg7SVGNodeESt14default_deleteIS1_EEptEv; std::unique_ptr<lunasvg::SVGNode>::operator->(void)
mov rdi, rax
mov rax, [rdi]
call qword ptr [rax+10h]
test al, 1
jnz short loc_4D62D
jmp short loc_4D64C
loc_4D62D:
mov rdi, [rbp+var_48]
call _ZNKSt10unique_ptrIN7lunasvg7SVGNodeESt14default_deleteIS1_EE3getEv; std::unique_ptr<lunasvg::SVGNode>::get(void)
mov rdi, rax; this
call _ZN7lunasvg13toSVGTextNodeEPKNS_7SVGNodeE; lunasvg::toSVGTextNode(lunasvg::SVGNode const*)
mov rdi, [rbp+var_60]; this
mov rsi, rax; lunasvg::SVGTextNode *
call _ZN7lunasvg23SVGTextFragmentsBuilder10handleTextEPKNS_11SVGTextNodeE; lunasvg::SVGTextFragmentsBuilder::handleText(lunasvg::SVGTextNode const*)
jmp short loc_4D683
loc_4D64C:
mov rdi, [rbp+var_48]
call _ZNKSt10unique_ptrIN7lunasvg7SVGNodeESt14default_deleteIS1_EEptEv; std::unique_ptr<lunasvg::SVGNode>::operator->(void)
mov rdi, rax
mov rax, [rdi]
call qword ptr [rax+38h]
test al, 1
jnz short loc_4D664
jmp short loc_4D681
loc_4D664:
mov rdi, [rbp+var_48]
call _ZNKSt10unique_ptrIN7lunasvg7SVGNodeESt14default_deleteIS1_EE3getEv; std::unique_ptr<lunasvg::SVGNode>::get(void)
mov rdi, rax; this
call _ZN7lunasvg27toSVGTextPositioningElementEPKNS_7SVGNodeE; lunasvg::toSVGTextPositioningElement(lunasvg::SVGNode const*)
mov rdi, [rbp+var_60]; this
mov rsi, rax; lunasvg::SVGTextPositioningElement *
call _ZN7lunasvg23SVGTextFragmentsBuilder13handleElementEPKNS_25SVGTextPositioningElementE; lunasvg::SVGTextFragmentsBuilder::handleElement(lunasvg::SVGTextPositioningElement const*)
loc_4D681:
jmp short $+2
loc_4D683:
jmp short $+2
loc_4D685:
lea rdi, [rbp+var_38]
call _ZNSt20_List_const_iteratorISt10unique_ptrIN7lunasvg7SVGNodeESt14default_deleteIS2_EEEppEv; std::_List_const_iterator<std::unique_ptr<lunasvg::SVGNode>>::operator++(void)
jmp loc_4D5F2
loc_4D693:
mov rdi, [rbp+var_60]
add rdi, 40h ; '@'
mov rsi, [rbp+var_18]
call _ZNSt6vectorIN7lunasvg15SVGTextPositionESaIS1_EEixEm; std::vector<lunasvg::SVGTextPosition>::operator[](ulong)
mov [rbp+var_50], rax
mov rax, [rbp+var_50]
mov rax, [rax]
cmp rax, [rbp+var_10]
jnz short loc_4D6B7
jmp short loc_4D6D6
loc_4D6B7:
lea rdi, aPositionNodeEl; "position.node == element"
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
mov edx, 144h
lea rcx, aVoidLunasvgSvg; "void lunasvg::SVGTextFragmentsBuilder::"...
call ___assert_fail
loc_4D6D6:
mov rax, [rbp+var_60]
mov rdi, [rax]
call _ZNKSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEE6lengthEv; std::basic_string<char32_t>::length(void)
mov rcx, rax
mov rax, [rbp+var_50]
mov [rax+10h], rcx
add rsp, 60h
pop rbp
retn
| _QWORD * lunasvg::SVGTextFragmentsBuilder::handleElement(
lunasvg::SVGTextFragmentsBuilder *this,
const lunasvg::SVGTextPositioningElement *a2)
{
long long v2; // rax
lunasvg *v3; // rax
const lunasvg::SVGTextNode *v4; // rax
long long v5; // rax
lunasvg *v6; // rax
const lunasvg::SVGTextPositioningElement *v7; // rax
long long v8; // rcx
_QWORD *result; // rax
_QWORD *v10; // [rsp+10h] [rbp-50h]
long long v11; // [rsp+20h] [rbp-40h] BYREF
_QWORD *v12; // [rsp+28h] [rbp-38h] BYREF
_QWORD *v13; // [rsp+30h] [rbp-30h]
long long v14; // [rsp+38h] [rbp-28h] BYREF
long long v15; // [rsp+40h] [rbp-20h] BYREF
long long v16; // [rsp+48h] [rbp-18h]
long long v17[2]; // [rsp+50h] [rbp-10h] BYREF
v17[1] = (long long)this;
v17[0] = (long long)a2;
v16 = std::vector<lunasvg::SVGTextPosition>::size((char *)this + 64);
v15 = std::basic_string<char32_t>::length(*(_QWORD *)this);
v14 = std::basic_string<char32_t>::length(*(_QWORD *)this);
std::vector<lunasvg::SVGTextPosition>::emplace_back<lunasvg::SVGTextPositioningElement const*&,unsigned long,unsigned long>(
(char *)this + 64,
v17,
&v15,
&v14);
v13 = (_QWORD *)lunasvg::SVGElement::children[abi:cxx11](v17[0]);
v12 = (_QWORD *)std::list<std::unique_ptr<lunasvg::SVGNode>>::begin(v13);
v11 = std::list<std::unique_ptr<lunasvg::SVGNode>>::end((long long)v13);
while ( std::operator!=(&v12, &v11) )
{
std::_List_const_iterator<std::unique_ptr<lunasvg::SVGNode>>::operator*(&v12);
v2 = std::unique_ptr<lunasvg::SVGNode>::operator->();
if ( ((*(long long ( **)(long long))(*(_QWORD *)v2 + 16LL))(v2) & 1) != 0 )
{
v3 = (lunasvg *)std::unique_ptr<lunasvg::SVGNode>::get();
v4 = (const lunasvg::SVGTextNode *)lunasvg::toSVGTextNode(v3, (const lunasvg::SVGNode *)&v11);
lunasvg::SVGTextFragmentsBuilder::handleText(this, v4);
}
else
{
v5 = std::unique_ptr<lunasvg::SVGNode>::operator->();
if ( ((*(long long ( **)(long long))(*(_QWORD *)v5 + 56LL))(v5) & 1) != 0 )
{
v6 = (lunasvg *)std::unique_ptr<lunasvg::SVGNode>::get();
v7 = (const lunasvg::SVGTextPositioningElement *)lunasvg::toSVGTextPositioningElement(
v6,
(const lunasvg::SVGNode *)&v11);
lunasvg::SVGTextFragmentsBuilder::handleElement(this, v7);
}
}
std::_List_const_iterator<std::unique_ptr<lunasvg::SVGNode>>::operator++(&v12);
}
v10 = (_QWORD *)std::vector<lunasvg::SVGTextPosition>::operator[]((char *)this + 64, v16);
if ( *v10 != v17[0] )
__assert_fail(
"position.node == element",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/source/svgtextelement.cpp",
324LL,
"void lunasvg::SVGTextFragmentsBuilder::handleElement(const SVGTextPositioningElement *)");
v8 = std::basic_string<char32_t>::length(*(_QWORD *)this);
result = v10;
v10[2] = v8;
return result;
}
| handleElement:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x60],RDI
ADD RDI,0x40
CALL 0x0014fcc0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x18],RCX
MOV RCX,RAX
ADD RCX,0x40
MOV qword ptr [RBP + -0x58],RCX
MOV RDI,qword ptr [RAX]
CALL 0x0014fad0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x20],RCX
MOV RDI,qword ptr [RAX]
CALL 0x0014fad0
MOV RDI,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x28],RAX
LEA RSI,[RBP + -0x10]
LEA RDX,[RBP + -0x20]
LEA RCX,[RBP + -0x28]
CALL 0x0014fcf0
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0010e950
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x0010e970
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x0010e9a0
MOV qword ptr [RBP + -0x40],RAX
LAB_0014d5f2:
LEA RDI,[RBP + -0x38]
LEA RSI,[RBP + -0x40]
CALL 0x0010e9d0
TEST AL,0x1
JNZ 0x0014d608
JMP 0x0014d693
LAB_0014d608:
LEA RDI,[RBP + -0x38]
CALL 0x0010ea00
MOV qword ptr [RBP + -0x48],RAX
MOV RDI,qword ptr [RBP + -0x48]
CALL 0x0011fc50
MOV RDI,RAX
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x10]
TEST AL,0x1
JNZ 0x0014d62d
JMP 0x0014d64c
LAB_0014d62d:
MOV RDI,qword ptr [RBP + -0x48]
CALL 0x0010ea60
MOV RDI,RAX
CALL 0x0014fd80
MOV RDI,qword ptr [RBP + -0x60]
MOV RSI,RAX
CALL 0x0014e2d0
JMP 0x0014d683
LAB_0014d64c:
MOV RDI,qword ptr [RBP + -0x48]
CALL 0x0011fc50
MOV RDI,RAX
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x38]
TEST AL,0x1
JNZ 0x0014d664
JMP 0x0014d681
LAB_0014d664:
MOV RDI,qword ptr [RBP + -0x48]
CALL 0x0010ea60
MOV RDI,RAX
CALL 0x0014f690
MOV RDI,qword ptr [RBP + -0x60]
MOV RSI,RAX
CALL 0x0014d560
LAB_0014d681:
JMP 0x0014d683
LAB_0014d683:
JMP 0x0014d685
LAB_0014d685:
LEA RDI,[RBP + -0x38]
CALL 0x0010ea90
JMP 0x0014d5f2
LAB_0014d693:
MOV RDI,qword ptr [RBP + -0x60]
ADD RDI,0x40
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0014fde0
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RAX]
CMP RAX,qword ptr [RBP + -0x10]
JNZ 0x0014d6b7
JMP 0x0014d6d6
LAB_0014d6b7:
LEA RDI,[0x18d589]
LEA RSI,[0x18d5a2]
MOV EDX,0x144
LEA RCX,[0x18d602]
CALL 0x0010b210
LAB_0014d6d6:
MOV RAX,qword ptr [RBP + -0x60]
MOV RDI,qword ptr [RAX]
CALL 0x0014fad0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RAX + 0x10],RCX
ADD RSP,0x60
POP RBP
RET
|
/* lunasvg::SVGTextFragmentsBuilder::handleElement(lunasvg::SVGTextPositioningElement const*) */
void __thiscall
lunasvg::SVGTextFragmentsBuilder::handleElement
(SVGTextFragmentsBuilder *this,SVGTextPositioningElement *param_1)
{
ulong uVar1;
unique_ptr<lunasvg::SVGNode,std::default_delete<lunasvg::SVGNode>> *this_00;
SVGTextNode *pSVar2;
SVGNode *pSVar3;
SVGTextPositioningElement *pSVar4;
long *plVar5;
long lVar6;
int8 local_48;
int8 local_40;
list<std::unique_ptr<lunasvg::SVGNode,std::default_delete<lunasvg::SVGNode>>,std::allocator<std::unique_ptr<lunasvg::SVGNode,std::default_delete<lunasvg::SVGNode>>>>
*local_38;
ulong local_30;
ulong local_28;
ulong local_20;
SVGTextPositioningElement *local_18;
SVGTextFragmentsBuilder *local_10;
local_18 = param_1;
local_10 = this;
local_20 = std::vector<lunasvg::SVGTextPosition,std::allocator<lunasvg::SVGTextPosition>>::size
((vector<lunasvg::SVGTextPosition,std::allocator<lunasvg::SVGTextPosition>> *
)(this + 0x40));
local_28 = std::__cxx11::u32string::length(*(u32string **)this);
local_30 = std::__cxx11::u32string::length(*(u32string **)this);
std::vector<lunasvg::SVGTextPosition,std::allocator<lunasvg::SVGTextPosition>>::
emplace_back<lunasvg::SVGTextPositioningElement_const*&,unsigned_long,unsigned_long>
((vector<lunasvg::SVGTextPosition,std::allocator<lunasvg::SVGTextPosition>> *)
(this + 0x40),&local_18,&local_28,&local_30);
local_38 = (list<std::unique_ptr<lunasvg::SVGNode,std::default_delete<lunasvg::SVGNode>>,std::allocator<std::unique_ptr<lunasvg::SVGNode,std::default_delete<lunasvg::SVGNode>>>>
*)SVGElement::children_abi_cxx11_((SVGElement *)local_18);
local_40 = std::__cxx11::
list<std::unique_ptr<lunasvg::SVGNode,std::default_delete<lunasvg::SVGNode>>,std::allocator<std::unique_ptr<lunasvg::SVGNode,std::default_delete<lunasvg::SVGNode>>>>
::begin(local_38);
local_48 = std::__cxx11::
list<std::unique_ptr<lunasvg::SVGNode,std::default_delete<lunasvg::SVGNode>>,std::allocator<std::unique_ptr<lunasvg::SVGNode,std::default_delete<lunasvg::SVGNode>>>>
::end(local_38);
while (uVar1 = std::operator!=((_List_const_iterator *)&local_40,(_List_const_iterator *)&local_48
), (uVar1 & 1) != 0) {
this_00 = (unique_ptr<lunasvg::SVGNode,std::default_delete<lunasvg::SVGNode>> *)
std::
_List_const_iterator<std::unique_ptr<lunasvg::SVGNode,std::default_delete<lunasvg::SVGNode>>>
::operator*((_List_const_iterator<std::unique_ptr<lunasvg::SVGNode,std::default_delete<lunasvg::SVGNode>>>
*)&local_40);
plVar5 = (long *)std::unique_ptr<lunasvg::SVGNode,std::default_delete<lunasvg::SVGNode>>::
operator->(this_00);
uVar1 = (**(code **)(*plVar5 + 0x10))();
if ((uVar1 & 1) == 0) {
plVar5 = (long *)std::unique_ptr<lunasvg::SVGNode,std::default_delete<lunasvg::SVGNode>>::
operator->(this_00);
uVar1 = (**(code **)(*plVar5 + 0x38))();
if ((uVar1 & 1) != 0) {
pSVar3 = (SVGNode *)
std::unique_ptr<lunasvg::SVGNode,std::default_delete<lunasvg::SVGNode>>::get
(this_00);
pSVar4 = (SVGTextPositioningElement *)toSVGTextPositioningElement(pSVar3);
handleElement(this,pSVar4);
}
}
else {
pSVar3 = (SVGNode *)
std::unique_ptr<lunasvg::SVGNode,std::default_delete<lunasvg::SVGNode>>::get(this_00)
;
pSVar2 = (SVGTextNode *)toSVGTextNode(pSVar3);
handleText(this,pSVar2);
}
std::
_List_const_iterator<std::unique_ptr<lunasvg::SVGNode,std::default_delete<lunasvg::SVGNode>>>::
operator++((_List_const_iterator<std::unique_ptr<lunasvg::SVGNode,std::default_delete<lunasvg::SVGNode>>>
*)&local_40);
}
plVar5 = (long *)std::vector<lunasvg::SVGTextPosition,std::allocator<lunasvg::SVGTextPosition>>::
operator[]((vector<lunasvg::SVGTextPosition,std::allocator<lunasvg::SVGTextPosition>>
*)(this + 0x40),local_20);
if ((SVGElement *)*plVar5 != (SVGElement *)local_18) {
/* WARNING: Subroutine does not return */
__assert_fail("position.node == element",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/source/svgtextelement.cpp"
,0x144,
"void lunasvg::SVGTextFragmentsBuilder::handleElement(const SVGTextPositioningElement *)"
);
}
lVar6 = std::__cxx11::u32string::length(*(u32string **)this);
plVar5[2] = lVar6;
return;
}
|
|
5,898 | lunasvg::SVGTextFragmentsBuilder::handleElement(lunasvg::SVGTextPositioningElement const*) | dmazzella[P]pylunasvg/lunasvg/source/svgtextelement.cpp | void SVGTextFragmentsBuilder::handleElement(const SVGTextPositioningElement* element)
{
const auto itemIndex = m_textPositions.size();
m_textPositions.emplace_back(element, m_text.length(), m_text.length());
for(const auto& child : element->children()) {
if(child->isTextNode()) {
handleText(toSVGTextNode(child.get()));
} else if(child->isTextPositioningElement()) {
handleElement(toSVGTextPositioningElement(child.get()));
}
}
auto& position = m_textPositions[itemIndex];
assert(position.node == element);
position.endOffset = m_text.length();
} | O1 | cpp | lunasvg::SVGTextFragmentsBuilder::handleElement(lunasvg::SVGTextPositioningElement const*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r15
movq %rsi, (%r15)
leaq 0x40(%rdi), %r14
movq 0x48(%rdi), %r12
subq 0x40(%rdi), %r12
movq (%rdi), %rax
movq 0x8(%rax), %rax
leaq 0x10(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x22930
movq (%r15), %r13
movq 0x58(%r13), %rbp
addq $0x58, %r13
cmpq %r13, %rbp
je 0x2161a
movq 0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x10(%rbp), %r15
testb %al, %al
je 0x215e6
testq %r15, %r15
je 0x21642
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
testb %al, %al
je 0x21642
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21c56
jmp 0x21614
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
testb %al, %al
je 0x21614
movq 0x10(%rbp), %r15
testq %r15, %r15
je 0x21661
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
testb %al, %al
je 0x21661
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21560
movq (%rbp), %rbp
jmp 0x215b0
movq (%r14), %rax
movq (%rax,%r12), %rcx
cmpq (%rsp), %rcx
jne 0x21680
movq (%rbx), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x10(%rax,%r12)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x23238(%rip), %rdi # 0x44881
leaq 0x22f76(%rip), %rsi # 0x445c6
leaq 0x23245(%rip), %rcx # 0x4489c
movl $0xb, %edx
callq 0xa200
leaq 0x23016(%rip), %rdi # 0x4467e
leaq 0x22f57(%rip), %rsi # 0x445c6
leaq 0x23031(%rip), %rcx # 0x446a7
movl $0x11, %edx
callq 0xa200
leaq 0x22f26(%rip), %rdi # 0x445ad
leaq 0x22f38(%rip), %rsi # 0x445c6
leaq 0x22f91(%rip), %rcx # 0x44626
movl $0x144, %edx # imm = 0x144
callq 0xa200
nop
| _ZN7lunasvg23SVGTextFragmentsBuilder13handleElementEPKNS_25SVGTextPositioningElementE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
mov r15, rsp
mov [r15], rsi
lea r14, [rdi+40h]
mov r12, [rdi+48h]
sub r12, [rdi+40h]
mov rax, [rdi]
mov rax, [rax+8]
lea rdx, [rsp+48h+var_38]
mov [rdx], rax
lea rcx, [rsp+48h+var_40]
mov [rcx], rax
mov rdi, r14
mov rsi, r15
call _ZNSt6vectorIN7lunasvg15SVGTextPositionESaIS1_EE12emplace_backIJRPKNS0_25SVGTextPositioningElementEmmEEERS1_DpOT_; std::vector<lunasvg::SVGTextPosition>::emplace_back<lunasvg::SVGTextPositioningElement const*&,ulong,ulong>(lunasvg::SVGTextPositioningElement const*&,ulong,ulong &&)
mov r13, [r15]
mov rbp, [r13+58h]
add r13, 58h ; 'X'
loc_215B0:
cmp rbp, r13
jz short loc_2161A
mov rdi, [rbp+10h]
mov rax, [rdi]
call qword ptr [rax+10h]
mov r15, [rbp+10h]
test al, al
jz short loc_215E6
test r15, r15
jz short loc_21642
mov rax, [r15]
mov rdi, r15
call qword ptr [rax+10h]
test al, al
jz short loc_21642
mov rdi, rbx; this
mov rsi, r15; lunasvg::SVGTextNode *
call _ZN7lunasvg23SVGTextFragmentsBuilder10handleTextEPKNS_11SVGTextNodeE; lunasvg::SVGTextFragmentsBuilder::handleText(lunasvg::SVGTextNode const*)
jmp short loc_21614
loc_215E6:
mov rax, [r15]
mov rdi, r15
call qword ptr [rax+38h]
test al, al
jz short loc_21614
mov r15, [rbp+10h]
test r15, r15
jz short loc_21661
mov rax, [r15]
mov rdi, r15
call qword ptr [rax+38h]
test al, al
jz short loc_21661
mov rdi, rbx; this
mov rsi, r15; lunasvg::SVGTextPositioningElement *
call _ZN7lunasvg23SVGTextFragmentsBuilder13handleElementEPKNS_25SVGTextPositioningElementE; lunasvg::SVGTextFragmentsBuilder::handleElement(lunasvg::SVGTextPositioningElement const*)
loc_21614:
mov rbp, [rbp+0]
jmp short loc_215B0
loc_2161A:
mov rax, [r14]
mov rcx, [rax+r12]
cmp rcx, [rsp+48h+var_48]
jnz short loc_21680
mov rcx, [rbx]
mov rcx, [rcx+8]
mov [rax+r12+10h], rcx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_21642:
lea rdi, aNodeNodeIstext_0; "node && node->isTextNode()"
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aConstSvgtextno; "const SVGTextNode *lunasvg::toSVGTextNo"...
mov edx, 0Bh
call ___assert_fail
loc_21661:
lea rdi, aNodeNodeIstext; "node && node->isTextPositioningElement("...
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aConstSvgtextpo; "const SVGTextPositioningElement *lunasv"...
mov edx, 11h
call ___assert_fail
loc_21680:
lea rdi, aPositionNodeEl; "position.node == element"
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidLunasvgSvg; "void lunasvg::SVGTextFragmentsBuilder::"...
mov edx, 144h
call ___assert_fail
| long long lunasvg::SVGTextFragmentsBuilder::handleElement(
lunasvg::SVGTextFragmentsBuilder *this,
const lunasvg::SVGTextPositioningElement *a2)
{
long long *v2; // r14
long long v3; // r12
long long *v4; // rbp
long long v5; // r13
char v6; // al
const lunasvg::SVGTextNode *v7; // r15
const lunasvg::SVGTextPositioningElement *v8; // r15
long long result; // rax
_QWORD v10[2]; // [rsp+0h] [rbp-48h] BYREF
long long v11; // [rsp+10h] [rbp-38h]
v10[0] = a2;
v2 = (long long *)((char *)this + 64);
v3 = *((_QWORD *)this + 9) - *((_QWORD *)this + 8);
v11 = *(_QWORD *)(*(_QWORD *)this + 8LL);
v10[1] = v11;
std::vector<lunasvg::SVGTextPosition>::emplace_back<lunasvg::SVGTextPositioningElement const*&,unsigned long,unsigned long>(
(char *)this + 64,
v10);
v4 = *(long long **)(v10[0] + 88LL);
v5 = v10[0] + 88LL;
while ( v4 != (long long *)v5 )
{
v6 = (*(long long ( **)(long long))(*(_QWORD *)v4[2] + 16LL))(v4[2]);
v7 = (const lunasvg::SVGTextNode *)v4[2];
if ( v6 )
{
if ( !v7 || !(*(unsigned __int8 ( **)(long long))(*(_QWORD *)v7 + 16LL))(v4[2]) )
__assert_fail(
"node && node->isTextNode()",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/source/svgtextelement.cpp",
11LL,
"const SVGTextNode *lunasvg::toSVGTextNode(const SVGNode *)");
lunasvg::SVGTextFragmentsBuilder::handleText(this, v7);
}
else if ( (*(unsigned __int8 ( **)(long long))(*(_QWORD *)v7 + 56LL))(v4[2]) )
{
v8 = (const lunasvg::SVGTextPositioningElement *)v4[2];
if ( !v8 || !(*(unsigned __int8 ( **)(long long))(*(_QWORD *)v8 + 56LL))(v4[2]) )
__assert_fail(
"node && node->isTextPositioningElement()",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/source/svgtextelement.cpp",
17LL,
"const SVGTextPositioningElement *lunasvg::toSVGTextPositioningElement(const SVGNode *)");
lunasvg::SVGTextFragmentsBuilder::handleElement(this, v8);
}
v4 = (long long *)*v4;
}
result = *v2;
if ( *(_QWORD *)(*v2 + v3) != v10[0] )
__assert_fail(
"position.node == element",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/source/svgtextelement.cpp",
324LL,
"void lunasvg::SVGTextFragmentsBuilder::handleElement(const SVGTextPositioningElement *)");
*(_QWORD *)(result + v3 + 16) = *(_QWORD *)(*(_QWORD *)this + 8LL);
return result;
}
| handleElement:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV R15,RSP
MOV qword ptr [R15],RSI
LEA R14,[RDI + 0x40]
MOV R12,qword ptr [RDI + 0x48]
SUB R12,qword ptr [RDI + 0x40]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x8]
LEA RDX,[RSP + 0x10]
MOV qword ptr [RDX],RAX
LEA RCX,[RSP + 0x8]
MOV qword ptr [RCX],RAX
MOV RDI,R14
MOV RSI,R15
CALL 0x00122930
MOV R13,qword ptr [R15]
MOV RBP,qword ptr [R13 + 0x58]
ADD R13,0x58
LAB_001215b0:
CMP RBP,R13
JZ 0x0012161a
MOV RDI,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x10]
MOV R15,qword ptr [RBP + 0x10]
TEST AL,AL
JZ 0x001215e6
TEST R15,R15
JZ 0x00121642
MOV RAX,qword ptr [R15]
MOV RDI,R15
CALL qword ptr [RAX + 0x10]
TEST AL,AL
JZ 0x00121642
MOV RDI,RBX
MOV RSI,R15
CALL 0x00121c56
JMP 0x00121614
LAB_001215e6:
MOV RAX,qword ptr [R15]
MOV RDI,R15
CALL qword ptr [RAX + 0x38]
TEST AL,AL
JZ 0x00121614
MOV R15,qword ptr [RBP + 0x10]
TEST R15,R15
JZ 0x00121661
MOV RAX,qword ptr [R15]
MOV RDI,R15
CALL qword ptr [RAX + 0x38]
TEST AL,AL
JZ 0x00121661
MOV RDI,RBX
MOV RSI,R15
CALL 0x00121560
LAB_00121614:
MOV RBP,qword ptr [RBP]
JMP 0x001215b0
LAB_0012161a:
MOV RAX,qword ptr [R14]
MOV RCX,qword ptr [RAX + R12*0x1]
CMP RCX,qword ptr [RSP]
JNZ 0x00121680
MOV RCX,qword ptr [RBX]
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + R12*0x1 + 0x10],RCX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00121642:
LEA RDI,[0x144881]
LEA RSI,[0x1445c6]
LEA RCX,[0x14489c]
MOV EDX,0xb
CALL 0x0010a200
LAB_00121661:
LEA RDI,[0x14467e]
LEA RSI,[0x1445c6]
LEA RCX,[0x1446a7]
MOV EDX,0x11
CALL 0x0010a200
LAB_00121680:
LEA RDI,[0x1445ad]
LEA RSI,[0x1445c6]
LEA RCX,[0x144626]
MOV EDX,0x144
CALL 0x0010a200
|
/* lunasvg::SVGTextFragmentsBuilder::handleElement(lunasvg::SVGTextPositioningElement const*) */
void __thiscall
lunasvg::SVGTextFragmentsBuilder::handleElement
(SVGTextFragmentsBuilder *this,SVGTextPositioningElement *param_1)
{
long lVar1;
long lVar2;
SVGTextNode *pSVar3;
SVGTextPositioningElement *pSVar4;
long lVar5;
char cVar6;
SVGTextPositioningElement *pSVar7;
SVGTextPositioningElement *pSVar8;
SVGTextPositioningElement *local_48;
ulong local_40;
ulong local_38;
lVar1 = *(long *)(this + 0x48);
lVar2 = *(long *)(this + 0x40);
local_40 = *(ulong *)(*(long *)this + 8);
local_48 = param_1;
local_38 = local_40;
std::vector<lunasvg::SVGTextPosition,std::allocator<lunasvg::SVGTextPosition>>::
emplace_back<lunasvg::SVGTextPositioningElement_const*&,unsigned_long,unsigned_long>
((vector<lunasvg::SVGTextPosition,std::allocator<lunasvg::SVGTextPosition>> *)
(this + 0x40),&local_48,&local_38,&local_40);
pSVar7 = *(SVGTextPositioningElement **)(local_48 + 0x58);
pSVar8 = local_48 + 0x58;
do {
if (pSVar7 == pSVar8) {
lVar5 = *(long *)(this + 0x40);
if (*(SVGTextPositioningElement **)(lVar5 + (lVar1 - lVar2)) == local_48) {
*(int8 *)(lVar5 + 0x10 + (lVar1 - lVar2)) = *(int8 *)(*(long *)this + 8);
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("position.node == element",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/source/svgtextelement.cpp"
,0x144,
"void lunasvg::SVGTextFragmentsBuilder::handleElement(const SVGTextPositioningElement *)"
);
}
cVar6 = (**(code **)(**(long **)(pSVar7 + 0x10) + 0x10))();
pSVar3 = *(SVGTextNode **)(pSVar7 + 0x10);
if (cVar6 == '\0') {
cVar6 = (**(code **)(*(long *)pSVar3 + 0x38))(pSVar3);
if (cVar6 != '\0') {
pSVar4 = *(SVGTextPositioningElement **)(pSVar7 + 0x10);
if (pSVar4 == (SVGTextPositioningElement *)0x0) {
LAB_00121661:
/* WARNING: Subroutine does not return */
__assert_fail("node && node->isTextPositioningElement()",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/source/svgtextelement.cpp"
,0x11,
"const SVGTextPositioningElement *lunasvg::toSVGTextPositioningElement(const SVGNode *)"
);
}
cVar6 = (**(code **)(*(long *)pSVar4 + 0x38))(pSVar4);
if (cVar6 == '\0') goto LAB_00121661;
handleElement(this,pSVar4);
}
}
else {
if (pSVar3 == (SVGTextNode *)0x0) {
LAB_00121642:
/* WARNING: Subroutine does not return */
__assert_fail("node && node->isTextNode()",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/source/svgtextelement.cpp"
,0xb,"const SVGTextNode *lunasvg::toSVGTextNode(const SVGNode *)");
}
cVar6 = (**(code **)(*(long *)pSVar3 + 0x10))(pSVar3);
if (cVar6 == '\0') goto LAB_00121642;
handleText(this,pSVar3);
}
pSVar7 = *(SVGTextPositioningElement **)pSVar7;
} while( true );
}
|
|
5,899 | ImageColorBrightness | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rtextures.c | void ImageColorBrightness(Image *image, int brightness)
{
// Security check to avoid program crash
if ((image->data == NULL) || (image->width == 0) || (image->height == 0)) return;
if (brightness < -255) brightness = -255;
if (brightness > 255) brightness = 255;
Color *pixels = LoadImageColors(*image);
for (int i = 0; i < image->width*image->height; i++)
{
int cR = pixels[i].r + brightness;
int cG = pixels[i].g + brightness;
int cB = pixels[i].b + brightness;
if (cR < 0) cR = 1;
if (cR > 255) cR = 255;
if (cG < 0) cG = 1;
if (cG > 255) cG = 255;
if (cB < 0) cB = 1;
if (cB > 255) cB = 255;
pixels[i].r = (unsigned char)cR;
pixels[i].g = (unsigned char)cG;
pixels[i].b = (unsigned char)cB;
}
int format = image->format;
RL_FREE(image->data);
image->data = pixels;
image->format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;
ImageFormat(image, format);
} | O3 | c | ImageColorBrightness:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
cmpq $0x0, (%rdi)
je 0x98ea0
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
je 0x98ea0
cmpl $0x0, 0xc(%rbx)
je 0x98ea0
cmpl $0xffffff02, %esi # imm = 0xFFFFFF02
movl $0xffffff01, %ebp # imm = 0xFFFFFF01
cmovgel %esi, %ebp
movl $0xff, %r15d
cmpl %r15d, %ebp
cmovgel %r15d, %ebp
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
callq 0x92846
movq %rax, %r14
movl 0xc(%rbx), %eax
imull 0x8(%rbx), %eax
testl %eax, %eax
jle 0x98e77
xorl %eax, %eax
movl $0x1, %ecx
movzbl (%r14,%rax,4), %edx
addl %ebp, %edx
movzbl 0x1(%r14,%rax,4), %esi
addl %ebp, %esi
movzbl 0x2(%r14,%rax,4), %edi
addl %ebp, %edi
cmpl %r15d, %edx
movl $0xff, %r8d
cmovll %edx, %r8d
cmpl %r15d, %esi
movl $0xff, %r9d
cmovll %esi, %r9d
cmpl %r15d, %edi
movl $0xff, %r10d
cmovll %edi, %r10d
testl %edx, %edx
cmovsl %ecx, %r8d
testl %esi, %esi
cmovsl %ecx, %r9d
testl %edi, %edi
movb %r8b, (%r14,%rax,4)
movb %r9b, 0x1(%r14,%rax,4)
cmovsl %ecx, %r10d
movb %r10b, 0x2(%r14,%rax,4)
incq %rax
movslq 0x8(%rbx), %rdx
movslq 0xc(%rbx), %rsi
imulq %rdx, %rsi
cmpq %rsi, %rax
jl 0x98e05
movl 0x14(%rbx), %ebp
movq (%rbx), %rdi
callq 0xa650
movq %r14, (%rbx)
movl $0x7, 0x14(%rbx)
movq %rbx, %rdi
movl %ebp, %esi
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x94249
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| ImageColorBrightness:
push rbp
push r15
push r14
push rbx
sub rsp, 18h
cmp qword ptr [rdi], 0
jz loc_98EA0
mov rbx, rdi
cmp dword ptr [rdi+8], 0
jz loc_98EA0
cmp dword ptr [rbx+0Ch], 0
jz loc_98EA0
cmp esi, 0FFFFFF02h
mov ebp, 0FFFFFF01h
cmovge ebp, esi
mov r15d, 0FFh
cmp ebp, r15d
cmovge ebp, r15d
mov rax, [rbx+10h]
mov [rsp+38h+var_28], rax
movups xmm0, xmmword ptr [rbx]
movups [rsp+38h+var_38], xmm0
call LoadImageColors
mov r14, rax
mov eax, [rbx+0Ch]
imul eax, [rbx+8]
test eax, eax
jle short loc_98E77
xor eax, eax
mov ecx, 1
loc_98E05:
movzx edx, byte ptr [r14+rax*4]
add edx, ebp
movzx esi, byte ptr [r14+rax*4+1]
add esi, ebp
movzx edi, byte ptr [r14+rax*4+2]
add edi, ebp
cmp edx, r15d
mov r8d, 0FFh
cmovl r8d, edx
cmp esi, r15d
mov r9d, 0FFh
cmovl r9d, esi
cmp edi, r15d
mov r10d, 0FFh
cmovl r10d, edi
test edx, edx
cmovs r8d, ecx
test esi, esi
cmovs r9d, ecx
test edi, edi
mov [r14+rax*4], r8b
mov [r14+rax*4+1], r9b
cmovs r10d, ecx
mov [r14+rax*4+2], r10b
inc rax
movsxd rdx, dword ptr [rbx+8]
movsxd rsi, dword ptr [rbx+0Ch]
imul rsi, rdx
cmp rax, rsi
jl short loc_98E05
loc_98E77:
mov ebp, [rbx+14h]
mov rdi, [rbx]
call _free
mov [rbx], r14
mov dword ptr [rbx+14h], 7
mov rdi, rbx
mov esi, ebp
add rsp, 18h
pop rbx
pop r14
pop r15
pop rbp
jmp ImageFormat
loc_98EA0:
add rsp, 18h
pop rbx
pop r14
pop r15
pop rbp
retn
| void ImageColorBrightness(__m128i *a1, long long a2, long long a3, long long a4, long long a5, long long a6)
{
int v7; // ebp
__m128i v8; // xmm0
long long ImageColors; // r14
long long v10; // rax
int v11; // edx
int v12; // esi
int v13; // edi
char v14; // r8
char v15; // r9
char v16; // r10
int v17; // ebp
long long v18; // rdx
long long v19; // rcx
int v20; // r8d
int v21; // r9d
if ( a1->m128i_i64[0] && a1->m128i_i32[2] && a1->m128i_i32[3] )
{
v7 = -255;
if ( (int)a2 >= -254 )
v7 = a2;
if ( v7 >= 255 )
v7 = 255;
v8 = *a1;
ImageColors = LoadImageColors(
*a1,
(long long)a1,
a2,
a3,
a4,
a5,
a6,
a1->m128i_i64[0],
a1->m128i_i64[1],
a1[1].m128i_i64[0]);
if ( a1->m128i_i32[2] * a1->m128i_i32[3] > 0 )
{
v10 = 0LL;
do
{
v11 = v7 + *(unsigned __int8 *)(ImageColors + 4 * v10);
v12 = v7 + *(unsigned __int8 *)(ImageColors + 4 * v10 + 1);
v13 = v7 + *(unsigned __int8 *)(ImageColors + 4 * v10 + 2);
v14 = -1;
if ( v11 < 255 )
v14 = v7 + *(_BYTE *)(ImageColors + 4 * v10);
v15 = -1;
if ( v12 < 255 )
v15 = v7 + *(_BYTE *)(ImageColors + 4 * v10 + 1);
v16 = -1;
if ( v13 < 255 )
v16 = v7 + *(_BYTE *)(ImageColors + 4 * v10 + 2);
if ( v11 < 0 )
v14 = 1;
if ( v12 < 0 )
v15 = 1;
*(_BYTE *)(ImageColors + 4 * v10) = v14;
*(_BYTE *)(ImageColors + 4 * v10 + 1) = v15;
if ( v13 < 0 )
v16 = 1;
*(_BYTE *)(ImageColors + 4 * v10++ + 2) = v16;
}
while ( v10 < a1->m128i_i32[2] * (long long)a1->m128i_i32[3] );
}
v17 = a1[1].m128i_i32[1];
free(a1->m128i_i64[0]);
a1->m128i_i64[0] = ImageColors;
a1[1].m128i_i32[1] = 7;
ImageFormat(a1->m128i_i64, v17, *(float *)v8.m128i_i32, v18, v19, v20, v21);
}
}
| ImageColorBrightness:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x18
CMP qword ptr [RDI],0x0
JZ 0x00198ea0
MOV RBX,RDI
CMP dword ptr [RDI + 0x8],0x0
JZ 0x00198ea0
CMP dword ptr [RBX + 0xc],0x0
JZ 0x00198ea0
CMP ESI,0xffffff02
MOV EBP,0xffffff01
CMOVGE EBP,ESI
MOV R15D,0xff
CMP EBP,R15D
CMOVGE EBP,R15D
MOV RAX,qword ptr [RBX + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RBX]
MOVUPS xmmword ptr [RSP],XMM0
CALL 0x00192846
MOV R14,RAX
MOV EAX,dword ptr [RBX + 0xc]
IMUL EAX,dword ptr [RBX + 0x8]
TEST EAX,EAX
JLE 0x00198e77
XOR EAX,EAX
MOV ECX,0x1
LAB_00198e05:
MOVZX EDX,byte ptr [R14 + RAX*0x4]
ADD EDX,EBP
MOVZX ESI,byte ptr [R14 + RAX*0x4 + 0x1]
ADD ESI,EBP
MOVZX EDI,byte ptr [R14 + RAX*0x4 + 0x2]
ADD EDI,EBP
CMP EDX,R15D
MOV R8D,0xff
CMOVL R8D,EDX
CMP ESI,R15D
MOV R9D,0xff
CMOVL R9D,ESI
CMP EDI,R15D
MOV R10D,0xff
CMOVL R10D,EDI
TEST EDX,EDX
CMOVS R8D,ECX
TEST ESI,ESI
CMOVS R9D,ECX
TEST EDI,EDI
MOV byte ptr [R14 + RAX*0x4],R8B
MOV byte ptr [R14 + RAX*0x4 + 0x1],R9B
CMOVS R10D,ECX
MOV byte ptr [R14 + RAX*0x4 + 0x2],R10B
INC RAX
MOVSXD RDX,dword ptr [RBX + 0x8]
MOVSXD RSI,dword ptr [RBX + 0xc]
IMUL RSI,RDX
CMP RAX,RSI
JL 0x00198e05
LAB_00198e77:
MOV EBP,dword ptr [RBX + 0x14]
MOV RDI,qword ptr [RBX]
CALL 0x0010a650
MOV qword ptr [RBX],R14
MOV dword ptr [RBX + 0x14],0x7
MOV RDI,RBX
MOV ESI,EBP
ADD RSP,0x18
POP RBX
POP R14
POP R15
POP RBP
JMP 0x00194249
LAB_00198ea0:
ADD RSP,0x18
POP RBX
POP R14
POP R15
POP RBP
RET
|
void ImageColorBrightness(long *param_1,int param_2)
{
int4 uVar1;
int1 uVar2;
long lVar3;
long lVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int1 uVar11;
int iVar12;
if (((*param_1 != 0) && ((int)param_1[1] != 0)) && (*(int *)((long)param_1 + 0xc) != 0)) {
iVar6 = -0xff;
if (-0xff < param_2) {
iVar6 = param_2;
}
if (0xfe < iVar6) {
iVar6 = 0xff;
}
lVar3 = LoadImageColors();
if (0 < *(int *)((long)param_1 + 0xc) * (int)param_1[1]) {
lVar4 = 0;
do {
iVar5 = (uint)*(byte *)(lVar3 + lVar4 * 4) + iVar6;
iVar7 = (uint)*(byte *)(lVar3 + 1 + lVar4 * 4) + iVar6;
iVar8 = (uint)*(byte *)(lVar3 + 2 + lVar4 * 4) + iVar6;
iVar9 = 0xff;
if (iVar5 < 0xff) {
iVar9 = iVar5;
}
iVar10 = 0xff;
if (iVar7 < 0xff) {
iVar10 = iVar7;
}
iVar12 = 0xff;
if (iVar8 < 0xff) {
iVar12 = iVar8;
}
uVar11 = (char)iVar9;
if (iVar5 < 0) {
uVar11 = 1;
}
uVar2 = (char)iVar10;
if (iVar7 < 0) {
uVar2 = 1;
}
*(int1 *)(lVar3 + lVar4 * 4) = uVar11;
*(int1 *)(lVar3 + 1 + lVar4 * 4) = uVar2;
uVar11 = (int1)iVar12;
if (iVar8 < 0) {
uVar11 = 1;
}
*(int1 *)(lVar3 + 2 + lVar4 * 4) = uVar11;
lVar4 = lVar4 + 1;
} while (lVar4 < (long)*(int *)((long)param_1 + 0xc) * (long)(int)param_1[1]);
}
uVar1 = *(int4 *)((long)param_1 + 0x14);
free((void *)*param_1);
*param_1 = lVar3;
*(int4 *)((long)param_1 + 0x14) = 7;
ImageFormat(param_1,uVar1);
return;
}
return;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.