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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
47,200 | LefDefParser::lefwLayerAntennaAreaMinusDiff(double) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp | int
lefwLayerAntennaAreaMinusDiff(double minusDiffFactor)
{
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (lefwState != LEFW_LAYERROUTING_START && lefwState != LEFW_LAYERROUTING &&
lefwState != LEFW_LAYER_START && lefwState != LEFW_LAYER)
return LEFW_BAD_ORDER;
if (!lefwIsRouting && !lefwIsCut)
return LEFW_BAD_DATA;
/* WANDA
if ((versionNum < 5.4) &&
(diffUseOnly && strcmp(diffUseOnly, "DIFFUSEONLY") == 0))
return LEFW_WRONG_VERSION;
*/
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*) " ANTENNAAREAMINUSDIFF %.11g ;\n",
minusDiffFactor);
else {
fprintf(lefwFile, " ANTENNAAREAMINUSDIFF %.11g ;\n", minusDiffFactor);
}
lefwLines++;
return LEFW_OK;
} | O3 | cpp | LefDefParser::lefwLayerAntennaAreaMinusDiff(double):
leaq 0x7648c(%rip), %rax # 0x8d0f0
movq (%rax), %rdi
testq %rdi, %rdi
je 0x16cbc
leaq 0x766cd(%rip), %rax # 0x8d340
movl (%rax), %ecx
movl $0x2, %eax
cmpl $0x1f, %ecx
ja 0x16cdf
movl $0x900000c0, %edx # imm = 0x900000C0
btl %ecx, %edx
jae 0x16cdf
leaq 0x76724(%rip), %rcx # 0x8d3b4
leaq 0x766dd(%rip), %rax # 0x8d374
movl (%rax), %edx
movl $0x3, %eax
orl (%rcx), %edx
je 0x16cdf
pushq %rax
cmpb $0x1, 0x76732(%rip) # 0x8d3dc
jne 0x16cc2
leaq 0x44894(%rip), %rsi # 0x5b547
movb $0x1, %al
callq 0x55afd
jmp 0x16cd0
movl $0x1, %eax
retq
leaq 0x4487e(%rip), %rsi # 0x5b547
movb $0x1, %al
callq 0x22e0
leaq 0x76665(%rip), %rax # 0x8d33c
incl (%rax)
xorl %eax, %eax
addq $0x8, %rsp
retq
| _ZN12LefDefParser29lefwLayerAntennaAreaMinusDiffEd:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
test rdi, rdi
jz short loc_16CBC
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
mov ecx, [rax]
mov eax, 2
cmp ecx, 1Fh
ja short locret_16CDF
mov edx, 900000C0h
bt edx, ecx
jnb short locret_16CDF
lea rcx, _ZN12LefDefParser13lefwIsRoutingE; LefDefParser::lefwIsRouting
lea rax, _ZN12LefDefParser9lefwIsCutE; LefDefParser::lefwIsCut
mov edx, [rax]
mov eax, 3
or edx, [rcx]
jz short locret_16CDF
push rax
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 1; LefDefParser::lefwWriteEncrypt
jnz short loc_16CC2
lea rsi, aAntennaareamin_0; " ANTENNAAREAMINUSDIFF %.11g ;\n"
mov al, 1
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_16CD0
loc_16CBC:
mov eax, 1
retn
loc_16CC2:
lea rsi, aAntennaareamin_0; " ANTENNAAREAMINUSDIFF %.11g ;\n"
mov al, 1
call _fprintf
loc_16CD0:
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
inc dword ptr [rax]
xor eax, eax
add rsp, 8
locret_16CDF:
retn
| long long LefDefParser::lefwLayerAntennaAreaMinusDiff(
LefDefParser *this,
double a2,
long long a3,
long long a4,
long long a5,
int a6,
int a7)
{
long long result; // rax
int v8; // edx
if ( !*(_QWORD *)&LefDefParser::lefwFile )
return 1LL;
result = 2LL;
if ( LefDefParser::lefwState <= 0x1F )
{
v8 = -1879048000;
if ( _bittest(&v8, LefDefParser::lefwState) )
{
result = 3LL;
if ( LefDefParser::lefwIsRouting | LefDefParser::lefwIsCut )
{
if ( LefDefParser::lefwWriteEncrypt == 1 )
LefDefParser::encPrint(
LefDefParser::lefwFile,
(unsigned int)" ANTENNAAREAMINUSDIFF %.11g ;\n",
LefDefParser::lefwIsRouting | LefDefParser::lefwIsCut,
(unsigned int)&LefDefParser::lefwIsRouting,
a6,
a7);
else
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " ANTENNAAREAMINUSDIFF %.11g ;\n", a2);
++LefDefParser::lefwLines;
return 0LL;
}
}
}
return result;
}
| lefwLayerAntennaAreaMinusDiff:
LEA RAX,[0x18d0f0]
MOV RDI,qword ptr [RAX]
TEST RDI,RDI
JZ 0x00116cbc
LEA RAX,[0x18d340]
MOV ECX,dword ptr [RAX]
MOV EAX,0x2
CMP ECX,0x1f
JA 0x00116cdf
MOV EDX,0x900000c0
BT EDX,ECX
JNC 0x00116cdf
LEA RCX,[0x18d3b4]
LEA RAX,[0x18d374]
MOV EDX,dword ptr [RAX]
MOV EAX,0x3
OR EDX,dword ptr [RCX]
JZ 0x00116cdf
PUSH RAX
CMP byte ptr [0x0018d3dc],0x1
JNZ 0x00116cc2
LEA RSI,[0x15b547]
MOV AL,0x1
CALL 0x00155afd
JMP 0x00116cd0
LAB_00116cbc:
MOV EAX,0x1
RET
LAB_00116cc2:
LEA RSI,[0x15b547]
MOV AL,0x1
CALL 0x001022e0
LAB_00116cd0:
LEA RAX,[0x18d33c]
INC dword ptr [RAX]
XOR EAX,EAX
ADD RSP,0x8
LAB_00116cdf:
RET
|
/* LefDefParser::lefwLayerAntennaAreaMinusDiff(double) */
int8 LefDefParser::lefwLayerAntennaAreaMinusDiff(double param_1)
{
int8 uVar1;
if (lefwFile != (_IO_FILE *)0x0) {
uVar1 = 2;
if ((lefwState < 0x20) && ((0x900000c0U >> (lefwState & 0x1f) & 1) != 0)) {
uVar1 = 3;
if (lefwIsCut != 0 || lefwIsRouting != 0) {
if (lefwWriteEncrypt == '\x01') {
encPrint(lefwFile," ANTENNAAREAMINUSDIFF %.11g ;\n");
}
else {
fprintf(lefwFile," ANTENNAAREAMINUSDIFF %.11g ;\n");
}
lefwLines = lefwLines + 1;
uVar1 = 0;
}
}
return uVar1;
}
return 1;
}
| |
47,201 | translog_relative_LSN_encode | eloqsql/storage/maria/ma_loghandler.c | static void translog_relative_LSN_encode(struct st_translog_parts *parts,
LSN base_lsn,
uint lsns, uchar *compressed_LSNs)
{
LEX_CUSTRING *part;
uint lsns_len= lsns * LSN_STORE_SIZE;
uchar buffer_src[MAX_NUMBER_OF_LSNS_PER_RECORD * LSN_STORE_SIZE];
uchar *buffer= buffer_src;
const uchar *cbuffer;
DBUG_ENTER("translog_relative_LSN_encode");
DBUG_ASSERT(parts->current != 0);
part= parts->parts + parts->current;
/* collect all LSN(s) in one chunk if it (they) is (are) divided */
if (part->length < lsns_len)
{
size_t copied= part->length;
LEX_CUSTRING *next_part;
DBUG_PRINT("info", ("Using buffer:%p", compressed_LSNs));
memcpy(buffer, part->str, part->length);
next_part= parts->parts + parts->current + 1;
do
{
DBUG_ASSERT(next_part < parts->parts + parts->elements);
if ((next_part->length + copied) < lsns_len)
{
memcpy(buffer + copied, next_part->str,
next_part->length);
copied+= next_part->length;
next_part->length= 0; next_part->str= 0;
/* delete_dynamic_element(&parts->parts, parts->current + 1); */
next_part++;
parts->current++;
part= parts->parts + parts->current;
}
else
{
size_t len= lsns_len - copied;
memcpy(buffer + copied, next_part->str, len);
copied= lsns_len;
next_part->str+= len;
next_part->length-= len;
}
} while (copied < lsns_len);
cbuffer= buffer;
}
else
{
cbuffer= part->str;
part->str+= lsns_len;
part->length-= lsns_len;
parts->current--;
part= parts->parts + parts->current;
}
{
/* Compress */
LSN ref;
int economy;
const uchar *src_ptr;
uchar *dst_ptr= compressed_LSNs + (MAX_NUMBER_OF_LSNS_PER_RECORD *
COMPRESSED_LSN_MAX_STORE_SIZE);
/*
We write the result in backward direction with no special sense or
tricks both directions are equal in complicity
*/
for (src_ptr= cbuffer + lsns_len - LSN_STORE_SIZE;
src_ptr >= (const uchar*)cbuffer;
src_ptr-= LSN_STORE_SIZE)
{
ref= lsn_korr(src_ptr);
dst_ptr= translog_put_LSN_diff(base_lsn, ref, dst_ptr);
}
part->length= (size_t)((compressed_LSNs +
(MAX_NUMBER_OF_LSNS_PER_RECORD *
COMPRESSED_LSN_MAX_STORE_SIZE)) -
dst_ptr);
economy= lsns_len - (uint)part->length;
parts->record_length-= economy;
DBUG_PRINT("info", ("new length of LSNs: %lu economy: %d",
(ulong)part->length, economy));
parts->total_record_length-= economy;
part->str= dst_ptr;
}
DBUG_VOID_RETURN;
} | O3 | c | translog_relative_LSN_encode:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
leal (,%rdx,8), %edi
subl %edx, %edi
movq 0x10(%rbx), %rax
movl 0x8(%rbx), %edx
shlq $0x4, %rdx
leaq (%rax,%rdx), %r15
movq (%rax,%rdx), %rsi
movq 0x8(%rax,%rdx), %r13
movq %r13, %rax
subq %rdi, %rax
movq %rdi, -0x48(%rbp)
jae 0x38bc9
movq %r14, -0x58(%rbp)
movq %rcx, -0x60(%rbp)
leaq -0x3e(%rbp), %r12
movl $0xe, %ecx
movq %r12, %rdi
movq %r13, %rdx
callq 0x29410
movq -0x48(%rbp), %rdi
movq %r15, %rcx
addq $0x18, %r15
movq 0x18(%rcx), %r14
leaq (%r14,%r13), %rax
cmpq %rdi, %rax
movq %rbx, -0x68(%rbp)
jae 0x38bec
movq %r13, %rbx
leaq -0x3e(,%r13), %rdi
addq %rbp, %rdi
movq -0x8(%r15), %rsi
movq %r14, %rdx
callq 0x29080
movq -0x48(%rbp), %rdi
movq %r14, %r13
addq %rbx, %r13
movq -0x68(%rbp), %rbx
xorps %xmm0, %xmm0
movups %xmm0, -0x8(%r15)
movl 0x8(%rbx), %eax
incl %eax
movl %eax, 0x8(%rbx)
cmpq %rdi, %r13
jae 0x38c3d
movq 0x10(%r15), %r14
addq $0x10, %r15
leaq (%r14,%r13), %rcx
cmpq %rdi, %rcx
jb 0x38b63
movl %eax, %eax
shlq $0x4, %rax
addq 0x10(%rbx), %rax
movq %rax, -0x50(%rbp)
leaq -0x8(%r15), %rax
jmp 0x38bf4
leaq (%rsi,%rdi), %rdx
movq %rdx, (%r15)
movq %rax, 0x8(%r15)
movl 0x8(%rbx), %r15d
decl %r15d
movl %r15d, 0x8(%rbx)
shlq $0x4, %r15
addq 0x10(%rbx), %r15
movq %rsi, %r12
jmp 0x38c50
movq %rcx, -0x50(%rbp)
leaq 0x10(%rcx), %rax
movq %rax, -0x70(%rbp)
movq %rdi, %rbx
subq %r13, %rbx
leaq -0x3e(,%r13), %rdi
addq %rbp, %rdi
movq (%rax), %r13
movq %r13, %rsi
movq %rbx, %rdx
callq 0x29080
movq -0x48(%rbp), %rdi
addq %rbx, %r13
movq -0x70(%rbp), %rax
movq %r13, (%rax)
subq %rbx, %r14
movq %r14, (%r15)
movq -0x68(%rbp), %rbx
movq -0x60(%rbp), %rcx
movq -0x58(%rbp), %r14
movq -0x50(%rbp), %r15
jmp 0x38c50
movl %eax, %r15d
shlq $0x4, %r15
addq 0x10(%rbx), %r15
movq -0x60(%rbp), %rcx
movq -0x58(%rbp), %r14
addq $0x12, %rcx
leaq (%r12,%rdi), %r11
addq $-0x7, %r11
movq %rcx, %rax
cmpq %r12, %r11
jb 0x38d4b
movq %rcx, %rax
movzbl (%r11), %esi
movzbl 0x1(%r11), %edi
movzbl 0x2(%r11), %r8d
movq %r8, %rdx
shlq $0x30, %rdx
movq %rdi, %r9
shlq $0x28, %r9
movq %rsi, %r10
shlq $0x20, %r10
orq %r9, %r10
orq %rdx, %r10
movl 0x3(%r11), %r9d
orq %r9, %r10
movq %r14, %rdx
subq %r10, %rdx
cmpq $0x3fff, %rdx # imm = 0x3FFF
ja 0x38cbb
rolw $0x8, %dx
movw %dx, -0x2(%rax)
addq $-0x2, %rax
jmp 0x38d3e
cmpq $0x3fffff, %rdx # imm = 0x3FFFFF
ja 0x38cdb
movl %edx, %esi
shrl $0x10, %esi
orb $0x40, %sil
movb %sil, -0x3(%rax)
movw %dx, -0x2(%rax)
addq $-0x3, %rax
jmp 0x38d3e
cmpq $0x3fffffff, %rdx # imm = 0x3FFFFFFF
ja 0x38d03
movl %edx, %esi
shrl $0x18, %esi
orb $-0x80, %sil
movb %sil, -0x4(%rax)
movb %dl, -0x3(%rax)
movb %dh, -0x2(%rax)
shrl $0x10, %edx
movb %dl, -0x1(%rax)
addq $-0x4, %rax
jmp 0x38d3e
movq %rdx, %r10
shrq $0x26, %r10
jne 0x38d24
movq %rdx, %rsi
shrq $0x20, %rsi
orb $-0x40, %sil
movb %sil, -0x5(%rax)
movl %edx, -0x4(%rax)
addq $-0x5, %rax
jmp 0x38d3e
movw $0x100, -0x9(%rax) # imm = 0x100
movb %sil, -0x7(%rax)
movb %dil, -0x6(%rax)
movb %r8b, -0x5(%rax)
movl %r9d, -0x4(%rax)
addq $-0x9, %rax
addq $-0x7, %r11
cmpq %r12, %r11
jae 0x38c6b
subq %rax, %rcx
movq %rcx, 0x8(%r15)
subl -0x48(%rbp), %ecx
movq (%rbx), %xmm0
movd %ecx, %xmm1
pshufd $0x50, %xmm1, %xmm1 # xmm1 = xmm1[0,0,1,1]
paddd %xmm0, %xmm1
movq %xmm1, (%rbx)
movq %rax, (%r15)
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x38d8b
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x29250
| translog_relative_LSN_encode:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r14, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
lea edi, ds:0[rdx*8]
sub edi, edx
mov rax, [rbx+10h]
mov edx, [rbx+8]
shl rdx, 4
lea r15, [rax+rdx]
mov rsi, [rax+rdx]
mov r13, [rax+rdx+8]
mov rax, r13
sub rax, rdi
mov [rbp+var_48], rdi
jnb loc_38BC9
mov [rbp+var_58], r14
mov [rbp+var_60], rcx
lea r12, [rbp+var_3E]
mov ecx, 0Eh
mov rdi, r12
mov rdx, r13
call ___memcpy_chk
mov rdi, [rbp+var_48]
mov rcx, r15
add r15, 18h
mov r14, [rcx+18h]
lea rax, [r14+r13]
cmp rax, rdi
mov [rbp+var_68], rbx
jnb loc_38BEC
loc_38B63:
mov rbx, r13
lea rdi, ds:0FFFFFFFFFFFFFFC2h[r13]
add rdi, rbp
mov rsi, [r15-8]
mov rdx, r14
call _memcpy
mov rdi, [rbp+var_48]
mov r13, r14
add r13, rbx
mov rbx, [rbp+var_68]
xorps xmm0, xmm0
movups xmmword ptr [r15-8], xmm0
mov eax, [rbx+8]
inc eax
mov [rbx+8], eax
cmp r13, rdi
jnb loc_38C3D
mov r14, [r15+10h]
add r15, 10h
lea rcx, [r14+r13]
cmp rcx, rdi
jb short loc_38B63
mov eax, eax
shl rax, 4
add rax, [rbx+10h]
mov [rbp+var_50], rax
lea rax, [r15-8]
jmp short loc_38BF4
loc_38BC9:
lea rdx, [rsi+rdi]
mov [r15], rdx
mov [r15+8], rax
mov r15d, [rbx+8]
dec r15d
mov [rbx+8], r15d
shl r15, 4
add r15, [rbx+10h]
mov r12, rsi
jmp short loc_38C50
loc_38BEC:
mov [rbp+var_50], rcx
lea rax, [rcx+10h]
loc_38BF4:
mov [rbp+var_70], rax
mov rbx, rdi
sub rbx, r13
lea rdi, ds:0FFFFFFFFFFFFFFC2h[r13]
add rdi, rbp
mov r13, [rax]
mov rsi, r13
mov rdx, rbx
call _memcpy
mov rdi, [rbp+var_48]
add r13, rbx
mov rax, [rbp+var_70]
mov [rax], r13
sub r14, rbx
mov [r15], r14
mov rbx, [rbp+var_68]
mov rcx, [rbp+var_60]
mov r14, [rbp+var_58]
mov r15, [rbp+var_50]
jmp short loc_38C50
loc_38C3D:
mov r15d, eax
shl r15, 4
add r15, [rbx+10h]
mov rcx, [rbp+var_60]
mov r14, [rbp+var_58]
loc_38C50:
add rcx, 12h
lea r11, [r12+rdi]
add r11, 0FFFFFFFFFFFFFFF9h
mov rax, rcx
cmp r11, r12
jb loc_38D4B
mov rax, rcx
loc_38C6B:
movzx esi, byte ptr [r11]
movzx edi, byte ptr [r11+1]
movzx r8d, byte ptr [r11+2]
mov rdx, r8
shl rdx, 30h
mov r9, rdi
shl r9, 28h
mov r10, rsi
shl r10, 20h
or r10, r9
or r10, rdx
mov r9d, [r11+3]
or r10, r9
mov rdx, r14
sub rdx, r10
cmp rdx, 3FFFh
ja short loc_38CBB
rol dx, 8
mov [rax-2], dx
add rax, 0FFFFFFFFFFFFFFFEh
jmp loc_38D3E
loc_38CBB:
cmp rdx, offset unk_3FFFFF
ja short loc_38CDB
mov esi, edx
shr esi, 10h
or sil, 40h
mov [rax-3], sil
mov [rax-2], dx
add rax, 0FFFFFFFFFFFFFFFDh
jmp short loc_38D3E
loc_38CDB:
cmp rdx, 3FFFFFFFh
ja short loc_38D03
mov esi, edx
shr esi, 18h
or sil, 80h
mov [rax-4], sil
mov [rax-3], dl
mov [rax-2], dh
shr edx, 10h
mov [rax-1], dl
add rax, 0FFFFFFFFFFFFFFFCh
jmp short loc_38D3E
loc_38D03:
mov r10, rdx
shr r10, 26h
jnz short loc_38D24
mov rsi, rdx
shr rsi, 20h
or sil, 0C0h
mov [rax-5], sil
mov [rax-4], edx
add rax, 0FFFFFFFFFFFFFFFBh
jmp short loc_38D3E
loc_38D24:
mov word ptr [rax-9], 100h
mov [rax-7], sil
mov [rax-6], dil
mov [rax-5], r8b
mov [rax-4], r9d
add rax, 0FFFFFFFFFFFFFFF7h
loc_38D3E:
add r11, 0FFFFFFFFFFFFFFF9h
cmp r11, r12
jnb loc_38C6B
loc_38D4B:
sub rcx, rax
mov [r15+8], rcx
sub ecx, dword ptr [rbp+var_48]
movq xmm0, qword ptr [rbx]
movd xmm1, ecx
pshufd xmm1, xmm1, 50h ; 'P'
paddd xmm1, xmm0
movq qword ptr [rbx], xmm1
mov [r15], rax
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_38D8B
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_38D8B:
call ___stack_chk_fail
| unsigned long long translog_relative_LSN_encode(__m128i *a1, long long a2, int a3, long long a4)
{
unsigned long long v6; // rdi
_QWORD *v7; // r15
unsigned __int8 *v8; // rsi
unsigned long long v9; // r13
unsigned __int8 *v10; // r12
_QWORD *v11; // rcx
_QWORD *v12; // r15
long long v13; // r14
unsigned int v14; // eax
_QWORD *v15; // rax
long long v16; // r15
_QWORD *v17; // r15
unsigned long long v18; // rbx
char *v19; // rdi
long long v20; // r13
long long v21; // rcx
unsigned __int8 *v22; // r11
long long v23; // rax
char v24; // si
unsigned __int8 v25; // di
unsigned __int8 v26; // r8
long long v27; // r9
unsigned long long v28; // rdx
long long v29; // rcx
_QWORD *v31; // [rsp+0h] [rbp-70h]
__m128i *v32; // [rsp+8h] [rbp-68h]
long long v33; // [rsp+10h] [rbp-60h]
long long v34; // [rsp+18h] [rbp-58h]
long long v35; // [rsp+20h] [rbp-50h]
unsigned long long v36; // [rsp+28h] [rbp-48h]
_BYTE v37[14]; // [rsp+32h] [rbp-3Eh] BYREF
unsigned long long v38; // [rsp+40h] [rbp-30h]
long long savedregs; // [rsp+70h] [rbp+0h] BYREF
v38 = __readfsqword(0x28u);
v6 = (unsigned int)(7 * a3);
v7 = (_QWORD *)(a1[1].m128i_i64[0] + 16LL * a1->m128i_u32[2]);
v8 = (unsigned __int8 *)*v7;
v9 = v7[1];
v36 = v6;
if ( v9 >= v6 )
{
*v7 = &v8[v6];
v7[1] = v9 - v6;
v16 = (unsigned int)(a1->m128i_i32[2] - 1);
a1->m128i_i32[2] = v16;
v17 = (_QWORD *)(a1[1].m128i_i64[0] + 16 * v16);
v10 = v8;
}
else
{
v34 = a2;
v33 = a4;
v10 = v37;
__memcpy_chk(v37, v8, v9, 14LL);
v6 = v36;
v11 = v7;
v12 = v7 + 3;
v13 = v11[3];
v32 = a1;
if ( v13 + v9 >= v36 )
{
v35 = (long long)v11;
v15 = v11 + 2;
LABEL_8:
v31 = v15;
v18 = v6 - v9;
v19 = (char *)&savedregs + v9 - 62;
v20 = *v15;
memcpy(v19, *v15, v18);
v6 = v36;
*v31 = v18 + v20;
*v12 = v13 - v18;
a1 = v32;
a4 = v33;
a2 = v34;
v17 = (_QWORD *)v35;
}
else
{
while ( 1 )
{
memcpy((char *)&savedregs + v9 - 62, *(v12 - 1), v13);
v6 = v36;
v9 += v13;
a1 = v32;
*(_OWORD *)(v12 - 1) = 0LL;
v14 = v32->m128i_i32[2] + 1;
v32->m128i_i32[2] = v14;
if ( v9 >= v6 )
break;
v13 = v12[2];
v12 += 2;
if ( v13 + v9 >= v6 )
{
v35 = v32[1].m128i_i64[0] + 16LL * v14;
v15 = v12 - 1;
goto LABEL_8;
}
}
v17 = (_QWORD *)(v32[1].m128i_i64[0] + 16LL * v14);
a4 = v33;
a2 = v34;
}
}
v21 = a4 + 18;
v22 = &v10[v6 - 7];
v23 = v21;
if ( v22 >= v10 )
{
v23 = v21;
do
{
v24 = *v22;
v25 = v22[1];
v26 = v22[2];
v27 = *(unsigned int *)(v22 + 3);
v28 = a2 - (v27 | ((unsigned long long)v26 << 48) | ((unsigned long long)v25 << 40) | ((unsigned long long)*v22 << 32));
if ( v28 > 0x3FFF )
{
if ( v28 > (unsigned long long)&unk_3FFFFF )
{
if ( v28 > 0x3FFFFFFF )
{
if ( v28 >> 38 )
{
*(_WORD *)(v23 - 9) = 256;
*(_BYTE *)(v23 - 7) = v24;
*(_BYTE *)(v23 - 6) = v25;
*(_BYTE *)(v23 - 5) = v26;
*(_DWORD *)(v23 - 4) = v27;
v23 -= 9LL;
}
else
{
*(_BYTE *)(v23 - 5) = BYTE4(v28) | 0xC0;
*(_DWORD *)(v23 - 4) = v28;
v23 -= 5LL;
}
}
else
{
*(_BYTE *)(v23 - 4) = ((unsigned int)(a2 - v27) >> 24) | 0x80;
*(_WORD *)(v23 - 3) = v28;
*(_BYTE *)(v23 - 1) = BYTE2(v28);
v23 -= 4LL;
}
}
else
{
*(_BYTE *)(v23 - 3) = ((unsigned int)(a2 - v27) >> 16) | 0x40;
*(_WORD *)(v23 - 2) = v28;
v23 -= 3LL;
}
}
else
{
*(_WORD *)(v23 - 2) = __ROL2__(a2 - v27, 8);
v23 -= 2LL;
}
v22 -= 7;
}
while ( v22 >= v10 );
}
v29 = v21 - v23;
v17[1] = v29;
a1->m128i_i64[0] = _mm_add_epi32(_mm_shuffle_epi32(_mm_cvtsi32_si128((int)v29 - (int)v36), 80), _mm_loadl_epi64(a1)).m128i_u64[0];
*v17 = v23;
return __readfsqword(0x28u);
}
| translog_relative_LSN_encode:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
LEA EDI,[RDX*0x8]
SUB EDI,EDX
MOV RAX,qword ptr [RBX + 0x10]
MOV EDX,dword ptr [RBX + 0x8]
SHL RDX,0x4
LEA R15,[RAX + RDX*0x1]
MOV RSI,qword ptr [RAX + RDX*0x1]
MOV R13,qword ptr [RAX + RDX*0x1 + 0x8]
MOV RAX,R13
SUB RAX,RDI
MOV qword ptr [RBP + -0x48],RDI
JNC 0x00138bc9
MOV qword ptr [RBP + -0x58],R14
MOV qword ptr [RBP + -0x60],RCX
LEA R12,[RBP + -0x3e]
MOV ECX,0xe
MOV RDI,R12
MOV RDX,R13
CALL 0x00129410
MOV RDI,qword ptr [RBP + -0x48]
MOV RCX,R15
ADD R15,0x18
MOV R14,qword ptr [RCX + 0x18]
LEA RAX,[R14 + R13*0x1]
CMP RAX,RDI
MOV qword ptr [RBP + -0x68],RBX
JNC 0x00138bec
LAB_00138b63:
MOV RBX,R13
LEA RDI,[-0x3e + R13*0x1]
ADD RDI,RBP
MOV RSI,qword ptr [R15 + -0x8]
MOV RDX,R14
CALL 0x00129080
MOV RDI,qword ptr [RBP + -0x48]
MOV R13,R14
ADD R13,RBX
MOV RBX,qword ptr [RBP + -0x68]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R15 + -0x8],XMM0
MOV EAX,dword ptr [RBX + 0x8]
INC EAX
MOV dword ptr [RBX + 0x8],EAX
CMP R13,RDI
JNC 0x00138c3d
MOV R14,qword ptr [R15 + 0x10]
ADD R15,0x10
LEA RCX,[R14 + R13*0x1]
CMP RCX,RDI
JC 0x00138b63
MOV EAX,EAX
SHL RAX,0x4
ADD RAX,qword ptr [RBX + 0x10]
MOV qword ptr [RBP + -0x50],RAX
LEA RAX,[R15 + -0x8]
JMP 0x00138bf4
LAB_00138bc9:
LEA RDX,[RSI + RDI*0x1]
MOV qword ptr [R15],RDX
MOV qword ptr [R15 + 0x8],RAX
MOV R15D,dword ptr [RBX + 0x8]
DEC R15D
MOV dword ptr [RBX + 0x8],R15D
SHL R15,0x4
ADD R15,qword ptr [RBX + 0x10]
MOV R12,RSI
JMP 0x00138c50
LAB_00138bec:
MOV qword ptr [RBP + -0x50],RCX
LEA RAX,[RCX + 0x10]
LAB_00138bf4:
MOV qword ptr [RBP + -0x70],RAX
MOV RBX,RDI
SUB RBX,R13
LEA RDI,[-0x3e + R13*0x1]
ADD RDI,RBP
MOV R13,qword ptr [RAX]
MOV RSI,R13
MOV RDX,RBX
CALL 0x00129080
MOV RDI,qword ptr [RBP + -0x48]
ADD R13,RBX
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RAX],R13
SUB R14,RBX
MOV qword ptr [R15],R14
MOV RBX,qword ptr [RBP + -0x68]
MOV RCX,qword ptr [RBP + -0x60]
MOV R14,qword ptr [RBP + -0x58]
MOV R15,qword ptr [RBP + -0x50]
JMP 0x00138c50
LAB_00138c3d:
MOV R15D,EAX
SHL R15,0x4
ADD R15,qword ptr [RBX + 0x10]
MOV RCX,qword ptr [RBP + -0x60]
MOV R14,qword ptr [RBP + -0x58]
LAB_00138c50:
ADD RCX,0x12
LEA R11,[R12 + RDI*0x1]
ADD R11,-0x7
MOV RAX,RCX
CMP R11,R12
JC 0x00138d4b
MOV RAX,RCX
LAB_00138c6b:
MOVZX ESI,byte ptr [R11]
MOVZX EDI,byte ptr [R11 + 0x1]
MOVZX R8D,byte ptr [R11 + 0x2]
MOV RDX,R8
SHL RDX,0x30
MOV R9,RDI
SHL R9,0x28
MOV R10,RSI
SHL R10,0x20
OR R10,R9
OR R10,RDX
MOV R9D,dword ptr [R11 + 0x3]
OR R10,R9
MOV RDX,R14
SUB RDX,R10
CMP RDX,0x3fff
JA 0x00138cbb
ROL DX,0x8
MOV word ptr [RAX + -0x2],DX
ADD RAX,-0x2
JMP 0x00138d3e
LAB_00138cbb:
CMP RDX,0x3fffff
JA 0x00138cdb
MOV ESI,EDX
SHR ESI,0x10
OR SIL,0x40
MOV byte ptr [RAX + -0x3],SIL
MOV word ptr [RAX + -0x2],DX
ADD RAX,-0x3
JMP 0x00138d3e
LAB_00138cdb:
CMP RDX,0x3fffffff
JA 0x00138d03
MOV ESI,EDX
SHR ESI,0x18
OR SIL,0x80
MOV byte ptr [RAX + -0x4],SIL
MOV byte ptr [RAX + -0x3],DL
MOV byte ptr [RAX + -0x2],DH
SHR EDX,0x10
MOV byte ptr [RAX + -0x1],DL
ADD RAX,-0x4
JMP 0x00138d3e
LAB_00138d03:
MOV R10,RDX
SHR R10,0x26
JNZ 0x00138d24
MOV RSI,RDX
SHR RSI,0x20
OR SIL,0xc0
MOV byte ptr [RAX + -0x5],SIL
MOV dword ptr [RAX + -0x4],EDX
ADD RAX,-0x5
JMP 0x00138d3e
LAB_00138d24:
MOV word ptr [RAX + -0x9],0x100
MOV byte ptr [RAX + -0x7],SIL
MOV byte ptr [RAX + -0x6],DIL
MOV byte ptr [RAX + -0x5],R8B
MOV dword ptr [RAX + -0x4],R9D
ADD RAX,-0x9
LAB_00138d3e:
ADD R11,-0x7
CMP R11,R12
JNC 0x00138c6b
LAB_00138d4b:
SUB RCX,RAX
MOV qword ptr [R15 + 0x8],RCX
SUB ECX,dword ptr [RBP + -0x48]
MOVQ XMM0,qword ptr [RBX]
MOVD XMM1,ECX
PSHUFD XMM1,XMM1,0x50
PADDD XMM1,XMM0
MOVQ qword ptr [RBX],XMM1
MOV qword ptr [R15],RAX
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00138d8b
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00138d8b:
CALL 0x00129250
|
void translog_relative_LSN_encode(int8 *param_1,long param_2,int param_3,long param_4)
{
byte bVar1;
byte bVar2;
byte bVar3;
void *__src;
byte bVar4;
uint uVar5;
long *plVar6;
long lVar7;
int iVar8;
ushort uVar9;
long lVar10;
size_t __n;
ulong uVar11;
byte *pbVar12;
byte *pbVar13;
ulong uVar14;
size_t __n_00;
long *plVar15;
long in_FS_OFFSET;
long *local_58;
byte local_46 [14];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
uVar11 = (ulong)(uint)(param_3 * 7);
lVar7 = param_1[2];
lVar10 = (ulong)*(uint *)(param_1 + 1) * 0x10;
local_58 = (long *)(lVar7 + lVar10);
pbVar13 = *(byte **)(lVar7 + lVar10);
uVar14 = *(ulong *)(lVar7 + 8 + lVar10);
if (uVar14 < uVar11) {
__memcpy_chk(local_46,pbVar13,uVar14,0xe);
plVar15 = local_58 + 3;
__n_00 = local_58[3];
pbVar13 = local_46;
if (__n_00 + uVar14 < uVar11) {
do {
plVar6 = plVar15;
memcpy(local_46 + uVar14,(void *)plVar6[-1],__n_00);
uVar14 = __n_00 + uVar14;
plVar6[-1] = 0;
*plVar6 = 0;
uVar5 = *(int *)(param_1 + 1) + 1;
*(uint *)(param_1 + 1) = uVar5;
if (uVar11 <= uVar14) {
local_58 = (long *)((ulong)uVar5 * 0x10 + param_1[2]);
goto LAB_00138c50;
}
__n_00 = plVar6[2];
plVar15 = plVar6 + 2;
} while (__n_00 + uVar14 < uVar11);
local_58 = (long *)((ulong)uVar5 * 0x10 + param_1[2]);
plVar6 = plVar6 + 1;
}
else {
plVar6 = local_58 + 2;
}
__n = uVar11 - uVar14;
__src = (void *)*plVar6;
memcpy(local_46 + uVar14,__src,__n);
*plVar6 = (long)__src + __n;
*plVar15 = __n_00 - __n;
}
else {
*local_58 = (long)(pbVar13 + uVar11);
local_58[1] = uVar14 - uVar11;
iVar8 = *(int *)(param_1 + 1);
*(uint *)(param_1 + 1) = iVar8 - 1U;
local_58 = (long *)((ulong)(iVar8 - 1U) * 0x10 + param_1[2]);
}
LAB_00138c50:
lVar7 = param_4 + 0x12;
for (pbVar12 = pbVar13 + (uVar11 - 7); pbVar13 <= pbVar12; pbVar12 = pbVar12 + -7) {
bVar1 = *pbVar12;
bVar2 = pbVar12[1];
bVar3 = pbVar12[2];
uVar5 = *(uint *)(pbVar12 + 3);
uVar14 = param_2 - ((ulong)bVar1 << 0x20 | (ulong)bVar2 << 0x28 | (ulong)bVar3 << 0x30 |
(ulong)uVar5);
uVar9 = (ushort)uVar14;
if (uVar14 < 0x4000) {
*(ushort *)(lVar7 + -2) = uVar9 << 8 | uVar9 >> 8;
lVar7 = lVar7 + -2;
}
else {
bVar4 = (byte)(uVar14 >> 0x10);
if (uVar14 < 0x400000) {
*(byte *)(lVar7 + -3) = bVar4 | 0x40;
*(ushort *)(lVar7 + -2) = uVar9;
lVar7 = lVar7 + -3;
}
else if (uVar14 < 0x40000000) {
*(byte *)(lVar7 + -4) = (byte)(uVar14 >> 0x18) | 0x80;
*(char *)(lVar7 + -3) = (char)uVar14;
*(char *)(lVar7 + -2) = (char)(uVar14 >> 8);
*(byte *)(lVar7 + -1) = bVar4;
lVar7 = lVar7 + -4;
}
else if (uVar14 >> 0x26 == 0) {
*(byte *)(lVar7 + -5) = (byte)(uVar14 >> 0x20) | 0xc0;
*(int *)(lVar7 + -4) = (int)uVar14;
lVar7 = lVar7 + -5;
}
else {
*(int2 *)(lVar7 + -9) = 0x100;
*(byte *)(lVar7 + -7) = bVar1;
*(byte *)(lVar7 + -6) = bVar2;
*(byte *)(lVar7 + -5) = bVar3;
*(uint *)(lVar7 + -4) = uVar5;
lVar7 = lVar7 + -9;
}
}
}
lVar10 = (param_4 + 0x12) - lVar7;
local_58[1] = lVar10;
iVar8 = (int)lVar10 + param_3 * -7;
*param_1 = CONCAT44(iVar8 + (int)((ulong)*param_1 >> 0x20),iVar8 + (int)*param_1);
*local_58 = lVar7;
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
47,202 | rope_yarn | monkey531[P]llama/ggml/src/ggml-cpu/ggml-cpu.c | static void rope_yarn(
float theta_extrap, float freq_scale, float corr_dims[2], int64_t i0, float ext_factor, float mscale,
float * cos_theta, float * sin_theta) {
// Get n-d rotational scaling corrected for extrapolation
float theta_interp = freq_scale * theta_extrap;
float theta = theta_interp;
if (ext_factor != 0.0f) {
float ramp_mix = rope_yarn_ramp(corr_dims[0], corr_dims[1], i0) * ext_factor;
theta = theta_interp * (1 - ramp_mix) + theta_extrap * ramp_mix;
// Get n-d magnitude scaling corrected for interpolation
mscale *= 1.0f + 0.1f * logf(1.0f / freq_scale);
}
*cos_theta = cosf(theta) * mscale;
*sin_theta = sinf(theta) * mscale;
} | O0 | c | rope_yarn:
subq $0x48, %rsp
vmovss %xmm0, 0x44(%rsp)
vmovss %xmm1, 0x40(%rsp)
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
vmovss %xmm2, 0x2c(%rsp)
vmovss %xmm3, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
vmovss 0x40(%rsp), %xmm0
vmulss 0x44(%rsp), %xmm0, %xmm0
vmovss %xmm0, 0x14(%rsp)
vmovss 0x14(%rsp), %xmm0
vmovss %xmm0, 0x10(%rsp)
vmovss 0x2c(%rsp), %xmm0
vpxor %xmm1, %xmm1, %xmm1
vucomiss %xmm1, %xmm0
jne 0x34d65
jp 0x34d65
jmp 0x34df3
movq 0x38(%rsp), %rax
vmovss (%rax), %xmm0
movq 0x38(%rsp), %rax
vmovss 0x4(%rax), %xmm1
movq 0x30(%rsp), %rax
movl %eax, %edi
callq 0x34e30
vmulss 0x2c(%rsp), %xmm0, %xmm0
vmovss %xmm0, 0xc(%rsp)
vmovss 0x14(%rsp), %xmm1
vmovss 0x7cd1e(%rip), %xmm0 # 0xb1abc
vsubss 0xc(%rsp), %xmm0, %xmm0
vmovss 0x44(%rsp), %xmm2
vmulss 0xc(%rsp), %xmm2, %xmm2
vfmadd213ss %xmm2, %xmm1, %xmm0 # xmm0 = (xmm1 * xmm0) + xmm2
vmovss %xmm0, 0x10(%rsp)
vmovss 0x7ccf9(%rip), %xmm0 # 0xb1abc
vdivss 0x40(%rsp), %xmm0, %xmm0
callq 0xd2c0
vmovaps %xmm0, %xmm1
vmovss 0x7cce2(%rip), %xmm2 # 0xb1abc
vmovss 0x7cd06(%rip), %xmm0 # 0xb1ae8
vfmadd213ss %xmm2, %xmm1, %xmm0 # xmm0 = (xmm1 * xmm0) + xmm2
vmulss 0x28(%rsp), %xmm0, %xmm0
vmovss %xmm0, 0x28(%rsp)
vmovss 0x10(%rsp), %xmm0
callq 0xc6b0
vmulss 0x28(%rsp), %xmm0, %xmm0
movq 0x20(%rsp), %rax
vmovss %xmm0, (%rax)
vmovss 0x10(%rsp), %xmm0
callq 0xc7f0
vmulss 0x28(%rsp), %xmm0, %xmm0
movq 0x18(%rsp), %rax
vmovss %xmm0, (%rax)
addq $0x48, %rsp
retq
nopl (%rax)
| rope_yarn:
sub rsp, 48h
vmovss [rsp+48h+var_4], xmm0
vmovss [rsp+48h+var_8], xmm1
mov [rsp+48h+var_10], rdi
mov [rsp+48h+var_18], rsi
vmovss [rsp+48h+var_1C], xmm2
vmovss [rsp+48h+var_20], xmm3
mov [rsp+48h+var_28], rdx
mov [rsp+48h+var_30], rcx
vmovss xmm0, [rsp+48h+var_8]
vmulss xmm0, xmm0, [rsp+48h+var_4]
vmovss [rsp+48h+var_34], xmm0
vmovss xmm0, [rsp+48h+var_34]
vmovss [rsp+48h+var_38], xmm0
vmovss xmm0, [rsp+48h+var_1C]
vpxor xmm1, xmm1, xmm1
vucomiss xmm0, xmm1
jnz short loc_34D65
jp short loc_34D65
jmp loc_34DF3
loc_34D65:
mov rax, [rsp+48h+var_10]
vmovss xmm0, dword ptr [rax]
mov rax, [rsp+48h+var_10]
vmovss xmm1, dword ptr [rax+4]
mov rax, [rsp+48h+var_18]
mov edi, eax
call rope_yarn_ramp
vmulss xmm0, xmm0, [rsp+48h+var_1C]
vmovss [rsp+48h+var_3C], xmm0
vmovss xmm1, [rsp+48h+var_34]
vmovss xmm0, cs:dword_B1ABC
vsubss xmm0, xmm0, [rsp+48h+var_3C]
vmovss xmm2, [rsp+48h+var_4]
vmulss xmm2, xmm2, [rsp+48h+var_3C]
vfmadd213ss xmm0, xmm1, xmm2
vmovss [rsp+48h+var_38], xmm0
vmovss xmm0, cs:dword_B1ABC
vdivss xmm0, xmm0, [rsp+48h+var_8]
call _logf
vmovaps xmm1, xmm0
vmovss xmm2, cs:dword_B1ABC
vmovss xmm0, cs:dword_B1AE8
vfmadd213ss xmm0, xmm1, xmm2
vmulss xmm0, xmm0, [rsp+48h+var_20]
vmovss [rsp+48h+var_20], xmm0
loc_34DF3:
vmovss xmm0, [rsp+48h+var_38]
call _cosf
vmulss xmm0, xmm0, [rsp+48h+var_20]
mov rax, [rsp+48h+var_28]
vmovss dword ptr [rax], xmm0
vmovss xmm0, [rsp+48h+var_38]
call _sinf
vmulss xmm0, xmm0, [rsp+48h+var_20]
mov rax, [rsp+48h+var_30]
vmovss dword ptr [rax], xmm0
add rsp, 48h
retn
| long long rope_yarn(
long long a1,
unsigned int a2,
long long a3,
long long a4,
__m128 _XMM0,
__m128 _XMM1,
__m128 _XMM2,
__m128 _XMM3)
{
long long result; // rax
__asm
{
vmovss [rsp+48h+var_4], xmm0
vmovss [rsp+48h+var_8], xmm1
vmovss [rsp+48h+var_1C], xmm2
vmovss [rsp+48h+var_20], xmm3
vmovss xmm0, [rsp+48h+var_8]
vmulss xmm0, xmm0, [rsp+48h+var_4]
vmovss [rsp+48h+var_34], xmm0
vmovss xmm0, [rsp+48h+var_34]
vmovss [rsp+48h+var_38], xmm0
vmovss xmm0, [rsp+48h+var_1C]
vpxor xmm1, xmm1, xmm1
vucomiss xmm0, xmm1
}
_RAX = a1;
__asm
{
vmovss xmm0, dword ptr [rax]
vmovss xmm1, dword ptr [rax+4]
}
*(double *)&_XMM0 = rope_yarn_ramp(a2, *(double *)&_XMM0, *(double *)&_XMM1);
__asm
{
vmulss xmm0, xmm0, [rsp+48h+var_1C]
vmovss [rsp+48h+var_3C], xmm0
vmovss xmm1, [rsp+48h+var_34]
vmovss xmm0, cs:dword_B1ABC
vsubss xmm0, xmm0, [rsp+48h+var_3C]
vmovss xmm2, [rsp+48h+var_4]
vmulss xmm2, xmm2, [rsp+48h+var_3C]
vfmadd213ss xmm0, xmm1, xmm2
vmovss [rsp+48h+var_38], xmm0
vmovss xmm0, cs:dword_B1ABC
vdivss xmm0, xmm0, [rsp+48h+var_8]
}
*(double *)&_XMM0 = logf(*(double *)&_XMM0);
__asm
{
vmovaps xmm1, xmm0
vmovss xmm2, cs:dword_B1ABC
vmovss xmm0, cs:dword_B1AE8
vfmadd213ss xmm0, xmm1, xmm2
vmulss xmm0, xmm0, [rsp+48h+var_20]
vmovss [rsp+48h+var_20], xmm0
vmovss xmm0, [rsp+48h+var_38]
}
*(double *)&_XMM0 = cosf(*(double *)&_XMM0);
__asm { vmulss xmm0, xmm0, [rsp+48h+var_20] }
_RAX = a3;
__asm
{
vmovss dword ptr [rax], xmm0
vmovss xmm0, [rsp+48h+var_38]
}
*(double *)&_XMM0 = sinf(*(double *)&_XMM0);
__asm { vmulss xmm0, xmm0, [rsp+48h+var_20] }
result = a4;
__asm { vmovss dword ptr [rax], xmm0 }
return result;
}
| rope_yarn:
SUB RSP,0x48
VMOVSS dword ptr [RSP + 0x44],XMM0
VMOVSS dword ptr [RSP + 0x40],XMM1
MOV qword ptr [RSP + 0x38],RDI
MOV qword ptr [RSP + 0x30],RSI
VMOVSS dword ptr [RSP + 0x2c],XMM2
VMOVSS dword ptr [RSP + 0x28],XMM3
MOV qword ptr [RSP + 0x20],RDX
MOV qword ptr [RSP + 0x18],RCX
VMOVSS XMM0,dword ptr [RSP + 0x40]
VMULSS XMM0,XMM0,dword ptr [RSP + 0x44]
VMOVSS dword ptr [RSP + 0x14],XMM0
VMOVSS XMM0,dword ptr [RSP + 0x14]
VMOVSS dword ptr [RSP + 0x10],XMM0
VMOVSS XMM0,dword ptr [RSP + 0x2c]
VPXOR XMM1,XMM1,XMM1
VUCOMISS XMM0,XMM1
JNZ 0x00134d65
JP 0x00134d65
JMP 0x00134df3
LAB_00134d65:
MOV RAX,qword ptr [RSP + 0x38]
VMOVSS XMM0,dword ptr [RAX]
MOV RAX,qword ptr [RSP + 0x38]
VMOVSS XMM1,dword ptr [RAX + 0x4]
MOV RAX,qword ptr [RSP + 0x30]
MOV EDI,EAX
CALL 0x00134e30
VMULSS XMM0,XMM0,dword ptr [RSP + 0x2c]
VMOVSS dword ptr [RSP + 0xc],XMM0
VMOVSS XMM1,dword ptr [RSP + 0x14]
VMOVSS XMM0,dword ptr [0x001b1abc]
VSUBSS XMM0,XMM0,dword ptr [RSP + 0xc]
VMOVSS XMM2,dword ptr [RSP + 0x44]
VMULSS XMM2,XMM2,dword ptr [RSP + 0xc]
VFMADD213SS XMM0,XMM1,XMM2
VMOVSS dword ptr [RSP + 0x10],XMM0
VMOVSS XMM0,dword ptr [0x001b1abc]
VDIVSS XMM0,XMM0,dword ptr [RSP + 0x40]
CALL 0x0010d2c0
VMOVAPS XMM1,XMM0
VMOVSS XMM2,dword ptr [0x001b1abc]
VMOVSS XMM0,dword ptr [0x001b1ae8]
VFMADD213SS XMM0,XMM1,XMM2
VMULSS XMM0,XMM0,dword ptr [RSP + 0x28]
VMOVSS dword ptr [RSP + 0x28],XMM0
LAB_00134df3:
VMOVSS XMM0,dword ptr [RSP + 0x10]
CALL 0x0010c6b0
VMULSS XMM0,XMM0,dword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x20]
VMOVSS dword ptr [RAX],XMM0
VMOVSS XMM0,dword ptr [RSP + 0x10]
CALL 0x0010c7f0
VMULSS XMM0,XMM0,dword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x18]
VMOVSS dword ptr [RAX],XMM0
ADD RSP,0x48
RET
|
void rope_yarn(float param_1,float param_2,float param_3,float param_4,int4 *param_5,
int4 param_6,float *param_7,float *param_8)
{
int1 auVar1 [16];
float fVar2;
int1 auVar3 [64];
float local_38;
float local_20;
int1 extraout_var [60];
local_38 = param_2 * param_1;
if ((param_3 != 0.0) || (local_20 = param_4, NAN(param_3))) {
fVar2 = (float)rope_yarn_ramp(*param_5,param_5[1],param_6);
auVar1 = vfmadd213ss_fma(ZEXT416((uint)(DAT_001b1abc - fVar2 * param_3)),ZEXT416((uint)local_38)
,ZEXT416((uint)(param_1 * fVar2 * param_3)));
local_38 = auVar1._0_4_;
auVar3._0_4_ = logf(DAT_001b1abc / param_2);
auVar3._4_60_ = extraout_var;
auVar1 = vfmadd213ss_fma(ZEXT416(DAT_001b1ae8),auVar3._0_16_,ZEXT416((uint)DAT_001b1abc));
local_20 = auVar1._0_4_ * param_4;
}
fVar2 = cosf(local_38);
*param_7 = fVar2 * local_20;
fVar2 = sinf(local_38);
*param_8 = fVar2 * local_20;
return;
}
| |
47,203 | ma_get_binary_pack_key | eloqsql/storage/maria/ma_search.c | uint _ma_get_binary_pack_key(MARIA_KEY *int_key, uint page_flag, uint nod_flag,
register uchar **page_pos)
{
reg1 HA_KEYSEG *keyseg;
uchar *page, *page_end, *from, *from_end, *key;
uint length,tmp;
MARIA_KEYDEF *keyinfo= int_key->keyinfo;
DBUG_ENTER("_ma_get_binary_pack_key");
page= *page_pos;
page_end=page + MARIA_MAX_KEY_BUFF + 1;
key= int_key->data;
/*
Keys are compressed the following way:
prefix length Packed length of prefix common with prev key.
(1 or 3 bytes)
for each key segment:
[is null] Null indicator if can be null (1 byte, zero means null)
[length] Packed length if varlength (1 or 3 bytes)
key segment 'length' bytes of key segment value
pointer Reference to the data file (last_keyseg->length).
get_key_length() is a macro. It gets the prefix length from 'page'
and puts it into 'length'. It increments 'page' by 1 or 3, depending
on the packed length of the prefix length.
*/
get_key_length(length,page);
if (length)
{
if (length > keyinfo->maxlength)
{
DBUG_PRINT("error",
("Found too long binary packed key: %u of %u at %p",
length, keyinfo->maxlength, *page_pos));
DBUG_DUMP("key", *page_pos, 16);
_ma_set_fatal_error_with_share(keyinfo->share, HA_ERR_CRASHED);
DBUG_RETURN(0); /* Wrong key */
}
/* Key is packed against prev key, take prefix from prev key. */
from= key;
from_end= key + length;
}
else
{
/* Key is not packed against prev key, take all from page buffer. */
from= page;
from_end= page_end;
}
/*
The trouble is that key can be split in two parts:
The first part (prefix) is in from .. from_end - 1.
The second part starts at page.
The split can be at every byte position. So we need to check for
the end of the first part before using every byte.
*/
for (keyseg=keyinfo->seg ; keyseg->type ;keyseg++)
{
if (keyseg->flag & HA_NULL_PART)
{
/* If prefix is used up, switch to rest. */
if (from == from_end)
{
from=page;
from_end=page_end;
}
if (!(*key++ = *from++))
continue; /* Null part */
}
if (keyseg->flag & (HA_VAR_LENGTH_PART | HA_BLOB_PART | HA_SPACE_PACK))
{
/* If prefix is used up, switch to rest. */
if (from == from_end) { from=page; from_end=page_end; }
/* Get length of dynamic length key part */
if ((length= (uint) (uchar) (*key++ = *from++)) == 255)
{
/* If prefix is used up, switch to rest. */
if (from == from_end) { from=page; from_end=page_end; }
length= ((uint) (uchar) ((*key++ = *from++))) << 8;
/* If prefix is used up, switch to rest. */
if (from == from_end) { from=page; from_end=page_end; }
length+= (uint) (uchar) ((*key++ = *from++));
}
}
else
length=keyseg->length;
if ((tmp=(uint) (from_end-from)) <= length)
{
key+=tmp; /* Use old key */
length-=tmp;
from=page; from_end=page_end;
}
DBUG_ASSERT((int) length >= 0);
DBUG_PRINT("info",("key: %p from: %p length: %u",
key, from, length));
memmove(key, from, (size_t) length);
key+=length;
from+=length;
}
/*
Last segment (type == 0) contains length of data pointer.
If we have mixed key blocks with data pointer and key block pointer,
we have to copy both.
*/
int_key->data_length= (uint)(key - int_key->data);
int_key->ref_length= length= keyseg->length;
int_key->flag= 0;
if ((tmp=(uint) (from_end-from)) <= length)
{
/* Skip over the last common part of the data */
key+= tmp;
length-= tmp;
from= page;
}
else
{
/*
Remaining length is greater than max possible length.
This can happen only if we switched to the new key bytes already.
'page_end' is calculated with MARIA_MAX_KEY_BUFF. So it can be far
behind the real end of the key.
*/
if (from_end != page_end)
{
DBUG_PRINT("error",("Error when unpacking key"));
_ma_set_fatal_error_with_share(keyinfo->share, HA_ERR_CRASHED);
DBUG_RETURN(0); /* Error */
}
}
if (page_flag & KEYPAGE_FLAG_HAS_TRANSID)
{
uchar *end= from + length;
if (key_has_transid(end-1))
{
uint trans_length= transid_packed_length(end);
length+= trans_length;
int_key->ref_length+= trans_length;
int_key->flag= SEARCH_PAGE_KEY_HAS_TRANSID;
}
}
/* Copy rest of data ptr and, if appropriate, trans_id and node_ptr */
memcpy(key, from, length + nod_flag);
*page_pos= from + length + nod_flag;
#ifdef USEFUL_FOR_DEBUGGING
DBUG_DUMP("key", int_key->data,
(uint) (int_key->data_length + int_key->ref_length));
#endif
DBUG_RETURN(int_key->data_length + int_key->ref_length);
} | O3 | c | ma_get_binary_pack_key:
movq (%rcx), %r8
movzbl (%r8), %eax
cmpl $0xff, %eax
je 0x578ee
movl $0x1, %r9d
jmp 0x57900
movzwl 0x1(%r8), %eax
rolw $0x8, %ax
movzwl %ax, %eax
movl $0x3, %r9d
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq (%rdi), %r13
movq 0x8(%rdi), %r10
leaq 0x9d4(%r8), %r11
addq %r8, %r9
movq %r9, %r12
movq %r11, %r14
testl %eax, %eax
je 0x5794a
movzwl 0xae(%r10), %r8d
cmpl %r8d, %eax
jbe 0x57941
movq (%r10), %rdi
jmp 0x57abc
movl %eax, %r14d
addq %r13, %r14
movq %r13, %r12
movl %esi, -0x34(%rbp)
movq %rdx, -0x48(%rbp)
movq %rcx, -0x50(%rbp)
movq %rdi, -0x30(%rbp)
movq %r10, -0x40(%rbp)
movq 0xc0(%r10), %rbx
cmpb $0x0, 0x18(%rbx)
je 0x57a82
movq %r9, -0x60(%rbp)
movq %r11, -0x58(%rbp)
movzwl 0x12(%rbx), %eax
testb $0x10, %al
jne 0x57983
movq %r14, %rcx
jmp 0x579af
movq %r9, %rax
movq %r11, %rcx
cmpq %r14, %r12
je 0x57994
movq %r12, %rax
movq %r14, %rcx
movb (%rax), %dl
movq %rax, %r12
incq %r12
movb %dl, (%r13)
incq %r13
testb %dl, %dl
je 0x57a74
movzwl 0x12(%rbx), %eax
testb $0x29, %al
je 0x579dd
movq %r9, %rdx
movq %r11, %r14
cmpq %rcx, %r12
je 0x579c4
movq %r12, %rdx
movq %rcx, %r14
movzbl (%rdx), %eax
movq %rdx, %r12
incq %r12
movb %al, (%r13)
cmpl $0xff, %eax
je 0x579e6
incq %r13
jmp 0x57a27
movzwl 0x14(%rbx), %eax
movq %rcx, %r14
jmp 0x57a27
movq %r9, %rcx
movq %r11, %rdx
cmpq %r14, %r12
je 0x579f7
movq %r12, %rcx
movq %r14, %rdx
movzbl (%rcx), %eax
incq %rcx
movb %al, 0x1(%r13)
movq %r9, %r12
movq %r11, %r14
cmpq %rdx, %rcx
je 0x57a12
movq %rcx, %r12
movq %rdx, %r14
shll $0x8, %eax
movzbl (%r12), %ecx
incq %r12
movb %cl, 0x2(%r13)
addq $0x3, %r13
orl %ecx, %eax
movq %r14, %rdx
subq %r12, %rdx
movl %eax, %ecx
subl %edx, %ecx
jae 0x57a37
movl %eax, %ecx
jmp 0x57a42
movl %edx, %eax
addq %rax, %r13
movq %r9, %r12
movq %r11, %r14
movl %ecx, %r15d
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x29120
addq %r15, %r13
addq %r15, %r12
movq -0x60(%rbp), %r9
movq -0x58(%rbp), %r11
leaq 0x20(%rbx), %rax
cmpb $0x0, 0x38(%rbx)
movq %rax, %rbx
jne 0x57976
jmp 0x57a79
movq %rcx, %r14
jmp 0x57a61
movq -0x30(%rbp), %rsi
movq (%rsi), %rcx
jmp 0x57a8c
movq %r13, %rcx
movq %rbx, %rax
movq -0x30(%rbp), %rsi
movl %r13d, %edx
subl %ecx, %edx
movl %edx, 0x10(%rsi)
movzwl 0x14(%rax), %eax
movl %eax, 0x14(%rsi)
movl $0x0, 0x18(%rsi)
movq %r14, %rcx
subq %r12, %rcx
movl %eax, %ebx
subl %ecx, %ebx
jae 0x57aca
movl %eax, %ebx
cmpq %r11, %r14
je 0x57ad2
movq -0x40(%rbp), %rax
movq (%rax), %rdi
movl $0x7e, %esi
callq 0x36a82
xorl %eax, %eax
jmp 0x57b3c
movl %ecx, %ecx
addq %rcx, %r13
movq %r9, %r12
testb $0x2, -0x34(%rbp)
je 0x57b0d
movl %ebx, %ecx
testb $0x1, -0x1(%r12,%rcx)
je 0x57b0d
movzbl (%r12,%rcx), %ecx
leal -0xf8(%rcx), %edx
cmpl $0xf3, %ecx
movl $0x1, %ecx
cmovael %edx, %ecx
addl %ecx, %ebx
addl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x14(%rax)
movl $0x100000, 0x18(%rax) # imm = 0x100000
movq -0x48(%rbp), %r14
leal (%rbx,%r14), %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x29080
movl %ebx, %eax
movl %r14d, %ecx
addq %r12, %rcx
addq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movl 0x14(%rcx), %eax
addl 0x10(%rcx), %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ma_get_binary_pack_key:
mov r8, [rcx]
movzx eax, byte ptr [r8]
cmp eax, 0FFh
jz short loc_578EE
mov r9d, 1
jmp short loc_57900
loc_578EE:
movzx eax, word ptr [r8+1]
rol ax, 8
movzx eax, ax
mov r9d, 3
loc_57900:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r13, [rdi]
mov r10, [rdi+8]
lea r11, [r8+9D4h]
add r9, r8
mov r12, r9
mov r14, r11
test eax, eax
jz short loc_5794A
movzx r8d, word ptr [r10+0AEh]
cmp eax, r8d
jbe short loc_57941
mov rdi, [r10]
jmp loc_57ABC
loc_57941:
mov r14d, eax
add r14, r13
mov r12, r13
loc_5794A:
mov [rbp-34h], esi
mov [rbp-48h], rdx
mov [rbp-50h], rcx
mov [rbp-30h], rdi
mov [rbp-40h], r10
mov rbx, [r10+0C0h]
cmp byte ptr [rbx+18h], 0
jz loc_57A82
mov [rbp-60h], r9
mov [rbp-58h], r11
loc_57976:
movzx eax, word ptr [rbx+12h]
test al, 10h
jnz short loc_57983
mov rcx, r14
jmp short loc_579AF
loc_57983:
mov rax, r9
mov rcx, r11
cmp r12, r14
jz short loc_57994
mov rax, r12
mov rcx, r14
loc_57994:
mov dl, [rax]
mov r12, rax
inc r12
mov [r13+0], dl
inc r13
test dl, dl
jz loc_57A74
movzx eax, word ptr [rbx+12h]
loc_579AF:
test al, 29h
jz short loc_579DD
mov rdx, r9
mov r14, r11
cmp r12, rcx
jz short loc_579C4
mov rdx, r12
mov r14, rcx
loc_579C4:
movzx eax, byte ptr [rdx]
mov r12, rdx
inc r12
mov [r13+0], al
cmp eax, 0FFh
jz short loc_579E6
inc r13
jmp short loc_57A27
loc_579DD:
movzx eax, word ptr [rbx+14h]
mov r14, rcx
jmp short loc_57A27
loc_579E6:
mov rcx, r9
mov rdx, r11
cmp r12, r14
jz short loc_579F7
mov rcx, r12
mov rdx, r14
loc_579F7:
movzx eax, byte ptr [rcx]
inc rcx
mov [r13+1], al
mov r12, r9
mov r14, r11
cmp rcx, rdx
jz short loc_57A12
mov r12, rcx
mov r14, rdx
loc_57A12:
shl eax, 8
movzx ecx, byte ptr [r12]
inc r12
mov [r13+2], cl
add r13, 3
or eax, ecx
loc_57A27:
mov rdx, r14
sub rdx, r12
mov ecx, eax
sub ecx, edx
jnb short loc_57A37
mov ecx, eax
jmp short loc_57A42
loc_57A37:
mov eax, edx
add r13, rax
mov r12, r9
mov r14, r11
loc_57A42:
mov r15d, ecx
mov rdi, r13
mov rsi, r12
mov rdx, r15
call _memmove
add r13, r15
add r12, r15
mov r9, [rbp-60h]
mov r11, [rbp-58h]
loc_57A61:
lea rax, [rbx+20h]
cmp byte ptr [rbx+38h], 0
mov rbx, rax
jnz loc_57976
jmp short loc_57A79
loc_57A74:
mov r14, rcx
jmp short loc_57A61
loc_57A79:
mov rsi, [rbp-30h]
mov rcx, [rsi]
jmp short loc_57A8C
loc_57A82:
mov rcx, r13
mov rax, rbx
mov rsi, [rbp-30h]
loc_57A8C:
mov edx, r13d
sub edx, ecx
mov [rsi+10h], edx
movzx eax, word ptr [rax+14h]
mov [rsi+14h], eax
mov dword ptr [rsi+18h], 0
mov rcx, r14
sub rcx, r12
mov ebx, eax
sub ebx, ecx
jnb short loc_57ACA
mov ebx, eax
cmp r14, r11
jz short loc_57AD2
mov rax, [rbp-40h]
mov rdi, [rax]
loc_57ABC:
mov esi, 7Eh ; '~'
call _ma_set_fatal_error_with_share
xor eax, eax
jmp short loc_57B3C
loc_57ACA:
mov ecx, ecx
add r13, rcx
mov r12, r9
loc_57AD2:
test byte ptr [rbp-34h], 2
jz short loc_57B0D
mov ecx, ebx
test byte ptr [r12+rcx-1], 1
jz short loc_57B0D
movzx ecx, byte ptr [r12+rcx]
lea edx, [rcx-0F8h]
cmp ecx, 0F3h
mov ecx, 1
cmovnb ecx, edx
add ebx, ecx
add ecx, eax
mov rax, [rbp-30h]
mov [rax+14h], ecx
mov dword ptr [rax+18h], offset xmmword_100000
loc_57B0D:
mov r14, [rbp-48h]
lea edx, [rbx+r14]
mov rdi, r13
mov rsi, r12
call _memcpy
mov eax, ebx
mov ecx, r14d
add rcx, r12
add rcx, rax
mov rax, [rbp-50h]
mov [rax], rcx
mov rcx, [rbp-30h]
mov eax, [rcx+14h]
add eax, [rcx+10h]
loc_57B3C:
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ma_get_binary_pack_key(long long a1, char a2, long long a3, long long *a4)
{
long long v4; // r8
unsigned int v5; // eax
long long v6; // r9
unsigned __int8 *v7; // r13
long long v8; // r10
long long v9; // r11
unsigned __int8 *v10; // r9
unsigned __int8 *v11; // r12
unsigned __int8 *v12; // r14
long long v13; // rdi
long long v14; // rbx
__int16 v15; // ax
unsigned __int8 *v16; // rcx
unsigned __int8 *v17; // rax
unsigned __int8 v18; // dl
unsigned __int8 *v19; // rdx
unsigned int v20; // eax
unsigned __int8 *v21; // rcx
unsigned __int8 *v22; // rdx
int v23; // eax
unsigned __int8 *v24; // rcx
unsigned __int8 *v25; // r12
int v26; // ecx
unsigned int v27; // ecx
long long v28; // r15
long long v29; // rax
bool v30; // zf
long long v31; // rsi
unsigned __int8 *v32; // rcx
unsigned int v33; // eax
unsigned int v34; // ebx
unsigned int v36; // ecx
int v37; // edx
bool v38; // cf
int v39; // ecx
unsigned __int8 *v40; // [rsp-68h] [rbp-68h]
long long v41; // [rsp-60h] [rbp-60h]
long long *v42; // [rsp-58h] [rbp-58h]
int v43; // [rsp-50h] [rbp-50h]
long long *v44; // [rsp-48h] [rbp-48h]
v4 = *a4;
v5 = *(unsigned __int8 *)*a4;
if ( v5 == 255 )
{
v5 = (unsigned __int16)__ROL2__(*(_WORD *)(v4 + 1), 8);
v6 = 3LL;
}
else
{
v6 = 1LL;
}
v7 = *(unsigned __int8 **)a1;
v8 = *(_QWORD *)(a1 + 8);
v9 = v4 + 2516;
v10 = (unsigned __int8 *)(v4 + v6);
v11 = v10;
v12 = (unsigned __int8 *)(v4 + 2516);
if ( v5 )
{
v4 = *(unsigned __int16 *)(v8 + 174);
if ( v5 > (unsigned int)v4 )
{
v13 = *(_QWORD *)v8;
LABEL_38:
ma_set_fatal_error_with_share(v13, 126, a3, (long long)a4, v4, (int)v10);
return 0LL;
}
v12 = &v7[v5];
v11 = *(unsigned __int8 **)a1;
}
v43 = a3;
v42 = a4;
v44 = *(long long **)(a1 + 8);
v14 = *(_QWORD *)(v8 + 192);
if ( *(_BYTE *)(v14 + 24) )
{
v40 = v10;
v41 = v9;
while ( 1 )
{
v15 = *(_WORD *)(v14 + 18);
if ( (v15 & 0x10) == 0 )
break;
v17 = v10;
v16 = (unsigned __int8 *)v9;
if ( v11 != v12 )
{
v17 = v11;
v16 = v12;
}
v18 = *v17;
v11 = v17 + 1;
*v7++ = *v17;
if ( v18 )
{
v15 = *(_WORD *)(v14 + 18);
goto LABEL_16;
}
v12 = v16;
LABEL_31:
v29 = v14 + 32;
v30 = *(_BYTE *)(v14 + 56) == 0;
v14 += 32LL;
if ( v30 )
{
v31 = a1;
v32 = *(unsigned __int8 **)a1;
goto LABEL_35;
}
}
v16 = v12;
LABEL_16:
if ( (v15 & 0x29) != 0 )
{
v19 = v10;
v12 = (unsigned __int8 *)v9;
if ( v11 != v16 )
{
v19 = v11;
v12 = v16;
}
v20 = *v19;
v11 = v19 + 1;
*v7 = v20;
if ( v20 == 255 )
{
v21 = v10;
v22 = (unsigned __int8 *)v9;
if ( v11 != v12 )
{
v21 = v11;
v22 = v12;
}
v23 = *v21;
v24 = v21 + 1;
v7[1] = v23;
v25 = v10;
v12 = (unsigned __int8 *)v9;
if ( v24 != v22 )
{
v25 = v24;
v12 = v22;
}
v26 = *v25;
v11 = v25 + 1;
v7[2] = v26;
v7 += 3;
v20 = v26 | (v23 << 8);
}
else
{
++v7;
}
}
else
{
v20 = *(unsigned __int16 *)(v14 + 20);
v12 = v16;
}
v27 = v20 - ((_DWORD)v12 - (_DWORD)v11);
if ( v20 >= (int)v12 - (int)v11 )
{
v7 += (unsigned int)((_DWORD)v12 - (_DWORD)v11);
v11 = v10;
v12 = (unsigned __int8 *)v9;
}
else
{
v27 = v20;
}
v28 = v27;
memmove(v7, v11, v27);
v7 += v28;
v11 += v28;
v10 = v40;
v9 = v41;
goto LABEL_31;
}
LODWORD(v32) = *(_QWORD *)a1;
v29 = *(_QWORD *)(v8 + 192);
v31 = a1;
LABEL_35:
a3 = (unsigned int)((_DWORD)v7 - (_DWORD)v32);
*(_DWORD *)(v31 + 16) = a3;
v33 = *(unsigned __int16 *)(v29 + 20);
*(_QWORD *)(v31 + 20) = v33;
a4 = (long long *)(v12 - v11);
v34 = v33 - ((_DWORD)v12 - (_DWORD)v11);
if ( v33 >= (int)v12 - (int)v11 )
{
v7 += (unsigned int)a4;
v11 = v10;
}
else
{
v34 = v33;
if ( v12 != (unsigned __int8 *)v9 )
{
v13 = *v44;
goto LABEL_38;
}
}
if ( (a2 & 2) != 0 && (v11[v34 - 1] & 1) != 0 )
{
v36 = v11[v34];
v37 = v36 - 248;
v38 = v36 < 0xF3;
v39 = 1;
if ( !v38 )
v39 = v37;
v34 += v39;
*(_DWORD *)(a1 + 20) = v33 + v39;
*(_DWORD *)(a1 + 24) = (_DWORD)&xmmword_100000;
}
memcpy(v7, v11, v34 + v43);
*v42 = (long long)&v11[v43 + v34];
return (unsigned int)(*(_DWORD *)(a1 + 16) + *(_DWORD *)(a1 + 20));
}
| _ma_get_binary_pack_key:
MOV R8,qword ptr [RCX]
MOVZX EAX,byte ptr [R8]
CMP EAX,0xff
JZ 0x001578ee
MOV R9D,0x1
JMP 0x00157900
LAB_001578ee:
MOVZX EAX,word ptr [R8 + 0x1]
ROL AX,0x8
MOVZX EAX,AX
MOV R9D,0x3
LAB_00157900:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R13,qword ptr [RDI]
MOV R10,qword ptr [RDI + 0x8]
LEA R11,[R8 + 0x9d4]
ADD R9,R8
MOV R12,R9
MOV R14,R11
TEST EAX,EAX
JZ 0x0015794a
MOVZX R8D,word ptr [R10 + 0xae]
CMP EAX,R8D
JBE 0x00157941
MOV RDI,qword ptr [R10]
JMP 0x00157abc
LAB_00157941:
MOV R14D,EAX
ADD R14,R13
MOV R12,R13
LAB_0015794a:
MOV dword ptr [RBP + -0x34],ESI
MOV qword ptr [RBP + -0x48],RDX
MOV qword ptr [RBP + -0x50],RCX
MOV qword ptr [RBP + -0x30],RDI
MOV qword ptr [RBP + -0x40],R10
MOV RBX,qword ptr [R10 + 0xc0]
CMP byte ptr [RBX + 0x18],0x0
JZ 0x00157a82
MOV qword ptr [RBP + -0x60],R9
MOV qword ptr [RBP + -0x58],R11
LAB_00157976:
MOVZX EAX,word ptr [RBX + 0x12]
TEST AL,0x10
JNZ 0x00157983
MOV RCX,R14
JMP 0x001579af
LAB_00157983:
MOV RAX,R9
MOV RCX,R11
CMP R12,R14
JZ 0x00157994
MOV RAX,R12
MOV RCX,R14
LAB_00157994:
MOV DL,byte ptr [RAX]
MOV R12,RAX
INC R12
MOV byte ptr [R13],DL
INC R13
TEST DL,DL
JZ 0x00157a74
MOVZX EAX,word ptr [RBX + 0x12]
LAB_001579af:
TEST AL,0x29
JZ 0x001579dd
MOV RDX,R9
MOV R14,R11
CMP R12,RCX
JZ 0x001579c4
MOV RDX,R12
MOV R14,RCX
LAB_001579c4:
MOVZX EAX,byte ptr [RDX]
MOV R12,RDX
INC R12
MOV byte ptr [R13],AL
CMP EAX,0xff
JZ 0x001579e6
INC R13
JMP 0x00157a27
LAB_001579dd:
MOVZX EAX,word ptr [RBX + 0x14]
MOV R14,RCX
JMP 0x00157a27
LAB_001579e6:
MOV RCX,R9
MOV RDX,R11
CMP R12,R14
JZ 0x001579f7
MOV RCX,R12
MOV RDX,R14
LAB_001579f7:
MOVZX EAX,byte ptr [RCX]
INC RCX
MOV byte ptr [R13 + 0x1],AL
MOV R12,R9
MOV R14,R11
CMP RCX,RDX
JZ 0x00157a12
MOV R12,RCX
MOV R14,RDX
LAB_00157a12:
SHL EAX,0x8
MOVZX ECX,byte ptr [R12]
INC R12
MOV byte ptr [R13 + 0x2],CL
ADD R13,0x3
OR EAX,ECX
LAB_00157a27:
MOV RDX,R14
SUB RDX,R12
MOV ECX,EAX
SUB ECX,EDX
JNC 0x00157a37
MOV ECX,EAX
JMP 0x00157a42
LAB_00157a37:
MOV EAX,EDX
ADD R13,RAX
MOV R12,R9
MOV R14,R11
LAB_00157a42:
MOV R15D,ECX
MOV RDI,R13
MOV RSI,R12
MOV RDX,R15
CALL 0x00129120
ADD R13,R15
ADD R12,R15
MOV R9,qword ptr [RBP + -0x60]
MOV R11,qword ptr [RBP + -0x58]
LAB_00157a61:
LEA RAX,[RBX + 0x20]
CMP byte ptr [RBX + 0x38],0x0
MOV RBX,RAX
JNZ 0x00157976
JMP 0x00157a79
LAB_00157a74:
MOV R14,RCX
JMP 0x00157a61
LAB_00157a79:
MOV RSI,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RSI]
JMP 0x00157a8c
LAB_00157a82:
MOV RCX,R13
MOV RAX,RBX
MOV RSI,qword ptr [RBP + -0x30]
LAB_00157a8c:
MOV EDX,R13D
SUB EDX,ECX
MOV dword ptr [RSI + 0x10],EDX
MOVZX EAX,word ptr [RAX + 0x14]
MOV dword ptr [RSI + 0x14],EAX
MOV dword ptr [RSI + 0x18],0x0
MOV RCX,R14
SUB RCX,R12
MOV EBX,EAX
SUB EBX,ECX
JNC 0x00157aca
MOV EBX,EAX
CMP R14,R11
JZ 0x00157ad2
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RAX]
LAB_00157abc:
MOV ESI,0x7e
CALL 0x00136a82
XOR EAX,EAX
JMP 0x00157b3c
LAB_00157aca:
MOV ECX,ECX
ADD R13,RCX
MOV R12,R9
LAB_00157ad2:
TEST byte ptr [RBP + -0x34],0x2
JZ 0x00157b0d
MOV ECX,EBX
TEST byte ptr [R12 + RCX*0x1 + -0x1],0x1
JZ 0x00157b0d
MOVZX ECX,byte ptr [R12 + RCX*0x1]
LEA EDX,[RCX + -0xf8]
CMP ECX,0xf3
MOV ECX,0x1
CMOVNC ECX,EDX
ADD EBX,ECX
ADD ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x14],ECX
MOV dword ptr [RAX + 0x18],0x100000
LAB_00157b0d:
MOV R14,qword ptr [RBP + -0x48]
LEA EDX,[RBX + R14*0x1]
MOV RDI,R13
MOV RSI,R12
CALL 0x00129080
MOV EAX,EBX
MOV ECX,R14D
ADD RCX,R12
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RCX + 0x14]
ADD EAX,dword ptr [RCX + 0x10]
LAB_00157b3c:
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int _ma_get_binary_pack_key(int8 *param_1,uint param_2,uint param_3,int8 *param_4)
{
char *pcVar1;
byte *pbVar2;
byte bVar3;
byte bVar4;
int8 *puVar5;
ushort uVar6;
uint uVar7;
int iVar8;
byte *pbVar9;
uint uVar10;
byte *pbVar11;
uint uVar12;
long lVar13;
int8 uVar14;
long lVar15;
byte *pbVar16;
byte *pbVar17;
byte *__dest;
byte *pbVar18;
ulong __n;
pbVar16 = (byte *)*param_4;
uVar12 = (uint)*pbVar16;
if (*pbVar16 == 0xff) {
uVar12 = (uint)(ushort)(*(ushort *)(pbVar16 + 1) << 8 | *(ushort *)(pbVar16 + 1) >> 8);
lVar15 = 3;
}
else {
lVar15 = 1;
}
__dest = (byte *)*param_1;
puVar5 = (int8 *)param_1[1];
pbVar2 = pbVar16 + 0x9d4;
pbVar16 = pbVar16 + lVar15;
pbVar17 = pbVar16;
pbVar18 = pbVar2;
if (uVar12 == 0) {
LAB_0015794a:
lVar15 = puVar5[0x18];
lVar13 = lVar15;
if (*(char *)(lVar15 + 0x18) == '\0') {
iVar8 = (int)__dest;
}
else {
do {
uVar6 = *(ushort *)(lVar13 + 0x12);
if ((uVar6 & 0x10) == 0) {
LAB_001579af:
if ((uVar6 & 0x29) == 0) {
uVar12 = (uint)*(ushort *)(lVar13 + 0x14);
}
else {
pbVar9 = pbVar16;
pbVar11 = pbVar2;
if (pbVar17 != pbVar18) {
pbVar9 = pbVar17;
pbVar11 = pbVar18;
}
pbVar18 = pbVar11;
bVar3 = *pbVar9;
uVar12 = (uint)bVar3;
pbVar17 = pbVar9 + 1;
*__dest = bVar3;
if (bVar3 == 0xff) {
pbVar9 = pbVar16;
pbVar11 = pbVar2;
if (pbVar17 != pbVar18) {
pbVar9 = pbVar17;
pbVar11 = pbVar18;
}
bVar3 = *pbVar9;
__dest[1] = bVar3;
pbVar17 = pbVar16;
pbVar18 = pbVar2;
if (pbVar9 + 1 != pbVar11) {
pbVar17 = pbVar9 + 1;
pbVar18 = pbVar11;
}
bVar4 = *pbVar17;
pbVar17 = pbVar17 + 1;
__dest[2] = bVar4;
__dest = __dest + 3;
uVar12 = (uint)CONCAT11(bVar3,bVar4);
}
else {
__dest = __dest + 1;
}
}
uVar7 = (uint)((long)pbVar18 - (long)pbVar17);
pbVar11 = pbVar18;
if (uVar7 <= uVar12) {
__dest = __dest + ((long)pbVar18 - (long)pbVar17 & 0xffffffff);
pbVar17 = pbVar16;
pbVar11 = pbVar2;
uVar12 = uVar12 - uVar7;
}
__n = (ulong)uVar12;
memmove(__dest,pbVar17,__n);
__dest = __dest + __n;
pbVar17 = pbVar17 + __n;
}
else {
pbVar9 = pbVar16;
pbVar11 = pbVar2;
if (pbVar17 != pbVar18) {
pbVar9 = pbVar17;
pbVar11 = pbVar18;
}
bVar3 = *pbVar9;
pbVar17 = pbVar9 + 1;
*__dest = bVar3;
__dest = __dest + 1;
if (bVar3 != 0) {
uVar6 = *(ushort *)(lVar13 + 0x12);
pbVar18 = pbVar11;
goto LAB_001579af;
}
}
lVar15 = lVar13 + 0x20;
pcVar1 = (char *)(lVar13 + 0x38);
lVar13 = lVar15;
pbVar18 = pbVar11;
} while (*pcVar1 != '\0');
iVar8 = (int)*param_1;
}
*(int *)(param_1 + 2) = (int)__dest - iVar8;
uVar6 = *(ushort *)(lVar15 + 0x14);
uVar7 = (uint)uVar6;
*(uint *)((long)param_1 + 0x14) = uVar7;
*(int4 *)(param_1 + 3) = 0;
uVar10 = (uint)((long)pbVar18 - (long)pbVar17);
uVar12 = uVar7 - uVar10;
if (uVar7 < uVar10) {
pbVar16 = pbVar17;
uVar12 = (uint)uVar6;
if (pbVar18 != pbVar2) {
uVar14 = *puVar5;
goto LAB_00157abc;
}
}
else {
__dest = __dest + ((long)pbVar18 - (long)pbVar17 & 0xffffffff);
}
if (((param_2 & 2) != 0) && ((pbVar16[(ulong)uVar12 - 1] & 1) != 0)) {
iVar8 = 1;
if (0xf2 < pbVar16[uVar12]) {
iVar8 = pbVar16[uVar12] - 0xf8;
}
uVar12 = uVar12 + iVar8;
*(uint *)((long)param_1 + 0x14) = iVar8 + (uint)uVar6;
*(int4 *)(param_1 + 3) = 0x100000;
}
memcpy(__dest,pbVar16,(ulong)(uVar12 + param_3));
*param_4 = pbVar16 + (ulong)uVar12 + (ulong)param_3;
iVar8 = *(int *)((long)param_1 + 0x14) + *(int *)(param_1 + 2);
}
else {
if (uVar12 <= *(ushort *)((long)puVar5 + 0xae)) {
pbVar18 = __dest + uVar12;
pbVar17 = __dest;
goto LAB_0015794a;
}
uVar14 = *puVar5;
LAB_00157abc:
_ma_set_fatal_error_with_share(uVar14,0x7e);
iVar8 = 0;
}
return iVar8;
}
| |
47,204 | JS_SetPropertyFunctionList | bluesky950520[P]quickjs/quickjs.c | void JS_SetPropertyFunctionList(JSContext *ctx, JSValue obj,
const JSCFunctionListEntry *tab, int len)
{
int i;
for (i = 0; i < len; i++) {
const JSCFunctionListEntry *e = &tab[i];
JSAtom atom = find_atom(ctx, e->name);
JS_InstantiateFunctionListItem(ctx, obj, atom, e);
JS_FreeAtom(ctx, atom);
}
} | O1 | c | JS_SetPropertyFunctionList:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
testl %r8d, %r8d
jle 0x32f8b
movq %rcx, %rbx
movq %rdi, %r12
leaq 0x48(%rdi), %rax
movq %rax, 0x38(%rsp)
movl %r8d, %r14d
movq (%rbx), %rsi
movq %r12, %rdi
callq 0x32fa2
movl %eax, %r13d
movzbl 0x9(%rbx), %eax
cmpq $0x9, %rax
ja 0x32f9d
movzbl 0x8(%rbx), %edx
leaq 0x69ba8(%rip), %rcx # 0x9c86c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpq $0x0, 0x10(%rbx)
movl %edx, 0x1c(%rsp)
je 0x32e08
movq (%rbx), %rcx
movl $0x40, %esi
leaq 0x50(%rsp), %r15
movq %r15, %rdi
leaq 0x6cd88(%rip), %rdx # 0x9fa7b
xorl %eax, %eax
callq 0xe2d0
xorl %eax, %eax
cmpb $0x2, 0x9(%rbx)
movq 0x10(%rbx), %rsi
sete %al
leal 0x8(,%rax,2), %r8d
movswl 0xa(%rbx), %r9d
movq 0x38(%rsp), %rax
movups (%rax), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x21006
movq %rax, %r15
movq %rdx, %rbp
movl 0x1c(%rsp), %edx
jmp 0x32e10
cmpl $0xd3, %r13d
je 0x32eb8
cmpl $0xdc, %r13d
jne 0x32ebd
xorl %edx, %edx
jmp 0x32ebd
movl %edx, 0x1c(%rsp)
movq 0x10(%rbx), %rsi
movq %r12, %rdi
callq 0x32fa2
movl 0x18(%rbx), %ecx
cmpl $0x1, %ecx
movl %eax, 0x34(%rsp)
je 0x32ef5
testl %ecx, %ecx
je 0x32ee3
cmpl $-0x1, %ecx
jne 0x32f9d
movl $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
movq %r12, %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
jmp 0x32f15
movq 0x10(%rbx), %rbp
movl $0x7, %r15d
jmp 0x32f55
movl 0x10(%rbx), %ebp
xorl %r15d, %r15d
jmp 0x32f55
movq 0x10(%rbx), %rax
movslq %eax, %rcx
cmpq %rax, %rcx
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movl %ecx, %eax
movq %xmm0, %rbp
cmoveq %rax, %rbp
movl $0x7, %r15d
movl $0x0, %eax
cmoveq %rax, %r15
jmp 0x32f55
movl $0x3, %r15d
xorl %ebp, %ebp
jmp 0x32f55
movl $0x3, %ebp
xorl %r15d, %r15d
movl $0x0, 0x40(%rsp)
movq $0x3, 0x48(%rsp)
cmpq $0x0, 0x18(%rbx)
je 0x32e89
movq (%rbx), %rcx
movl $0x40, %esi
leaq 0x50(%rsp), %rdi
leaq 0x6cc46(%rip), %rdx # 0x9fa82
xorl %eax, %eax
callq 0xe2d0
xorl %eax, %eax
cmpb $0x2, 0x9(%rbx)
movq 0x18(%rbx), %rsi
sete %al
leal 0x9(,%rax,2), %r8d
movswl 0xa(%rbx), %r9d
movq 0x38(%rsp), %rax
movups (%rax), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
leaq 0x50(%rsp), %rdx
movl $0x1, %ecx
callq 0x21006
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movl 0x1c(%rsp), %edx
movupd 0x40(%rsp), %xmm0
movupd %xmm0, (%rsp)
movl %edx, 0x10(%rsp)
movq %r12, %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movl %r13d, %ecx
movq %r15, %r8
movq %rbp, %r9
callq 0x26cc9
jmp 0x32f73
movl $0x1, %edx
movl %edx, (%rsp)
movq %r12, %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movl %r13d, %ecx
movl $0x2, %r8d
movq %rbx, %r9
callq 0x41517
jmp 0x32f73
movq 0x1a0(%r12), %rsi
movq 0x1a8(%r12), %rdx
jmp 0x32f02
movq 0x40(%r12), %rcx
movq 0x20(%rcx), %rsi
movq 0x28(%rcx), %rdx
movl $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
movq %r12, %rdi
movl %eax, %ecx
movq %rsi, %r8
movq %rdx, %r9
callq 0x22fa3
movq %rax, %rbp
movq %rdx, %r15
movq %r12, %rdi
movl 0x34(%rsp), %esi
callq 0x207d8
cmpl $0xd3, %r13d
je 0x32f4a
cmpl $0xdc, %r13d
jne 0x32f51
xorl %edx, %edx
jmp 0x32f55
movl $0x1, %edx
jmp 0x32f55
movl 0x1c(%rsp), %edx
movl %edx, (%rsp)
movq %r12, %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movl %r13d, %ecx
movq %rbp, %r8
movq %r15, %r9
callq 0x26abb
movq %r12, %rdi
movl %r13d, %esi
callq 0x207d8
addq $0x20, %rbx
decq %r14
jne 0x32c9d
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xe090
| JS_SetPropertyFunctionList:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 98h
mov [rsp+0C8h+var_A0], rdx
mov [rsp+0C8h+var_A8], rsi
test r8d, r8d
jle loc_32F8B
mov rbx, rcx
mov r12, rdi
lea rax, [rdi+48h]
mov [rsp+0C8h+var_90], rax
mov r14d, r8d
loc_32C9D:
mov rsi, [rbx]
mov rdi, r12
call find_atom
mov r13d, eax
movzx eax, byte ptr [rbx+9]
cmp rax, 9; switch 10 cases
ja def_32CCB; jumptable 0000000000032CCB default case
movzx edx, byte ptr [rbx+8]
lea rcx, jpt_32CCB
movsxd rax, ds:(jpt_32CCB - 9C86Ch)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_32CCD:
cmp qword ptr [rbx+10h], 0; jumptable 0000000000032CCB cases 1,2
mov [rsp+0C8h+var_AC], edx
jz loc_32E08
mov rcx, [rbx]
mov esi, 40h ; '@'
lea r15, [rsp+0C8h+var_78]
mov rdi, r15
lea rdx, aGetS; "get %s"
xor eax, eax
call _snprintf
xor eax, eax
cmp byte ptr [rbx+9], 2
mov rsi, [rbx+10h]
setz al
lea r8d, ds:8[rax*2]
movsx r9d, word ptr [rbx+0Ah]
mov rax, [rsp+0C8h+var_90]
movups xmm0, xmmword ptr [rax]
movups [rsp+0C8h+var_C8], xmm0
mov rdi, r12
mov rdx, r15
xor ecx, ecx
call JS_NewCFunction3
mov r15, rax
mov rbp, rdx
mov edx, [rsp+0C8h+var_AC]
jmp loc_32E10
loc_32D3C:
cmp r13d, 0D3h; jumptable 0000000000032CCB case 0
jz loc_32EB8
cmp r13d, 0DCh
jnz loc_32EBD; jumptable 0000000000032CCB cases 3,8
xor edx, edx
jmp loc_32EBD; jumptable 0000000000032CCB cases 3,8
loc_32D5D:
mov [rsp+0C8h+var_AC], edx; jumptable 0000000000032CCB case 9
mov rsi, [rbx+10h]
mov rdi, r12
call find_atom
mov ecx, [rbx+18h]
cmp ecx, 1
mov [rsp+0C8h+var_94], eax
jz loc_32EF5
test ecx, ecx
jz loc_32EE3
cmp ecx, 0FFFFFFFFh
jnz def_32CCB; jumptable 0000000000032CCB default case
mov dword ptr [rsp+0C8h+var_C8+8], 0
mov qword ptr [rsp+0C8h+var_C8], 0
mov rdi, r12
mov rsi, [rsp+0C8h+var_A8]
mov rdx, [rsp+0C8h+var_A0]
jmp loc_32F15
loc_32DB0:
mov rbp, [rbx+10h]; jumptable 0000000000032CCB case 6
mov r15d, 7
jmp loc_32F55
loc_32DBF:
mov ebp, [rbx+10h]; jumptable 0000000000032CCB case 4
xor r15d, r15d
jmp loc_32F55
loc_32DCA:
mov rax, [rbx+10h]; jumptable 0000000000032CCB case 5
movsxd rcx, eax
cmp rcx, rax
xorps xmm0, xmm0
cvtsi2sd xmm0, rax
mov eax, ecx
movq rbp, xmm0
cmovz rbp, rax
mov r15d, 7
mov eax, 0
cmovz r15, rax
jmp loc_32F55
loc_32DFB:
mov r15d, 3; jumptable 0000000000032CCB case 7
xor ebp, ebp
jmp loc_32F55
loc_32E08:
mov ebp, 3
xor r15d, r15d
loc_32E10:
mov dword ptr [rsp+0C8h+var_88], 0
mov qword ptr [rsp+0C8h+var_88+8], 3
cmp qword ptr [rbx+18h], 0
jz short loc_32E89
mov rcx, [rbx]
mov esi, 40h ; '@'
lea rdi, [rsp+0C8h+var_78]
lea rdx, aSetS; "set %s"
xor eax, eax
call _snprintf
xor eax, eax
cmp byte ptr [rbx+9], 2
mov rsi, [rbx+18h]
setz al
lea r8d, ds:9[rax*2]
movsx r9d, word ptr [rbx+0Ah]
mov rax, [rsp+0C8h+var_90]
movups xmm0, xmmword ptr [rax]
movups [rsp+0C8h+var_C8], xmm0
mov rdi, r12
lea rdx, [rsp+0C8h+var_78]
mov ecx, 1
call JS_NewCFunction3
mov qword ptr [rsp+0C8h+var_88], rax
mov qword ptr [rsp+0C8h+var_88+8], rdx
mov edx, [rsp+0C8h+var_AC]
loc_32E89:
movupd xmm0, [rsp+0C8h+var_88]
movupd [rsp+0C8h+var_C8], xmm0
mov [rsp+0C8h+var_B8], edx
mov rdi, r12
mov rsi, [rsp+0C8h+var_A8]
mov rdx, [rsp+0C8h+var_A0]
mov ecx, r13d
mov r8, r15
mov r9, rbp
call JS_DefinePropertyGetSet
jmp loc_32F73
loc_32EB8:
mov edx, 1
loc_32EBD:
mov dword ptr [rsp+0C8h+var_C8], edx; jumptable 0000000000032CCB cases 3,8
mov rdi, r12
mov rsi, [rsp+0C8h+var_A8]
mov rdx, [rsp+0C8h+var_A0]
mov ecx, r13d
mov r8d, 2
mov r9, rbx
call JS_DefineAutoInitProperty
jmp loc_32F73
loc_32EE3:
mov rsi, [r12+1A0h]
mov rdx, [r12+1A8h]
jmp short loc_32F02
loc_32EF5:
mov rcx, [r12+40h]
mov rsi, [rcx+20h]
mov rdx, [rcx+28h]
loc_32F02:
mov dword ptr [rsp+0C8h+var_C8+8], 0
mov qword ptr [rsp+0C8h+var_C8], 0
mov rdi, r12
loc_32F15:
mov ecx, eax
mov r8, rsi
mov r9, rdx
call JS_GetPropertyInternal2
mov rbp, rax
mov r15, rdx
mov rdi, r12
mov esi, [rsp+0C8h+var_94]
call JS_FreeAtom
cmp r13d, 0D3h
jz short loc_32F4A
cmp r13d, 0DCh
jnz short loc_32F51
xor edx, edx
jmp short loc_32F55
loc_32F4A:
mov edx, 1
jmp short loc_32F55
loc_32F51:
mov edx, [rsp+0C8h+var_AC]
loc_32F55:
mov dword ptr [rsp+0C8h+var_C8], edx
mov rdi, r12
mov rsi, [rsp+0C8h+var_A8]
mov rdx, [rsp+0C8h+var_A0]
mov ecx, r13d
mov r8, rbp
mov r9, r15
call JS_DefinePropertyValue
loc_32F73:
mov rdi, r12
mov esi, r13d
call JS_FreeAtom
add rbx, 20h ; ' '
dec r14
jnz loc_32C9D
loc_32F8B:
add rsp, 98h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
def_32CCB:
call _abort; jumptable 0000000000032CCB default case
| void JS_SetPropertyFunctionList(
long long a1,
unsigned long long a2,
long long a3,
const char **a4,
int a5,
double a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
long long v15; // r14
const char *v16; // rsi
const char *v17; // rdi
unsigned int atom; // r13d
__m128 v19; // xmm4
__m128 v20; // xmm5
__int128 v21; // rax
_DWORD *v22; // r15
long long v23; // rbp
int v24; // ecx
unsigned long long PropertyInternal2; // rax
long long v26; // rdx
double v27; // rbp
long long v28; // r15
const char *v29; // rax
long long v30; // rsi
long long v31; // rcx
int v32; // [rsp+1Ch] [rbp-ACh]
int v33; // [rsp+1Ch] [rbp-ACh]
int v36; // [rsp+34h] [rbp-94h]
long long *v37; // [rsp+38h] [rbp-90h]
__int128 v38; // [rsp+40h] [rbp-88h]
unsigned __int8 v39[120]; // [rsp+50h] [rbp-78h] BYREF
if ( a5 > 0 )
{
v37 = (long long *)(a1 + 72);
v15 = (unsigned int)a5;
while ( 1 )
{
v16 = *a4;
v17 = (const char *)a1;
atom = find_atom(a1, *a4);
*((_QWORD *)&v21 + 1) = *((unsigned __int8 *)a4 + 8);
switch ( *((_BYTE *)a4 + 9) )
{
case 0:
if ( atom == 211 )
{
DWORD2(v21) = 1;
}
else if ( atom == 220 )
{
DWORD2(v21) = 0;
}
goto LABEL_26;
case 1:
case 2:
v32 = *((unsigned __int8 *)a4 + 8);
if ( a4[2] )
{
snprintf(v39, 64LL, "get %s", *a4);
v22 = (_DWORD *)JS_NewCFunction3(
(_DWORD *)a1,
(long long)a4[2],
v39,
0,
2 * (unsigned int)(*((_BYTE *)a4 + 9) == 2) + 8,
*((_WORD *)a4 + 5),
*v37,
v37[1]);
v23 = *((_QWORD *)&v21 + 1);
DWORD2(v21) = v32;
}
else
{
v23 = 3LL;
v22 = 0LL;
}
LODWORD(v38) = 0;
*((_QWORD *)&v38 + 1) = 3LL;
if ( a4[3] )
{
snprintf(v39, 64LL, "set %s", *a4);
*(_QWORD *)&v21 = JS_NewCFunction3(
(_DWORD *)a1,
(long long)a4[3],
v39,
1u,
2 * (unsigned int)(*((_BYTE *)a4 + 9) == 2) + 9,
*((_WORD *)a4 + 5),
*v37,
v37[1]);
v38 = v21;
DWORD2(v21) = v32;
}
a6 = *(double *)&v38;
JS_DefinePropertyGetSet(
a1,
a2,
a3,
atom,
v22,
v23,
*(double *)&v38,
a7,
a8,
a9,
v19,
v20,
a12,
a13,
v38,
SDWORD2(v21));
goto LABEL_36;
case 3:
case 8:
LABEL_26:
JS_DefineAutoInitProperty(a1, a2, a3, atom, 2, (_DWORD)a4, DWORD2(v21));
goto LABEL_36;
case 4:
*(_QWORD *)&v27 = *((unsigned int *)a4 + 4);
v28 = 0LL;
goto LABEL_35;
case 5:
v29 = a4[2];
a6 = (double)(int)v29;
v27 = (double)(int)v29;
if ( (const char *)(int)v29 == v29 )
*(_QWORD *)&v27 = (unsigned int)v29;
v28 = 7LL;
if ( (const char *)(int)v29 == v29 )
v28 = 0LL;
goto LABEL_35;
case 6:
v27 = *((double *)a4 + 2);
v28 = 7LL;
goto LABEL_35;
case 7:
v28 = 3LL;
v27 = 0.0;
goto LABEL_35;
case 9:
v33 = *((unsigned __int8 *)a4 + 8);
v16 = a4[2];
v17 = (const char *)a1;
LODWORD(v21) = find_atom(a1, v16);
v24 = *((_DWORD *)a4 + 6);
v36 = v21;
if ( v24 == 1 )
{
v31 = *(_QWORD *)(a1 + 64);
v30 = *(_QWORD *)(v31 + 32);
*((_QWORD *)&v21 + 1) = *(_QWORD *)(v31 + 40);
goto LABEL_29;
}
if ( !v24 )
{
v30 = *(_QWORD *)(a1 + 416);
*((_QWORD *)&v21 + 1) = *(_QWORD *)(a1 + 424);
LABEL_29:
PropertyInternal2 = JS_GetPropertyInternal2(
a1,
v30,
*((long long *)&v21 + 1),
v21,
v30,
*((long long *)&v21 + 1),
0LL,
0);
goto LABEL_30;
}
if ( v24 != -1 )
LABEL_38:
abort(v17, v16, *((_QWORD *)&v21 + 1));
PropertyInternal2 = JS_GetPropertyInternal2(a1, a2, a3, v21, a2, a3, 0LL, 0);
LABEL_30:
v27 = *(double *)&PropertyInternal2;
v28 = v26;
JS_FreeAtom(a1, v36);
if ( atom == 211 )
{
DWORD2(v21) = 1;
}
else if ( atom == 220 )
{
DWORD2(v21) = 0;
}
else
{
DWORD2(v21) = v33;
}
LABEL_35:
JS_DefinePropertyValue(
a1,
a2,
a3,
atom,
*(_DWORD **)&v27,
v28,
a6,
a7,
a8,
a9,
v19,
v20,
a12,
a13,
SDWORD2(v21));
LABEL_36:
JS_FreeAtom(a1, atom);
a4 += 4;
if ( !--v15 )
return;
break;
default:
goto LABEL_38;
}
}
}
}
| JS_SetPropertyFunctionList:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x98
MOV qword ptr [RSP + 0x28],RDX
MOV qword ptr [RSP + 0x20],RSI
TEST R8D,R8D
JLE 0x00132f8b
MOV RBX,RCX
MOV R12,RDI
LEA RAX,[RDI + 0x48]
MOV qword ptr [RSP + 0x38],RAX
MOV R14D,R8D
LAB_00132c9d:
MOV RSI,qword ptr [RBX]
MOV RDI,R12
CALL 0x00132fa2
MOV R13D,EAX
MOVZX EAX,byte ptr [RBX + 0x9]
CMP RAX,0x9
JA 0x00132f9d
MOVZX EDX,byte ptr [RBX + 0x8]
LEA RCX,[0x19c86c]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
CMP qword ptr [RBX + 0x10],0x0
MOV dword ptr [RSP + 0x1c],EDX
JZ 0x00132e08
MOV RCX,qword ptr [RBX]
MOV ESI,0x40
LEA R15,[RSP + 0x50]
MOV RDI,R15
LEA RDX,[0x19fa7b]
XOR EAX,EAX
CALL 0x0010e2d0
XOR EAX,EAX
CMP byte ptr [RBX + 0x9],0x2
MOV RSI,qword ptr [RBX + 0x10]
SETZ AL
LEA R8D,[0x8 + RAX*0x2]
MOVSX R9D,word ptr [RBX + 0xa]
MOV RAX,qword ptr [RSP + 0x38]
MOVUPS XMM0,xmmword ptr [RAX]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,R12
MOV RDX,R15
XOR ECX,ECX
CALL 0x00121006
MOV R15,RAX
MOV RBP,RDX
MOV EDX,dword ptr [RSP + 0x1c]
JMP 0x00132e10
caseD_0:
CMP R13D,0xd3
JZ 0x00132eb8
CMP R13D,0xdc
JNZ 0x00132ebd
XOR EDX,EDX
JMP 0x00132ebd
caseD_9:
MOV dword ptr [RSP + 0x1c],EDX
MOV RSI,qword ptr [RBX + 0x10]
MOV RDI,R12
CALL 0x00132fa2
MOV ECX,dword ptr [RBX + 0x18]
CMP ECX,0x1
MOV dword ptr [RSP + 0x34],EAX
JZ 0x00132ef5
TEST ECX,ECX
JZ 0x00132ee3
CMP ECX,-0x1
JNZ 0x00132f9d
MOV dword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP],0x0
MOV RDI,R12
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
JMP 0x00132f15
caseD_6:
MOV RBP,qword ptr [RBX + 0x10]
MOV R15D,0x7
JMP 0x00132f55
caseD_4:
MOV EBP,dword ptr [RBX + 0x10]
XOR R15D,R15D
JMP 0x00132f55
caseD_5:
MOV RAX,qword ptr [RBX + 0x10]
MOVSXD RCX,EAX
CMP RCX,RAX
XORPS XMM0,XMM0
CVTSI2SD XMM0,RAX
MOV EAX,ECX
MOVQ RBP,XMM0
CMOVZ RBP,RAX
MOV R15D,0x7
MOV EAX,0x0
CMOVZ R15,RAX
JMP 0x00132f55
caseD_7:
MOV R15D,0x3
XOR EBP,EBP
JMP 0x00132f55
LAB_00132e08:
MOV EBP,0x3
XOR R15D,R15D
LAB_00132e10:
MOV dword ptr [RSP + 0x40],0x0
MOV qword ptr [RSP + 0x48],0x3
CMP qword ptr [RBX + 0x18],0x0
JZ 0x00132e89
MOV RCX,qword ptr [RBX]
MOV ESI,0x40
LEA RDI,[RSP + 0x50]
LEA RDX,[0x19fa82]
XOR EAX,EAX
CALL 0x0010e2d0
XOR EAX,EAX
CMP byte ptr [RBX + 0x9],0x2
MOV RSI,qword ptr [RBX + 0x18]
SETZ AL
LEA R8D,[0x9 + RAX*0x2]
MOVSX R9D,word ptr [RBX + 0xa]
MOV RAX,qword ptr [RSP + 0x38]
MOVUPS XMM0,xmmword ptr [RAX]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,R12
LEA RDX,[RSP + 0x50]
MOV ECX,0x1
CALL 0x00121006
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x48],RDX
MOV EDX,dword ptr [RSP + 0x1c]
LAB_00132e89:
MOVUPD XMM0,xmmword ptr [RSP + 0x40]
MOVUPD xmmword ptr [RSP],XMM0
MOV dword ptr [RSP + 0x10],EDX
MOV RDI,R12
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
MOV ECX,R13D
MOV R8,R15
MOV R9,RBP
CALL 0x00126cc9
JMP 0x00132f73
LAB_00132eb8:
MOV EDX,0x1
caseD_3:
MOV dword ptr [RSP],EDX
MOV RDI,R12
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
MOV ECX,R13D
MOV R8D,0x2
MOV R9,RBX
CALL 0x00141517
JMP 0x00132f73
LAB_00132ee3:
MOV RSI,qword ptr [R12 + 0x1a0]
MOV RDX,qword ptr [R12 + 0x1a8]
JMP 0x00132f02
LAB_00132ef5:
MOV RCX,qword ptr [R12 + 0x40]
MOV RSI,qword ptr [RCX + 0x20]
MOV RDX,qword ptr [RCX + 0x28]
LAB_00132f02:
MOV dword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP],0x0
MOV RDI,R12
LAB_00132f15:
MOV ECX,EAX
MOV R8,RSI
MOV R9,RDX
CALL 0x00122fa3
MOV RBP,RAX
MOV R15,RDX
MOV RDI,R12
MOV ESI,dword ptr [RSP + 0x34]
CALL 0x001207d8
CMP R13D,0xd3
JZ 0x00132f4a
CMP R13D,0xdc
JNZ 0x00132f51
XOR EDX,EDX
JMP 0x00132f55
LAB_00132f4a:
MOV EDX,0x1
JMP 0x00132f55
LAB_00132f51:
MOV EDX,dword ptr [RSP + 0x1c]
LAB_00132f55:
MOV dword ptr [RSP],EDX
MOV RDI,R12
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
MOV ECX,R13D
MOV R8,RBP
MOV R9,R15
CALL 0x00126abb
LAB_00132f73:
MOV RDI,R12
MOV ESI,R13D
CALL 0x001207d8
ADD RBX,0x20
DEC R14
JNZ 0x00132c9d
LAB_00132f8b:
ADD RSP,0x98
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00132f9d:
CALL 0x0010e090
|
void JS_SetPropertyFunctionList
(long param_1,int8 param_2,int8 param_3,int8 *param_4,uint param_5)
{
byte bVar1;
int iVar2;
ulong uVar3;
int iVar4;
int4 uVar5;
uint uVar6;
int8 uVar8;
double dVar9;
int8 uVar10;
ulong uVar11;
bool bVar12;
int1 auVar13 [12];
int1 auVar14 [16];
ulong in_stack_ffffffffffffff38;
int4 uVar15;
ulong local_88;
char local_78 [72];
uint uVar7;
if (0 < (int)param_5) {
uVar11 = (ulong)param_5;
do {
uVar15 = (int4)(in_stack_ffffffffffffff38 >> 0x20);
iVar4 = find_atom(param_1,*param_4);
if (9 < *(byte *)((long)param_4 + 9)) {
LAB_00132f9d:
/* WARNING: Subroutine does not return */
abort();
}
bVar1 = *(byte *)(param_4 + 1);
uVar7 = (uint)bVar1;
uVar6 = (uint)bVar1;
switch(*(byte *)((long)param_4 + 9)) {
case 0:
if (iVar4 == 0xd3) {
uVar6 = 1;
}
else if (iVar4 == 0xdc) {
uVar6 = 0;
}
case 3:
case 8:
in_stack_ffffffffffffff38 = CONCAT44(uVar15,uVar6);
JS_DefineAutoInitProperty(param_1,param_2,param_3,iVar4,2,param_4,in_stack_ffffffffffffff38)
;
goto LAB_00132f73;
default:
if (param_4[2] == 0) {
auVar14 = ZEXT816(3) << 0x40;
}
else {
snprintf(local_78,0x40,"get %s",*param_4);
auVar14 = JS_NewCFunction3(param_1,param_4[2],local_78,0,
(*(char *)((long)param_4 + 9) == '\x02') * '\x02' + '\b',
(int)*(short *)((long)param_4 + 10),
*(int8 *)(param_1 + 0x48),*(int4 *)(param_1 + 0x50)
);
}
local_88 = local_88 & 0xffffffff00000000;
auVar13._8_4_ = 3;
auVar13._0_8_ = local_88;
if (param_4[3] != 0) {
snprintf(local_78,0x40,"set %s",*param_4);
auVar13 = JS_NewCFunction3(param_1,param_4[3],local_78,1,
(*(char *)((long)param_4 + 9) == '\x02') * '\x02' + '\t',
(int)*(short *)((long)param_4 + 10),
*(int8 *)(param_1 + 0x48),*(int4 *)(param_1 + 0x50)
);
}
local_88 = auVar13._0_8_;
in_stack_ffffffffffffff38 = local_88;
JS_DefinePropertyGetSet
(param_1,param_2,param_3,iVar4,auVar14._0_8_,auVar14._8_8_,auVar13,bVar1);
goto LAB_00132f73;
case 4:
auVar14 = ZEXT416(*(uint *)(param_4 + 2));
break;
case 5:
uVar3 = param_4[2];
bVar12 = (long)(int)uVar3 == uVar3;
dVar9 = (double)(long)uVar3;
if (bVar12) {
dVar9 = (double)(uVar3 & 0xffffffff);
}
auVar14._8_8_ = 7;
auVar14._0_8_ = dVar9;
if (bVar12) {
auVar14._8_8_ = 0;
}
break;
case 6:
auVar14._8_8_ = 7;
auVar14._0_8_ = param_4[2];
break;
case 7:
auVar14 = ZEXT816(3) << 0x40;
break;
case 9:
uVar5 = find_atom(param_1,param_4[2]);
iVar2 = *(int *)(param_4 + 3);
if (iVar2 == 1) {
uVar8 = *(int8 *)(*(long *)(param_1 + 0x40) + 0x28);
uVar10 = *(int8 *)(*(long *)(param_1 + 0x40) + 0x20);
}
else if (iVar2 == 0) {
uVar8 = *(int8 *)(param_1 + 0x1a8);
uVar10 = *(int8 *)(param_1 + 0x1a0);
}
else {
uVar8 = param_3;
uVar10 = param_2;
if (iVar2 != -1) goto LAB_00132f9d;
}
uVar15 = 0;
auVar14 = JS_GetPropertyInternal2(param_1,uVar10,uVar8,uVar5,uVar10,uVar8,0,0);
JS_FreeAtom(param_1,uVar5);
if (iVar4 == 0xd3) {
uVar7 = 1;
}
else {
uVar7 = (uint)bVar1;
if (iVar4 == 0xdc) {
uVar7 = 0;
}
}
}
in_stack_ffffffffffffff38 = CONCAT44(uVar15,uVar7);
JS_DefinePropertyValue
(param_1,param_2,param_3,iVar4,auVar14._0_8_,auVar14._8_8_,in_stack_ffffffffffffff38
);
LAB_00132f73:
JS_FreeAtom(param_1,iVar4);
param_4 = param_4 + 4;
uVar11 = uVar11 - 1;
} while (uVar11 != 0);
}
return;
}
| |
47,205 | JS_SetPropertyFunctionList | bluesky950520[P]quickjs/quickjs.c | void JS_SetPropertyFunctionList(JSContext *ctx, JSValue obj,
const JSCFunctionListEntry *tab, int len)
{
int i;
for (i = 0; i < len; i++) {
const JSCFunctionListEntry *e = &tab[i];
JSAtom atom = find_atom(ctx, e->name);
JS_InstantiateFunctionListItem(ctx, obj, atom, e);
JS_FreeAtom(ctx, atom);
}
} | O2 | c | JS_SetPropertyFunctionList:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdi, %r13
xorl %eax, %eax
testl %r8d, %r8d
cmovlel %eax, %ebx
subq $0x1, %rbx
jb 0x2c6a9
movq (%r14), %rsi
movq %r13, %rdi
callq 0x2c6c0
movl %eax, %ebp
movzbl 0x9(%r14), %eax
cmpq $0x9, %rax
ja 0x2c6bb
movzbl 0x8(%r14), %edx
leaq 0x573af(%rip), %rcx # 0x8380c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpq $0x0, 0x10(%r14)
movl %edx, 0x24(%rsp)
je 0x2c56b
movq (%r14), %rcx
leaq 0x50(%rsp), %r15
movq %r15, %rdi
pushq $0x40
popq %rsi
leaq 0x5a541(%rip), %rdx # 0x869cb
xorl %eax, %eax
callq 0xe2e0
xorl %eax, %eax
cmpb $0x2, 0x9(%r14)
movq 0x10(%r14), %rsi
sete %al
leal 0x8(%rax,%rax), %r8d
movswl 0xa(%r14), %r9d
movq %r13, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x1b2dd
movq %rax, %r15
movq %rdx, %r12
movl 0x24(%rsp), %edx
jmp 0x2c572
movl %edx, (%rsp)
jmp 0x2c607
pushq $0x1
popq %rax
cmpl $0xd3, %ebp
je 0x2c604
cmpl $0xdc, %ebp
jne 0x2c602
xorl %eax, %eax
jmp 0x2c604
movl %edx, 0x24(%rsp)
movq 0x10(%r14), %rsi
movq %r13, %rdi
callq 0x2c6c0
movl 0x18(%r14), %ecx
cmpl $0x1, %ecx
movl %eax, 0x3c(%rsp)
je 0x2c634
testl %ecx, %ecx
je 0x2c624
cmpl $-0x1, %ecx
jne 0x2c6bb
movq %r13, %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
jmp 0x2c643
movq 0x10(%r14), %r15
pushq $0x7
jmp 0x2c564
movl 0x10(%r14), %r15d
xorl %r12d, %r12d
jmp 0x2c674
movq 0x10(%r14), %rdi
movl %edx, 0x24(%rsp)
callq 0x20a0b
movq %rax, %r15
movq %rdx, %r12
jmp 0x2c670
xorl %r15d, %r15d
pushq $0x3
popq %r12
jmp 0x2c674
xorl %r15d, %r15d
pushq $0x3
popq %r12
andl $0x0, 0x40(%rsp)
movq $0x3, 0x48(%rsp)
cmpq $0x0, 0x18(%r14)
je 0x2c5d6
movq (%r14), %rcx
leaq 0x50(%rsp), %rdi
pushq $0x40
popq %rsi
leaq 0x5a439(%rip), %rdx # 0x869d2
xorl %eax, %eax
callq 0xe2e0
xorl %eax, %eax
cmpb $0x2, 0x9(%r14)
movq 0x18(%r14), %rsi
sete %al
leal 0x9(%rax,%rax), %r8d
movswl 0xa(%r14), %r9d
movq %r13, %rdi
leaq 0x50(%rsp), %rdx
pushq $0x1
popq %rcx
callq 0x1b2dd
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movl 0x24(%rsp), %edx
movups 0x40(%rsp), %xmm0
movups %xmm0, (%rsp)
movl %edx, 0x10(%rsp)
movq %r13, %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movl %ebp, %ecx
movq %r15, %r8
movq %r12, %r9
callq 0x20a89
jmp 0x2c691
movl %edx, %eax
movl %eax, (%rsp)
movq %r13, %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movl %ebp, %ecx
pushq $0x2
popq %r8
movq %r14, %r9
callq 0x393f2
jmp 0x2c691
movq 0x1a0(%r13), %rsi
movq 0x1a8(%r13), %rdx
jmp 0x2c640
movq 0x40(%r13), %rcx
movq 0x20(%rcx), %rsi
movq 0x28(%rcx), %rdx
movq %r13, %rdi
movl %eax, %ecx
callq 0x1b043
movq %rax, %r15
movq %rdx, %r12
movq %r13, %rdi
movl 0x3c(%rsp), %esi
callq 0x1a995
cmpl $0xd3, %ebp
je 0x2c6a4
cmpl $0xdc, %ebp
jne 0x2c670
xorl %edx, %edx
jmp 0x2c674
movl 0x24(%rsp), %edx
movl %edx, (%rsp)
movq %r13, %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movl %ebp, %ecx
movq %r15, %r8
movq %r12, %r9
callq 0x20872
movq %r13, %rdi
movl %ebp, %esi
callq 0x1a995
addq $0x20, %r14
jmp 0x2c42b
pushq $0x1
popq %rdx
jmp 0x2c674
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xe090
| JS_SetPropertyFunctionList:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 98h
mov ebx, r8d
mov r14, rcx
mov [rsp+0C8h+var_98], rdx
mov [rsp+0C8h+var_A0], rsi
mov r13, rdi
xor eax, eax
test r8d, r8d
cmovle ebx, eax
loc_2C42B:
sub rbx, 1
jb loc_2C6A9
mov rsi, [r14]
mov rdi, r13
call find_atom
mov ebp, eax
movzx eax, byte ptr [r14+9]
cmp rax, 9; switch 10 cases
ja def_2C464; jumptable 000000000002C464 default case
movzx edx, byte ptr [r14+8]
lea rcx, jpt_2C464
movsxd rax, ds:(jpt_2C464 - 8380Ch)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_2C466:
cmp qword ptr [r14+10h], 0; jumptable 000000000002C464 cases 1,2
mov [rsp+0C8h+var_A4], edx
jz loc_2C56B
mov rcx, [r14]
lea r15, [rsp+0C8h+var_78]
mov rdi, r15
push 40h ; '@'
pop rsi
lea rdx, aGetS; "get %s"
xor eax, eax
call _snprintf
xor eax, eax
cmp byte ptr [r14+9], 2
mov rsi, [r14+10h]
setz al
lea r8d, [rax+rax+8]
movsx r9d, word ptr [r14+0Ah]
mov rdi, r13
mov rdx, r15
xor ecx, ecx
call JS_NewCFunction2
mov r15, rax
mov r12, rdx
mov edx, [rsp+0C8h+var_A4]
jmp loc_2C572
loc_2C4C5:
mov dword ptr [rsp+0C8h+var_C8], edx; jumptable 000000000002C464 cases 3,8
jmp loc_2C607
loc_2C4CD:
push 1; jumptable 000000000002C464 case 0
pop rax
cmp ebp, 0D3h
jz loc_2C604
cmp ebp, 0DCh
jnz loc_2C602
xor eax, eax
jmp loc_2C604
loc_2C4EF:
mov [rsp+0C8h+var_A4], edx; jumptable 000000000002C464 case 9
mov rsi, [r14+10h]
mov rdi, r13
call find_atom
mov ecx, [r14+18h]
cmp ecx, 1
mov [rsp+0C8h+var_8C], eax
jz loc_2C634
test ecx, ecx
jz loc_2C624
cmp ecx, 0FFFFFFFFh
jnz def_2C464; jumptable 000000000002C464 default case
mov rdi, r13
mov rsi, [rsp+0C8h+var_A0]
mov rdx, [rsp+0C8h+var_98]
jmp loc_2C643
loc_2C533:
mov r15, [r14+10h]; jumptable 000000000002C464 case 6
push 7
jmp short loc_2C564
loc_2C53B:
mov r15d, [r14+10h]; jumptable 000000000002C464 case 4
xor r12d, r12d
jmp loc_2C674
loc_2C547:
mov rdi, [r14+10h]; jumptable 000000000002C464 case 5
mov [rsp+0C8h+var_A4], edx
call js_int64
mov r15, rax
mov r12, rdx
jmp loc_2C670
loc_2C55F:
xor r15d, r15d; jumptable 000000000002C464 case 7
push 3
loc_2C564:
pop r12
jmp loc_2C674
loc_2C56B:
xor r15d, r15d
push 3
pop r12
loc_2C572:
and dword ptr [rsp+0C8h+var_88], 0
mov qword ptr [rsp+0C8h+var_88+8], 3
cmp qword ptr [r14+18h], 0
jz short loc_2C5D6
mov rcx, [r14]
lea rdi, [rsp+0C8h+var_78]
push 40h ; '@'
pop rsi
lea rdx, aSetS; "set %s"
xor eax, eax
call _snprintf
xor eax, eax
cmp byte ptr [r14+9], 2
mov rsi, [r14+18h]
setz al
lea r8d, [rax+rax+9]
movsx r9d, word ptr [r14+0Ah]
mov rdi, r13
lea rdx, [rsp+0C8h+var_78]
push 1
pop rcx
call JS_NewCFunction2
mov qword ptr [rsp+0C8h+var_88], rax
mov qword ptr [rsp+0C8h+var_88+8], rdx
mov edx, [rsp+0C8h+var_A4]
loc_2C5D6:
movups xmm0, [rsp+0C8h+var_88]
movups [rsp+0C8h+var_C8], xmm0
mov [rsp+0C8h+var_B8], edx
mov rdi, r13
mov rsi, [rsp+0C8h+var_A0]
mov rdx, [rsp+0C8h+var_98]
mov ecx, ebp
mov r8, r15
mov r9, r12
call JS_DefinePropertyGetSet
jmp loc_2C691
loc_2C602:
mov eax, edx
loc_2C604:
mov dword ptr [rsp+0C8h+var_C8], eax
loc_2C607:
mov rdi, r13
mov rsi, [rsp+0C8h+var_A0]
mov rdx, [rsp+0C8h+var_98]
mov ecx, ebp
push 2
pop r8
mov r9, r14
call JS_DefineAutoInitProperty
jmp short loc_2C691
loc_2C624:
mov rsi, [r13+1A0h]
mov rdx, [r13+1A8h]
jmp short loc_2C640
loc_2C634:
mov rcx, [r13+40h]
mov rsi, [rcx+20h]
mov rdx, [rcx+28h]
loc_2C640:
mov rdi, r13
loc_2C643:
mov ecx, eax
call JS_GetProperty
mov r15, rax
mov r12, rdx
mov rdi, r13
mov esi, [rsp+0C8h+var_8C]
call JS_FreeAtom
cmp ebp, 0D3h
jz short loc_2C6A4
cmp ebp, 0DCh
jnz short loc_2C670
xor edx, edx
jmp short loc_2C674
loc_2C670:
mov edx, [rsp+0C8h+var_A4]
loc_2C674:
mov dword ptr [rsp+0C8h+var_C8], edx
mov rdi, r13
mov rsi, [rsp+0C8h+var_A0]
mov rdx, [rsp+0C8h+var_98]
mov ecx, ebp
mov r8, r15
mov r9, r12
call JS_DefinePropertyValue
loc_2C691:
mov rdi, r13
mov esi, ebp
call JS_FreeAtom
add r14, 20h ; ' '
jmp loc_2C42B
loc_2C6A4:
push 1
pop rdx
jmp short loc_2C674
loc_2C6A9:
add rsp, 98h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
def_2C464:
call _abort; jumptable 000000000002C464 default case
| long long JS_SetPropertyFunctionList(
const char *a1,
long long a2,
long long a3,
const char **a4,
int a5,
double a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
long long v13; // rbx
long long result; // rax
const char *v18; // rsi
const char *v19; // rdi
unsigned int atom; // ebp
__m128 v21; // xmm4
__m128 v22; // xmm5
__int128 v23; // rax
_DWORD *v24; // r15
unsigned long long v25; // r12
int v26; // eax
int v27; // ecx
int v28; // edi
long long v29; // rsi
long long Property; // r15
long long v31; // r12
long long v32; // rdx
long long v33; // rcx
long long v34; // rdx
long long v35; // [rsp-8h] [rbp-D0h]
int v36; // [rsp+24h] [rbp-A4h]
int v37; // [rsp+24h] [rbp-A4h]
int v40; // [rsp+3Ch] [rbp-8Ch]
__int128 v41; // [rsp+40h] [rbp-88h]
_BYTE v42[120]; // [rsp+50h] [rbp-78h] BYREF
v13 = (unsigned int)a5;
result = 0LL;
if ( a5 <= 0 )
v13 = 0LL;
while ( v13-- != 0 )
{
v18 = *a4;
v19 = a1;
atom = find_atom(a1, *a4);
*((_QWORD *)&v23 + 1) = *((unsigned __int8 *)a4 + 8);
switch ( *((_BYTE *)a4 + 9) )
{
case 0:
v26 = 1;
if ( atom != 211 )
{
if ( atom == 220 )
v26 = 0;
else
v26 = *((unsigned __int8 *)a4 + 8);
}
JS_DefineAutoInitProperty((_DWORD)a1, a2, a3, atom, 2, (_DWORD)a4, v26);
goto LABEL_35;
case 1:
case 2:
v36 = *((unsigned __int8 *)a4 + 8);
if ( a4[2] )
{
snprintf(v42, 64LL, "get %s", *a4);
v24 = (_DWORD *)JS_NewCFunction2(
(long long)a1,
(int)a4[2],
(int)v42,
0,
2 * (unsigned int)(*((_BYTE *)a4 + 9) == 2) + 8,
*((__int16 *)a4 + 5));
v25 = *((_QWORD *)&v23 + 1);
DWORD2(v23) = v36;
}
else
{
v24 = 0LL;
v25 = 3LL;
}
LODWORD(v41) = 0;
*((_QWORD *)&v41 + 1) = 3LL;
if ( a4[3] )
{
snprintf(v42, 64LL, "set %s", *a4);
*(_QWORD *)&v23 = JS_NewCFunction2(
(long long)a1,
(int)a4[3],
(int)v42,
1,
2 * (unsigned int)(*((_BYTE *)a4 + 9) == 2) + 9,
*((__int16 *)a4 + 5));
v41 = v23;
DWORD2(v23) = v36;
}
a6 = *(double *)&v41;
JS_DefinePropertyGetSet(
(long long)a1,
a2,
a3,
atom,
v24,
v25,
*(double *)&v41,
a7,
a8,
a9,
v21,
v22,
a12,
a13,
v41,
SDWORD2(v23));
goto LABEL_35;
case 3:
case 8:
JS_DefineAutoInitProperty((_DWORD)a1, a2, a3, atom, 2, (_DWORD)a4, DWORD2(v23));
goto LABEL_35;
case 4:
Property = *((unsigned int *)a4 + 4);
v31 = 0LL;
goto LABEL_34;
case 5:
v37 = *((unsigned __int8 *)a4 + 8);
Property = js_int64((long long)a4[2]);
v31 = v32;
goto LABEL_33;
case 6:
Property = (long long)a4[2];
v35 = 7LL;
goto LABEL_19;
case 7:
Property = 0LL;
v35 = 3LL;
LABEL_19:
v31 = v35;
goto LABEL_34;
case 9:
v37 = *((unsigned __int8 *)a4 + 8);
v18 = a4[2];
v19 = a1;
LODWORD(v23) = find_atom(a1, v18);
v27 = *((_DWORD *)a4 + 6);
v40 = v23;
if ( v27 == 1 )
{
v33 = *((_QWORD *)a1 + 8);
v29 = *(_QWORD *)(v33 + 32);
*((_QWORD *)&v23 + 1) = *(_QWORD *)(v33 + 40);
goto LABEL_29;
}
if ( !v27 )
{
v29 = *((_QWORD *)a1 + 52);
*((_QWORD *)&v23 + 1) = *((_QWORD *)a1 + 53);
LABEL_29:
v28 = (int)a1;
goto LABEL_30;
}
if ( v27 != -1 )
LABEL_38:
abort(v19, v18, *((_QWORD *)&v23 + 1));
v28 = (int)a1;
LODWORD(v29) = a2;
DWORD2(v23) = a3;
LABEL_30:
Property = JS_GetProperty(v28, v29, SDWORD2(v23), v23);
v31 = v34;
JS_FreeAtom((long long)a1, v40);
if ( atom == 211 )
{
DWORD2(v23) = 1;
}
else if ( atom == 220 )
{
DWORD2(v23) = 0;
}
else
{
LABEL_33:
DWORD2(v23) = v37;
}
LABEL_34:
JS_DefinePropertyValue(
(long long)a1,
a2,
a3,
atom,
(_DWORD *)Property,
v31,
a6,
a7,
a8,
a9,
v21,
v22,
a12,
a13,
SDWORD2(v23));
LABEL_35:
result = JS_FreeAtom((long long)a1, atom);
a4 += 4;
break;
default:
goto LABEL_38;
}
}
return result;
}
| JS_SetPropertyFunctionList:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x98
MOV EBX,R8D
MOV R14,RCX
MOV qword ptr [RSP + 0x30],RDX
MOV qword ptr [RSP + 0x28],RSI
MOV R13,RDI
XOR EAX,EAX
TEST R8D,R8D
CMOVLE EBX,EAX
LAB_0012c42b:
SUB RBX,0x1
JC 0x0012c6a9
MOV RSI,qword ptr [R14]
MOV RDI,R13
CALL 0x0012c6c0
MOV EBP,EAX
MOVZX EAX,byte ptr [R14 + 0x9]
CMP RAX,0x9
JA 0x0012c6bb
MOVZX EDX,byte ptr [R14 + 0x8]
LEA RCX,[0x18380c]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
CMP qword ptr [R14 + 0x10],0x0
MOV dword ptr [RSP + 0x24],EDX
JZ 0x0012c56b
MOV RCX,qword ptr [R14]
LEA R15,[RSP + 0x50]
MOV RDI,R15
PUSH 0x40
POP RSI
LEA RDX,[0x1869cb]
XOR EAX,EAX
CALL 0x0010e2e0
XOR EAX,EAX
CMP byte ptr [R14 + 0x9],0x2
MOV RSI,qword ptr [R14 + 0x10]
SETZ AL
LEA R8D,[RAX + RAX*0x1 + 0x8]
MOVSX R9D,word ptr [R14 + 0xa]
MOV RDI,R13
MOV RDX,R15
XOR ECX,ECX
CALL 0x0011b2dd
MOV R15,RAX
MOV R12,RDX
MOV EDX,dword ptr [RSP + 0x24]
JMP 0x0012c572
caseD_3:
MOV dword ptr [RSP],EDX
JMP 0x0012c607
caseD_0:
PUSH 0x1
POP RAX
CMP EBP,0xd3
JZ 0x0012c604
CMP EBP,0xdc
JNZ 0x0012c602
XOR EAX,EAX
JMP 0x0012c604
caseD_9:
MOV dword ptr [RSP + 0x24],EDX
MOV RSI,qword ptr [R14 + 0x10]
MOV RDI,R13
CALL 0x0012c6c0
MOV ECX,dword ptr [R14 + 0x18]
CMP ECX,0x1
MOV dword ptr [RSP + 0x3c],EAX
JZ 0x0012c634
TEST ECX,ECX
JZ 0x0012c624
CMP ECX,-0x1
JNZ 0x0012c6bb
MOV RDI,R13
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
JMP 0x0012c643
caseD_6:
MOV R15,qword ptr [R14 + 0x10]
PUSH 0x7
JMP 0x0012c564
caseD_4:
MOV R15D,dword ptr [R14 + 0x10]
XOR R12D,R12D
JMP 0x0012c674
caseD_5:
MOV RDI,qword ptr [R14 + 0x10]
MOV dword ptr [RSP + 0x24],EDX
CALL 0x00120a0b
MOV R15,RAX
MOV R12,RDX
JMP 0x0012c670
caseD_7:
XOR R15D,R15D
PUSH 0x3
LAB_0012c564:
POP R12
JMP 0x0012c674
LAB_0012c56b:
XOR R15D,R15D
PUSH 0x3
POP R12
LAB_0012c572:
AND dword ptr [RSP + 0x40],0x0
MOV qword ptr [RSP + 0x48],0x3
CMP qword ptr [R14 + 0x18],0x0
JZ 0x0012c5d6
MOV RCX,qword ptr [R14]
LEA RDI,[RSP + 0x50]
PUSH 0x40
POP RSI
LEA RDX,[0x1869d2]
XOR EAX,EAX
CALL 0x0010e2e0
XOR EAX,EAX
CMP byte ptr [R14 + 0x9],0x2
MOV RSI,qword ptr [R14 + 0x18]
SETZ AL
LEA R8D,[RAX + RAX*0x1 + 0x9]
MOVSX R9D,word ptr [R14 + 0xa]
MOV RDI,R13
LEA RDX,[RSP + 0x50]
PUSH 0x1
POP RCX
CALL 0x0011b2dd
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x48],RDX
MOV EDX,dword ptr [RSP + 0x24]
LAB_0012c5d6:
MOVUPS XMM0,xmmword ptr [RSP + 0x40]
MOVUPS xmmword ptr [RSP],XMM0
MOV dword ptr [RSP + 0x10],EDX
MOV RDI,R13
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
MOV ECX,EBP
MOV R8,R15
MOV R9,R12
CALL 0x00120a89
JMP 0x0012c691
LAB_0012c602:
MOV EAX,EDX
LAB_0012c604:
MOV dword ptr [RSP],EAX
LAB_0012c607:
MOV RDI,R13
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
MOV ECX,EBP
PUSH 0x2
POP R8
MOV R9,R14
CALL 0x001393f2
JMP 0x0012c691
LAB_0012c624:
MOV RSI,qword ptr [R13 + 0x1a0]
MOV RDX,qword ptr [R13 + 0x1a8]
JMP 0x0012c640
LAB_0012c634:
MOV RCX,qword ptr [R13 + 0x40]
MOV RSI,qword ptr [RCX + 0x20]
MOV RDX,qword ptr [RCX + 0x28]
LAB_0012c640:
MOV RDI,R13
LAB_0012c643:
MOV ECX,EAX
CALL 0x0011b043
MOV R15,RAX
MOV R12,RDX
MOV RDI,R13
MOV ESI,dword ptr [RSP + 0x3c]
CALL 0x0011a995
CMP EBP,0xd3
JZ 0x0012c6a4
CMP EBP,0xdc
JNZ 0x0012c670
XOR EDX,EDX
JMP 0x0012c674
LAB_0012c670:
MOV EDX,dword ptr [RSP + 0x24]
LAB_0012c674:
MOV dword ptr [RSP],EDX
MOV RDI,R13
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
MOV ECX,EBP
MOV R8,R15
MOV R9,R12
CALL 0x00120872
LAB_0012c691:
MOV RDI,R13
MOV ESI,EBP
CALL 0x0011a995
ADD R14,0x20
JMP 0x0012c42b
LAB_0012c6a4:
PUSH 0x1
POP RDX
JMP 0x0012c674
LAB_0012c6a9:
ADD RSP,0x98
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0012c6bb:
CALL 0x0010e090
|
void JS_SetPropertyFunctionList
(long param_1,int8 param_2,int8 param_3,int8 *param_4,uint param_5)
{
int iVar1;
int iVar2;
int4 uVar3;
int1 uVar4;
int4 extraout_EDX;
int8 uVar5;
ulong uVar6;
int8 uVar7;
bool bVar8;
int1 auVar9 [16];
int1 uVar10;
int4 local_88;
int4 uStack_80;
char local_78 [72];
uVar6 = (ulong)param_5;
if ((int)param_5 < 1) {
uVar6 = 0;
}
do {
bVar8 = uVar6 == 0;
uVar6 = uVar6 - 1;
if (bVar8) {
return;
}
iVar2 = find_atom(param_1,*param_4);
if (9 < *(byte *)((long)param_4 + 9)) {
LAB_0012c6bb:
/* WARNING: Subroutine does not return */
abort();
}
uVar4 = *(int1 *)(param_4 + 1);
switch(*(byte *)((long)param_4 + 9)) {
case 0:
uVar10 = 1;
if ((iVar2 != 0xd3) && (uVar10 = uVar4, iVar2 == 0xdc)) {
uVar10 = 0;
}
goto LAB_0012c607;
default:
if (param_4[2] == 0) {
auVar9 = ZEXT816(3) << 0x40;
}
else {
snprintf(local_78,0x40,"get %s",*param_4);
auVar9 = JS_NewCFunction2(param_1,param_4[2],local_78,0,
(*(char *)((long)param_4 + 9) == '\x02') * '\x02' + '\b',
(int)*(short *)((long)param_4 + 10));
}
local_88 = 0;
uStack_80 = 3;
if (param_4[3] != 0) {
snprintf(local_78,0x40,"set %s",*param_4);
local_88 = JS_NewCFunction2(param_1,param_4[3],local_78,1,
(*(char *)((long)param_4 + 9) == '\x02') * '\x02' + '\t',
(int)*(short *)((long)param_4 + 10));
uStack_80 = extraout_EDX;
}
JS_DefinePropertyGetSet
(param_1,param_2,param_3,iVar2,auVar9._0_8_,auVar9._8_8_,local_88,uStack_80,uVar4);
goto LAB_0012c691;
case 3:
case 8:
uVar10 = uVar4;
LAB_0012c607:
JS_DefineAutoInitProperty(param_1,param_2,param_3,iVar2,2,param_4,uVar10);
goto LAB_0012c691;
case 4:
auVar9 = ZEXT416(*(uint *)(param_4 + 2));
break;
case 5:
auVar9 = js_int64(param_4[2]);
break;
case 6:
auVar9._8_8_ = 7;
auVar9._0_8_ = param_4[2];
break;
case 7:
auVar9 = ZEXT816(3) << 0x40;
break;
case 9:
uVar3 = find_atom(param_1,param_4[2]);
iVar1 = *(int *)(param_4 + 3);
if (iVar1 == 1) {
uVar5 = *(int8 *)(*(long *)(param_1 + 0x40) + 0x28);
uVar7 = *(int8 *)(*(long *)(param_1 + 0x40) + 0x20);
}
else if (iVar1 == 0) {
uVar5 = *(int8 *)(param_1 + 0x1a8);
uVar7 = *(int8 *)(param_1 + 0x1a0);
}
else {
uVar5 = param_3;
uVar7 = param_2;
if (iVar1 != -1) goto LAB_0012c6bb;
}
auVar9 = JS_GetProperty(param_1,uVar7,uVar5,uVar3);
JS_FreeAtom(param_1,uVar3);
if (iVar2 == 0xd3) {
uVar4 = 1;
}
else if (iVar2 == 0xdc) {
uVar4 = 0;
}
}
JS_DefinePropertyValue(param_1,param_2,param_3,iVar2,auVar9._0_8_,auVar9._8_8_,uVar4);
LAB_0012c691:
JS_FreeAtom(param_1,iVar2);
param_4 = param_4 + 4;
} while( true );
}
| |
47,206 | my_wc_mb_sjis | eloqsql/strings/ctype-sjis.c | static int
my_wc_mb_sjis(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
int code;
if ((int) wc < 0x80) /* ASCII: [U+0000..U+007F] -> [00-7F] */
{
/*
This branch is for performance purposes on ASCII range,
to avoid using unicode_to_cp932[]: about 10% improvement.
*/
if (wc == 0x5c)
{
/*
Special case when converting from Unicode to SJIS:
U+005C -> [81][5F] FULL WIDTH REVERSE SOLIDUS
*/
code= MB2(0x815F);
goto mb;
}
if (s >= e)
return MY_CS_TOOSMALL;
s[0]= (uchar) wc; /* ASCII */
return 1;
}
if (wc > 0xFFFF ||
!(code= unicode_to_sjis[wc])) /* Bad Unicode code point */
return MY_CS_ILUNI;
if (code <= 0xFF)
{
/* JIS-X-0201 HALF WIDTH KATAKANA [U+FF61..U+FF9F] -> [A1..DF] */
if (s >= e)
return MY_CS_TOOSMALL;
s[0]= code;
return 1;
}
mb:
if (s + 2 > e)
return MY_CS_TOOSMALL2;
MY_PUT_MB2(s, code); /* JIS-X-0208 */
return 2;
} | O3 | c | my_wc_mb_sjis:
pushq %rbp
movq %rsp, %rbp
cmpl $0x7f, %esi
jg 0x3a602
movl $0x815f, %edi # imm = 0x815F
cmpq $0x5c, %rsi
je 0x3a638
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x3a652
movb %sil, (%rdx)
jmp 0x3a631
xorl %eax, %eax
cmpq $0xffff, %rsi # imm = 0xFFFF
ja 0x3a652
leaq 0x188f4c(%rip), %rdi # 0x1c3560
movzwl (%rdi,%rsi,2), %edi
testl %edi, %edi
je 0x3a652
cmpl $0xff, %edi
ja 0x3a638
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x3a652
movb %dil, (%rdx)
movl $0x1, %eax
jmp 0x3a652
leaq 0x2(%rdx), %rsi
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %rsi
ja 0x3a652
rolw $0x8, %di
movw %di, (%rdx)
movl $0x2, %eax
popq %rbp
retq
| my_wc_mb_sjis:
push rbp
mov rbp, rsp
cmp esi, 7Fh
jg short loc_3A602
mov edi, 815Fh
cmp rsi, 5Ch ; '\'
jz short loc_3A638
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short loc_3A652
mov [rdx], sil
jmp short loc_3A631
loc_3A602:
xor eax, eax
cmp rsi, 0FFFFh
ja short loc_3A652
lea rdi, unicode_to_sjis
movzx edi, word ptr [rdi+rsi*2]
test edi, edi
jz short loc_3A652
cmp edi, 0FFh
ja short loc_3A638
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short loc_3A652
mov [rdx], dil
loc_3A631:
mov eax, 1
jmp short loc_3A652
loc_3A638:
lea rsi, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp rsi, rcx
ja short loc_3A652
rol di, 8
mov [rdx], di
mov eax, 2
loc_3A652:
pop rbp
retn
| long long my_wc_mb_sjis(long long a1, unsigned long long a2, _BYTE *a3, unsigned long long a4)
{
unsigned int v4; // edi
long long result; // rax
if ( (int)a2 <= 127 )
{
LOWORD(v4) = -32417;
if ( a2 != 92 )
{
result = 4294967195LL;
if ( (unsigned long long)a3 >= a4 )
return result;
*a3 = a2;
return 1LL;
}
LABEL_11:
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
*(_WORD *)a3 = __ROL2__(v4, 8);
return 2LL;
}
return result;
}
result = 0LL;
if ( a2 <= 0xFFFF )
{
v4 = unicode_to_sjis[a2];
if ( unicode_to_sjis[a2] )
{
if ( v4 <= 0xFF )
{
result = 4294967195LL;
if ( (unsigned long long)a3 >= a4 )
return result;
*a3 = v4;
return 1LL;
}
goto LABEL_11;
}
}
return result;
}
| my_wc_mb_sjis:
PUSH RBP
MOV RBP,RSP
CMP ESI,0x7f
JG 0x0013a602
MOV EDI,0x815f
CMP RSI,0x5c
JZ 0x0013a638
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x0013a652
MOV byte ptr [RDX],SIL
JMP 0x0013a631
LAB_0013a602:
XOR EAX,EAX
CMP RSI,0xffff
JA 0x0013a652
LEA RDI,[0x2c3560]
MOVZX EDI,word ptr [RDI + RSI*0x2]
TEST EDI,EDI
JZ 0x0013a652
CMP EDI,0xff
JA 0x0013a638
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x0013a652
MOV byte ptr [RDX],DIL
LAB_0013a631:
MOV EAX,0x1
JMP 0x0013a652
LAB_0013a638:
LEA RSI,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP RSI,RCX
JA 0x0013a652
ROL DI,0x8
MOV word ptr [RDX],DI
MOV EAX,0x2
LAB_0013a652:
POP RBP
RET
|
int8 my_wc_mb_sjis(int8 param_1,ulong param_2,ushort *param_3,ushort *param_4)
{
ushort uVar1;
if ((int)param_2 < 0x80) {
uVar1 = 0x815f;
if (param_2 == 0x5c) {
LAB_0013a638:
if (param_4 < param_3 + 1) {
return 0xffffff9a;
}
*param_3 = uVar1 << 8 | uVar1 >> 8;
return 2;
}
if (param_4 <= param_3) {
return 0xffffff9b;
}
*(char *)param_3 = (char)param_2;
}
else {
if (0xffff < param_2) {
return 0;
}
uVar1 = *(ushort *)(unicode_to_sjis + param_2 * 2);
if (uVar1 == 0) {
return 0;
}
if (0xff < uVar1) goto LAB_0013a638;
if (param_4 <= param_3) {
return 0xffffff9b;
}
*(char *)param_3 = (char)uVar1;
}
return 1;
}
| |
47,207 | trnman_get_min_safe_trid | eloqsql/storage/maria/trnman.c | TrID trnman_get_min_safe_trid()
{
TrID trid;
mysql_mutex_lock(&LOCK_trn_list);
trid= MY_MIN(active_list_min.next->min_read_from,
global_trid_generator);
mysql_mutex_unlock(&LOCK_trn_list);
return trid;
} | O3 | c | trnman_get_min_safe_trid:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpq $0x0, 0x3dd01a(%rip) # 0x450860
jne 0x73890
leaq 0x3dcfd1(%rip), %rdi # 0x450820
callq 0x2b230
movq 0x3dcc85(%rip), %rax # 0x4504e0
movq 0x80(%rax), %r14
movq 0x3dcee7(%rip), %rbx # 0x450750
movq 0x3dcff0(%rip), %rdi # 0x450860
testq %rdi, %rdi
jne 0x73897
cmpq %rbx, %r14
cmovbq %r14, %rbx
leaq 0x3dcf9d(%rip), %rdi # 0x450820
callq 0x2b1f0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x2d484
jmp 0x73854
leaq 0x34536a(%rip), %rax # 0x3b8c08
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x73875
| trnman_get_min_safe_trid:
push rbp
mov rbp, rsp
push r14
push rbx
cmp cs:qword_450860, 0
jnz short loc_73890
lea rdi, LOCK_trn_list
call _pthread_mutex_lock
loc_73854:
mov rax, cs:qword_4504E0
mov r14, [rax+80h]
mov rbx, cs:global_trid_generator
mov rdi, cs:qword_450860
test rdi, rdi
jnz short loc_73897
loc_73875:
cmp r14, rbx
cmovb rbx, r14
lea rdi, LOCK_trn_list
call _pthread_mutex_unlock
mov rax, rbx
pop rbx
pop r14
pop rbp
retn
loc_73890:
call trnman_get_min_safe_trid_cold_1
jmp short loc_73854
loc_73897:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_73875
| unsigned long long trnman_get_min_safe_trid()
{
unsigned long long v0; // r14
unsigned long long v1; // rbx
if ( qword_450860 )
trnman_get_min_safe_trid_cold_1();
else
pthread_mutex_lock(&LOCK_trn_list);
v0 = *(_QWORD *)(qword_4504E0 + 128);
v1 = global_trid_generator;
if ( qword_450860 )
PSI_server[44]();
if ( v0 < v1 )
v1 = v0;
pthread_mutex_unlock(&LOCK_trn_list);
return v1;
}
| trnman_get_min_safe_trid:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
CMP qword ptr [0x00550860],0x0
JNZ 0x00173890
LEA RDI,[0x550820]
CALL 0x0012b230
LAB_00173854:
MOV RAX,qword ptr [0x005504e0]
MOV R14,qword ptr [RAX + 0x80]
MOV RBX,qword ptr [0x00550750]
MOV RDI,qword ptr [0x00550860]
TEST RDI,RDI
JNZ 0x00173897
LAB_00173875:
CMP R14,RBX
CMOVC RBX,R14
LEA RDI,[0x550820]
CALL 0x0012b1f0
MOV RAX,RBX
POP RBX
POP R14
POP RBP
RET
LAB_00173890:
CALL 0x0012d484
JMP 0x00173854
LAB_00173897:
LEA RAX,[0x4b8c08]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00173875
|
ulong trnman_get_min_safe_trid(void)
{
ulong uVar1;
ulong uVar2;
if (LOCK_trn_list._64_8_ == 0) {
pthread_mutex_lock((pthread_mutex_t *)LOCK_trn_list);
}
else {
trnman_get_min_safe_trid_cold_1();
}
uVar2 = global_trid_generator;
uVar1 = *(ulong *)(active_list_min._104_8_ + 0x80);
if (LOCK_trn_list._64_8_ != 0) {
(**(code **)(PSI_server + 0x160))();
}
if (uVar1 < uVar2) {
uVar2 = uVar1;
}
pthread_mutex_unlock((pthread_mutex_t *)LOCK_trn_list);
return uVar2;
}
| |
47,208 | SpriteAnim::update(float) | GhostEscape/src/affiliate/sprite_anim.cpp | void SpriteAnim::update(float dt)
{
if (is_finish_) return;
frame_timer_ += dt;
if (frame_timer_ >= 1.0f / fps_)
{
current_frame_++;
if (current_frame_ >= total_frames_)
{
current_frame_ = 0;
if (!is_loop_) is_finish_ = true;
}
frame_timer_ = 0.0f;
}
texture_.src_rect.x = texture_.src_rect.w * current_frame_;
} | O0 | cpp | SpriteAnim::update(float):
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x90(%rax)
je 0x1ae43
jmp 0x1aeee
movq -0x18(%rbp), %rax
movss -0xc(%rbp), %xmm0
addss 0xa8(%rax), %xmm0
movss %xmm0, 0xa8(%rax)
movss 0xa8(%rax), %xmm0
cvtsi2ssl 0xa4(%rax), %xmm2
movss 0x7190(%rip), %xmm1 # 0x22004
divss %xmm2, %xmm1
ucomiss %xmm1, %xmm0
jb 0x1aed1
movq -0x18(%rbp), %rcx
movl 0x9c(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x9c(%rcx)
movl 0x9c(%rcx), %eax
cmpl 0xa0(%rcx), %eax
jl 0x1aec2
movq -0x18(%rbp), %rax
movl $0x0, 0x9c(%rax)
testb $0x1, 0xac(%rax)
jne 0x1aec0
movq -0x18(%rbp), %rax
movb $0x1, 0x90(%rax)
jmp 0x1aec2
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0xa8(%rax)
movq -0x18(%rbp), %rax
movss 0x80(%rax), %xmm0
cvtsi2ssl 0x9c(%rax), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, 0x78(%rax)
popq %rbp
retq
| _ZN10SpriteAnim6updateEf:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
movss [rbp+var_C], xmm0
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
test byte ptr [rax+90h], 1
jz short loc_1AE43
jmp loc_1AEEE
loc_1AE43:
mov rax, [rbp+var_18]
movss xmm0, [rbp+var_C]
addss xmm0, dword ptr [rax+0A8h]
movss dword ptr [rax+0A8h], xmm0
movss xmm0, dword ptr [rax+0A8h]
cvtsi2ss xmm2, dword ptr [rax+0A4h]
movss xmm1, cs:flt_22004
divss xmm1, xmm2
ucomiss xmm0, xmm1
jb short loc_1AED1
mov rcx, [rbp+var_18]
mov eax, [rcx+9Ch]
add eax, 1
mov [rcx+9Ch], eax
mov eax, [rcx+9Ch]
cmp eax, [rcx+0A0h]
jl short loc_1AEC2
mov rax, [rbp+var_18]
mov dword ptr [rax+9Ch], 0
test byte ptr [rax+0ACh], 1
jnz short loc_1AEC0
mov rax, [rbp+var_18]
mov byte ptr [rax+90h], 1
loc_1AEC0:
jmp short $+2
loc_1AEC2:
mov rax, [rbp+var_18]
xorps xmm0, xmm0
movss dword ptr [rax+0A8h], xmm0
loc_1AED1:
mov rax, [rbp+var_18]
movss xmm0, dword ptr [rax+80h]
cvtsi2ss xmm1, dword ptr [rax+9Ch]
mulss xmm0, xmm1
movss dword ptr [rax+78h], xmm0
loc_1AEEE:
pop rbp
retn
| SpriteAnim * SpriteAnim::update(SpriteAnim *this, float a2)
{
SpriteAnim *result; // rax
result = this;
if ( (*((_BYTE *)this + 144) & 1) == 0 )
{
*((float *)this + 42) = a2 + *((float *)this + 42);
if ( *((float *)this + 42) >= (float)(1.0 / (float)*((int *)this + 41)) )
{
if ( ++*((_DWORD *)this + 39) >= *((_DWORD *)this + 40) )
{
*((_DWORD *)this + 39) = 0;
if ( (*((_BYTE *)this + 172) & 1) == 0 )
*((_BYTE *)this + 144) = 1;
}
*((_DWORD *)this + 42) = 0;
}
result = this;
*((float *)this + 30) = *((float *)this + 32) * (float)*((int *)this + 39);
}
return result;
}
| update:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOVSS dword ptr [RBP + -0xc],XMM0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
TEST byte ptr [RAX + 0x90],0x1
JZ 0x0011ae43
JMP 0x0011aeee
LAB_0011ae43:
MOV RAX,qword ptr [RBP + -0x18]
MOVSS XMM0,dword ptr [RBP + -0xc]
ADDSS XMM0,dword ptr [RAX + 0xa8]
MOVSS dword ptr [RAX + 0xa8],XMM0
MOVSS XMM0,dword ptr [RAX + 0xa8]
CVTSI2SS XMM2,dword ptr [RAX + 0xa4]
MOVSS XMM1,dword ptr [0x00122004]
DIVSS XMM1,XMM2
UCOMISS XMM0,XMM1
JC 0x0011aed1
MOV RCX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RCX + 0x9c]
ADD EAX,0x1
MOV dword ptr [RCX + 0x9c],EAX
MOV EAX,dword ptr [RCX + 0x9c]
CMP EAX,dword ptr [RCX + 0xa0]
JL 0x0011aec2
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x9c],0x0
TEST byte ptr [RAX + 0xac],0x1
JNZ 0x0011aec0
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x90],0x1
LAB_0011aec0:
JMP 0x0011aec2
LAB_0011aec2:
MOV RAX,qword ptr [RBP + -0x18]
XORPS XMM0,XMM0
MOVSS dword ptr [RAX + 0xa8],XMM0
LAB_0011aed1:
MOV RAX,qword ptr [RBP + -0x18]
MOVSS XMM0,dword ptr [RAX + 0x80]
CVTSI2SS XMM1,dword ptr [RAX + 0x9c]
MULSS XMM0,XMM1
MOVSS dword ptr [RAX + 0x78],XMM0
LAB_0011aeee:
POP RBP
RET
|
/* SpriteAnim::update(float) */
void __thiscall SpriteAnim::update(SpriteAnim *this,float param_1)
{
if (((byte)this[0x90] & 1) == 0) {
*(float *)(this + 0xa8) = param_1 + *(float *)(this + 0xa8);
if (DAT_00122004 / (float)*(int *)(this + 0xa4) <= *(float *)(this + 0xa8)) {
*(int *)(this + 0x9c) = *(int *)(this + 0x9c) + 1;
if ((*(int *)(this + 0xa0) <= *(int *)(this + 0x9c)) &&
(*(int4 *)(this + 0x9c) = 0, ((byte)this[0xac] & 1) == 0)) {
this[0x90] = (SpriteAnim)0x1;
}
*(int4 *)(this + 0xa8) = 0;
}
*(float *)(this + 0x78) = *(float *)(this + 0x80) * (float)*(int *)(this + 0x9c);
}
return;
}
| |
47,209 | SpriteAnim::update(float) | GhostEscape/src/affiliate/sprite_anim.cpp | void SpriteAnim::update(float dt)
{
if (is_finish_) return;
frame_timer_ += dt;
if (frame_timer_ >= 1.0f / fps_)
{
current_frame_++;
if (current_frame_ >= total_frames_)
{
current_frame_ = 0;
if (!is_loop_) is_finish_ = true;
}
frame_timer_ = 0.0f;
}
texture_.src_rect.x = texture_.src_rect.w * current_frame_;
} | O3 | cpp | SpriteAnim::update(float):
cmpb $0x0, 0x90(%rdi)
jne 0xc365
pushq %rbp
movq %rsp, %rbp
addss 0xa8(%rdi), %xmm0
movss %xmm0, 0xa8(%rdi)
cvtsi2ssl 0xa4(%rdi), %xmm1
movss 0x3cf9(%rip), %xmm2 # 0x10004
divss %xmm1, %xmm2
ucomiss %xmm2, %xmm0
movl 0x9c(%rdi), %eax
jb 0xc350
incl %eax
movl %eax, 0x9c(%rdi)
cmpl 0xa0(%rdi), %eax
jl 0xc346
movl $0x0, 0x9c(%rdi)
xorl %eax, %eax
cmpb $0x0, 0xac(%rdi)
jne 0xc346
movb $0x1, 0x90(%rdi)
movl $0x0, 0xa8(%rdi)
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
mulss 0x80(%rdi), %xmm0
movss %xmm0, 0x78(%rdi)
popq %rbp
retq
| _ZN10SpriteAnim6updateEf:
cmp byte ptr [rdi+90h], 0
jnz short locret_C365
push rbp
mov rbp, rsp
addss xmm0, dword ptr [rdi+0A8h]
movss dword ptr [rdi+0A8h], xmm0
cvtsi2ss xmm1, dword ptr [rdi+0A4h]
movss xmm2, cs:dword_10004
divss xmm2, xmm1
ucomiss xmm0, xmm2
mov eax, [rdi+9Ch]
jb short loc_C350
inc eax
mov [rdi+9Ch], eax
cmp eax, [rdi+0A0h]
jl short loc_C346
mov dword ptr [rdi+9Ch], 0
xor eax, eax
cmp byte ptr [rdi+0ACh], 0
jnz short loc_C346
mov byte ptr [rdi+90h], 1
loc_C346:
mov dword ptr [rdi+0A8h], 0
loc_C350:
xorps xmm0, xmm0
cvtsi2ss xmm0, eax
mulss xmm0, dword ptr [rdi+80h]
movss dword ptr [rdi+78h], xmm0
pop rbp
locret_C365:
retn
| void SpriteAnim::update(SpriteAnim *this, float a2)
{
float v2; // xmm0_4
int v3; // eax
if ( !*((_BYTE *)this + 144) )
{
v2 = a2 + *((float *)this + 42);
*((float *)this + 42) = v2;
v3 = *((_DWORD *)this + 39);
if ( v2 >= (float)(1.0 / (float)*((int *)this + 41)) )
{
*((_DWORD *)this + 39) = ++v3;
if ( v3 >= *((_DWORD *)this + 40) )
{
*((_DWORD *)this + 39) = 0;
v3 = 0;
if ( !*((_BYTE *)this + 172) )
*((_BYTE *)this + 144) = 1;
}
*((_DWORD *)this + 42) = 0;
}
*((float *)this + 30) = (float)v3 * *((float *)this + 32);
}
}
| update:
CMP byte ptr [RDI + 0x90],0x0
JNZ 0x0010c365
PUSH RBP
MOV RBP,RSP
ADDSS XMM0,dword ptr [RDI + 0xa8]
MOVSS dword ptr [RDI + 0xa8],XMM0
CVTSI2SS XMM1,dword ptr [RDI + 0xa4]
MOVSS XMM2,dword ptr [0x00110004]
DIVSS XMM2,XMM1
UCOMISS XMM0,XMM2
MOV EAX,dword ptr [RDI + 0x9c]
JC 0x0010c350
INC EAX
MOV dword ptr [RDI + 0x9c],EAX
CMP EAX,dword ptr [RDI + 0xa0]
JL 0x0010c346
MOV dword ptr [RDI + 0x9c],0x0
XOR EAX,EAX
CMP byte ptr [RDI + 0xac],0x0
JNZ 0x0010c346
MOV byte ptr [RDI + 0x90],0x1
LAB_0010c346:
MOV dword ptr [RDI + 0xa8],0x0
LAB_0010c350:
XORPS XMM0,XMM0
CVTSI2SS XMM0,EAX
MULSS XMM0,dword ptr [RDI + 0x80]
MOVSS dword ptr [RDI + 0x78],XMM0
POP RBP
LAB_0010c365:
RET
|
/* SpriteAnim::update(float) */
void __thiscall SpriteAnim::update(SpriteAnim *this,float param_1)
{
float fVar1;
int iVar2;
if (this[0x90] == (SpriteAnim)0x0) {
fVar1 = *(float *)(this + 0xa8);
*(float *)(this + 0xa8) = param_1 + fVar1;
iVar2 = *(int *)(this + 0x9c);
if (DAT_00110004 / (float)*(int *)(this + 0xa4) <= param_1 + fVar1) {
iVar2 = iVar2 + 1;
*(int *)(this + 0x9c) = iVar2;
if (*(int *)(this + 0xa0) <= iVar2) {
*(int4 *)(this + 0x9c) = 0;
iVar2 = 0;
if (this[0xac] == (SpriteAnim)0x0) {
this[0x90] = (SpriteAnim)0x1;
}
}
*(int4 *)(this + 0xa8) = 0;
}
*(float *)(this + 0x78) = (float)iVar2 * *(float *)(this + 0x80);
}
return;
}
| |
47,210 | ma_state_info_write_sub | eloqsql/storage/maria/ma_open.c | uint _ma_state_info_write_sub(File file, MARIA_STATE_INFO *state, uint pWrite)
{
uchar buff[MARIA_STATE_INFO_SIZE + MARIA_STATE_EXTRA_SIZE];
uchar *ptr=buff;
uint i, keys= (uint) state->header.keys;
size_t res;
DBUG_ENTER("_ma_state_info_write_sub");
DBUG_PRINT("info", ("Records: %lld", state->state.records));
memcpy(ptr,&state->header,sizeof(state->header));
ptr+=sizeof(state->header);
/* open_count must be first because of _ma_mark_file_changed ! */
mi_int2store(ptr,state->open_count); ptr+= 2;
/* changed must be second, because of _ma_mark_file_crashed */
mi_int2store(ptr,state->changed); ptr+= 2;
/*
If you change the offset of these LSNs, note that some functions do a
direct write of them without going through this function.
*/
lsn_store(ptr, state->create_rename_lsn); ptr+= LSN_STORE_SIZE;
lsn_store(ptr, state->is_of_horizon); ptr+= LSN_STORE_SIZE;
lsn_store(ptr, state->skip_redo_lsn); ptr+= LSN_STORE_SIZE;
mi_rowstore(ptr,state->state.records); ptr+= 8;
mi_rowstore(ptr,state->state.del); ptr+= 8;
mi_rowstore(ptr,state->split); ptr+= 8;
mi_sizestore(ptr,state->dellink); ptr+= 8;
mi_sizestore(ptr,state->first_bitmap_with_space); ptr+= 8;
mi_sizestore(ptr,state->state.key_file_length); ptr+= 8;
mi_sizestore(ptr,state->state.data_file_length); ptr+= 8;
mi_sizestore(ptr,state->state.empty); ptr+= 8;
mi_sizestore(ptr,state->state.key_empty); ptr+= 8;
mi_int8store(ptr,state->auto_increment); ptr+= 8;
mi_int8store(ptr,(ulonglong) state->state.checksum); ptr+= 8;
mi_int8store(ptr,state->create_trid); ptr+= 8;
mi_int4store(ptr,state->status); ptr+= 4;
mi_int4store(ptr,state->update_count); ptr+= 4;
*ptr++= state->sortkey;
*ptr++= 0; /* Reserved */
ptr+= state->state_diff_length;
for (i=0; i < keys; i++)
{
mi_sizestore(ptr,state->key_root[i]); ptr+= 8;
}
mi_sizestore(ptr,state->key_del); ptr+= 8;
if (pWrite & MA_STATE_INFO_WRITE_FULL_INFO) /* From maria_chk */
{
uint key_parts= mi_uint2korr(state->header.key_parts);
mi_int4store(ptr,state->sec_index_changed); ptr+= 4;
mi_int4store(ptr,state->sec_index_used); ptr+= 4;
mi_int4store(ptr,state->version); ptr+= 4;
mi_int8store(ptr,state->key_map); ptr+= 8;
mi_int8store(ptr,(ulonglong) state->create_time); ptr+= 8;
mi_int8store(ptr,(ulonglong) state->recover_time); ptr+= 8;
mi_int8store(ptr,(ulonglong) state->check_time); ptr+= 8;
mi_sizestore(ptr, state->records_at_analyze); ptr+= 8;
/* reserve place for some information per key */
bzero(ptr, keys*4); ptr+= keys*4;
for (i=0 ; i < key_parts ; i++)
{
float8store(ptr, state->rec_per_key_part[i]); ptr+= 8;
mi_int4store(ptr, state->nulls_per_key_part[i]); ptr+= 4;
}
}
res= (pWrite & MA_STATE_INFO_WRITE_DONT_MOVE_OFFSET) ?
mysql_file_pwrite(file, buff, (size_t) (ptr-buff), 0L,
MYF(MY_NABP | MY_THREADSAFE)) :
mysql_file_write(file, buff, (size_t) (ptr-buff),
MYF(MY_NABP));
DBUG_RETURN(res != 0);
} | O3 | c | ma_state_info_write_sub:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x6438, %rsp # imm = 0x6438
movq %rsi, %r14
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movzbl 0x12(%rsi), %r13d
movq 0x10(%rsi), %rax
movq %rax, -0x6400(%rbp)
movups (%rsi), %xmm0
movaps %xmm0, -0x6410(%rbp)
movzwl 0x16c(%rsi), %eax
rolw $0x8, %ax
movw %ax, -0x63f8(%rbp)
movzwl 0x170(%rsi), %eax
rolw $0x8, %ax
movw %ax, -0x63f6(%rbp)
movq 0x178(%rsi), %rax
movq %rax, %rcx
shrq $0x20, %rcx
movb %cl, -0x63f4(%rbp)
movq %rax, %rcx
shrq $0x28, %rcx
movb %cl, -0x63f3(%rbp)
movq %rax, %rcx
shrq $0x30, %rcx
movb %cl, -0x63f2(%rbp)
movl %eax, -0x63f1(%rbp)
movq 0x180(%rsi), %rax
movq %rax, %rcx
shrq $0x20, %rcx
movb %cl, -0x63ed(%rbp)
movq %rax, %rcx
shrq $0x28, %rcx
movb %cl, -0x63ec(%rbp)
movq %rax, %rcx
shrq $0x30, %rcx
movb %cl, -0x63eb(%rbp)
movl %eax, -0x63ea(%rbp)
movq 0x188(%rsi), %rax
movq %rax, %rcx
shrq $0x20, %rcx
movb %cl, -0x63e6(%rbp)
movq %rax, %rcx
shrq $0x28, %rcx
movb %cl, -0x63e5(%rbp)
movq %rax, %rcx
shrq $0x30, %rcx
movb %cl, -0x63e4(%rbp)
movl %eax, -0x63e3(%rbp)
movq 0x18(%rsi), %rax
bswapq %rax
movq %rax, -0x63df(%rbp)
movq 0x20(%rsi), %rax
bswapq %rax
movq %rax, -0x63d7(%rbp)
movq 0xc0(%rsi), %rax
bswapq %rax
movq %rax, -0x63cf(%rbp)
movq 0xc8(%rsi), %rax
bswapq %rax
movq %rax, -0x63c7(%rbp)
movq 0xd0(%rsi), %rax
bswapq %rax
movq %rax, -0x63bf(%rbp)
movq 0x38(%rsi), %rax
bswapq %rax
movq %rax, -0x63b7(%rbp)
movq 0x40(%rsi), %rax
bswapq %rax
movq %rax, -0x63af(%rbp)
movq 0x28(%rsi), %rax
bswapq %rax
movq %rax, -0x63a7(%rbp)
movq 0x30(%rsi), %rax
bswapq %rax
movq %rax, -0x639f(%rbp)
movq 0xd8(%rsi), %rax
bswapq %rax
movl %edi, %r15d
movq %rax, -0x6397(%rbp)
movl 0x48(%rsi), %eax
movl %eax, %ecx
movl $0x0, -0x638f(%rbp)
movb %al, -0x6388(%rbp)
movb %ah, -0x6389(%rbp)
shrl $0x10, %eax
shrl $0x18, %ecx
movb %al, -0x638a(%rbp)
movb %cl, -0x638b(%rbp)
movq 0xe0(%rsi), %rax
bswapq %rax
movq %rax, -0x6387(%rbp)
movl 0xf8(%rsi), %eax
bswapl %eax
movl %eax, -0x637f(%rbp)
movl 0xf0(%rsi), %eax
bswapl %eax
movl %eax, -0x637b(%rbp)
movb 0x168(%rsi), %al
movb %al, -0x6377(%rbp)
movb $0x0, -0x6376(%rbp)
movl 0x19c(%rsi), %eax
leaq (%rax,%rbp), %r12
addq $-0x6375, %r12 # imm = 0x9C8B
testq %r13, %r13
je 0x54d8a
movq 0x118(%r14), %rax
leal (,%r13,8), %r8d
xorl %ecx, %ecx
movq (%rax,%rcx), %rsi
bswapq %rsi
movq %rsi, (%r12,%rcx)
addq $0x8, %rcx
cmpq %rcx, %r8
jne 0x54d73
addq %rcx, %r12
movq 0x120(%r14), %rax
bswapq %rax
movq %rax, (%r12)
testb $0x2, %dl
jne 0x54da6
addq $0x8, %r12
jmp 0x54e92
movl %edx, -0x6414(%rbp)
movzbl 0xf(%r14), %eax
movl %eax, -0x6418(%rbp)
movzbl 0xe(%r14), %ebx
movl 0x130(%r14), %eax
bswapl %eax
movl %eax, 0x8(%r12)
movl 0x138(%r14), %eax
bswapl %eax
movl %eax, 0xc(%r12)
movl 0x148(%r14), %eax
bswapl %eax
movl %eax, 0x10(%r12)
movq 0x140(%r14), %rax
bswapq %rax
movq %rax, 0x14(%r12)
movq 0x150(%r14), %rax
bswapq %rax
movq %rax, 0x1c(%r12)
movq 0x158(%r14), %rax
bswapq %rax
movq %rax, 0x24(%r12)
movq 0x160(%r14), %rax
bswapq %rax
movq %rax, 0x2c(%r12)
movq 0x128(%r14), %rax
bswapq %rax
shll $0x8, %ebx
movq %rax, 0x34(%r12)
leaq 0x3c(%r12), %rdi
shll $0x2, %r13d
xorl %esi, %esi
movq %r13, %rdx
callq 0x292c0
addq %r13, %r12
addq $0x3c, %r12
orl -0x6418(%rbp), %ebx
je 0x54e8c
xorl %eax, %eax
movl -0x6414(%rbp), %edx
movq 0x100(%r14), %rcx
movq (%rcx,%rax,8), %rcx
movq %rcx, (%r12)
movq 0x108(%r14), %rcx
movl (%rcx,%rax,8), %ecx
bswapl %ecx
movl %ecx, 0x8(%r12)
addq $0xc, %r12
incq %rax
cmpq %rax, %rbx
jne 0x54e5e
jmp 0x54e92
movl -0x6414(%rbp), %edx
leaq -0x6410(%rbp), %rax
subq %rax, %r12
leaq 0x33116d(%rip), %r13 # 0x386010
testb $0x1, %dl
jne 0x54ee3
movq (%r13), %rax
leaq -0x6460(%rbp), %rdi
movl %r15d, %esi
movl $0x7, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x54f53
leaq -0x6410(%rbp), %rsi
movl $0x4, %ecx
movl %r15d, %edi
movq %r12, %rdx
callq 0x2f004
jmp 0x54f21
movq (%r13), %rax
leaq -0x6460(%rbp), %rdi
movl %r15d, %ebx
movl %r15d, %esi
movl $0x7, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x54f9e
leaq -0x6410(%rbp), %rsi
movl $0x804, %r8d # imm = 0x804
movl %ebx, %edi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0xa033e
movq %rax, %rbx
xorl %eax, %eax
testq %rbx, %rbx
setne %cl
movq %fs:0x28, %rdx
cmpq -0x30(%rbp), %rdx
jne 0x54ff8
movb %cl, %al
addq $0x6438, %rsp # imm = 0x6438
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r13), %rax
leaq 0x8581a(%rip), %rdx # 0xda77b
movq %r14, %rdi
movq %r12, %rsi
movl $0x65c, %ecx # imm = 0x65C
callq *0x210(%rax)
leaq -0x6410(%rbp), %rsi
movl $0x4, %ecx
movl %r15d, %edi
movq %r12, %rdx
callq 0x2f004
movq %rax, %rbx
xorl %esi, %esi
testq %rax, %rax
cmoveq %r12, %rsi
movq (%r13), %rax
movq %r14, %rdi
jmp 0x54fed
movq %rax, %r14
movq (%r13), %rax
leaq 0x857cf(%rip), %rdx # 0xda77b
movq %r14, %rdi
movq %r12, %rsi
movl $0x65a, %ecx # imm = 0x65A
callq *0x210(%rax)
xorl %r15d, %r15d
leaq -0x6410(%rbp), %rsi
movl $0x804, %r8d # imm = 0x804
movl %ebx, %edi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0xa033e
movq %rax, %rbx
testq %rax, %rax
cmoveq %r12, %r15
movq (%r13), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x218(%rax)
jmp 0x54f24
callq 0x29270
| _ma_state_info_write_sub:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 6438h
mov r14, rsi
mov rax, fs:28h
mov [rbp+var_30], rax
movzx r13d, byte ptr [rsi+12h]
mov rax, [rsi+10h]
mov [rbp+var_6400], rax
movups xmm0, xmmword ptr [rsi]
movaps [rbp+var_6410], xmm0
movzx eax, word ptr [rsi+16Ch]
rol ax, 8
mov [rbp+var_63F8], ax
movzx eax, word ptr [rsi+170h]
rol ax, 8
mov [rbp+var_63F6], ax
mov rax, [rsi+178h]
mov rcx, rax
shr rcx, 20h
mov [rbp+var_63F4], cl
mov rcx, rax
shr rcx, 28h
mov [rbp+var_63F3], cl
mov rcx, rax
shr rcx, 30h
mov [rbp+var_63F2], cl
mov [rbp+var_63F1], eax
mov rax, [rsi+180h]
mov rcx, rax
shr rcx, 20h
mov [rbp+var_63ED], cl
mov rcx, rax
shr rcx, 28h
mov [rbp+var_63EC], cl
mov rcx, rax
shr rcx, 30h
mov [rbp+var_63EB], cl
mov [rbp+var_63EA], eax
mov rax, [rsi+188h]
mov rcx, rax
shr rcx, 20h
mov [rbp+var_63E6], cl
mov rcx, rax
shr rcx, 28h
mov [rbp+var_63E5], cl
mov rcx, rax
shr rcx, 30h
mov [rbp+var_63E4], cl
mov [rbp+var_63E3], eax
mov rax, [rsi+18h]
bswap rax
mov [rbp+var_63DF], rax
mov rax, [rsi+20h]
bswap rax
mov [rbp+var_63D7], rax
mov rax, [rsi+0C0h]
bswap rax
mov [rbp+var_63CF], rax
mov rax, [rsi+0C8h]
bswap rax
mov [rbp+var_63C7], rax
mov rax, [rsi+0D0h]
bswap rax
mov [rbp+var_63BF], rax
mov rax, [rsi+38h]
bswap rax
mov [rbp+var_63B7], rax
mov rax, [rsi+40h]
bswap rax
mov [rbp+var_63AF], rax
mov rax, [rsi+28h]
bswap rax
mov [rbp+var_63A7], rax
mov rax, [rsi+30h]
bswap rax
mov [rbp+var_639F], rax
mov rax, [rsi+0D8h]
bswap rax
mov r15d, edi
mov [rbp+var_6397], rax
mov eax, [rsi+48h]
mov ecx, eax
mov [rbp+var_638F], 0
mov [rbp+var_6388], al
mov [rbp+var_6389], ah
shr eax, 10h
shr ecx, 18h
mov [rbp+var_638A], al
mov [rbp+var_638B], cl
mov rax, [rsi+0E0h]
bswap rax
mov [rbp+var_6387], rax
mov eax, [rsi+0F8h]
bswap eax
mov [rbp+var_637F], eax
mov eax, [rsi+0F0h]
bswap eax
mov [rbp+var_637B], eax
mov al, [rsi+168h]
mov [rbp+var_6377], al
mov [rbp+var_6376], 0
mov eax, [rsi+19Ch]
lea r12, [rax+rbp]
add r12, 0FFFFFFFFFFFF9C8Bh
test r13, r13
jz short loc_54D8A
mov rax, [r14+118h]
lea r8d, ds:0[r13*8]
xor ecx, ecx
loc_54D73:
mov rsi, [rax+rcx]
bswap rsi
mov [r12+rcx], rsi
add rcx, 8
cmp r8, rcx
jnz short loc_54D73
add r12, rcx
loc_54D8A:
mov rax, [r14+120h]
bswap rax
mov [r12], rax
test dl, 2
jnz short loc_54DA6
add r12, 8
jmp loc_54E92
loc_54DA6:
mov [rbp+var_6414], edx
movzx eax, byte ptr [r14+0Fh]
mov [rbp+var_6418], eax
movzx ebx, byte ptr [r14+0Eh]
mov eax, [r14+130h]
bswap eax
mov [r12+8], eax
mov eax, [r14+138h]
bswap eax
mov [r12+0Ch], eax
mov eax, [r14+148h]
bswap eax
mov [r12+10h], eax
mov rax, [r14+140h]
bswap rax
mov [r12+14h], rax
mov rax, [r14+150h]
bswap rax
mov [r12+1Ch], rax
mov rax, [r14+158h]
bswap rax
mov [r12+24h], rax
mov rax, [r14+160h]
bswap rax
mov [r12+2Ch], rax
mov rax, [r14+128h]
bswap rax
shl ebx, 8
mov [r12+34h], rax
lea rdi, [r12+3Ch]
shl r13d, 2
xor esi, esi
mov rdx, r13
call _memset
add r12, r13
add r12, 3Ch ; '<'
or ebx, [rbp+var_6418]
jz short loc_54E8C
xor eax, eax
mov edx, [rbp+var_6414]
loc_54E5E:
mov rcx, [r14+100h]
mov rcx, [rcx+rax*8]
mov [r12], rcx
mov rcx, [r14+108h]
mov ecx, [rcx+rax*8]
bswap ecx
mov [r12+8], ecx
add r12, 0Ch
inc rax
cmp rbx, rax
jnz short loc_54E5E
jmp short loc_54E92
loc_54E8C:
mov edx, [rbp+var_6414]
loc_54E92:
lea rax, [rbp+var_6410]
sub r12, rax
lea r13, PSI_server
test dl, 1
jnz short loc_54EE3
mov rax, [r13+0]
lea rdi, [rbp+var_6460]
mov esi, r15d
mov edx, 7
call qword ptr [rax+158h]
test rax, rax
jnz loc_54F53
lea rsi, [rbp+var_6410]
mov ecx, 4
mov edi, r15d
mov rdx, r12
call my_write
jmp short loc_54F21
loc_54EE3:
mov rax, [r13+0]
lea rdi, [rbp+var_6460]
mov ebx, r15d
mov esi, r15d
mov edx, 7
call qword ptr [rax+158h]
test rax, rax
jnz loc_54F9E
lea rsi, [rbp+var_6410]
mov r8d, 804h
mov edi, ebx
mov rdx, r12
xor ecx, ecx
call my_pwrite
loc_54F21:
mov rbx, rax
loc_54F24:
xor eax, eax
test rbx, rbx
setnz cl
mov rdx, fs:28h
cmp rdx, [rbp+var_30]
jnz loc_54FF8
mov al, cl
add rsp, 6438h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_54F53:
mov r14, rax
mov rax, [r13+0]
lea rdx, aWorkspaceLlm4b_9; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r14
mov rsi, r12
mov ecx, 65Ch
call qword ptr [rax+210h]
lea rsi, [rbp+var_6410]
mov ecx, 4
mov edi, r15d
mov rdx, r12
call my_write
mov rbx, rax
xor esi, esi
test rax, rax
cmovz rsi, r12
mov rax, [r13+0]
mov rdi, r14
jmp short loc_54FED
loc_54F9E:
mov r14, rax
mov rax, [r13+0]
lea rdx, aWorkspaceLlm4b_9; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r14
mov rsi, r12
mov ecx, 65Ah
call qword ptr [rax+210h]
xor r15d, r15d
lea rsi, [rbp+var_6410]
mov r8d, 804h
mov edi, ebx
mov rdx, r12
xor ecx, ecx
call my_pwrite
mov rbx, rax
test rax, rax
cmovz r15, r12
mov rax, [r13+0]
mov rdi, r14
mov rsi, r15
loc_54FED:
call qword ptr [rax+218h]
jmp loc_54F24
loc_54FF8:
call ___stack_chk_fail
| bool ma_state_info_write_sub(unsigned int a1, __int128 *a2, int a3)
{
long long v3; // r13
long long v4; // rax
long long v5; // rax
long long v6; // rax
int v7; // ecx
_BYTE *v8; // r12
long long v9; // rax
long long v10; // rcx
long long v11; // r12
int v12; // ebx
long long v13; // r13
int v14; // ebx
long long v15; // rax
long long v16; // r12
long long v17; // rax
long long v18; // rax
long long v19; // rax
long long v20; // rbx
long long v22; // r14
long long v23; // rsi
long long ( **v24)(); // rax
long long v25; // rdi
long long v26; // r14
long long v27; // r15
_BYTE v29[72]; // [rsp+0h] [rbp-6460h] BYREF
int v30; // [rsp+48h] [rbp-6418h]
int v31; // [rsp+4Ch] [rbp-6414h]
__int128 v32; // [rsp+50h] [rbp-6410h] BYREF
long long v33; // [rsp+60h] [rbp-6400h]
__int16 v34; // [rsp+68h] [rbp-63F8h]
__int16 v35; // [rsp+6Ah] [rbp-63F6h]
char v36; // [rsp+6Ch] [rbp-63F4h]
char v37; // [rsp+6Dh] [rbp-63F3h]
char v38; // [rsp+6Eh] [rbp-63F2h]
int v39; // [rsp+6Fh] [rbp-63F1h]
char v40; // [rsp+73h] [rbp-63EDh]
char v41; // [rsp+74h] [rbp-63ECh]
char v42; // [rsp+75h] [rbp-63EBh]
int v43; // [rsp+76h] [rbp-63EAh]
char v44; // [rsp+7Ah] [rbp-63E6h]
char v45; // [rsp+7Bh] [rbp-63E5h]
char v46; // [rsp+7Ch] [rbp-63E4h]
int v47; // [rsp+7Dh] [rbp-63E3h]
unsigned long long v48; // [rsp+81h] [rbp-63DFh]
unsigned long long v49; // [rsp+89h] [rbp-63D7h]
unsigned long long v50; // [rsp+91h] [rbp-63CFh]
unsigned long long v51; // [rsp+99h] [rbp-63C7h]
unsigned long long v52; // [rsp+A1h] [rbp-63BFh]
unsigned long long v53; // [rsp+A9h] [rbp-63B7h]
unsigned long long v54; // [rsp+B1h] [rbp-63AFh]
unsigned long long v55; // [rsp+B9h] [rbp-63A7h]
unsigned long long v56; // [rsp+C1h] [rbp-639Fh]
unsigned long long v57; // [rsp+C9h] [rbp-6397h]
int v58; // [rsp+D1h] [rbp-638Fh]
char v59; // [rsp+D5h] [rbp-638Bh]
char v60; // [rsp+D6h] [rbp-638Ah]
char v61; // [rsp+D7h] [rbp-6389h]
char v62; // [rsp+D8h] [rbp-6388h]
unsigned long long v63; // [rsp+D9h] [rbp-6387h]
unsigned __int32 v64; // [rsp+E1h] [rbp-637Fh]
unsigned __int32 v65; // [rsp+E5h] [rbp-637Bh]
char v66; // [rsp+E9h] [rbp-6377h]
char v67; // [rsp+EAh] [rbp-6376h]
_BYTE v68[25413]; // [rsp+EBh] [rbp-6375h] BYREF
unsigned long long v69; // [rsp+6430h] [rbp-30h]
v69 = __readfsqword(0x28u);
v3 = *((unsigned __int8 *)a2 + 18);
v33 = *((_QWORD *)a2 + 2);
v32 = *a2;
v34 = __ROL2__(*((_WORD *)a2 + 182), 8);
v35 = __ROL2__(*((_WORD *)a2 + 184), 8);
v4 = *((_QWORD *)a2 + 47);
v36 = BYTE4(v4);
v37 = BYTE5(v4);
v38 = BYTE6(v4);
v39 = v4;
v5 = *((_QWORD *)a2 + 48);
v40 = BYTE4(v5);
v41 = BYTE5(v5);
v42 = BYTE6(v5);
v43 = v5;
v6 = *((_QWORD *)a2 + 49);
v44 = BYTE4(v6);
v45 = BYTE5(v6);
v46 = BYTE6(v6);
v47 = v6;
v48 = _byteswap_uint64(*((_QWORD *)a2 + 3));
v49 = _byteswap_uint64(*((_QWORD *)a2 + 4));
v50 = _byteswap_uint64(*((_QWORD *)a2 + 24));
v51 = _byteswap_uint64(*((_QWORD *)a2 + 25));
v52 = _byteswap_uint64(*((_QWORD *)a2 + 26));
v53 = _byteswap_uint64(*((_QWORD *)a2 + 7));
v54 = _byteswap_uint64(*((_QWORD *)a2 + 8));
v55 = _byteswap_uint64(*((_QWORD *)a2 + 5));
v56 = _byteswap_uint64(*((_QWORD *)a2 + 6));
v57 = _byteswap_uint64(*((_QWORD *)a2 + 27));
v7 = *((_DWORD *)a2 + 18);
v58 = 0;
v61 = BYTE1(v7);
v62 = v7;
v60 = BYTE2(v7);
v59 = HIBYTE(v7);
v63 = _byteswap_uint64(*((_QWORD *)a2 + 28));
v64 = _byteswap_ulong(*((_DWORD *)a2 + 62));
v65 = _byteswap_ulong(*((_DWORD *)a2 + 60));
v66 = *((_BYTE *)a2 + 360);
v67 = 0;
v8 = &v68[*((unsigned int *)a2 + 103)];
if ( v3 )
{
v9 = *((_QWORD *)a2 + 35);
v10 = 0LL;
do
{
*(_QWORD *)&v8[v10] = _byteswap_uint64(*(_QWORD *)(v9 + v10));
v10 += 8LL;
}
while ( 8 * (_DWORD)v3 != v10 );
v8 += v10;
}
*(_QWORD *)v8 = _byteswap_uint64(*((_QWORD *)a2 + 36));
if ( (a3 & 2) != 0 )
{
v31 = a3;
v30 = *((unsigned __int8 *)a2 + 15);
v12 = *((unsigned __int8 *)a2 + 14);
*((_DWORD *)v8 + 2) = _byteswap_ulong(*((_DWORD *)a2 + 76));
*((_DWORD *)v8 + 3) = _byteswap_ulong(*((_DWORD *)a2 + 78));
*((_DWORD *)v8 + 4) = _byteswap_ulong(*((_DWORD *)a2 + 82));
*(_QWORD *)(v8 + 20) = _byteswap_uint64(*((_QWORD *)a2 + 40));
*(_QWORD *)(v8 + 28) = _byteswap_uint64(*((_QWORD *)a2 + 42));
*(_QWORD *)(v8 + 36) = _byteswap_uint64(*((_QWORD *)a2 + 43));
*(_QWORD *)(v8 + 44) = _byteswap_uint64(*((_QWORD *)a2 + 44));
*(_QWORD *)(v8 + 52) = _byteswap_uint64(*((_QWORD *)a2 + 37));
v13 = (unsigned int)(4 * v3);
memset(v8 + 60, 0LL, v13);
v11 = (long long)&v8[v13 + 60];
v14 = v30 | (v12 << 8);
if ( v14 )
{
v15 = 0LL;
LOBYTE(a3) = v31;
do
{
*(_QWORD *)v11 = *(_QWORD *)(*((_QWORD *)a2 + 32) + 8 * v15);
*(_DWORD *)(v11 + 8) = _byteswap_ulong(*(_DWORD *)(*((_QWORD *)a2 + 33) + 8 * v15));
v11 += 12LL;
++v15;
}
while ( v14 != v15 );
}
else
{
LOBYTE(a3) = v31;
}
}
else
{
v11 = (long long)(v8 + 8);
}
v16 = v11 - (_QWORD)&v32;
if ( (a3 & 1) != 0 )
{
v19 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v29, a1, 7LL);
if ( !v19 )
{
v18 = my_pwrite(a1, &v32, v16, 0LL, 2052LL);
goto LABEL_17;
}
v26 = v19;
((void ( *)(long long, long long, const char *, long long))PSI_server[66])(
v19,
v16,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_open.c",
1626LL);
v27 = 0LL;
v20 = my_pwrite(a1, &v32, v16, 0LL, 2052LL);
if ( !v20 )
v27 = v16;
v24 = PSI_server;
v25 = v26;
v23 = v27;
LABEL_25:
((void ( *)(long long, long long))v24[67])(v25, v23);
return v20 != 0;
}
v17 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v29, a1, 7LL);
if ( v17 )
{
v22 = v17;
((void ( *)(long long, long long, const char *, long long))PSI_server[66])(
v17,
v16,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_open.c",
1628LL);
v20 = my_write(a1, (long long)&v32, v16, 4LL);
v23 = 0LL;
if ( !v20 )
v23 = v16;
v24 = PSI_server;
v25 = v22;
goto LABEL_25;
}
v18 = my_write(a1, (long long)&v32, v16, 4LL);
LABEL_17:
v20 = v18;
return v20 != 0;
}
| _ma_state_info_write_sub:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x6438
MOV R14,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOVZX R13D,byte ptr [RSI + 0x12]
MOV RAX,qword ptr [RSI + 0x10]
MOV qword ptr [RBP + -0x6400],RAX
MOVUPS XMM0,xmmword ptr [RSI]
MOVAPS xmmword ptr [RBP + -0x6410],XMM0
MOVZX EAX,word ptr [RSI + 0x16c]
ROL AX,0x8
MOV word ptr [RBP + -0x63f8],AX
MOVZX EAX,word ptr [RSI + 0x170]
ROL AX,0x8
MOV word ptr [RBP + -0x63f6],AX
MOV RAX,qword ptr [RSI + 0x178]
MOV RCX,RAX
SHR RCX,0x20
MOV byte ptr [RBP + -0x63f4],CL
MOV RCX,RAX
SHR RCX,0x28
MOV byte ptr [RBP + -0x63f3],CL
MOV RCX,RAX
SHR RCX,0x30
MOV byte ptr [RBP + -0x63f2],CL
MOV dword ptr [RBP + -0x63f1],EAX
MOV RAX,qword ptr [RSI + 0x180]
MOV RCX,RAX
SHR RCX,0x20
MOV byte ptr [RBP + -0x63ed],CL
MOV RCX,RAX
SHR RCX,0x28
MOV byte ptr [RBP + -0x63ec],CL
MOV RCX,RAX
SHR RCX,0x30
MOV byte ptr [RBP + -0x63eb],CL
MOV dword ptr [RBP + -0x63ea],EAX
MOV RAX,qword ptr [RSI + 0x188]
MOV RCX,RAX
SHR RCX,0x20
MOV byte ptr [RBP + -0x63e6],CL
MOV RCX,RAX
SHR RCX,0x28
MOV byte ptr [RBP + -0x63e5],CL
MOV RCX,RAX
SHR RCX,0x30
MOV byte ptr [RBP + -0x63e4],CL
MOV dword ptr [RBP + -0x63e3],EAX
MOV RAX,qword ptr [RSI + 0x18]
BSWAP RAX
MOV qword ptr [RBP + -0x63df],RAX
MOV RAX,qword ptr [RSI + 0x20]
BSWAP RAX
MOV qword ptr [RBP + -0x63d7],RAX
MOV RAX,qword ptr [RSI + 0xc0]
BSWAP RAX
MOV qword ptr [RBP + -0x63cf],RAX
MOV RAX,qword ptr [RSI + 0xc8]
BSWAP RAX
MOV qword ptr [RBP + -0x63c7],RAX
MOV RAX,qword ptr [RSI + 0xd0]
BSWAP RAX
MOV qword ptr [RBP + -0x63bf],RAX
MOV RAX,qword ptr [RSI + 0x38]
BSWAP RAX
MOV qword ptr [RBP + -0x63b7],RAX
MOV RAX,qword ptr [RSI + 0x40]
BSWAP RAX
MOV qword ptr [RBP + -0x63af],RAX
MOV RAX,qword ptr [RSI + 0x28]
BSWAP RAX
MOV qword ptr [RBP + -0x63a7],RAX
MOV RAX,qword ptr [RSI + 0x30]
BSWAP RAX
MOV qword ptr [RBP + -0x639f],RAX
MOV RAX,qword ptr [RSI + 0xd8]
BSWAP RAX
MOV R15D,EDI
MOV qword ptr [RBP + -0x6397],RAX
MOV EAX,dword ptr [RSI + 0x48]
MOV ECX,EAX
MOV dword ptr [RBP + -0x638f],0x0
MOV byte ptr [RBP + -0x6388],AL
MOV byte ptr [RBP + -0x6389],AH
SHR EAX,0x10
SHR ECX,0x18
MOV byte ptr [RBP + -0x638a],AL
MOV byte ptr [RBP + -0x638b],CL
MOV RAX,qword ptr [RSI + 0xe0]
BSWAP RAX
MOV qword ptr [RBP + -0x6387],RAX
MOV EAX,dword ptr [RSI + 0xf8]
BSWAP EAX
MOV dword ptr [RBP + -0x637f],EAX
MOV EAX,dword ptr [RSI + 0xf0]
BSWAP EAX
MOV dword ptr [RBP + -0x637b],EAX
MOV AL,byte ptr [RSI + 0x168]
MOV byte ptr [RBP + -0x6377],AL
MOV byte ptr [RBP + -0x6376],0x0
MOV EAX,dword ptr [RSI + 0x19c]
LEA R12,[RAX + RBP*0x1]
ADD R12,-0x6375
TEST R13,R13
JZ 0x00154d8a
MOV RAX,qword ptr [R14 + 0x118]
LEA R8D,[R13*0x8]
XOR ECX,ECX
LAB_00154d73:
MOV RSI,qword ptr [RAX + RCX*0x1]
BSWAP RSI
MOV qword ptr [R12 + RCX*0x1],RSI
ADD RCX,0x8
CMP R8,RCX
JNZ 0x00154d73
ADD R12,RCX
LAB_00154d8a:
MOV RAX,qword ptr [R14 + 0x120]
BSWAP RAX
MOV qword ptr [R12],RAX
TEST DL,0x2
JNZ 0x00154da6
ADD R12,0x8
JMP 0x00154e92
LAB_00154da6:
MOV dword ptr [RBP + -0x6414],EDX
MOVZX EAX,byte ptr [R14 + 0xf]
MOV dword ptr [RBP + -0x6418],EAX
MOVZX EBX,byte ptr [R14 + 0xe]
MOV EAX,dword ptr [R14 + 0x130]
BSWAP EAX
MOV dword ptr [R12 + 0x8],EAX
MOV EAX,dword ptr [R14 + 0x138]
BSWAP EAX
MOV dword ptr [R12 + 0xc],EAX
MOV EAX,dword ptr [R14 + 0x148]
BSWAP EAX
MOV dword ptr [R12 + 0x10],EAX
MOV RAX,qword ptr [R14 + 0x140]
BSWAP RAX
MOV qword ptr [R12 + 0x14],RAX
MOV RAX,qword ptr [R14 + 0x150]
BSWAP RAX
MOV qword ptr [R12 + 0x1c],RAX
MOV RAX,qword ptr [R14 + 0x158]
BSWAP RAX
MOV qword ptr [R12 + 0x24],RAX
MOV RAX,qword ptr [R14 + 0x160]
BSWAP RAX
MOV qword ptr [R12 + 0x2c],RAX
MOV RAX,qword ptr [R14 + 0x128]
BSWAP RAX
SHL EBX,0x8
MOV qword ptr [R12 + 0x34],RAX
LEA RDI,[R12 + 0x3c]
SHL R13D,0x2
XOR ESI,ESI
MOV RDX,R13
CALL 0x001292c0
ADD R12,R13
ADD R12,0x3c
OR EBX,dword ptr [RBP + -0x6418]
JZ 0x00154e8c
XOR EAX,EAX
MOV EDX,dword ptr [RBP + -0x6414]
LAB_00154e5e:
MOV RCX,qword ptr [R14 + 0x100]
MOV RCX,qword ptr [RCX + RAX*0x8]
MOV qword ptr [R12],RCX
MOV RCX,qword ptr [R14 + 0x108]
MOV ECX,dword ptr [RCX + RAX*0x8]
BSWAP ECX
MOV dword ptr [R12 + 0x8],ECX
ADD R12,0xc
INC RAX
CMP RBX,RAX
JNZ 0x00154e5e
JMP 0x00154e92
LAB_00154e8c:
MOV EDX,dword ptr [RBP + -0x6414]
LAB_00154e92:
LEA RAX,[RBP + -0x6410]
SUB R12,RAX
LEA R13,[0x486010]
TEST DL,0x1
JNZ 0x00154ee3
MOV RAX,qword ptr [R13]
LEA RDI,[RBP + -0x6460]
MOV ESI,R15D
MOV EDX,0x7
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x00154f53
LEA RSI,[RBP + -0x6410]
MOV ECX,0x4
MOV EDI,R15D
MOV RDX,R12
CALL 0x0012f004
JMP 0x00154f21
LAB_00154ee3:
MOV RAX,qword ptr [R13]
LEA RDI,[RBP + -0x6460]
MOV EBX,R15D
MOV ESI,R15D
MOV EDX,0x7
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x00154f9e
LEA RSI,[RBP + -0x6410]
MOV R8D,0x804
MOV EDI,EBX
MOV RDX,R12
XOR ECX,ECX
CALL 0x001a033e
LAB_00154f21:
MOV RBX,RAX
LAB_00154f24:
XOR EAX,EAX
TEST RBX,RBX
SETNZ CL
MOV RDX,qword ptr FS:[0x28]
CMP RDX,qword ptr [RBP + -0x30]
JNZ 0x00154ff8
MOV AL,CL
ADD RSP,0x6438
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00154f53:
MOV R14,RAX
MOV RAX,qword ptr [R13]
LEA RDX,[0x1da77b]
MOV RDI,R14
MOV RSI,R12
MOV ECX,0x65c
CALL qword ptr [RAX + 0x210]
LEA RSI,[RBP + -0x6410]
MOV ECX,0x4
MOV EDI,R15D
MOV RDX,R12
CALL 0x0012f004
MOV RBX,RAX
XOR ESI,ESI
TEST RAX,RAX
CMOVZ RSI,R12
MOV RAX,qword ptr [R13]
MOV RDI,R14
JMP 0x00154fed
LAB_00154f9e:
MOV R14,RAX
MOV RAX,qword ptr [R13]
LEA RDX,[0x1da77b]
MOV RDI,R14
MOV RSI,R12
MOV ECX,0x65a
CALL qword ptr [RAX + 0x210]
XOR R15D,R15D
LEA RSI,[RBP + -0x6410]
MOV R8D,0x804
MOV EDI,EBX
MOV RDX,R12
XOR ECX,ECX
CALL 0x001a033e
MOV RBX,RAX
TEST RAX,RAX
CMOVZ R15,R12
MOV RAX,qword ptr [R13]
MOV RDI,R14
MOV RSI,R15
LAB_00154fed:
CALL qword ptr [RAX + 0x218]
JMP 0x00154f24
LAB_00154ff8:
CALL 0x00129270
|
bool _ma_state_info_write_sub(int4 param_1,int8 *param_2,uint param_3)
{
byte bVar1;
byte bVar2;
int4 uVar3;
uint uVar4;
int8 uVar5;
ulong uVar6;
long lVar7;
long lVar8;
ulong uVar9;
uint uVar10;
long lVar11;
ulong *puVar12;
long lVar13;
long in_FS_OFFSET;
int1 local_6468 [72];
uint local_6420;
uint local_641c;
int8 local_6418;
int8 uStack_6410;
int8 local_6408;
ushort local_6400;
ushort local_63fe;
int1 local_63fc;
int1 local_63fb;
int1 local_63fa;
int4 local_63f9;
int1 local_63f5;
int1 local_63f4;
int1 local_63f3;
int4 local_63f2;
int1 local_63ee;
int1 local_63ed;
int1 local_63ec;
int4 local_63eb;
ulong local_63e7;
ulong local_63df;
ulong local_63d7;
ulong local_63cf;
ulong local_63c7;
ulong local_63bf;
ulong local_63b7;
ulong local_63af;
ulong local_63a7;
ulong local_639f;
int4 local_6397;
int1 local_6393;
int1 local_6392;
int1 local_6391;
int1 local_6390;
ulong local_638f;
uint local_6387;
uint local_6383;
int1 local_637f;
int1 local_637e;
ulong auStack_637d [3176];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
bVar1 = *(byte *)((long)param_2 + 0x12);
local_6408 = param_2[2];
local_6418 = *param_2;
uStack_6410 = param_2[1];
local_6400 = *(ushort *)((long)param_2 + 0x16c) << 8 | *(ushort *)((long)param_2 + 0x16c) >> 8;
local_63fe = *(ushort *)(param_2 + 0x2e) << 8 | *(ushort *)(param_2 + 0x2e) >> 8;
uVar5 = param_2[0x2f];
local_63fc = (int1)((ulong)uVar5 >> 0x20);
local_63fb = (int1)((ulong)uVar5 >> 0x28);
local_63fa = (int1)((ulong)uVar5 >> 0x30);
local_63f9 = (int4)uVar5;
uVar5 = param_2[0x30];
local_63f5 = (int1)((ulong)uVar5 >> 0x20);
local_63f4 = (int1)((ulong)uVar5 >> 0x28);
local_63f3 = (int1)((ulong)uVar5 >> 0x30);
local_63f2 = (int4)uVar5;
uVar5 = param_2[0x31];
local_63ee = (int1)((ulong)uVar5 >> 0x20);
local_63ed = (int1)((ulong)uVar5 >> 0x28);
local_63ec = (int1)((ulong)uVar5 >> 0x30);
local_63eb = (int4)uVar5;
uVar9 = param_2[3];
local_63e7 = uVar9 >> 0x38 | (uVar9 & 0xff000000000000) >> 0x28 | (uVar9 & 0xff0000000000) >> 0x18
| (uVar9 & 0xff00000000) >> 8 | (uVar9 & 0xff000000) << 8 |
(uVar9 & 0xff0000) << 0x18 | (uVar9 & 0xff00) << 0x28 | uVar9 << 0x38;
uVar9 = param_2[4];
local_63df = uVar9 >> 0x38 | (uVar9 & 0xff000000000000) >> 0x28 | (uVar9 & 0xff0000000000) >> 0x18
| (uVar9 & 0xff00000000) >> 8 | (uVar9 & 0xff000000) << 8 |
(uVar9 & 0xff0000) << 0x18 | (uVar9 & 0xff00) << 0x28 | uVar9 << 0x38;
uVar9 = param_2[0x18];
local_63d7 = uVar9 >> 0x38 | (uVar9 & 0xff000000000000) >> 0x28 | (uVar9 & 0xff0000000000) >> 0x18
| (uVar9 & 0xff00000000) >> 8 | (uVar9 & 0xff000000) << 8 |
(uVar9 & 0xff0000) << 0x18 | (uVar9 & 0xff00) << 0x28 | uVar9 << 0x38;
uVar9 = param_2[0x19];
local_63cf = uVar9 >> 0x38 | (uVar9 & 0xff000000000000) >> 0x28 | (uVar9 & 0xff0000000000) >> 0x18
| (uVar9 & 0xff00000000) >> 8 | (uVar9 & 0xff000000) << 8 |
(uVar9 & 0xff0000) << 0x18 | (uVar9 & 0xff00) << 0x28 | uVar9 << 0x38;
uVar9 = param_2[0x1a];
local_63c7 = uVar9 >> 0x38 | (uVar9 & 0xff000000000000) >> 0x28 | (uVar9 & 0xff0000000000) >> 0x18
| (uVar9 & 0xff00000000) >> 8 | (uVar9 & 0xff000000) << 8 |
(uVar9 & 0xff0000) << 0x18 | (uVar9 & 0xff00) << 0x28 | uVar9 << 0x38;
uVar9 = param_2[7];
local_63bf = uVar9 >> 0x38 | (uVar9 & 0xff000000000000) >> 0x28 | (uVar9 & 0xff0000000000) >> 0x18
| (uVar9 & 0xff00000000) >> 8 | (uVar9 & 0xff000000) << 8 |
(uVar9 & 0xff0000) << 0x18 | (uVar9 & 0xff00) << 0x28 | uVar9 << 0x38;
uVar9 = param_2[8];
local_63b7 = uVar9 >> 0x38 | (uVar9 & 0xff000000000000) >> 0x28 | (uVar9 & 0xff0000000000) >> 0x18
| (uVar9 & 0xff00000000) >> 8 | (uVar9 & 0xff000000) << 8 |
(uVar9 & 0xff0000) << 0x18 | (uVar9 & 0xff00) << 0x28 | uVar9 << 0x38;
uVar9 = param_2[5];
local_63af = uVar9 >> 0x38 | (uVar9 & 0xff000000000000) >> 0x28 | (uVar9 & 0xff0000000000) >> 0x18
| (uVar9 & 0xff00000000) >> 8 | (uVar9 & 0xff000000) << 8 |
(uVar9 & 0xff0000) << 0x18 | (uVar9 & 0xff00) << 0x28 | uVar9 << 0x38;
uVar9 = param_2[6];
local_63a7 = uVar9 >> 0x38 | (uVar9 & 0xff000000000000) >> 0x28 | (uVar9 & 0xff0000000000) >> 0x18
| (uVar9 & 0xff00000000) >> 8 | (uVar9 & 0xff000000) << 8 |
(uVar9 & 0xff0000) << 0x18 | (uVar9 & 0xff00) << 0x28 | uVar9 << 0x38;
uVar9 = param_2[0x1b];
local_639f = uVar9 >> 0x38 | (uVar9 & 0xff000000000000) >> 0x28 | (uVar9 & 0xff0000000000) >> 0x18
| (uVar9 & 0xff00000000) >> 8 | (uVar9 & 0xff000000) << 8 |
(uVar9 & 0xff0000) << 0x18 | (uVar9 & 0xff00) << 0x28 | uVar9 << 0x38;
uVar3 = *(int4 *)(param_2 + 9);
local_6397 = 0;
local_6390 = (int1)uVar3;
local_6391 = (int1)((uint)uVar3 >> 8);
local_6392 = (int1)((uint)uVar3 >> 0x10);
local_6393 = (int1)((uint)uVar3 >> 0x18);
uVar9 = param_2[0x1c];
local_638f = uVar9 >> 0x38 | (uVar9 & 0xff000000000000) >> 0x28 | (uVar9 & 0xff0000000000) >> 0x18
| (uVar9 & 0xff00000000) >> 8 | (uVar9 & 0xff000000) << 8 |
(uVar9 & 0xff0000) << 0x18 | (uVar9 & 0xff00) << 0x28 | uVar9 << 0x38;
uVar10 = *(uint *)(param_2 + 0x1f);
local_6387 = uVar10 >> 0x18 | (uVar10 & 0xff0000) >> 8 | (uVar10 & 0xff00) << 8 | uVar10 << 0x18;
uVar10 = *(uint *)(param_2 + 0x1e);
local_6383 = uVar10 >> 0x18 | (uVar10 & 0xff0000) >> 8 | (uVar10 & 0xff00) << 8 | uVar10 << 0x18;
local_637f = *(int1 *)(param_2 + 0x2d);
local_637e = 0;
puVar12 = (ulong *)((long)auStack_637d + (ulong)*(uint *)((long)param_2 + 0x19c));
if (bVar1 != 0) {
lVar13 = param_2[0x23];
uVar9 = 0;
do {
uVar6 = *(ulong *)(lVar13 + uVar9);
*(ulong *)((long)puVar12 + uVar9) =
uVar6 >> 0x38 | (uVar6 & 0xff000000000000) >> 0x28 | (uVar6 & 0xff0000000000) >> 0x18 |
(uVar6 & 0xff00000000) >> 8 | (uVar6 & 0xff000000) << 8 | (uVar6 & 0xff0000) << 0x18 |
(uVar6 & 0xff00) << 0x28 | uVar6 << 0x38;
uVar9 = uVar9 + 8;
} while ((uint)bVar1 * 8 != uVar9);
puVar12 = (ulong *)((long)puVar12 + uVar9);
}
uVar9 = param_2[0x24];
*puVar12 = uVar9 >> 0x38 | (uVar9 & 0xff000000000000) >> 0x28 | (uVar9 & 0xff0000000000) >> 0x18 |
(uVar9 & 0xff00000000) >> 8 | (uVar9 & 0xff000000) << 8 | (uVar9 & 0xff0000) << 0x18 |
(uVar9 & 0xff00) << 0x28 | uVar9 << 0x38;
if ((param_3 & 2) == 0) {
puVar12 = puVar12 + 1;
}
else {
local_6420 = (uint)*(byte *)((long)param_2 + 0xf);
bVar2 = *(byte *)((long)param_2 + 0xe);
uVar10 = *(uint *)(param_2 + 0x26);
*(uint *)(puVar12 + 1) =
uVar10 >> 0x18 | (uVar10 & 0xff0000) >> 8 | (uVar10 & 0xff00) << 8 | uVar10 << 0x18;
uVar10 = *(uint *)(param_2 + 0x27);
*(uint *)((long)puVar12 + 0xc) =
uVar10 >> 0x18 | (uVar10 & 0xff0000) >> 8 | (uVar10 & 0xff00) << 8 | uVar10 << 0x18;
uVar10 = *(uint *)(param_2 + 0x29);
*(uint *)(puVar12 + 2) =
uVar10 >> 0x18 | (uVar10 & 0xff0000) >> 8 | (uVar10 & 0xff00) << 8 | uVar10 << 0x18;
uVar9 = param_2[0x28];
*(ulong *)((long)puVar12 + 0x14) =
uVar9 >> 0x38 | (uVar9 & 0xff000000000000) >> 0x28 | (uVar9 & 0xff0000000000) >> 0x18 |
(uVar9 & 0xff00000000) >> 8 | (uVar9 & 0xff000000) << 8 | (uVar9 & 0xff0000) << 0x18 |
(uVar9 & 0xff00) << 0x28 | uVar9 << 0x38;
uVar9 = param_2[0x2a];
*(ulong *)((long)puVar12 + 0x1c) =
uVar9 >> 0x38 | (uVar9 & 0xff000000000000) >> 0x28 | (uVar9 & 0xff0000000000) >> 0x18 |
(uVar9 & 0xff00000000) >> 8 | (uVar9 & 0xff000000) << 8 | (uVar9 & 0xff0000) << 0x18 |
(uVar9 & 0xff00) << 0x28 | uVar9 << 0x38;
uVar9 = param_2[0x2b];
*(ulong *)((long)puVar12 + 0x24) =
uVar9 >> 0x38 | (uVar9 & 0xff000000000000) >> 0x28 | (uVar9 & 0xff0000000000) >> 0x18 |
(uVar9 & 0xff00000000) >> 8 | (uVar9 & 0xff000000) << 8 | (uVar9 & 0xff0000) << 0x18 |
(uVar9 & 0xff00) << 0x28 | uVar9 << 0x38;
uVar9 = param_2[0x2c];
*(ulong *)((long)puVar12 + 0x2c) =
uVar9 >> 0x38 | (uVar9 & 0xff000000000000) >> 0x28 | (uVar9 & 0xff0000000000) >> 0x18 |
(uVar9 & 0xff00000000) >> 8 | (uVar9 & 0xff000000) << 8 | (uVar9 & 0xff0000) << 0x18 |
(uVar9 & 0xff00) << 0x28 | uVar9 << 0x38;
uVar9 = param_2[0x25];
*(ulong *)((long)puVar12 + 0x34) =
uVar9 >> 0x38 | (uVar9 & 0xff000000000000) >> 0x28 | (uVar9 & 0xff0000000000) >> 0x18 |
(uVar9 & 0xff00000000) >> 8 | (uVar9 & 0xff000000) << 8 | (uVar9 & 0xff0000) << 0x18 |
(uVar9 & 0xff00) << 0x28 | uVar9 << 0x38;
local_641c = param_3;
memset((void *)((long)puVar12 + 0x3c),0,(ulong)bVar1 * 4);
puVar12 = (ulong *)((long)puVar12 + (ulong)bVar1 * 4 + 0x3c);
uVar10 = (uint)bVar2 << 8 | local_6420;
param_3 = local_641c;
if (uVar10 != 0) {
uVar9 = 0;
do {
*puVar12 = *(ulong *)(param_2[0x20] + uVar9 * 8);
uVar4 = *(uint *)(param_2[0x21] + uVar9 * 8);
*(uint *)(puVar12 + 1) =
uVar4 >> 0x18 | (uVar4 & 0xff0000) >> 8 | (uVar4 & 0xff00) << 8 | uVar4 << 0x18;
puVar12 = (ulong *)((long)puVar12 + 0xc);
uVar9 = uVar9 + 1;
} while (uVar10 != uVar9);
}
}
lVar13 = (long)puVar12 - (long)&local_6418;
if ((param_3 & 1) == 0) {
lVar7 = (**(code **)(PSI_server + 0x158))(local_6468,param_1,7);
if (lVar7 == 0) {
lVar8 = my_write(param_1,&local_6418,lVar13,4);
goto LAB_00154f24;
}
(**(code **)(PSI_server + 0x210))
(lVar7,lVar13,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_open.c",0x65c
);
lVar8 = my_write(param_1,&local_6418,lVar13,4);
lVar11 = 0;
if (lVar8 == 0) {
lVar11 = lVar13;
}
}
else {
lVar7 = (**(code **)(PSI_server + 0x158))(local_6468,param_1,7);
if (lVar7 == 0) {
lVar8 = my_pwrite(param_1,&local_6418,lVar13,0,0x804);
goto LAB_00154f24;
}
(**(code **)(PSI_server + 0x210))
(lVar7,lVar13,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_open.c",0x65a
);
lVar8 = my_pwrite(param_1,&local_6418,lVar13,0,0x804);
lVar11 = 0;
if (lVar8 == 0) {
lVar11 = lVar13;
}
}
(**(code **)(PSI_server + 0x218))(lVar7,lVar11);
LAB_00154f24:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return lVar8 != 0;
}
| |
47,211 | strxnmov | eloqsql/strings/strxnmov.c | char *strxnmov(char *dst, size_t len, const char *src, ...)
{
va_list pvar;
char *end_of_dst=dst+len;
va_start(pvar,src);
while (src != NullS)
{
do
{
if (dst == end_of_dst)
goto end;
}
while ((*dst++ = *src++));
dst--;
src = va_arg(pvar, char *);
}
end:
*dst=0;
va_end(pvar);
return dst;
} | O3 | c | strxnmov:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %eax, %r10d
movq %rdi, %rax
leaq -0xd0(%rbp), %rdi
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %r10b, %r10b
je 0x8f9a4
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 %rdi, -0x10(%rbp)
leaq 0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movabsq $0x3000000018, %rcx # imm = 0x3000000018
movq %rcx, -0x20(%rbp)
testq %rdx, %rdx
je 0x8fa1d
addq %rax, %rsi
movq -0x10(%rbp), %rcx
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %r8
movq %r8, %r9
cmpq %rsi, %rax
je 0x8fa1a
movb (%rdx), %r10b
movb %r10b, (%rax)
testb %r10b, %r10b
jne 0x8fa12
cmpl $0x28, %edi
ja 0x8f9fa
movq %r9, %r10
movl %edi, %r9d
addq %rcx, %r9
addl $0x8, %edi
movl %edi, -0x20(%rbp)
jmp 0x8fa05
leaq 0x8(%r9), %r8
movq %r8, -0x18(%rbp)
movq %r8, %r10
movq (%r9), %rdx
movq %r10, %r9
testq %rdx, %rdx
jne 0x8f9d4
jmp 0x8fa1d
incq %rax
incq %rdx
jmp 0x8f9d1
movq %rsi, %rax
movb $0x0, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nop
| strxnmov:
push rbp
mov rbp, rsp
sub rsp, 50h
mov r10d, eax
mov rax, rdi
lea rdi, [rbp+var_D0]
mov [rdi+18h], rcx
mov [rdi+20h], r8
mov [rdi+28h], r9
test r10b, r10b
jz short loc_8F9A4
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_8F9A4:
mov [rbp+var_10], rdi
lea rcx, [rbp+arg_0]
mov [rbp+var_18], rcx
mov rcx, 3000000018h
mov [rbp+var_20], rcx
test rdx, rdx
jz short loc_8FA1D
add rsi, rax
mov rcx, [rbp+var_10]
mov edi, dword ptr [rbp+var_20]
mov r8, [rbp+var_18]
loc_8F9D1:
mov r9, r8
loc_8F9D4:
cmp rax, rsi
jz short loc_8FA1A
mov r10b, [rdx]
mov [rax], r10b
test r10b, r10b
jnz short loc_8FA12
cmp edi, 28h ; '('
ja short loc_8F9FA
mov r10, r9
mov r9d, edi
add r9, rcx
add edi, 8
mov dword ptr [rbp+var_20], edi
jmp short loc_8FA05
loc_8F9FA:
lea r8, [r9+8]
mov [rbp+var_18], r8
mov r10, r8
loc_8FA05:
mov rdx, [r9]
mov r9, r10
test rdx, rdx
jnz short loc_8F9D4
jmp short loc_8FA1D
loc_8FA12:
inc rax
inc rdx
jmp short loc_8F9D1
loc_8FA1A:
mov rax, rsi
loc_8FA1D:
mov byte ptr [rax], 0
add rsp, 50h
pop rbp
retn
| char *strxnmov(char *a1, long long a2, char *a3, ...)
{
char *result; // rax
char *v4; // rsi
char *reg_save_area; // rcx
unsigned int gp_offset; // edi
char *overflow_arg_area; // r8
char *v8; // r9
char v9; // r10
char *v10; // r10
va_list va; // [rsp+B0h] [rbp-20h] BYREF
result = a1;
va_start(va, a3);
if ( a3 )
{
v4 = &a1[a2];
reg_save_area = (char *)va[0].reg_save_area;
gp_offset = va[0].gp_offset;
overflow_arg_area = (char *)va[0].overflow_arg_area;
LABEL_3:
v8 = overflow_arg_area;
while ( result != v4 )
{
v9 = *a3;
*result = *a3;
if ( v9 )
{
++result;
++a3;
goto LABEL_3;
}
if ( gp_offset > 0x28 )
{
overflow_arg_area = v8 + 8;
va[0].overflow_arg_area = v8 + 8;
v10 = v8 + 8;
}
else
{
v10 = v8;
v8 = ®_save_area[gp_offset];
gp_offset += 8;
va[0].gp_offset = gp_offset;
}
a3 = *(char **)v8;
v8 = v10;
if ( !a3 )
goto LABEL_13;
}
result = v4;
}
LABEL_13:
*result = 0;
return result;
}
| strxnmov:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV R10D,EAX
MOV RAX,RDI
LEA RDI,[RBP + -0xd0]
MOV qword ptr [RDI + 0x18],RCX
MOV qword ptr [RDI + 0x20],R8
MOV qword ptr [RDI + 0x28],R9
TEST R10B,R10B
JZ 0x0018f9a4
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_0018f9a4:
MOV qword ptr [RBP + -0x10],RDI
LEA RCX,[RBP + 0x10]
MOV qword ptr [RBP + -0x18],RCX
MOV RCX,0x3000000018
MOV qword ptr [RBP + -0x20],RCX
TEST RDX,RDX
JZ 0x0018fa1d
ADD RSI,RAX
MOV RCX,qword ptr [RBP + -0x10]
MOV EDI,dword ptr [RBP + -0x20]
MOV R8,qword ptr [RBP + -0x18]
LAB_0018f9d1:
MOV R9,R8
LAB_0018f9d4:
CMP RAX,RSI
JZ 0x0018fa1a
MOV R10B,byte ptr [RDX]
MOV byte ptr [RAX],R10B
TEST R10B,R10B
JNZ 0x0018fa12
CMP EDI,0x28
JA 0x0018f9fa
MOV R10,R9
MOV R9D,EDI
ADD R9,RCX
ADD EDI,0x8
MOV dword ptr [RBP + -0x20],EDI
JMP 0x0018fa05
LAB_0018f9fa:
LEA R8,[R9 + 0x8]
MOV qword ptr [RBP + -0x18],R8
MOV R10,R8
LAB_0018fa05:
MOV RDX,qword ptr [R9]
MOV R9,R10
TEST RDX,RDX
JNZ 0x0018f9d4
JMP 0x0018fa1d
LAB_0018fa12:
INC RAX
INC RDX
JMP 0x0018f9d1
LAB_0018fa1a:
MOV RAX,RSI
LAB_0018fa1d:
MOV byte ptr [RAX],0x0
ADD RSP,0x50
POP RBP
RET
|
void strxnmov(char *param_1,long param_2,char *param_3)
{
char cVar1;
char *pcVar2;
char *pcVar3;
int8 *puVar4;
int8 *puVar5;
ulong uVar6;
int8 *puVar7;
int8 local_d8 [22];
uint local_28;
puVar4 = (int8 *)&stack0x00000008;
pcVar2 = param_1;
if (param_3 != (char *)0x0) {
pcVar3 = param_1 + param_2;
local_28 = 0x18;
puVar5 = puVar4;
do {
while( true ) {
pcVar2 = pcVar3;
if (param_1 == pcVar3) goto LAB_0018fa1d;
cVar1 = *param_3;
*param_1 = cVar1;
if (cVar1 == '\0') break;
param_1 = param_1 + 1;
param_3 = param_3 + 1;
puVar5 = puVar4;
}
if (local_28 < 0x29) {
uVar6 = (ulong)local_28;
local_28 = local_28 + 8;
puVar7 = (int8 *)((long)local_d8 + uVar6);
}
else {
puVar4 = puVar5 + 1;
puVar7 = puVar5;
puVar5 = puVar4;
}
param_3 = (char *)*puVar7;
pcVar2 = param_1;
} while (param_3 != (char *)0x0);
}
LAB_0018fa1d:
*pcVar2 = '\0';
return;
}
| |
47,212 | my_coll_parser_scan_logical_position | eloqsql/strings/ctype-uca.c | static int
my_coll_parser_scan_logical_position(MY_COLL_RULE_PARSER *p,
my_wc_t *pwc, size_t limit)
{
MY_COLL_RULES *rules= p->rules;
MY_COLL_LEXEM *lexem= my_coll_parser_curr(p);
if (!lex_cmp(lexem, C_STRING_WITH_LEN("[first non-ignorable]")))
lexem->code= rules->uca->first_non_ignorable;
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[last non-ignorable]")))
lexem->code= rules->uca->last_non_ignorable;
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[first primary ignorable]")))
lexem->code= rules->uca->first_primary_ignorable;
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[last primary ignorable]")))
lexem->code= rules->uca->last_primary_ignorable;
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[first secondary ignorable]")))
lexem->code= rules->uca->first_secondary_ignorable;
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[last secondary ignorable]")))
lexem->code= rules->uca->last_secondary_ignorable;
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[first tertiary ignorable]")))
lexem->code= rules->uca->first_tertiary_ignorable;
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[last tertiary ignorable]")))
lexem->code= rules->uca->last_tertiary_ignorable;
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[first trailing]")))
lexem->code= rules->uca->first_trailing;
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[last trailing]")))
lexem->code= rules->uca->last_trailing;
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[first variable]")))
lexem->code= rules->uca->first_variable;
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[last variable]")))
lexem->code= rules->uca->last_variable;
else
return 0; /* Don't scan the next token */
if (!my_coll_rule_expand(pwc, limit, lexem->code))
{
/*
Logical position can not be in a contraction,
so the above call should never fail.
Let's assert in debug version and print
a nice error message in production version.
*/
DBUG_ASSERT(0);
return my_coll_parser_too_long_error(p, "Logical position");
}
return my_coll_parser_scan(p);
} | O0 | c | my_coll_parser_scan_logical_position:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4f5b0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x2c8d0(%rip), %rsi # 0x7cb5b
movl $0x15, %edx
callq 0x4fd30
cmpl $0x0, %eax
jne 0x502b4
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x70(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0x50524
movq -0x30(%rbp), %rdi
leaq 0x2c8b2(%rip), %rsi # 0x7cb71
movl $0x14, %edx
callq 0x4fd30
cmpl $0x0, %eax
jne 0x502e8
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x78(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0x50522
movq -0x30(%rbp), %rdi
leaq 0x2c893(%rip), %rsi # 0x7cb86
movl $0x19, %edx
callq 0x4fd30
cmpl $0x0, %eax
jne 0x5031f
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x80(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0x50520
movq -0x30(%rbp), %rdi
leaq 0x2c876(%rip), %rsi # 0x7cba0
movl $0x18, %edx
callq 0x4fd30
cmpl $0x0, %eax
jne 0x50356
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x88(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0x5051e
movq -0x30(%rbp), %rdi
leaq 0x2c858(%rip), %rsi # 0x7cbb9
movl $0x1b, %edx
callq 0x4fd30
cmpl $0x0, %eax
jne 0x5038d
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x90(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0x5051c
movq -0x30(%rbp), %rdi
leaq 0x2c83d(%rip), %rsi # 0x7cbd5
movl $0x1a, %edx
callq 0x4fd30
cmpl $0x0, %eax
jne 0x503c4
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x98(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0x5051a
movq -0x30(%rbp), %rdi
leaq 0x2c821(%rip), %rsi # 0x7cbf0
movl $0x1a, %edx
callq 0x4fd30
cmpl $0x0, %eax
jne 0x503fb
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xa0(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0x50518
movq -0x30(%rbp), %rdi
leaq 0x2c805(%rip), %rsi # 0x7cc0b
movl $0x19, %edx
callq 0x4fd30
cmpl $0x0, %eax
jne 0x50432
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xa8(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0x50516
movq -0x30(%rbp), %rdi
leaq 0x2c7e8(%rip), %rsi # 0x7cc25
movl $0x10, %edx
callq 0x4fd30
cmpl $0x0, %eax
jne 0x50469
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xb0(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0x50514
movq -0x30(%rbp), %rdi
leaq 0x2c7c2(%rip), %rsi # 0x7cc36
movl $0xf, %edx
callq 0x4fd30
cmpl $0x0, %eax
jne 0x5049d
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xb8(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0x50512
movq -0x30(%rbp), %rdi
leaq 0x2c79e(%rip), %rsi # 0x7cc46
movl $0x10, %edx
callq 0x4fd30
cmpl $0x0, %eax
jne 0x504d1
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xc0(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0x50510
movq -0x30(%rbp), %rdi
leaq 0x2c77b(%rip), %rsi # 0x7cc57
movl $0xf, %edx
callq 0x4fd30
cmpl $0x0, %eax
jne 0x50505
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xc8(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0x5050e
movl $0x0, -0x4(%rbp)
jmp 0x50563
jmp 0x50510
jmp 0x50512
jmp 0x50514
jmp 0x50516
jmp 0x50518
jmp 0x5051a
jmp 0x5051c
jmp 0x5051e
jmp 0x50520
jmp 0x50522
jmp 0x50524
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rax
movslq 0x24(%rax), %rdx
callq 0x50680
cmpl $0x0, %eax
jne 0x50557
jmp 0x50540
jmp 0x50542
movq -0x10(%rbp), %rdi
leaq 0x2c71a(%rip), %rsi # 0x7cc67
callq 0x506f0
movl %eax, -0x4(%rbp)
jmp 0x50563
movq -0x10(%rbp), %rdi
callq 0x4fd90
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| my_coll_parser_scan_logical_position:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
mov rax, [rax+0F0h]
mov [rbp+var_28], rax
mov rdi, [rbp+var_10]
call my_coll_parser_curr
mov [rbp+var_30], rax
mov rdi, [rbp+var_30]
lea rsi, aFirstNonIgnora; "[first non-ignorable]"
mov edx, 15h
call lex_cmp
cmp eax, 0
jnz short loc_502B4
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+70h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp loc_50524
loc_502B4:
mov rdi, [rbp+var_30]
lea rsi, aLastNonIgnorab; "[last non-ignorable]"
mov edx, 14h
call lex_cmp
cmp eax, 0
jnz short loc_502E8
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+78h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp loc_50522
loc_502E8:
mov rdi, [rbp+var_30]
lea rsi, aFirstPrimaryIg; "[first primary ignorable]"
mov edx, 19h
call lex_cmp
cmp eax, 0
jnz short loc_5031F
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+80h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp loc_50520
loc_5031F:
mov rdi, [rbp+var_30]
lea rsi, aLastPrimaryIgn; "[last primary ignorable]"
mov edx, 18h
call lex_cmp
cmp eax, 0
jnz short loc_50356
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+88h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp loc_5051E
loc_50356:
mov rdi, [rbp+var_30]
lea rsi, aFirstSecondary; "[first secondary ignorable]"
mov edx, 1Bh
call lex_cmp
cmp eax, 0
jnz short loc_5038D
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+90h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp loc_5051C
loc_5038D:
mov rdi, [rbp+var_30]
lea rsi, aLastSecondaryI; "[last secondary ignorable]"
mov edx, 1Ah
call lex_cmp
cmp eax, 0
jnz short loc_503C4
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+98h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp loc_5051A
loc_503C4:
mov rdi, [rbp+var_30]
lea rsi, aFirstTertiaryI; "[first tertiary ignorable]"
mov edx, 1Ah
call lex_cmp
cmp eax, 0
jnz short loc_503FB
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+0A0h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp loc_50518
loc_503FB:
mov rdi, [rbp+var_30]
lea rsi, aLastTertiaryIg; "[last tertiary ignorable]"
mov edx, 19h
call lex_cmp
cmp eax, 0
jnz short loc_50432
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+0A8h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp loc_50516
loc_50432:
mov rdi, [rbp+var_30]
lea rsi, aFirstTrailing; "[first trailing]"
mov edx, 10h
call lex_cmp
cmp eax, 0
jnz short loc_50469
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+0B0h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp loc_50514
loc_50469:
mov rdi, [rbp+var_30]
lea rsi, aLastTrailing; "[last trailing]"
mov edx, 0Fh
call lex_cmp
cmp eax, 0
jnz short loc_5049D
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+0B8h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp short loc_50512
loc_5049D:
mov rdi, [rbp+var_30]
lea rsi, aFirstVariable; "[first variable]"
mov edx, 10h
call lex_cmp
cmp eax, 0
jnz short loc_504D1
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+0C0h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp short loc_50510
loc_504D1:
mov rdi, [rbp+var_30]
lea rsi, aLastVariable; "[last variable]"
mov edx, 0Fh
call lex_cmp
cmp eax, 0
jnz short loc_50505
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+0C8h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp short loc_5050E
loc_50505:
mov [rbp+var_4], 0
jmp short loc_50563
loc_5050E:
jmp short $+2
loc_50510:
jmp short $+2
loc_50512:
jmp short $+2
loc_50514:
jmp short $+2
loc_50516:
jmp short $+2
loc_50518:
jmp short $+2
loc_5051A:
jmp short $+2
loc_5051C:
jmp short $+2
loc_5051E:
jmp short $+2
loc_50520:
jmp short $+2
loc_50522:
jmp short $+2
loc_50524:
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rax, [rbp+var_30]
movsxd rdx, dword ptr [rax+24h]
call my_coll_rule_expand
cmp eax, 0
jnz short loc_50557
jmp short $+2
loc_50540:
jmp short $+2
loc_50542:
mov rdi, [rbp+var_10]
lea rsi, aLogicalPositio; "Logical position"
call my_coll_parser_too_long_error
mov [rbp+var_4], eax
jmp short loc_50563
loc_50557:
mov rdi, [rbp+var_10]
call my_coll_parser_scan
mov [rbp+var_4], eax
loc_50563:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long my_coll_parser_scan_logical_position(long long a1, long long a2, long long a3)
{
long long v4; // [rsp+0h] [rbp-30h]
long long v5; // [rsp+8h] [rbp-28h]
v5 = *(_QWORD *)(a1 + 240);
v4 = my_coll_parser_curr(a1);
if ( (unsigned int)lex_cmp(v4, (long long)"[first non-ignorable]", 0x15uLL) )
{
if ( (unsigned int)lex_cmp(v4, (long long)"[last non-ignorable]", 0x14uLL) )
{
if ( (unsigned int)lex_cmp(v4, (long long)"[first primary ignorable]", 0x19uLL) )
{
if ( (unsigned int)lex_cmp(v4, (long long)"[last primary ignorable]", 0x18uLL) )
{
if ( (unsigned int)lex_cmp(v4, (long long)"[first secondary ignorable]", 0x1BuLL) )
{
if ( (unsigned int)lex_cmp(v4, (long long)"[last secondary ignorable]", 0x1AuLL) )
{
if ( (unsigned int)lex_cmp(v4, (long long)"[first tertiary ignorable]", 0x1AuLL) )
{
if ( (unsigned int)lex_cmp(v4, (long long)"[last tertiary ignorable]", 0x19uLL) )
{
if ( (unsigned int)lex_cmp(v4, (long long)"[first trailing]", 0x10uLL) )
{
if ( (unsigned int)lex_cmp(v4, (long long)"[last trailing]", 0xFuLL) )
{
if ( (unsigned int)lex_cmp(v4, (long long)"[first variable]", 0x10uLL) )
{
if ( (unsigned int)lex_cmp(v4, (long long)"[last variable]", 0xFuLL) )
return 0;
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 200LL);
}
else
{
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 192LL);
}
}
else
{
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 184LL);
}
}
else
{
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 176LL);
}
}
else
{
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 168LL);
}
}
else
{
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 160LL);
}
}
else
{
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 152LL);
}
}
else
{
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 144LL);
}
}
else
{
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 136LL);
}
}
else
{
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 128LL);
}
}
else
{
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 120LL);
}
}
else
{
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 112LL);
}
if ( (unsigned int)my_coll_rule_expand(a2, a3, *(int *)(v4 + 36)) )
return (unsigned int)my_coll_parser_scan(a1);
else
return (unsigned int)my_coll_parser_too_long_error(a1, "Logical position");
}
| my_coll_parser_scan_logical_position:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xf0]
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0014f5b0
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x17cb5b]
MOV EDX,0x15
CALL 0x0014fd30
CMP EAX,0x0
JNZ 0x001502b4
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x70]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x00150524
LAB_001502b4:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x17cb71]
MOV EDX,0x14
CALL 0x0014fd30
CMP EAX,0x0
JNZ 0x001502e8
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x78]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x00150522
LAB_001502e8:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x17cb86]
MOV EDX,0x19
CALL 0x0014fd30
CMP EAX,0x0
JNZ 0x0015031f
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x80]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x00150520
LAB_0015031f:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x17cba0]
MOV EDX,0x18
CALL 0x0014fd30
CMP EAX,0x0
JNZ 0x00150356
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x88]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x0015051e
LAB_00150356:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x17cbb9]
MOV EDX,0x1b
CALL 0x0014fd30
CMP EAX,0x0
JNZ 0x0015038d
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x90]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x0015051c
LAB_0015038d:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x17cbd5]
MOV EDX,0x1a
CALL 0x0014fd30
CMP EAX,0x0
JNZ 0x001503c4
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x98]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x0015051a
LAB_001503c4:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x17cbf0]
MOV EDX,0x1a
CALL 0x0014fd30
CMP EAX,0x0
JNZ 0x001503fb
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0xa0]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x00150518
LAB_001503fb:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x17cc0b]
MOV EDX,0x19
CALL 0x0014fd30
CMP EAX,0x0
JNZ 0x00150432
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0xa8]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x00150516
LAB_00150432:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x17cc25]
MOV EDX,0x10
CALL 0x0014fd30
CMP EAX,0x0
JNZ 0x00150469
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0xb0]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x00150514
LAB_00150469:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x17cc36]
MOV EDX,0xf
CALL 0x0014fd30
CMP EAX,0x0
JNZ 0x0015049d
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0xb8]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x00150512
LAB_0015049d:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x17cc46]
MOV EDX,0x10
CALL 0x0014fd30
CMP EAX,0x0
JNZ 0x001504d1
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0xc0]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x00150510
LAB_001504d1:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x17cc57]
MOV EDX,0xf
CALL 0x0014fd30
CMP EAX,0x0
JNZ 0x00150505
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0xc8]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x0015050e
LAB_00150505:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00150563
LAB_0015050e:
JMP 0x00150510
LAB_00150510:
JMP 0x00150512
LAB_00150512:
JMP 0x00150514
LAB_00150514:
JMP 0x00150516
LAB_00150516:
JMP 0x00150518
LAB_00150518:
JMP 0x0015051a
LAB_0015051a:
JMP 0x0015051c
LAB_0015051c:
JMP 0x0015051e
LAB_0015051e:
JMP 0x00150520
LAB_00150520:
JMP 0x00150522
LAB_00150522:
JMP 0x00150524
LAB_00150524:
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x30]
MOVSXD RDX,dword ptr [RAX + 0x24]
CALL 0x00150680
CMP EAX,0x0
JNZ 0x00150557
JMP 0x00150540
LAB_00150540:
JMP 0x00150542
LAB_00150542:
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x17cc67]
CALL 0x001506f0
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00150563
LAB_00150557:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0014fd90
MOV dword ptr [RBP + -0x4],EAX
LAB_00150563:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 my_coll_parser_scan_logical_position(long param_1,int8 param_2,int8 param_3)
{
long lVar1;
int iVar2;
long lVar3;
int4 local_c;
lVar1 = *(long *)(param_1 + 0xf0);
lVar3 = my_coll_parser_curr(param_1);
iVar2 = lex_cmp(lVar3,"[first non-ignorable]",0x15);
if (iVar2 == 0) {
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 0x70);
}
else {
iVar2 = lex_cmp(lVar3,"[last non-ignorable]",0x14);
if (iVar2 == 0) {
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 0x78);
}
else {
iVar2 = lex_cmp(lVar3,"[first primary ignorable]",0x19);
if (iVar2 == 0) {
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 0x80);
}
else {
iVar2 = lex_cmp(lVar3,"[last primary ignorable]",0x18);
if (iVar2 == 0) {
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 0x88);
}
else {
iVar2 = lex_cmp(lVar3,"[first secondary ignorable]",0x1b);
if (iVar2 == 0) {
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 0x90);
}
else {
iVar2 = lex_cmp(lVar3,"[last secondary ignorable]",0x1a);
if (iVar2 == 0) {
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 0x98);
}
else {
iVar2 = lex_cmp(lVar3,"[first tertiary ignorable]",0x1a);
if (iVar2 == 0) {
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 0xa0);
}
else {
iVar2 = lex_cmp(lVar3,"[last tertiary ignorable]",0x19);
if (iVar2 == 0) {
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 0xa8);
}
else {
iVar2 = lex_cmp(lVar3,"[first trailing]",0x10);
if (iVar2 == 0) {
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 0xb0);
}
else {
iVar2 = lex_cmp(lVar3,"[last trailing]",0xf);
if (iVar2 == 0) {
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 0xb8);
}
else {
iVar2 = lex_cmp(lVar3,"[first variable]",0x10);
if (iVar2 == 0) {
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 0xc0);
}
else {
iVar2 = lex_cmp(lVar3,"[last variable]",0xf);
if (iVar2 != 0) {
return 0;
}
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 200);
}
}
}
}
}
}
}
}
}
}
}
iVar2 = my_coll_rule_expand(param_2,param_3,(long)*(int *)(lVar3 + 0x24));
if (iVar2 == 0) {
local_c = my_coll_parser_too_long_error(param_1,"Logical position");
}
else {
local_c = my_coll_parser_scan(param_1);
}
return local_c;
}
| |
47,213 | mi_write_blob_record | eloqsql/storage/myisam/mi_dynrec.c | int _mi_write_blob_record(MI_INFO *info, const uchar *record)
{
uchar *rec_buff;
int error;
ulong reclength,reclength2,extra;
extra= (ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER)+MI_SPLIT_LENGTH+
MI_DYN_DELETE_BLOCK_HEADER+1);
reclength= (info->s->base.pack_reclength +
_mi_calc_total_blob_length(info,record)+ extra);
if (!(rec_buff=(uchar*) my_alloca(reclength)))
{
my_errno= HA_ERR_OUT_OF_MEM; /* purecov: inspected */
return(-1);
}
reclength2= _mi_rec_pack(info,rec_buff+ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER),
record);
DBUG_PRINT("info",("reclength: %lu reclength2: %lu",
reclength, reclength2));
DBUG_ASSERT(reclength2 <= reclength);
error=write_dynamic_record(info,rec_buff+ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER),
reclength2);
my_afree(rec_buff);
return(error);
} | O0 | c | mi_write_blob_record:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x5d, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x148(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa88d0
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq %rcx, %rax
addq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0xf3860
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xa8876
callq 0xf60c0
movl $0x80, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa88be
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x18, %rsi
movq -0x18(%rbp), %rdx
callq 0xa7940
movl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0xa8893
jmp 0xa8895
jmp 0xa8897
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x18, %rsi
movq -0x38(%rbp), %rdx
callq 0xa7e90
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0xf3be0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _mi_write_blob_record:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_40], 5Dh ; ']'
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+148h]
mov [rbp+var_48], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call _mi_calc_total_blob_length
mov rcx, rax
mov rax, [rbp+var_48]
add rax, rcx
add rax, [rbp+var_40]
mov [rbp+var_30], rax
mov rsi, [rbp+var_30]
xor edi, edi
xor eax, eax
mov edx, eax
call my_malloc
mov [rbp+var_20], rax
cmp rax, 0
jnz short loc_A8876
call _my_thread_var
mov dword ptr [rax], 80h
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_A88BE
loc_A8876:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
add rsi, 18h
mov rdx, [rbp+var_18]
call _mi_rec_pack
mov eax, eax
mov [rbp+var_38], rax
jmp short $+2
loc_A8893:
jmp short $+2
loc_A8895:
jmp short $+2
loc_A8897:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
add rsi, 18h
mov rdx, [rbp+var_38]
call write_dynamic_record_0
mov [rbp+var_24], eax
mov rdi, [rbp+var_20]
call my_free
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
loc_A88BE:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
| long long mi_write_blob_record(_DWORD *a1, _BYTE *a2)
{
const char *v2; // rsi
long long v4; // [rsp+8h] [rbp-48h]
long long v5; // [rsp+18h] [rbp-38h]
unsigned int v6; // [rsp+2Ch] [rbp-24h]
long long v7; // [rsp+30h] [rbp-20h]
v4 = *(_QWORD *)(*(_QWORD *)a1 + 328LL);
v2 = (const char *)(mi_calc_total_blob_length(a1, a2) + v4 + 93);
v7 = my_malloc(0LL, v2, 0LL);
if ( v7 )
{
v5 = (unsigned int)mi_rec_pack(a1, (_BYTE *)(v7 + 24), a2);
v6 = write_dynamic_record_0(a1, (const char *)(v7 + 24), v5);
my_free(v7);
return v6;
}
else
{
*(_DWORD *)my_thread_var(0LL, v2) = 128;
return (unsigned int)-1;
}
}
| _mi_write_blob_record:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x40],0x5d
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x148]
MOV qword ptr [RBP + -0x48],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x001a88d0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RCX
ADD RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x30],RAX
MOV RSI,qword ptr [RBP + -0x30]
XOR EDI,EDI
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001f3860
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JNZ 0x001a8876
CALL 0x001f60c0
MOV dword ptr [RAX],0x80
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001a88be
LAB_001a8876:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
ADD RSI,0x18
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x001a7940
MOV EAX,EAX
MOV qword ptr [RBP + -0x38],RAX
JMP 0x001a8893
LAB_001a8893:
JMP 0x001a8895
LAB_001a8895:
JMP 0x001a8897
LAB_001a8897:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
ADD RSI,0x18
MOV RDX,qword ptr [RBP + -0x38]
CALL 0x001a7e90
MOV dword ptr [RBP + -0x24],EAX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001f3be0
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
LAB_001a88be:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
int4 _mi_write_blob_record(long *param_1,int8 param_2)
{
int4 uVar1;
long lVar2;
long lVar3;
int4 *puVar4;
int4 local_c;
lVar3 = *(long *)(*param_1 + 0x148);
lVar2 = _mi_calc_total_blob_length(param_1,param_2);
lVar3 = my_malloc(0,lVar3 + lVar2 + 0x5d,0);
if (lVar3 == 0) {
puVar4 = (int4 *)_my_thread_var();
*puVar4 = 0x80;
local_c = 0xffffffff;
}
else {
uVar1 = _mi_rec_pack(param_1,lVar3 + 0x18,param_2);
local_c = write_dynamic_record(param_1,lVar3 + 0x18,uVar1);
my_free(lVar3);
}
return local_c;
}
| |
47,214 | ma_read_block_record | eloqsql/storage/maria/ma_blockrec.c | int _ma_read_block_record(MARIA_HA *info, uchar *record,
MARIA_RECORD_POS record_pos)
{
MARIA_SHARE *share= info->s;
uchar *data, *end_of_data, *buff;
uint offset;
int ret;
DBUG_ENTER("_ma_read_block_record");
DBUG_PRINT("enter", ("rowid: %lu page: %lu rownr: %u",
(ulong) record_pos,
(ulong) ma_recordpos_to_page(record_pos),
ma_recordpos_to_dir_entry(record_pos)));
offset= ma_recordpos_to_dir_entry(record_pos);
if (!(buff= pagecache_read(share->pagecache,
&info->dfile, ma_recordpos_to_page(record_pos), 0,
info->buff, share->page_type,
PAGECACHE_LOCK_LEFT_UNLOCKED, 0)))
DBUG_RETURN(my_errno);
/*
Unallocated page access can happen if this is an access to a page where
all rows where deleted as part of this statement.
*/
DBUG_ASSERT((buff[PAGE_TYPE_OFFSET] & PAGE_TYPE_MASK) == HEAD_PAGE ||
(buff[PAGE_TYPE_OFFSET] & PAGE_TYPE_MASK) == UNALLOCATED_PAGE);
if (((buff[PAGE_TYPE_OFFSET] & PAGE_TYPE_MASK) == UNALLOCATED_PAGE) ||
!(data= get_record_position(share, buff, offset, &end_of_data)))
{
DBUG_ASSERT(!maria_assert_if_crashed_table);
DBUG_PRINT("warning", ("Wrong directory entry in data block"));
my_errno= HA_ERR_RECORD_DELETED; /* File crashed */
DBUG_RETURN(HA_ERR_RECORD_DELETED);
}
ret= _ma_read_block_record2(info, record, data, end_of_data);
DBUG_RETURN(ret);
} | O0 | c | ma_read_block_record:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x57071
movq -0x20(%rbp), %rdi
callq 0x549a0
movl %eax, -0x44(%rbp)
movq -0x28(%rbp), %rax
movq 0x600(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
addq $0x470, %rax # imm = 0x470
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rdi
callq 0x54980
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq 0x378(%rax), %r8
movq -0x28(%rbp), %rax
movl 0x7d4(%rax), %r9d
xorl %ecx, %ecx
xorl %eax, %eax
movl $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0x3b470
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x570f5
jmp 0x570e9
callq 0xfc1b0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x57161
jmp 0x570f7
jmp 0x570f9
movq -0x40(%rbp), %rax
movzbl 0x7(%rax), %eax
andl $0x7, %eax
cmpl $0x0, %eax
je 0x57127
movq -0x28(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl -0x44(%rbp), %edx
leaq -0x38(%rbp), %rcx
callq 0x57170
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x57143
jmp 0x57129
jmp 0x5712b
jmp 0x5712d
jmp 0x5712f
callq 0xfc1b0
movl $0x86, (%rax)
movl $0x86, -0x4(%rbp)
jmp 0x57161
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x55f50
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _ma_read_block_record:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_28], rax
jmp short $+2
loc_57071:
mov rdi, [rbp+var_20]
call ma_recordpos_to_dir_entry
mov [rbp+var_44], eax
mov rax, [rbp+var_28]
mov rax, [rax+600h]
mov [rbp+var_58], rax
mov rax, [rbp+var_10]
add rax, 470h
mov [rbp+var_50], rax
mov rdi, [rbp+var_20]
call ma_recordpos_to_page
mov rdi, [rbp+var_58]
mov rsi, [rbp+var_50]
mov rdx, rax
mov rax, [rbp+var_10]
mov r8, [rax+378h]
mov rax, [rbp+var_28]
mov r9d, [rax+7D4h]
xor ecx, ecx
xor eax, eax
mov [rsp+70h+var_70], 0
mov [rsp+70h+var_68], 0
call pagecache_read
mov [rbp+var_40], rax
cmp rax, 0
jnz short loc_570F5
jmp short $+2
loc_570E9:
call _my_thread_var
mov eax, [rax]
mov [rbp+var_4], eax
jmp short loc_57161
loc_570F5:
jmp short $+2
loc_570F7:
jmp short $+2
loc_570F9:
mov rax, [rbp+var_40]
movzx eax, byte ptr [rax+7]
and eax, 7
cmp eax, 0
jz short loc_57127
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_40]
mov edx, [rbp+var_44]
lea rcx, [rbp+var_38]
call get_record_position
mov [rbp+var_30], rax
cmp rax, 0
jnz short loc_57143
loc_57127:
jmp short $+2
loc_57129:
jmp short $+2
loc_5712B:
jmp short $+2
loc_5712D:
jmp short $+2
loc_5712F:
call _my_thread_var
mov dword ptr [rax], 86h
mov [rbp+var_4], 86h
jmp short loc_57161
loc_57143:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_30]
mov rcx, [rbp+var_38]
call _ma_read_block_record2
mov [rbp+var_48], eax
mov eax, [rbp+var_48]
mov [rbp+var_4], eax
loc_57161:
mov eax, [rbp+var_4]
add rsp, 70h
pop rbp
retn
| long long ma_read_block_record(_QWORD *a1, long long a2, unsigned long long a3)
{
unsigned long long v3; // rax
long long v4; // r8
int v5; // r9d
_QWORD *v7; // [rsp+18h] [rbp-58h]
unsigned int v8; // [rsp+2Ch] [rbp-44h]
long long v9; // [rsp+30h] [rbp-40h]
char *v10; // [rsp+38h] [rbp-38h] BYREF
char *record_position; // [rsp+40h] [rbp-30h]
long long v12; // [rsp+48h] [rbp-28h]
unsigned long long v13; // [rsp+50h] [rbp-20h]
long long v14; // [rsp+58h] [rbp-18h]
_QWORD *v15; // [rsp+60h] [rbp-10h]
v15 = a1;
v14 = a2;
v13 = a3;
v12 = *a1;
v8 = ma_recordpos_to_dir_entry(a3);
v7 = *(_QWORD **)(v12 + 1536);
v3 = ma_recordpos_to_page(v13);
v9 = pagecache_read(v7, (long long)(a1 + 142), v3, 0, a1[111], *(_DWORD *)(v12 + 2004), 0, 0LL);
if ( v9 )
{
if ( (*(_BYTE *)(v9 + 7) & 7) != 0 && (record_position = (char *)get_record_position(v12, v9, v8, &v10)) != 0LL )
{
return (unsigned int)ma_read_block_record2((long long)v15, v14, record_position, v10, v4, v5);
}
else
{
*(_DWORD *)my_thread_var() = 134;
return 134;
}
}
else
{
return *(unsigned int *)my_thread_var();
}
}
| _ma_read_block_record:
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 RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00157071
LAB_00157071:
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001549a0
MOV dword ptr [RBP + -0x44],EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x600]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x470
MOV qword ptr [RBP + -0x50],RAX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00154980
MOV RDI,qword ptr [RBP + -0x58]
MOV RSI,qword ptr [RBP + -0x50]
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV R8,qword ptr [RAX + 0x378]
MOV RAX,qword ptr [RBP + -0x28]
MOV R9D,dword ptr [RAX + 0x7d4]
XOR ECX,ECX
XOR EAX,EAX
MOV dword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],0x0
CALL 0x0013b470
MOV qword ptr [RBP + -0x40],RAX
CMP RAX,0x0
JNZ 0x001570f5
JMP 0x001570e9
LAB_001570e9:
CALL 0x001fc1b0
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00157161
LAB_001570f5:
JMP 0x001570f7
LAB_001570f7:
JMP 0x001570f9
LAB_001570f9:
MOV RAX,qword ptr [RBP + -0x40]
MOVZX EAX,byte ptr [RAX + 0x7]
AND EAX,0x7
CMP EAX,0x0
JZ 0x00157127
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x40]
MOV EDX,dword ptr [RBP + -0x44]
LEA RCX,[RBP + -0x38]
CALL 0x00157170
MOV qword ptr [RBP + -0x30],RAX
CMP RAX,0x0
JNZ 0x00157143
LAB_00157127:
JMP 0x00157129
LAB_00157129:
JMP 0x0015712b
LAB_0015712b:
JMP 0x0015712d
LAB_0015712d:
JMP 0x0015712f
LAB_0015712f:
CALL 0x001fc1b0
MOV dword ptr [RAX],0x86
MOV dword ptr [RBP + -0x4],0x86
JMP 0x00157161
LAB_00157143:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x38]
CALL 0x00155f50
MOV dword ptr [RBP + -0x48],EAX
MOV EAX,dword ptr [RBP + -0x48]
MOV dword ptr [RBP + -0x4],EAX
LAB_00157161:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x70
POP RBP
RET
|
int4 _ma_read_block_record(long *param_1,int8 param_2,int8 param_3)
{
int8 uVar1;
int4 uVar2;
long *plVar3;
int8 uVar4;
long lVar5;
int4 *puVar6;
int8 local_40;
long local_38;
long local_30;
int8 local_28;
int8 local_20;
long *local_18;
int4 local_c;
local_30 = *param_1;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
uVar2 = ma_recordpos_to_dir_entry(param_3);
uVar1 = *(int8 *)(local_30 + 0x600);
plVar3 = local_18 + 0x8e;
uVar4 = ma_recordpos_to_page(local_28);
lVar5 = pagecache_read(uVar1,plVar3,uVar4,0,local_18[0x6f],*(int4 *)(local_30 + 0x7d4),0,0);
if (lVar5 == 0) {
puVar6 = (int4 *)_my_thread_var();
local_c = *puVar6;
}
else {
if (((*(byte *)(lVar5 + 7) & 7) != 0) &&
(local_38 = get_record_position(local_30,lVar5,uVar2,&local_40), local_38 != 0)) {
uVar2 = _ma_read_block_record2(local_18,local_20,local_38,local_40);
return uVar2;
}
puVar6 = (int4 *)_my_thread_var();
*puVar6 = 0x86;
local_c = 0x86;
}
return local_c;
}
| |
47,215 | my_caseup_utf32 | eloqsql/strings/ctype-ucs2.c | static size_t
my_caseup_utf32(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_utf32_uni(cs, &wc, (uchar *)src, (uchar*) srcend)) > 0)
{
my_toupper_utf32(uni_plane, &wc);
if (res != my_uni_utf32(cs, wc, (uchar*) dst, (uchar*) dstend))
break;
src+= res;
dst+= res;
}
return srclen;
} | O3 | c | my_caseup_utf32:
movq %rdx, %rax
cmpq $0x4, %rdx
jl 0x485dd
pushq %rbp
movq %rsp, %rbp
pushq %rbx
leaq (%rsi,%rax), %rdx
addq %rcx, %r8
movq 0x78(%rdi), %rdi
addq $0x4, %rcx
movzbl (%rsi), %r9d
shll $0x18, %r9d
movzbl 0x1(%rsi), %r10d
shll $0x10, %r10d
orl %r9d, %r10d
cmpl $0x10ffff, %r10d # imm = 0x10FFFF
ja 0x485db
movzbl 0x2(%rsi), %ebx
shll $0x8, %ebx
movzbl 0x3(%rsi), %r9d
orq %r9, %rbx
orq %r10, %rbx
cmpq (%rdi), %rbx
ja 0x4859c
movq 0x8(%rdi), %r10
movl %ebx, %r11d
shrl $0x8, %r11d
movq (%r10,%r11,8), %r10
testq %r10, %r10
je 0x4859c
leaq (%r9,%r9,2), %r9
movl (%r10,%r9,4), %ebx
cmpq %r8, %rcx
ja 0x485db
cmpl $0x10ffff, %ebx # imm = 0x10FFFF
ja 0x485db
movb $0x0, -0x4(%rcx)
movl %ebx, %r9d
shrl $0x10, %r9d
movb %r9b, -0x3(%rcx)
movb %bh, -0x2(%rcx)
movb %bl, -0x1(%rcx)
leaq 0x4(%rsi), %r9
cmpq %rdx, %r9
jae 0x485db
addq $0x8, %rsi
addq $0x4, %rcx
cmpq %rdx, %rsi
movq %r9, %rsi
jbe 0x4854c
popq %rbx
popq %rbp
retq
| my_caseup_utf32:
mov rax, rdx
cmp rdx, 4
jl locret_485DD
push rbp
mov rbp, rsp
push rbx
lea rdx, [rsi+rax]
add r8, rcx
mov rdi, [rdi+78h]
add rcx, 4
loc_4854C:
movzx r9d, byte ptr [rsi]
shl r9d, 18h
movzx r10d, byte ptr [rsi+1]
shl r10d, 10h
or r10d, r9d
cmp r10d, offset unk_10FFFF
ja short loc_485DB
movzx ebx, byte ptr [rsi+2]
shl ebx, 8
movzx r9d, byte ptr [rsi+3]
or rbx, r9
or rbx, r10
cmp rbx, [rdi]
ja short loc_4859C
mov r10, [rdi+8]
mov r11d, ebx
shr r11d, 8
mov r10, [r10+r11*8]
test r10, r10
jz short loc_4859C
lea r9, [r9+r9*2]
mov ebx, [r10+r9*4]
loc_4859C:
cmp rcx, r8
ja short loc_485DB
cmp ebx, offset unk_10FFFF
ja short loc_485DB
mov byte ptr [rcx-4], 0
mov r9d, ebx
shr r9d, 10h
mov [rcx-3], r9b
mov [rcx-2], bh
mov [rcx-1], bl
lea r9, [rsi+4]
cmp r9, rdx
jnb short loc_485DB
add rsi, 8
add rcx, 4
cmp rsi, rdx
mov rsi, r9
jbe loc_4854C
loc_485DB:
pop rbx
pop rbp
locret_485DD:
retn
| long long my_caseup_utf32(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
unsigned long long *v8; // rdi
unsigned long long v9; // rcx
long long v10; // r10
long long v11; // r9
unsigned long long v12; // rbx
long long v13; // r10
bool v14; // cc
result = a3;
if ( a3 >= 4 )
{
v6 = (unsigned long long)&a2[a3];
v7 = a4 + a5;
v8 = *(unsigned long long **)(a1 + 120);
v9 = a4 + 4;
do
{
v10 = (*a2 << 24) | (a2[1] << 16);
if ( (unsigned int)v10 > (unsigned int)&unk_10FFFF )
break;
v11 = a2[3];
v12 = v10 | v11 | (a2[2] << 8);
if ( v12 <= *v8 )
{
v13 = *(_QWORD *)(v8[1] + 8LL * ((unsigned int)v12 >> 8));
if ( v13 )
LODWORD(v12) = *(_DWORD *)(v13 + 12 * v11);
}
if ( v9 > v7 )
break;
if ( (unsigned int)v12 > (unsigned int)&unk_10FFFF )
break;
*(_BYTE *)(v9 - 4) = 0;
*(_BYTE *)(v9 - 3) = BYTE2(v12);
*(_BYTE *)(v9 - 2) = BYTE1(v12);
*(_BYTE *)(v9 - 1) = v12;
if ( (unsigned long long)(a2 + 4) >= v6 )
break;
v9 += 4LL;
v14 = (unsigned long long)(a2 + 8) <= v6;
a2 += 4;
}
while ( v14 );
}
return result;
}
| my_caseup_utf32:
MOV RAX,RDX
CMP RDX,0x4
JL 0x001485dd
PUSH RBP
MOV RBP,RSP
PUSH RBX
LEA RDX,[RSI + RAX*0x1]
ADD R8,RCX
MOV RDI,qword ptr [RDI + 0x78]
ADD RCX,0x4
LAB_0014854c:
MOVZX R9D,byte ptr [RSI]
SHL R9D,0x18
MOVZX R10D,byte ptr [RSI + 0x1]
SHL R10D,0x10
OR R10D,R9D
CMP R10D,0x10ffff
JA 0x001485db
MOVZX EBX,byte ptr [RSI + 0x2]
SHL EBX,0x8
MOVZX R9D,byte ptr [RSI + 0x3]
OR RBX,R9
OR RBX,R10
CMP RBX,qword ptr [RDI]
JA 0x0014859c
MOV R10,qword ptr [RDI + 0x8]
MOV R11D,EBX
SHR R11D,0x8
MOV R10,qword ptr [R10 + R11*0x8]
TEST R10,R10
JZ 0x0014859c
LEA R9,[R9 + R9*0x2]
MOV EBX,dword ptr [R10 + R9*0x4]
LAB_0014859c:
CMP RCX,R8
JA 0x001485db
CMP EBX,0x10ffff
JA 0x001485db
MOV byte ptr [RCX + -0x4],0x0
MOV R9D,EBX
SHR R9D,0x10
MOV byte ptr [RCX + -0x3],R9B
MOV byte ptr [RCX + -0x2],BH
MOV byte ptr [RCX + -0x1],BL
LEA R9,[RSI + 0x4]
CMP R9,RDX
JNC 0x001485db
ADD RSI,0x8
ADD RCX,0x4
CMP RSI,RDX
MOV RSI,R9
JBE 0x0014854c
LAB_001485db:
POP RBX
POP RBP
LAB_001485dd:
RET
|
void my_caseup_utf32(long param_1,byte *param_2,long param_3,long param_4,long param_5)
{
ulong *puVar1;
long lVar2;
ulong uVar3;
ulong uVar4;
byte *pbVar5;
byte *pbVar6;
uint uVar7;
if (3 < param_3) {
puVar1 = *(ulong **)(param_1 + 0x78);
uVar3 = param_4 + 4;
pbVar5 = param_2;
while (uVar7 = (uint)pbVar5[1] << 0x10 | (uint)*pbVar5 << 0x18, uVar7 < 0x110000) {
uVar4 = (ulong)CONCAT11(pbVar5[2],pbVar5[3]) | (ulong)uVar7;
if ((uVar4 <= *puVar1) && (lVar2 = *(long *)(puVar1[1] + (uVar4 >> 8) * 8), lVar2 != 0)) {
uVar4 = (ulong)*(uint *)(lVar2 + (ulong)pbVar5[3] * 0xc);
}
if ((ulong)(param_5 + param_4) < uVar3) {
return;
}
if (0x10ffff < (uint)uVar4) {
return;
}
*(int1 *)(uVar3 - 4) = 0;
*(char *)(uVar3 - 3) = (char)(uVar4 >> 0x10);
*(char *)(uVar3 - 2) = (char)(uVar4 >> 8);
*(char *)(uVar3 - 1) = (char)uVar4;
if (param_2 + param_3 <= pbVar5 + 4) {
return;
}
pbVar6 = pbVar5 + 8;
uVar3 = uVar3 + 4;
pbVar5 = pbVar5 + 4;
if (param_2 + param_3 < pbVar6) {
return;
}
}
}
return;
}
| |
47,216 | my_wc_mb_gbk | eloqsql/strings/ctype-gbk.c | static int
my_wc_mb_gbk(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
int code;
if (s >= e)
return MY_CS_TOOSMALL;
if ((uint) wc < 0x80)
{
s[0]= (uchar) wc;
return 1;
}
if (!(code=func_uni_gbk_onechar(wc)))
return MY_CS_ILUNI;
if (s+2>e)
return MY_CS_TOOSMALL2;
s[0]=code>>8;
s[1]=code&0xFF;
return 2;
} | O0 | c | my_wc_mb_gbk:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x4fadb
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x4fb54
movq -0x18(%rbp), %rax
cmpl $0x80, %eax
jae 0x4fafb
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x4fb54
movq -0x18(%rbp), %rax
movl %eax, %edi
callq 0x4fe20
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jne 0x4fb17
movl $0x0, -0x4(%rbp)
jmp 0x4fb54
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0x4fb2e
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x4fb54
movl -0x2c(%rbp), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl -0x2c(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| my_wc_mb_gbk:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jb short loc_4FADB
mov [rbp+var_4], 0FFFFFF9Bh
jmp short loc_4FB54
loc_4FADB:
mov rax, [rbp+var_18]
cmp eax, 80h
jnb short loc_4FAFB
mov rax, [rbp+var_18]
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov [rbp+var_4], 1
jmp short loc_4FB54
loc_4FAFB:
mov rax, [rbp+var_18]
mov edi, eax
call func_uni_gbk_onechar
mov [rbp+var_2C], eax
cmp eax, 0
jnz short loc_4FB17
mov [rbp+var_4], 0
jmp short loc_4FB54
loc_4FB17:
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_4FB2E
mov [rbp+var_4], 0FFFFFF9Ah
jmp short loc_4FB54
loc_4FB2E:
mov eax, [rbp+var_2C]
sar eax, 8
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov eax, [rbp+var_2C]
and eax, 0FFh
mov cl, al
mov rax, [rbp+var_20]
mov [rax+1], cl
mov [rbp+var_4], 2
loc_4FB54:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long my_wc_mb_gbk(long long a1, unsigned int a2, _BYTE *a3, unsigned long long a4)
{
int v5; // [rsp+4h] [rbp-2Ch]
if ( (unsigned long long)a3 < a4 )
{
if ( a2 >= 0x80 )
{
v5 = func_uni_gbk_onechar(a2);
if ( v5 )
{
if ( (unsigned long long)(a3 + 2) <= a4 )
{
*a3 = BYTE1(v5);
a3[1] = v5;
return 2;
}
else
{
return (unsigned int)-102;
}
}
else
{
return 0;
}
}
else
{
*a3 = a2;
return 1;
}
}
else
{
return (unsigned int)-101;
}
}
| my_wc_mb_gbk:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x0014fadb
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x0014fb54
LAB_0014fadb:
MOV RAX,qword ptr [RBP + -0x18]
CMP EAX,0x80
JNC 0x0014fafb
MOV RAX,qword ptr [RBP + -0x18]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0014fb54
LAB_0014fafb:
MOV RAX,qword ptr [RBP + -0x18]
MOV EDI,EAX
CALL 0x0014fe20
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JNZ 0x0014fb17
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0014fb54
LAB_0014fb17:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x0014fb2e
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x0014fb54
LAB_0014fb2e:
MOV EAX,dword ptr [RBP + -0x2c]
SAR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV EAX,dword ptr [RBP + -0x2c]
AND EAX,0xff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x1],CL
MOV dword ptr [RBP + -0x4],0x2
LAB_0014fb54:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 my_wc_mb_gbk(int8 param_1,uint param_2,int1 *param_3,int1 *param_4)
{
int iVar1;
int4 local_c;
if (param_3 < param_4) {
if (param_2 < 0x80) {
*param_3 = (char)param_2;
local_c = 1;
}
else {
iVar1 = func_uni_gbk_onechar(param_2);
if (iVar1 == 0) {
local_c = 0;
}
else if (param_4 < param_3 + 2) {
local_c = 0xffffff9a;
}
else {
*param_3 = (char)((uint)iVar1 >> 8);
param_3[1] = (char)iVar1;
local_c = 2;
}
}
}
else {
local_c = 0xffffff9b;
}
return local_c;
}
| |
47,217 | mysys_namespace::crc32c::Fast_CRC32(unsigned long*, unsigned char const**) | eloqsql/mysys/crc32/crc32c.cc | USE_SSE42
static inline void Fast_CRC32(uint64_t* l, uint8_t const **p)
{
# if (SIZEOF_SIZE_T == 8)
*l = _mm_crc32_u64(*l, LE_LOAD64(*p));
*p += 8;
# else
*l = _mm_crc32_u32(static_cast<unsigned int>(*l), LE_LOAD32(*p));
*p += 4;
*l = _mm_crc32_u32(static_cast<unsigned int>(*l), LE_LOAD32(*p));
*p += 4;
# endif
} | O0 | cpp | mysys_namespace::crc32c::Fast_CRC32(unsigned long*, unsigned char const**):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x28c70
movq -0x28(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
crc32q -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $0x8, %rcx
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| _ZN15mysys_namespace6crc32cL10Fast_CRC32EPmPPKh:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_28], rax
mov rax, [rbp+var_20]
mov rdi, [rax]; this
call _ZN15mysys_namespace6crc32cL9LE_LOAD64EPKh; mysys_namespace::crc32c::LE_LOAD64(uchar const*)
mov rcx, [rbp+var_28]
mov [rbp+var_8], rcx
mov [rbp+var_10], rax
mov rcx, [rbp+var_8]
crc32 rcx, [rbp+var_10]
mov rax, [rbp+var_18]
mov [rax], rcx
mov rax, [rbp+var_20]
mov rcx, [rax]
add rcx, 8
mov [rax], rcx
add rsp, 30h
pop rbp
retn
| const unsigned __int8 * mysys_namespace::crc32c::Fast_CRC32(
mysys_namespace::crc32c *this,
const unsigned __int8 *a2,
const unsigned __int8 **a3)
{
const unsigned __int8 *result; // rax
*(_QWORD *)this = _mm_crc32_u64(
*(_QWORD *)this,
mysys_namespace::crc32c::LE_LOAD64(*(mysys_namespace::crc32c **)a2, a2));
result = a2;
*(_QWORD *)a2 += 8LL;
return result;
}
| Fast_CRC32:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,qword ptr [RAX]
CALL 0x00128c70
MOV RCX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RCX
MOV qword ptr [RBP + -0x10],RAX
MOV RCX,qword ptr [RBP + -0x8]
CRC32 RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX]
ADD RCX,0x8
MOV qword ptr [RAX],RCX
ADD RSP,0x30
POP RBP
RET
|
/* mysys_namespace::crc32c::Fast_CRC32(unsigned long*, unsigned char const**) */
void mysys_namespace::crc32c::Fast_CRC32(ulong *param_1,uchar **param_2)
{
int8 uVar1;
ulong uVar2;
uVar2 = *param_1;
uVar1 = LE_LOAD64(*param_2);
uVar2 = crc32(uVar2,uVar1);
*param_1 = uVar2;
*param_2 = *param_2 + 8;
return;
}
| |
47,218 | init_state_maps | eloqsql/mysys/charset.c | static my_bool init_state_maps(struct charset_info_st *cs)
{
uint i;
uchar *state_map;
uchar *ident_map;
if (!(cs->state_map= state_map= (uchar*) my_once_alloc(256*2, MYF(MY_WME))))
return 1;
cs->ident_map= ident_map= state_map + 256;
/* Fill state_map with states to get a faster parser */
for (i=0; i < 256 ; i++)
{
if (my_isalpha(cs,i))
state_map[i]=(uchar) MY_LEX_IDENT;
else if (my_isdigit(cs,i))
state_map[i]=(uchar) MY_LEX_NUMBER_IDENT;
else if (is_multi_byte_ident(cs, i))
state_map[i]=(uchar) MY_LEX_IDENT;
else if (my_isspace(cs,i))
state_map[i]=(uchar) MY_LEX_SKIP;
else
state_map[i]=(uchar) MY_LEX_CHAR;
}
state_map[(uchar)'_']=state_map[(uchar)'$']=(uchar) MY_LEX_IDENT;
state_map[(uchar)'\'']=(uchar) MY_LEX_STRING;
state_map[(uchar)'.']=(uchar) MY_LEX_REAL_OR_POINT;
state_map[(uchar)'>']=state_map[(uchar)'=']=state_map[(uchar)'!']= (uchar) MY_LEX_CMP_OP;
state_map[(uchar)'<']= (uchar) MY_LEX_LONG_CMP_OP;
state_map[(uchar)'&']=state_map[(uchar)'|']=(uchar) MY_LEX_BOOL;
state_map[(uchar)'#']=(uchar) MY_LEX_COMMENT;
state_map[(uchar)';']=(uchar) MY_LEX_SEMICOLON;
state_map[(uchar)':']=(uchar) MY_LEX_SET_VAR;
state_map[0]=(uchar) MY_LEX_EOL;
state_map[(uchar)'\\']= (uchar) MY_LEX_ESCAPE;
state_map[(uchar)'/']= (uchar) MY_LEX_LONG_COMMENT;
state_map[(uchar)'*']= (uchar) MY_LEX_END_LONG_COMMENT;
state_map[(uchar)'@']= (uchar) MY_LEX_USER_END;
state_map[(uchar) '`']= (uchar) MY_LEX_USER_VARIABLE_DELIMITER;
state_map[(uchar)'"']= (uchar) MY_LEX_STRING_OR_DELIMITER;
state_map[(uchar)'-']= (uchar) MY_LEX_MINUS_OR_COMMENT;
state_map[(uchar)',']= (uchar) MY_LEX_COMMA;
state_map[(uchar)'?']= (uchar) MY_LEX_PLACEHOLDER;
/*
Create a second map to make it faster to find identifiers
*/
for (i=0; i < 256 ; i++)
{
ident_map[i]= (uchar) (state_map[i] == MY_LEX_IDENT ||
state_map[i] == MY_LEX_NUMBER_IDENT);
}
/* Special handling of hex and binary strings */
state_map[(uchar)'x']= state_map[(uchar)'X']= (uchar) MY_LEX_IDENT_OR_HEX;
state_map[(uchar)'b']= state_map[(uchar)'B']= (uchar) MY_LEX_IDENT_OR_BIN;
state_map[(uchar)'n']= state_map[(uchar)'N']= (uchar) MY_LEX_IDENT_OR_NCHAR;
return 0;
} | O0 | c | init_state_maps:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x200, %edi # imm = 0x200
movl $0x10, %esi
callq 0x28ea0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq %rax, 0x80(%rcx)
cmpq $0x0, %rax
jne 0x2b259
movb $0x1, -0x1(%rbp)
jmp 0x2b486
movq -0x20(%rbp), %rcx
addq $0x100, %rcx # imm = 0x100
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rcx, 0x88(%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x100, -0x14(%rbp) # imm = 0x100
jae 0x2b343
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x14(%rbp), %ecx
movzbl %cl, %ecx
movzbl 0x1(%rax,%rcx), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x2b2b2
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movb $0x2, (%rax,%rcx)
jmp 0x2b333
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x14(%rbp), %ecx
movzbl %cl, %ecx
movzbl 0x1(%rax,%rcx), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x2b2da
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movb $0xe, (%rax,%rcx)
jmp 0x2b331
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movzbl %al, %esi
callq 0x2b560
cmpb $0x0, %al
je 0x2b2fa
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movb $0x2, (%rax,%rcx)
jmp 0x2b32f
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x14(%rbp), %ecx
movzbl %cl, %ecx
movzbl 0x1(%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x2b322
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movb $0x1a, (%rax,%rcx)
jmp 0x2b32d
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movb $0x1, (%rax,%rcx)
jmp 0x2b32f
jmp 0x2b331
jmp 0x2b333
jmp 0x2b335
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2b27a
movq -0x20(%rbp), %rax
movb $0x2, 0x24(%rax)
movq -0x20(%rbp), %rax
movb $0x2, 0x5f(%rax)
movq -0x20(%rbp), %rax
movb $0xa, 0x27(%rax)
movq -0x20(%rbp), %rax
movb $0x10, 0x2e(%rax)
movq -0x20(%rbp), %rax
movb $0x8, 0x21(%rax)
movq -0x20(%rbp), %rax
movb $0x8, 0x3d(%rax)
movq -0x20(%rbp), %rax
movb $0x8, 0x3e(%rax)
movq -0x20(%rbp), %rax
movb $0x9, 0x3c(%rax)
movq -0x20(%rbp), %rax
movb $0x11, 0x7c(%rax)
movq -0x20(%rbp), %rax
movb $0x11, 0x26(%rax)
movq -0x20(%rbp), %rax
movb $0xb, 0x23(%rax)
movq -0x20(%rbp), %rax
movb $0x16, 0x3b(%rax)
movq -0x20(%rbp), %rax
movb $0x17, 0x3a(%rax)
movq -0x20(%rbp), %rax
movb $0x12, (%rax)
movq -0x20(%rbp), %rax
movb $0x13, 0x5c(%rax)
movq -0x20(%rbp), %rax
movb $0x14, 0x2f(%rax)
movq -0x20(%rbp), %rax
movb $0x15, 0x2a(%rax)
movq -0x20(%rbp), %rax
movb $0x18, 0x40(%rax)
movq -0x20(%rbp), %rax
movb $0x1b, 0x60(%rax)
movq -0x20(%rbp), %rax
movb $0x21, 0x22(%rax)
movq -0x20(%rbp), %rax
movb $0x22, 0x2d(%rax)
movq -0x20(%rbp), %rax
movb $0x24, 0x2c(%rax)
movq -0x20(%rbp), %rax
movb $0x23, 0x3f(%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x100, -0x14(%rbp) # imm = 0x100
jae 0x2b452
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movzbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x2, %ecx
movb %al, -0x29(%rbp)
je 0x2b433
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movzbl (%rax,%rcx), %eax
cmpl $0xe, %eax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, %dl
movq -0x28(%rbp), %rax
movl -0x14(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2b401
movq -0x20(%rbp), %rax
movb $0x1e, 0x58(%rax)
movq -0x20(%rbp), %rax
movb $0x1e, 0x78(%rax)
movq -0x20(%rbp), %rax
movb $0x1f, 0x42(%rax)
movq -0x20(%rbp), %rax
movb $0x1f, 0x62(%rax)
movq -0x20(%rbp), %rax
movb $0x20, 0x4e(%rax)
movq -0x20(%rbp), %rax
movb $0x20, 0x6e(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nop
| init_state_maps:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov edi, 200h
mov esi, 10h
call my_once_alloc
mov [rbp+var_20], rax
mov rcx, [rbp+var_10]
mov [rcx+80h], rax
cmp rax, 0
jnz short loc_2B259
mov [rbp+var_1], 1
jmp loc_2B486
loc_2B259:
mov rcx, [rbp+var_20]
add rcx, 100h
mov [rbp+var_28], rcx
mov rax, [rbp+var_10]
mov [rax+88h], rcx
mov [rbp+var_14], 0
loc_2B27A:
cmp [rbp+var_14], 100h
jnb loc_2B343
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov ecx, [rbp+var_14]
movzx ecx, cl
movzx eax, byte ptr [rax+rcx+1]
and eax, 3
cmp eax, 0
jz short loc_2B2B2
mov rax, [rbp+var_20]
mov ecx, [rbp+var_14]
mov byte ptr [rax+rcx], 2
jmp loc_2B333
loc_2B2B2:
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov ecx, [rbp+var_14]
movzx ecx, cl
movzx eax, byte ptr [rax+rcx+1]
and eax, 4
cmp eax, 0
jz short loc_2B2DA
mov rax, [rbp+var_20]
mov ecx, [rbp+var_14]
mov byte ptr [rax+rcx], 0Eh
jmp short loc_2B331
loc_2B2DA:
mov rdi, [rbp+var_10]
mov eax, [rbp+var_14]
movzx esi, al
call is_multi_byte_ident
cmp al, 0
jz short loc_2B2FA
mov rax, [rbp+var_20]
mov ecx, [rbp+var_14]
mov byte ptr [rax+rcx], 2
jmp short loc_2B32F
loc_2B2FA:
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov ecx, [rbp+var_14]
movzx ecx, cl
movzx eax, byte ptr [rax+rcx+1]
and eax, 8
cmp eax, 0
jz short loc_2B322
mov rax, [rbp+var_20]
mov ecx, [rbp+var_14]
mov byte ptr [rax+rcx], 1Ah
jmp short loc_2B32D
loc_2B322:
mov rax, [rbp+var_20]
mov ecx, [rbp+var_14]
mov byte ptr [rax+rcx], 1
loc_2B32D:
jmp short $+2
loc_2B32F:
jmp short $+2
loc_2B331:
jmp short $+2
loc_2B333:
jmp short $+2
loc_2B335:
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_14], eax
jmp loc_2B27A
loc_2B343:
mov rax, [rbp+var_20]
mov byte ptr [rax+24h], 2
mov rax, [rbp+var_20]
mov byte ptr [rax+5Fh], 2
mov rax, [rbp+var_20]
mov byte ptr [rax+27h], 0Ah
mov rax, [rbp+var_20]
mov byte ptr [rax+2Eh], 10h
mov rax, [rbp+var_20]
mov byte ptr [rax+21h], 8
mov rax, [rbp+var_20]
mov byte ptr [rax+3Dh], 8
mov rax, [rbp+var_20]
mov byte ptr [rax+3Eh], 8
mov rax, [rbp+var_20]
mov byte ptr [rax+3Ch], 9
mov rax, [rbp+var_20]
mov byte ptr [rax+7Ch], 11h
mov rax, [rbp+var_20]
mov byte ptr [rax+26h], 11h
mov rax, [rbp+var_20]
mov byte ptr [rax+23h], 0Bh
mov rax, [rbp+var_20]
mov byte ptr [rax+3Bh], 16h
mov rax, [rbp+var_20]
mov byte ptr [rax+3Ah], 17h
mov rax, [rbp+var_20]
mov byte ptr [rax], 12h
mov rax, [rbp+var_20]
mov byte ptr [rax+5Ch], 13h
mov rax, [rbp+var_20]
mov byte ptr [rax+2Fh], 14h
mov rax, [rbp+var_20]
mov byte ptr [rax+2Ah], 15h
mov rax, [rbp+var_20]
mov byte ptr [rax+40h], 18h
mov rax, [rbp+var_20]
mov byte ptr [rax+60h], 1Bh
mov rax, [rbp+var_20]
mov byte ptr [rax+22h], 21h ; '!'
mov rax, [rbp+var_20]
mov byte ptr [rax+2Dh], 22h ; '"'
mov rax, [rbp+var_20]
mov byte ptr [rax+2Ch], 24h ; '$'
mov rax, [rbp+var_20]
mov byte ptr [rax+3Fh], 23h ; '#'
mov [rbp+var_14], 0
loc_2B401:
cmp [rbp+var_14], 100h
jnb short loc_2B452
mov rax, [rbp+var_20]
mov ecx, [rbp+var_14]
movzx ecx, byte ptr [rax+rcx]
mov al, 1
cmp ecx, 2
mov [rbp+var_29], al
jz short loc_2B433
mov rax, [rbp+var_20]
mov ecx, [rbp+var_14]
movzx eax, byte ptr [rax+rcx]
cmp eax, 0Eh
setz al
mov [rbp+var_29], al
loc_2B433:
mov al, [rbp+var_29]
and al, 1
movzx eax, al
mov dl, al
mov rax, [rbp+var_28]
mov ecx, [rbp+var_14]
mov [rax+rcx], dl
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_14], eax
jmp short loc_2B401
loc_2B452:
mov rax, [rbp+var_20]
mov byte ptr [rax+58h], 1Eh
mov rax, [rbp+var_20]
mov byte ptr [rax+78h], 1Eh
mov rax, [rbp+var_20]
mov byte ptr [rax+42h], 1Fh
mov rax, [rbp+var_20]
mov byte ptr [rax+62h], 1Fh
mov rax, [rbp+var_20]
mov byte ptr [rax+4Eh], 20h ; ' '
mov rax, [rbp+var_20]
mov byte ptr [rax+6Eh], 20h ; ' '
mov [rbp+var_1], 0
loc_2B486:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
| char init_state_maps(_QWORD *a1)
{
bool v2; // [rsp+7h] [rbp-29h]
char *v3; // [rsp+10h] [rbp-20h]
unsigned int i; // [rsp+1Ch] [rbp-14h]
unsigned int j; // [rsp+1Ch] [rbp-14h]
v3 = my_once_alloc(512LL, 16);
a1[16] = v3;
if ( !v3 )
return 1;
a1[17] = v3 + 256;
for ( i = 0; i < 0x100; ++i )
{
if ( (*(_BYTE *)(a1[8] + (unsigned __int8)i + 1LL) & 3) != 0 )
{
v3[i] = 2;
}
else if ( (*(_BYTE *)(a1[8] + (unsigned __int8)i + 1LL) & 4) != 0 )
{
v3[i] = 14;
}
else if ( (unsigned __int8)is_multi_byte_ident(a1, (unsigned __int8)i) )
{
v3[i] = 2;
}
else if ( (*(_BYTE *)(a1[8] + (unsigned __int8)i + 1LL) & 8) != 0 )
{
v3[i] = 26;
}
else
{
v3[i] = 1;
}
}
v3[36] = 2;
v3[95] = 2;
v3[39] = 10;
v3[46] = 16;
v3[33] = 8;
v3[61] = 8;
v3[62] = 8;
v3[60] = 9;
v3[124] = 17;
v3[38] = 17;
v3[35] = 11;
v3[59] = 22;
v3[58] = 23;
*v3 = 18;
v3[92] = 19;
v3[47] = 20;
v3[42] = 21;
v3[64] = 24;
v3[96] = 27;
v3[34] = 33;
v3[45] = 34;
v3[44] = 36;
v3[63] = 35;
for ( j = 0; j < 0x100; ++j )
{
v2 = 1;
if ( v3[j] != 2 )
v2 = v3[j] == 14;
v3[j + 256] = v2;
}
v3[88] = 30;
v3[120] = 30;
v3[66] = 31;
v3[98] = 31;
v3[78] = 32;
v3[110] = 32;
return 0;
}
| init_state_maps:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV EDI,0x200
MOV ESI,0x10
CALL 0x00128ea0
MOV qword ptr [RBP + -0x20],RAX
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x80],RAX
CMP RAX,0x0
JNZ 0x0012b259
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0012b486
LAB_0012b259:
MOV RCX,qword ptr [RBP + -0x20]
ADD RCX,0x100
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x88],RCX
MOV dword ptr [RBP + -0x14],0x0
LAB_0012b27a:
CMP dword ptr [RBP + -0x14],0x100
JNC 0x0012b343
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV ECX,dword ptr [RBP + -0x14]
MOVZX ECX,CL
MOVZX EAX,byte ptr [RAX + RCX*0x1 + 0x1]
AND EAX,0x3
CMP EAX,0x0
JZ 0x0012b2b2
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x14]
MOV byte ptr [RAX + RCX*0x1],0x2
JMP 0x0012b333
LAB_0012b2b2:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV ECX,dword ptr [RBP + -0x14]
MOVZX ECX,CL
MOVZX EAX,byte ptr [RAX + RCX*0x1 + 0x1]
AND EAX,0x4
CMP EAX,0x0
JZ 0x0012b2da
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x14]
MOV byte ptr [RAX + RCX*0x1],0xe
JMP 0x0012b331
LAB_0012b2da:
MOV RDI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x14]
MOVZX ESI,AL
CALL 0x0012b560
CMP AL,0x0
JZ 0x0012b2fa
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x14]
MOV byte ptr [RAX + RCX*0x1],0x2
JMP 0x0012b32f
LAB_0012b2fa:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV ECX,dword ptr [RBP + -0x14]
MOVZX ECX,CL
MOVZX EAX,byte ptr [RAX + RCX*0x1 + 0x1]
AND EAX,0x8
CMP EAX,0x0
JZ 0x0012b322
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x14]
MOV byte ptr [RAX + RCX*0x1],0x1a
JMP 0x0012b32d
LAB_0012b322:
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x14]
MOV byte ptr [RAX + RCX*0x1],0x1
LAB_0012b32d:
JMP 0x0012b32f
LAB_0012b32f:
JMP 0x0012b331
LAB_0012b331:
JMP 0x0012b333
LAB_0012b333:
JMP 0x0012b335
LAB_0012b335:
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x0012b27a
LAB_0012b343:
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x24],0x2
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x5f],0x2
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x27],0xa
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x2e],0x10
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x21],0x8
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x3d],0x8
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x3e],0x8
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x3c],0x9
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x7c],0x11
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x26],0x11
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x23],0xb
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x3b],0x16
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x3a],0x17
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],0x12
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x5c],0x13
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x2f],0x14
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x2a],0x15
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x40],0x18
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x60],0x1b
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x22],0x21
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x2d],0x22
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x2c],0x24
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x3f],0x23
MOV dword ptr [RBP + -0x14],0x0
LAB_0012b401:
CMP dword ptr [RBP + -0x14],0x100
JNC 0x0012b452
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x14]
MOVZX ECX,byte ptr [RAX + RCX*0x1]
MOV AL,0x1
CMP ECX,0x2
MOV byte ptr [RBP + -0x29],AL
JZ 0x0012b433
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x14]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
CMP EAX,0xe
SETZ AL
MOV byte ptr [RBP + -0x29],AL
LAB_0012b433:
MOV AL,byte ptr [RBP + -0x29]
AND AL,0x1
MOVZX EAX,AL
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RBP + -0x14]
MOV byte ptr [RAX + RCX*0x1],DL
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x0012b401
LAB_0012b452:
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x58],0x1e
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x78],0x1e
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x42],0x1f
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x62],0x1f
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x4e],0x20
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x6e],0x20
MOV byte ptr [RBP + -0x1],0x0
LAB_0012b486:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 init_state_maps(long param_1)
{
char cVar1;
int1 *puVar2;
bool local_31;
uint local_1c;
int1 local_9;
puVar2 = (int1 *)my_once_alloc(0x200,0x10);
*(int1 **)(param_1 + 0x80) = puVar2;
if (puVar2 == (int1 *)0x0) {
local_9 = 1;
}
else {
*(int1 **)(param_1 + 0x88) = puVar2 + 0x100;
for (local_1c = 0; local_1c < 0x100; local_1c = local_1c + 1) {
if ((*(byte *)(*(long *)(param_1 + 0x40) + 1 + (ulong)(local_1c & 0xff)) & 3) == 0) {
if ((*(byte *)(*(long *)(param_1 + 0x40) + 1 + (ulong)(local_1c & 0xff)) & 4) == 0) {
cVar1 = is_multi_byte_ident(param_1,local_1c & 0xff);
if (cVar1 == '\0') {
if ((*(byte *)(*(long *)(param_1 + 0x40) + 1 + (ulong)(local_1c & 0xff)) & 8) == 0) {
puVar2[local_1c] = 1;
}
else {
puVar2[local_1c] = 0x1a;
}
}
else {
puVar2[local_1c] = 2;
}
}
else {
puVar2[local_1c] = 0xe;
}
}
else {
puVar2[local_1c] = 2;
}
}
puVar2[0x24] = 2;
puVar2[0x5f] = 2;
puVar2[0x27] = 10;
puVar2[0x2e] = 0x10;
puVar2[0x21] = 8;
puVar2[0x3d] = 8;
puVar2[0x3e] = 8;
puVar2[0x3c] = 9;
puVar2[0x7c] = 0x11;
puVar2[0x26] = 0x11;
puVar2[0x23] = 0xb;
puVar2[0x3b] = 0x16;
puVar2[0x3a] = 0x17;
*puVar2 = 0x12;
puVar2[0x5c] = 0x13;
puVar2[0x2f] = 0x14;
puVar2[0x2a] = 0x15;
puVar2[0x40] = 0x18;
puVar2[0x60] = 0x1b;
puVar2[0x22] = 0x21;
puVar2[0x2d] = 0x22;
puVar2[0x2c] = 0x24;
puVar2[0x3f] = 0x23;
for (local_1c = 0; local_1c < 0x100; local_1c = local_1c + 1) {
local_31 = true;
if (puVar2[local_1c] != '\x02') {
local_31 = puVar2[local_1c] == '\x0e';
}
(puVar2 + 0x100)[local_1c] = local_31;
}
puVar2[0x58] = 0x1e;
puVar2[0x78] = 0x1e;
puVar2[0x42] = 0x1f;
puVar2[0x62] = 0x1f;
puVar2[0x4e] = 0x20;
puVar2[0x6e] = 0x20;
local_9 = 0;
}
return local_9;
}
| |
47,219 | init_state_maps | eloqsql/mysys/charset.c | static my_bool init_state_maps(struct charset_info_st *cs)
{
uint i;
uchar *state_map;
uchar *ident_map;
if (!(cs->state_map= state_map= (uchar*) my_once_alloc(256*2, MYF(MY_WME))))
return 1;
cs->ident_map= ident_map= state_map + 256;
/* Fill state_map with states to get a faster parser */
for (i=0; i < 256 ; i++)
{
if (my_isalpha(cs,i))
state_map[i]=(uchar) MY_LEX_IDENT;
else if (my_isdigit(cs,i))
state_map[i]=(uchar) MY_LEX_NUMBER_IDENT;
else if (is_multi_byte_ident(cs, i))
state_map[i]=(uchar) MY_LEX_IDENT;
else if (my_isspace(cs,i))
state_map[i]=(uchar) MY_LEX_SKIP;
else
state_map[i]=(uchar) MY_LEX_CHAR;
}
state_map[(uchar)'_']=state_map[(uchar)'$']=(uchar) MY_LEX_IDENT;
state_map[(uchar)'\'']=(uchar) MY_LEX_STRING;
state_map[(uchar)'.']=(uchar) MY_LEX_REAL_OR_POINT;
state_map[(uchar)'>']=state_map[(uchar)'=']=state_map[(uchar)'!']= (uchar) MY_LEX_CMP_OP;
state_map[(uchar)'<']= (uchar) MY_LEX_LONG_CMP_OP;
state_map[(uchar)'&']=state_map[(uchar)'|']=(uchar) MY_LEX_BOOL;
state_map[(uchar)'#']=(uchar) MY_LEX_COMMENT;
state_map[(uchar)';']=(uchar) MY_LEX_SEMICOLON;
state_map[(uchar)':']=(uchar) MY_LEX_SET_VAR;
state_map[0]=(uchar) MY_LEX_EOL;
state_map[(uchar)'\\']= (uchar) MY_LEX_ESCAPE;
state_map[(uchar)'/']= (uchar) MY_LEX_LONG_COMMENT;
state_map[(uchar)'*']= (uchar) MY_LEX_END_LONG_COMMENT;
state_map[(uchar)'@']= (uchar) MY_LEX_USER_END;
state_map[(uchar) '`']= (uchar) MY_LEX_USER_VARIABLE_DELIMITER;
state_map[(uchar)'"']= (uchar) MY_LEX_STRING_OR_DELIMITER;
state_map[(uchar)'-']= (uchar) MY_LEX_MINUS_OR_COMMENT;
state_map[(uchar)',']= (uchar) MY_LEX_COMMA;
state_map[(uchar)'?']= (uchar) MY_LEX_PLACEHOLDER;
/*
Create a second map to make it faster to find identifiers
*/
for (i=0; i < 256 ; i++)
{
ident_map[i]= (uchar) (state_map[i] == MY_LEX_IDENT ||
state_map[i] == MY_LEX_NUMBER_IDENT);
}
/* Special handling of hex and binary strings */
state_map[(uchar)'x']= state_map[(uchar)'X']= (uchar) MY_LEX_IDENT_OR_HEX;
state_map[(uchar)'b']= state_map[(uchar)'B']= (uchar) MY_LEX_IDENT_OR_BIN;
state_map[(uchar)'n']= state_map[(uchar)'N']= (uchar) MY_LEX_IDENT_OR_NCHAR;
return 0;
} | O3 | c | init_state_maps:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x200, %edi # imm = 0x200
movl $0x10, %esi
callq 0x27898
movq %rax, 0x80(%r14)
testq %rax, %rax
je 0x29386
movq %rax, %rbx
movq %rax, %r13
addq $0x100, %r13 # imm = 0x100
movq %r13, 0x88(%r14)
xorl %r15d, %r15d
leaq -0x29(%rbp), %r12
movq 0x40(%r14), %rax
movzbl 0x1(%rax,%r15), %eax
testb $0x3, %al
je 0x29292
movb $0x2, (%rbx,%r15)
jmp 0x292d1
testb $0x4, %al
jne 0x292cc
movb %r15b, -0x29(%rbp)
movq 0xb8(%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
leaq -0x28(%rbp), %rdx
callq *0xc0(%rax)
addl $0x64, %eax
cmpl $-0x6, %eax
jae 0x2928b
movq 0x40(%r14), %rax
testb $0x8, 0x1(%rax,%r15)
jne 0x292df
movb $0x1, (%rbx,%r15)
jmp 0x292d1
movb $0xe, (%rbx,%r15)
incq %r15
cmpq $0x100, %r15 # imm = 0x100
jne 0x2927d
jmp 0x292e6
movb $0x1a, (%rbx,%r15)
jmp 0x292d1
movw $0x1b02, 0x5f(%rbx) # imm = 0x1B02
movb $0x8, 0x3e(%rbx)
movb $0x11, 0x7c(%rbx)
movw $0xa11, 0x26(%rbx) # imm = 0xA11
movl $0x8091617, 0x3a(%rbx) # imm = 0x8091617
movb $0x12, (%rbx)
movb $0x13, 0x5c(%rbx)
movb $0x15, 0x2a(%rbx)
movl $0x20b2108, 0x21(%rbx) # imm = 0x20B2108
movl $0x14102224, 0x2c(%rbx) # imm = 0x14102224
movw $0x1823, 0x3f(%rbx) # imm = 0x1823
movq $-0x100, %rax
movdqa 0x37a51(%rip), %xmm0 # 0x60d80
movdqa 0x37a59(%rip), %xmm1 # 0x60d90
movdqa 0x37a61(%rip), %xmm2 # 0x60da0
movdqu (%r13,%rax), %xmm3
movdqa %xmm3, %xmm4
pcmpeqb %xmm0, %xmm4
pcmpeqb %xmm1, %xmm3
por %xmm4, %xmm3
pand %xmm2, %xmm3
movdqu %xmm3, 0x100(%r13,%rax)
addq $0x10, %rax
jne 0x2933f
movb $0x1e, %al
movb %al, 0x58(%rbx)
movb %al, 0x78(%rbx)
movb $0x1f, %al
movb %al, 0x42(%rbx)
movb %al, 0x62(%rbx)
movb $0x20, %al
movb %al, 0x4e(%rbx)
movb %al, 0x6e(%rbx)
xorl %eax, %eax
jmp 0x29388
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| init_state_maps:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rdi
mov edi, 200h
mov esi, 10h
call my_once_alloc
mov [r14+80h], rax
test rax, rax
jz loc_29386
mov rbx, rax
mov r13, rax
add r13, 100h
mov [r14+88h], r13
xor r15d, r15d
lea r12, [rbp+var_29]
loc_2927D:
mov rax, [r14+40h]
movzx eax, byte ptr [rax+r15+1]
test al, 3
jz short loc_29292
loc_2928B:
mov byte ptr [rbx+r15], 2
jmp short loc_292D1
loc_29292:
test al, 4
jnz short loc_292CC
mov [rbp+var_29], r15b
mov rax, [r14+0B8h]
mov rdi, r14
mov rsi, r12
lea rdx, [rbp+var_28]
call qword ptr [rax+0C0h]
add eax, 64h ; 'd'
cmp eax, 0FFFFFFFAh
jnb short loc_2928B
mov rax, [r14+40h]
test byte ptr [rax+r15+1], 8
jnz short loc_292DF
mov byte ptr [rbx+r15], 1
jmp short loc_292D1
loc_292CC:
mov byte ptr [rbx+r15], 0Eh
loc_292D1:
inc r15
cmp r15, 100h
jnz short loc_2927D
jmp short loc_292E6
loc_292DF:
mov byte ptr [rbx+r15], 1Ah
jmp short loc_292D1
loc_292E6:
mov word ptr [rbx+5Fh], 1B02h
mov byte ptr [rbx+3Eh], 8
mov byte ptr [rbx+7Ch], 11h
mov word ptr [rbx+26h], 0A11h
mov dword ptr [rbx+3Ah], 8091617h
mov byte ptr [rbx], 12h
mov byte ptr [rbx+5Ch], 13h
mov byte ptr [rbx+2Ah], 15h
mov dword ptr [rbx+21h], 20B2108h
mov dword ptr [rbx+2Ch], 14102224h
mov word ptr [rbx+3Fh], 1823h
mov rax, 0FFFFFFFFFFFFFF00h
movdqa xmm0, cs:xmmword_60D80
movdqa xmm1, cs:xmmword_60D90
movdqa xmm2, cs:xmmword_60DA0
loc_2933F:
movdqu xmm3, xmmword ptr [r13+rax+0]
movdqa xmm4, xmm3
pcmpeqb xmm4, xmm0
pcmpeqb xmm3, xmm1
por xmm3, xmm4
pand xmm3, xmm2
movdqu xmmword ptr [r13+rax+100h], xmm3
add rax, 10h
jnz short loc_2933F
mov al, 1Eh
mov [rbx+58h], al
mov [rbx+78h], al
mov al, 1Fh
mov [rbx+42h], al
mov [rbx+62h], al
mov al, 20h ; ' '
mov [rbx+4Eh], al
mov [rbx+6Eh], al
xor eax, eax
jmp short loc_29388
loc_29386:
mov al, 1
loc_29388:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long init_state_maps(_QWORD *a1)
{
long long v1; // rax
long long v2; // rax
long long v3; // rbx
long long v4; // r13
long long i; // r15
char v6; // al
long long v7; // rax
__m128i si128; // xmm0
__m128i v9; // xmm1
__m128i v10; // xmm2
__m128i v11; // xmm3
char v13; // [rsp+1h] [rbp-29h] BYREF
_BYTE v14[40]; // [rsp+2h] [rbp-28h] BYREF
v13 = HIBYTE(v1);
v2 = my_once_alloc(512LL, 16);
a1[16] = v2;
if ( !v2 )
return 1LL;
v3 = v2;
v4 = v2 + 256;
a1[17] = v2 + 256;
for ( i = 0LL; i != 256; ++i )
{
v6 = *(_BYTE *)(a1[8] + i + 1);
if ( (v6 & 3) != 0 )
{
LABEL_4:
*(_BYTE *)(v3 + i) = 2;
continue;
}
if ( (v6 & 4) != 0 )
{
*(_BYTE *)(v3 + i) = 14;
}
else
{
v13 = i;
if ( (*(unsigned int ( **)(_QWORD *, char *, _BYTE *))(a1[23] + 192LL))(a1, &v13, v14) + 100 >= 0xFFFFFFFA )
goto LABEL_4;
if ( (*(_BYTE *)(a1[8] + i + 1) & 8) != 0 )
*(_BYTE *)(v3 + i) = 26;
else
*(_BYTE *)(v3 + i) = 1;
}
}
*(_WORD *)(v3 + 95) = 6914;
*(_BYTE *)(v3 + 62) = 8;
*(_BYTE *)(v3 + 124) = 17;
*(_WORD *)(v3 + 38) = 2577;
*(_DWORD *)(v3 + 58) = 134813207;
*(_BYTE *)v3 = 18;
*(_BYTE *)(v3 + 92) = 19;
*(_BYTE *)(v3 + 42) = 21;
*(_DWORD *)(v3 + 33) = 34283784;
*(_DWORD *)(v3 + 44) = 336601636;
*(_WORD *)(v3 + 63) = 6179;
v7 = -256LL;
si128 = _mm_load_si128((const __m128i *)&xmmword_60D80);
v9 = _mm_load_si128((const __m128i *)&xmmword_60D90);
v10 = _mm_load_si128((const __m128i *)&xmmword_60DA0);
do
{
v11 = _mm_loadu_si128((const __m128i *)(v4 + v7));
*(__m128i *)(v4 + v7 + 256) = _mm_and_si128(_mm_or_si128(_mm_cmpeq_epi8(v11, v9), _mm_cmpeq_epi8(v11, si128)), v10);
v7 += 16LL;
}
while ( v7 );
*(_BYTE *)(v3 + 88) = 30;
*(_BYTE *)(v3 + 120) = 30;
*(_BYTE *)(v3 + 66) = 31;
*(_BYTE *)(v3 + 98) = 31;
*(_BYTE *)(v3 + 78) = 32;
*(_BYTE *)(v3 + 110) = 32;
return 0LL;
}
| init_state_maps:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDI
MOV EDI,0x200
MOV ESI,0x10
CALL 0x00127898
MOV qword ptr [R14 + 0x80],RAX
TEST RAX,RAX
JZ 0x00129386
MOV RBX,RAX
MOV R13,RAX
ADD R13,0x100
MOV qword ptr [R14 + 0x88],R13
XOR R15D,R15D
LEA R12,[RBP + -0x29]
LAB_0012927d:
MOV RAX,qword ptr [R14 + 0x40]
MOVZX EAX,byte ptr [RAX + R15*0x1 + 0x1]
TEST AL,0x3
JZ 0x00129292
LAB_0012928b:
MOV byte ptr [RBX + R15*0x1],0x2
JMP 0x001292d1
LAB_00129292:
TEST AL,0x4
JNZ 0x001292cc
MOV byte ptr [RBP + -0x29],R15B
MOV RAX,qword ptr [R14 + 0xb8]
MOV RDI,R14
MOV RSI,R12
LEA RDX,[RBP + -0x28]
CALL qword ptr [RAX + 0xc0]
ADD EAX,0x64
CMP EAX,-0x6
JNC 0x0012928b
MOV RAX,qword ptr [R14 + 0x40]
TEST byte ptr [RAX + R15*0x1 + 0x1],0x8
JNZ 0x001292df
MOV byte ptr [RBX + R15*0x1],0x1
JMP 0x001292d1
LAB_001292cc:
MOV byte ptr [RBX + R15*0x1],0xe
LAB_001292d1:
INC R15
CMP R15,0x100
JNZ 0x0012927d
JMP 0x001292e6
LAB_001292df:
MOV byte ptr [RBX + R15*0x1],0x1a
JMP 0x001292d1
LAB_001292e6:
MOV word ptr [RBX + 0x5f],0x1b02
MOV byte ptr [RBX + 0x3e],0x8
MOV byte ptr [RBX + 0x7c],0x11
MOV word ptr [RBX + 0x26],0xa11
MOV dword ptr [RBX + 0x3a],0x8091617
MOV byte ptr [RBX],0x12
MOV byte ptr [RBX + 0x5c],0x13
MOV byte ptr [RBX + 0x2a],0x15
MOV dword ptr [RBX + 0x21],0x20b2108
MOV dword ptr [RBX + 0x2c],0x14102224
MOV word ptr [RBX + 0x3f],0x1823
MOV RAX,-0x100
MOVDQA XMM0,xmmword ptr [0x00160d80]
MOVDQA XMM1,xmmword ptr [0x00160d90]
MOVDQA XMM2,xmmword ptr [0x00160da0]
LAB_0012933f:
MOVDQU XMM3,xmmword ptr [R13 + RAX*0x1]
MOVDQA XMM4,XMM3
PCMPEQB XMM4,XMM0
PCMPEQB XMM3,XMM1
POR XMM3,XMM4
PAND XMM3,XMM2
MOVDQU xmmword ptr [R13 + RAX*0x1 + 0x100],XMM3
ADD RAX,0x10
JNZ 0x0012933f
MOV AL,0x1e
MOV byte ptr [RBX + 0x58],AL
MOV byte ptr [RBX + 0x78],AL
MOV AL,0x1f
MOV byte ptr [RBX + 0x42],AL
MOV byte ptr [RBX + 0x62],AL
MOV AL,0x20
MOV byte ptr [RBX + 0x4e],AL
MOV byte ptr [RBX + 0x6e],AL
XOR EAX,EAX
JMP 0x00129388
LAB_00129386:
MOV AL,0x1
LAB_00129388:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 init_state_maps(long param_1)
{
char *pcVar1;
byte *pbVar2;
byte bVar3;
char cVar4;
char cVar5;
char cVar6;
char cVar7;
char cVar8;
char cVar9;
char cVar10;
char cVar11;
char cVar12;
char cVar13;
char cVar14;
char cVar15;
char cVar16;
char cVar17;
char cVar18;
char cVar19;
char cVar20;
char cVar21;
char cVar22;
char cVar23;
char cVar24;
char cVar25;
char cVar26;
char cVar27;
char cVar28;
char cVar29;
char cVar30;
char cVar31;
char cVar32;
char cVar33;
char cVar34;
char cVar35;
char cVar36;
char cVar37;
char cVar38;
char cVar39;
char cVar40;
char cVar41;
char cVar42;
char cVar43;
char cVar44;
char cVar45;
char cVar46;
char cVar47;
char cVar48;
char cVar49;
char cVar50;
byte bVar51;
byte bVar52;
byte bVar53;
byte bVar54;
byte bVar55;
byte bVar56;
byte bVar57;
byte bVar58;
byte bVar59;
byte bVar60;
byte bVar61;
byte bVar62;
byte bVar63;
byte bVar64;
byte bVar65;
int iVar66;
int8 in_RAX;
int1 *puVar67;
int8 uVar68;
long lVar69;
int8 uStack_38;
uStack_38 = in_RAX;
puVar67 = (int1 *)my_once_alloc(0x200,0x10);
*(int1 **)(param_1 + 0x80) = puVar67;
if (puVar67 == (int1 *)0x0) {
uVar68 = 1;
}
else {
*(int1 **)(param_1 + 0x88) = puVar67 + 0x100;
lVar69 = 0;
do {
bVar3 = *(byte *)(*(long *)(param_1 + 0x40) + 1 + lVar69);
if ((bVar3 & 3) == 0) {
if ((bVar3 & 4) == 0) {
uStack_38 = CONCAT17((char)lVar69,(int7)uStack_38);
iVar66 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xc0))
(param_1,(long)&uStack_38 + 7,&stack0xffffffffffffffd0);
if (0xfffffff9 < iVar66 + 100U) goto LAB_0012928b;
if ((*(byte *)(*(long *)(param_1 + 0x40) + 1 + lVar69) & 8) == 0) {
puVar67[lVar69] = 1;
}
else {
puVar67[lVar69] = 0x1a;
}
}
else {
puVar67[lVar69] = 0xe;
}
}
else {
LAB_0012928b:
puVar67[lVar69] = 2;
}
lVar69 = lVar69 + 1;
} while (lVar69 != 0x100);
*(int2 *)(puVar67 + 0x5f) = 0x1b02;
puVar67[0x3e] = 8;
puVar67[0x7c] = 0x11;
*(int2 *)(puVar67 + 0x26) = 0xa11;
*(int4 *)(puVar67 + 0x3a) = 0x8091617;
*puVar67 = 0x12;
puVar67[0x5c] = 0x13;
puVar67[0x2a] = 0x15;
*(int4 *)(puVar67 + 0x21) = 0x20b2108;
*(int4 *)(puVar67 + 0x2c) = 0x14102224;
*(int2 *)(puVar67 + 0x3f) = 0x1823;
bVar65 = UNK_00160daf;
bVar64 = UNK_00160dae;
bVar63 = UNK_00160dad;
bVar62 = UNK_00160dac;
bVar61 = UNK_00160dab;
bVar60 = UNK_00160daa;
bVar59 = UNK_00160da9;
bVar58 = UNK_00160da8;
bVar57 = UNK_00160da7;
bVar56 = UNK_00160da6;
bVar55 = UNK_00160da5;
bVar54 = UNK_00160da4;
bVar53 = UNK_00160da3;
bVar52 = UNK_00160da2;
bVar51 = UNK_00160da1;
bVar3 = DAT_00160da0;
cVar50 = UNK_00160d9f;
cVar49 = UNK_00160d9e;
cVar48 = UNK_00160d9d;
cVar47 = UNK_00160d9c;
cVar46 = UNK_00160d9b;
cVar45 = UNK_00160d9a;
cVar44 = UNK_00160d99;
cVar43 = UNK_00160d98;
cVar42 = UNK_00160d97;
cVar41 = UNK_00160d96;
cVar40 = UNK_00160d95;
cVar39 = UNK_00160d94;
cVar38 = UNK_00160d93;
cVar37 = UNK_00160d92;
cVar36 = UNK_00160d91;
cVar35 = DAT_00160d90;
cVar34 = UNK_00160d8f;
cVar33 = UNK_00160d8e;
cVar32 = UNK_00160d8d;
cVar31 = UNK_00160d8c;
cVar30 = UNK_00160d8b;
cVar29 = UNK_00160d8a;
cVar28 = UNK_00160d89;
cVar27 = UNK_00160d88;
cVar26 = UNK_00160d87;
cVar25 = UNK_00160d86;
cVar24 = UNK_00160d85;
cVar23 = UNK_00160d84;
cVar22 = UNK_00160d83;
cVar21 = UNK_00160d82;
cVar20 = UNK_00160d81;
cVar19 = DAT_00160d80;
lVar69 = -0x100;
do {
pcVar1 = puVar67 + 0x100 + lVar69;
cVar4 = pcVar1[1];
cVar5 = pcVar1[2];
cVar6 = pcVar1[3];
cVar7 = pcVar1[4];
cVar8 = pcVar1[5];
cVar9 = pcVar1[6];
cVar10 = pcVar1[7];
cVar11 = pcVar1[8];
cVar12 = pcVar1[9];
cVar13 = pcVar1[10];
cVar14 = pcVar1[0xb];
cVar15 = pcVar1[0xc];
cVar16 = pcVar1[0xd];
cVar17 = pcVar1[0xe];
cVar18 = pcVar1[0xf];
pbVar2 = puVar67 + lVar69 + 0x200;
*pbVar2 = (-(*pcVar1 == cVar35) | -(*pcVar1 == cVar19)) & bVar3;
pbVar2[1] = (-(cVar4 == cVar36) | -(cVar4 == cVar20)) & bVar51;
pbVar2[2] = (-(cVar5 == cVar37) | -(cVar5 == cVar21)) & bVar52;
pbVar2[3] = (-(cVar6 == cVar38) | -(cVar6 == cVar22)) & bVar53;
pbVar2[4] = (-(cVar7 == cVar39) | -(cVar7 == cVar23)) & bVar54;
pbVar2[5] = (-(cVar8 == cVar40) | -(cVar8 == cVar24)) & bVar55;
pbVar2[6] = (-(cVar9 == cVar41) | -(cVar9 == cVar25)) & bVar56;
pbVar2[7] = (-(cVar10 == cVar42) | -(cVar10 == cVar26)) & bVar57;
pbVar2[8] = (-(cVar11 == cVar43) | -(cVar11 == cVar27)) & bVar58;
pbVar2[9] = (-(cVar12 == cVar44) | -(cVar12 == cVar28)) & bVar59;
pbVar2[10] = (-(cVar13 == cVar45) | -(cVar13 == cVar29)) & bVar60;
pbVar2[0xb] = (-(cVar14 == cVar46) | -(cVar14 == cVar30)) & bVar61;
pbVar2[0xc] = (-(cVar15 == cVar47) | -(cVar15 == cVar31)) & bVar62;
pbVar2[0xd] = (-(cVar16 == cVar48) | -(cVar16 == cVar32)) & bVar63;
pbVar2[0xe] = (-(cVar17 == cVar49) | -(cVar17 == cVar33)) & bVar64;
pbVar2[0xf] = (-(cVar18 == cVar50) | -(cVar18 == cVar34)) & bVar65;
lVar69 = lVar69 + 0x10;
} while (lVar69 != 0);
puVar67[0x58] = 0x1e;
puVar67[0x78] = 0x1e;
puVar67[0x42] = 0x1f;
puVar67[0x62] = 0x1f;
puVar67[0x4e] = 0x20;
puVar67[0x6e] = 0x20;
uVar68 = 0;
}
return uVar68;
}
| |
47,220 | minja::Parser::consumeToken(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, minja::SpaceHandling) | monkey531[P]llama/common/minja.hpp | std::string consumeToken(const std::string & token, SpaceHandling space_handling = SpaceHandling::Strip) {
auto start = it;
consumeSpaces(space_handling);
if (std::distance(it, end) >= (int64_t) token.size() && std::string(it, it + token.size()) == token) {
it += token.size();
return token;
}
it = start;
return "";
} | O2 | cpp | minja::Parser::consumeToken(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, minja::SpaceHandling):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x20(%rsi), %r13
movq %rsi, %rdi
movl %ecx, %esi
callq 0x3aee0
movq 0x18(%r15), %rax
movq 0x20(%r15), %rsi
subq %rsi, %rax
movq 0x8(%r14), %rdx
cmpq %rdx, %rax
jl 0x310a3
addq %rsi, %rdx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x56226
movq %r12, %rdi
movq %r14, %rsi
callq 0x22d1d
movl %eax, %ebp
movq %r12, %rdi
callq 0x20d98
testb %bpl, %bpl
je 0x310a3
movq 0x8(%r14), %rax
addq %rax, 0x20(%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20910
jmp 0x310bb
movq %r13, 0x20(%r15)
leaq 0x5bd07(%rip), %rsi # 0x8cdb5
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x22a2a
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN5minja6Parser12consumeTokenERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_13SpaceHandlingE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov r13, [rsi+20h]
mov rdi, rsi
mov esi, ecx
call _ZN5minja6Parser13consumeSpacesENS_13SpaceHandlingE; minja::Parser::consumeSpaces(minja::SpaceHandling)
mov rax, [r15+18h]
mov rsi, [r15+20h]
sub rax, rsi
mov rdx, [r14+8]
cmp rax, rdx
jl short loc_310A3
add rdx, rsi
lea rax, [rsp+58h+var_40]
mov [rax-10h], rax
lea r12, [rsp+58h+var_50]
mov rdi, r12
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)
mov rdi, r12
mov rsi, r14
call _ZSteqIcEN9__gnu_cxx11__enable_ifIXsr9__is_charIT_EE7__valueEbE6__typeERKNSt7__cxx1112basic_stringIS2_St11char_traitsIS2_ESaIS2_EEESC_
mov ebp, eax
mov rdi, r12; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jz short loc_310A3
mov rax, [r14+8]
add [r15+20h], rax
mov rdi, rbx
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
jmp short loc_310BB
loc_310A3:
mov [r15+20h], r13
lea rsi, aEndIndexOutOfB+19h; ""
lea rdx, [rsp+58h+var_50]
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
loc_310BB:
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| _QWORD * minja::Parser::consumeToken(_QWORD *a1, long long a2, _QWORD *a3, unsigned int a4)
{
long long v6; // r13
long long v7; // rsi
long long v8; // rdx
bool v9; // bp
_QWORD v11[2]; // [rsp+8h] [rbp-50h] BYREF
char v12; // [rsp+18h] [rbp-40h] BYREF
v6 = *(_QWORD *)(a2 + 32);
minja::Parser::consumeSpaces(a2, a4);
v7 = *(_QWORD *)(a2 + 32);
v8 = a3[1];
if ( *(_QWORD *)(a2 + 24) - v7 >= v8
&& (v11[0] = &v12,
std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(v11, v7, v7 + v8),
v9 = std::operator==<char>(v11, a3),
std::string::~string(v11),
v9) )
{
*(_QWORD *)(a2 + 32) += a3[1];
std::string::basic_string(a1, a3);
}
else
{
*(_QWORD *)(a2 + 32) = v6;
std::string::basic_string<std::allocator<char>>(a1, (long long)"");
}
return a1;
}
| consumeToken:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV R13,qword ptr [RSI + 0x20]
MOV RDI,RSI
MOV ESI,ECX
CALL 0x0013aee0
MOV RAX,qword ptr [R15 + 0x18]
MOV RSI,qword ptr [R15 + 0x20]
SUB RAX,RSI
MOV RDX,qword ptr [R14 + 0x8]
CMP RAX,RDX
JL 0x001310a3
ADD RDX,RSI
LEA RAX,[RSP + 0x18]
MOV qword ptr [RAX + -0x10],RAX
LEA R12,[RSP + 0x8]
MOV RDI,R12
CALL 0x00156226
MOV RDI,R12
MOV RSI,R14
CALL 0x00122d1d
MOV EBP,EAX
MOV RDI,R12
CALL 0x00120d98
TEST BPL,BPL
JZ 0x001310a3
MOV RAX,qword ptr [R14 + 0x8]
ADD qword ptr [R15 + 0x20],RAX
MOV RDI,RBX
MOV RSI,R14
CALL 0x00120910
JMP 0x001310bb
LAB_001310a3:
MOV qword ptr [R15 + 0x20],R13
LEA RSI,[0x18cdb5]
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
CALL 0x00122a2a
LAB_001310bb:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* minja::Parser::consumeToken(std::__cxx11::string const&, minja::SpaceHandling) */
string * minja::Parser::consumeToken
(string *param_1,Parser *param_2,string *param_3,int4 param_4)
{
int8 uVar1;
long lVar2;
char cVar3;
int1 *local_50 [2];
int1 local_40 [16];
uVar1 = *(int8 *)(param_2 + 0x20);
consumeSpaces(param_2,param_4);
lVar2 = *(long *)(param_2 + 0x20);
if (*(long *)(param_3 + 8) <= *(long *)(param_2 + 0x18) - lVar2) {
local_50[0] = local_40;
std::__cxx11::string::
_M_construct<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>
((string *)local_50,lVar2,*(long *)(param_3 + 8) + lVar2);
cVar3 = std::operator==((string *)local_50,param_3);
std::__cxx11::string::~string((string *)local_50);
if (cVar3 != '\0') {
*(long *)(param_2 + 0x20) = *(long *)(param_2 + 0x20) + *(long *)(param_3 + 8);
std::__cxx11::string::string(param_1,param_3);
return param_1;
}
}
*(int8 *)(param_2 + 0x20) = uVar1;
std::__cxx11::string::string<std::allocator<char>>(param_1,"",(allocator *)local_50);
return param_1;
}
| |
47,221 | minja::Parser::consumeToken(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, minja::SpaceHandling) | monkey531[P]llama/common/minja.hpp | std::string consumeToken(const std::string & token, SpaceHandling space_handling = SpaceHandling::Strip) {
auto start = it;
consumeSpaces(space_handling);
if (std::distance(it, end) >= (int64_t) token.size() && std::string(it, it + token.size()) == token) {
it += token.size();
return token;
}
it = start;
return "";
} | O3 | cpp | minja::Parser::consumeToken(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, minja::SpaceHandling):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x20(%rsi), %r13
movq %rsi, %rdi
movl %ecx, %esi
callq 0x3b628
movq 0x18(%r15), %rax
movq 0x20(%r15), %rsi
subq %rsi, %rax
movq 0x8(%r14), %rdx
cmpq %rdx, %rax
jl 0x2fcfc
addq %rsi, %rdx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x5bc0a
movq 0x8(%r12), %rdx
cmpq 0x8(%r14), %rdx
jne 0x2fcb2
movq 0x8(%rsp), %r12
testq %rdx, %rdx
je 0x2fcbb
movq (%r14), %rsi
movq %r12, %rdi
callq 0x186e0
testl %eax, %eax
sete %bpl
jmp 0x2fcbe
movq 0x8(%rsp), %r12
xorl %ebp, %ebp
jmp 0x2fcbe
movb $0x1, %bpl
leaq 0x18(%rsp), %rax
cmpq %rax, %r12
je 0x2fcd8
movq 0x18(%rsp), %rsi
incq %rsi
movq %r12, %rdi
callq 0x186a0
testb %bpl, %bpl
je 0x2fcfc
movq 0x8(%r14), %rdx
addq %rdx, 0x20(%r15)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x35dc6
jmp 0x2fd19
movq %r13, 0x20(%r15)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x780d7(%rip), %rdx # 0xa7de5
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x1ca72
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN5minja6Parser12consumeTokenERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_13SpaceHandlingE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov r13, [rsi+20h]
mov rdi, rsi
mov esi, ecx
call _ZN5minja6Parser13consumeSpacesENS_13SpaceHandlingE; minja::Parser::consumeSpaces(minja::SpaceHandling)
mov rax, [r15+18h]
mov rsi, [r15+20h]
sub rax, rsi
mov rdx, [r14+8]
cmp rax, rdx
jl loc_2FCFC
add rdx, rsi
lea rax, [rsp+58h+var_40]
mov [rax-10h], rax
lea r12, [rsp+58h+var_50]
mov rdi, r12
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)
mov rdx, [r12+8]
cmp rdx, [r14+8]
jnz short loc_2FCB2
mov r12, [rsp+58h+var_50]
test rdx, rdx
jz short loc_2FCBB
mov rsi, [r14]
mov rdi, r12
call _bcmp
test eax, eax
setz bpl
jmp short loc_2FCBE
loc_2FCB2:
mov r12, [rsp+58h+var_50]
xor ebp, ebp
jmp short loc_2FCBE
loc_2FCBB:
mov bpl, 1
loc_2FCBE:
lea rax, [rsp+58h+var_40]
cmp r12, rax
jz short loc_2FCD8
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
mov rdi, r12; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_2FCD8:
test bpl, bpl
jz short loc_2FCFC
mov rdx, [r14+8]
add [r15+20h], rdx
lea rax, [rbx+10h]
mov [rbx], rax
mov rsi, [r14]
add rdx, rsi
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
jmp short loc_2FD19
loc_2FCFC:
mov [r15+20h], r13
lea rax, [rbx+10h]
mov [rbx], rax
lea rdx, aEndIndexOutOfB+19h; ""
mov rdi, rbx
mov rsi, rdx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
loc_2FD19:
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| _QWORD * minja::Parser::consumeToken(_QWORD *a1, long long a2, _QWORD *a3, unsigned int a4)
{
long long v6; // r13
long long v7; // rsi
long long v8; // rdx
_QWORD *v9; // r12
bool v10; // bp
long long v11; // rdx
void *v13; // [rsp+8h] [rbp-50h] BYREF
long long v14; // [rsp+10h] [rbp-48h]
_QWORD v15[8]; // [rsp+18h] [rbp-40h] BYREF
v6 = *(_QWORD *)(a2 + 32);
minja::Parser::consumeSpaces(a2, a4);
v7 = *(_QWORD *)(a2 + 32);
v8 = a3[1];
if ( *(_QWORD *)(a2 + 24) - v7 < v8 )
goto LABEL_11;
v13 = v15;
std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(&v13, v7, v7 + v8);
if ( v14 == a3[1] )
{
v9 = v13;
v10 = !v14 || (unsigned int)bcmp(v13, *a3, v14) == 0;
}
else
{
v9 = v13;
v10 = 0;
}
if ( v9 != v15 )
operator delete(v9, v15[0] + 1LL);
if ( v10 )
{
v11 = a3[1];
*(_QWORD *)(a2 + 32) += v11;
*a1 = a1 + 2;
std::string::_M_construct<char *>(a1, *a3, *a3 + v11);
}
else
{
LABEL_11:
*(_QWORD *)(a2 + 32) = v6;
*a1 = a1 + 2;
std::string::_M_construct<char const*>((long long)a1, "", (long long)"");
}
return a1;
}
| consumeToken:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV R13,qword ptr [RSI + 0x20]
MOV RDI,RSI
MOV ESI,ECX
CALL 0x0013b628
MOV RAX,qword ptr [R15 + 0x18]
MOV RSI,qword ptr [R15 + 0x20]
SUB RAX,RSI
MOV RDX,qword ptr [R14 + 0x8]
CMP RAX,RDX
JL 0x0012fcfc
ADD RDX,RSI
LEA RAX,[RSP + 0x18]
MOV qword ptr [RAX + -0x10],RAX
LEA R12,[RSP + 0x8]
MOV RDI,R12
CALL 0x0015bc0a
MOV RDX,qword ptr [R12 + 0x8]
CMP RDX,qword ptr [R14 + 0x8]
JNZ 0x0012fcb2
MOV R12,qword ptr [RSP + 0x8]
TEST RDX,RDX
JZ 0x0012fcbb
MOV RSI,qword ptr [R14]
MOV RDI,R12
CALL 0x001186e0
TEST EAX,EAX
SETZ BPL
JMP 0x0012fcbe
LAB_0012fcb2:
MOV R12,qword ptr [RSP + 0x8]
XOR EBP,EBP
JMP 0x0012fcbe
LAB_0012fcbb:
MOV BPL,0x1
LAB_0012fcbe:
LEA RAX,[RSP + 0x18]
CMP R12,RAX
JZ 0x0012fcd8
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
MOV RDI,R12
CALL 0x001186a0
LAB_0012fcd8:
TEST BPL,BPL
JZ 0x0012fcfc
MOV RDX,qword ptr [R14 + 0x8]
ADD qword ptr [R15 + 0x20],RDX
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
MOV RSI,qword ptr [R14]
ADD RDX,RSI
MOV RDI,RBX
CALL 0x00135dc6
JMP 0x0012fd19
LAB_0012fcfc:
MOV qword ptr [R15 + 0x20],R13
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LEA RDX,[0x1a7de5]
MOV RDI,RBX
MOV RSI,RDX
CALL 0x0011ca72
LAB_0012fd19:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* minja::Parser::consumeToken(std::__cxx11::string const&, minja::SpaceHandling) */
long * minja::Parser::consumeToken(long *param_1,Parser *param_2,long *param_3,int4 param_4)
{
int8 uVar1;
long lVar2;
long *plVar3;
int iVar4;
bool bVar5;
long *local_50;
size_t local_48;
long local_40 [2];
uVar1 = *(int8 *)(param_2 + 0x20);
consumeSpaces(param_2,param_4);
lVar2 = *(long *)(param_2 + 0x20);
if (param_3[1] <= *(long *)(param_2 + 0x18) - lVar2) {
local_50 = local_40;
std::__cxx11::string::
_M_construct<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>
(&local_50,lVar2,param_3[1] + lVar2);
plVar3 = local_50;
if (local_48 == param_3[1]) {
if (local_48 == 0) {
bVar5 = true;
}
else {
iVar4 = bcmp(local_50,(void *)*param_3,local_48);
bVar5 = iVar4 == 0;
}
}
else {
bVar5 = false;
}
if (plVar3 != local_40) {
operator_delete(plVar3,local_40[0] + 1);
}
if (bVar5) {
lVar2 = param_3[1];
*(long *)(param_2 + 0x20) = *(long *)(param_2 + 0x20) + lVar2;
*param_1 = (long)(param_1 + 2);
std::__cxx11::string::_M_construct<char*>(param_1,*param_3,lVar2 + *param_3);
return param_1;
}
}
*(int8 *)(param_2 + 0x20) = uVar1;
*param_1 = (long)(param_1 + 2);
std::__cxx11::string::_M_construct<char_const*>(param_1,"");
return param_1;
}
| |
47,222 | 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::input_stream_adapter>::next_byte_in_range(std::initializer_list<int>) | llama.cpp/common/json.hpp | bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
{
JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
add(current);
for (auto range = ranges.begin(); range != ranges.end(); ++range)
{
get();
if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range))) // NOLINT(bugprone-inc-dec-in-conditions)
{
add(current);
}
else
{
error_message = "invalid string: ill-formed UTF-8 byte";
return false;
}
}
return true;
} | 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::input_stream_adapter>::next_byte_in_range(std::initializer_list<int>):
pushq %rbx
subq $0x10, %rsp
cmpq $0x6, %rdx
ja 0x9a6b1
movl $0x54, %eax
btq %rdx, %rax
jae 0x9a6b1
leaq 0xf(%rsp), %rbx
movq %rbx, %rcx
callq 0x25668
movb (%rbx), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbx
retq
leaq 0xa6b6f(%rip), %rdi # 0x141227
leaq 0x9e116(%rip), %rdx # 0x1387d5
leaq 0xa78a4(%rip), %rcx # 0x141f6a
movl $0x1da8, %esi # imm = 0x1DA8
xorl %eax, %eax
callq 0x24340
| _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE18next_byte_in_rangeESt16initializer_listIiE:
push rbx
sub rsp, 10h
cmp rdx, 6
ja short loc_9A6B1
mov eax, 54h ; 'T'
bt rax, rdx
jnb short loc_9A6B1
lea rbx, [rsp+18h+var_9]
mov rcx, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE18next_byte_in_rangeESt16initializer_listIiE_cold_1; 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::input_stream_adapter>::next_byte_in_range(std::initializer_list<int>) [clone]
mov al, [rbx]
and al, 1
add rsp, 10h
pop rbx
retn
loc_9A6B1:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aRangesSize2Ran; "ranges.size() == 2 || ranges.size() == "...
mov esi, 1DA8h
xor eax, eax
call _ggml_abort
| char 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::input_stream_adapter>::next_byte_in_range(
__m128i *a1,
__int32 *a2,
unsigned long long a3)
{
long long v3; // rax
long long v5; // rdx
long long v6; // rcx
char v7[9]; // [rsp+Fh] [rbp-9h] BYREF
if ( a3 <= 6 && (v3 = 84LL, _bittest64(&v3, a3)) )
{
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::input_stream_adapter>::next_byte_in_range(
a1,
a2,
a3,
v7);
return v7[0] & 1;
}
else
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
7592LL,
"GGML_ASSERT(%s) failed",
"ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6");
return nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<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>>::json_sax_dom_callback_parser(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
7592LL,
v5,
v6);
}
}
| next_byte_in_range:
PUSH RBX
SUB RSP,0x10
CMP RDX,0x6
JA 0x0019a6b1
MOV EAX,0x54
BT RAX,RDX
JNC 0x0019a6b1
LEA RBX,[RSP + 0xf]
MOV RCX,RBX
CALL 0x00125668
MOV AL,byte ptr [RBX]
AND AL,0x1
ADD RSP,0x10
POP RBX
RET
LAB_0019a6b1:
LEA RDI,[0x241227]
LEA RDX,[0x2387d5]
LEA RCX,[0x241f6a]
MOV ESI,0x1da8
XOR EAX,EAX
CALL 0x00124340
|
/* 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::input_stream_adapter>::next_byte_in_range(std::initializer_list<int>)
*/
ulong 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::input_stream_adapter>
::next_byte_in_range(int8 param_1,int8 param_2,ulong param_3)
{
int8 uVar1;
int1 local_9;
if ((param_3 < 7) && ((0x54UL >> (param_3 & 0x3f) & 1) != 0)) {
uVar1 = next_byte_in_range();
return CONCAT71((int7)((ulong)uVar1 >> 8),local_9) & 0xffffffffffffff01;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",0x1da8,
"GGML_ASSERT(%s) failed",
"ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6");
}
| |
47,223 | intern_filename | eloqsql/mysys/mf_pack.c | char *intern_filename(char *to, const char *from)
{
size_t length, to_length;
char buff[FN_REFLEN + 1];
if (from == to)
{ /* Dirname may destroy from */
(void) strnmov(buff, from, FN_REFLEN);
from=buff;
}
length= dirname_part(to, from, &to_length); /* Copy dirname & fix chars */
(void) strnmov(to + to_length, from + length, FN_REFLEN - to_length);
return (to);
} | O0 | c | intern_filename:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp # imm = 0x240
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x218(%rbp)
movq %rsi, -0x220(%rbp)
movq -0x220(%rbp), %rax
cmpq -0x218(%rbp), %rax
jne 0x65f4c
leaq -0x210(%rbp), %rdi
movq -0x220(%rbp), %rsi
movl $0x200, %edx # imm = 0x200
callq 0xae0d0
leaq -0x210(%rbp), %rax
movq %rax, -0x220(%rbp)
movq -0x218(%rbp), %rdi
movq -0x220(%rbp), %rsi
leaq -0x230(%rbp), %rdx
callq 0x5a6c0
movq %rax, -0x228(%rbp)
movq -0x218(%rbp), %rdi
movq -0x230(%rbp), %rax
addq %rax, %rdi
movq -0x220(%rbp), %rsi
movq -0x228(%rbp), %rcx
addq %rcx, %rsi
movl $0x200, %edx # imm = 0x200
subq %rax, %rdx
callq 0xae0d0
movq -0x218(%rbp), %rax
movq %rax, -0x238(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x65fcc
movq -0x238(%rbp), %rax
addq $0x240, %rsp # imm = 0x240
popq %rbp
retq
callq 0x26370
nopw %cs:(%rax,%rax)
| intern_filename:
push rbp
mov rbp, rsp
sub rsp, 240h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_218], rdi
mov [rbp+var_220], rsi
mov rax, [rbp+var_220]
cmp rax, [rbp+var_218]
jnz short loc_65F4C
lea rdi, [rbp+var_210]
mov rsi, [rbp+var_220]
mov edx, 200h
call strnmov
lea rax, [rbp+var_210]
mov [rbp+var_220], rax
loc_65F4C:
mov rdi, [rbp+var_218]
mov rsi, [rbp+var_220]
lea rdx, [rbp+var_230]
call dirname_part
mov [rbp+var_228], rax
mov rdi, [rbp+var_218]
mov rax, [rbp+var_230]
add rdi, rax
mov rsi, [rbp+var_220]
mov rcx, [rbp+var_228]
add rsi, rcx
mov edx, 200h
sub rdx, rax
call strnmov
mov rax, [rbp+var_218]
mov [rbp+var_238], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_65FCC
mov rax, [rbp+var_238]
add rsp, 240h
pop rbp
retn
loc_65FCC:
call ___stack_chk_fail
| long long intern_filename(long long a1, _BYTE *a2)
{
long long v3; // [rsp+10h] [rbp-230h] BYREF
long long v4; // [rsp+18h] [rbp-228h]
_BYTE *v5; // [rsp+20h] [rbp-220h]
long long v6; // [rsp+28h] [rbp-218h]
_BYTE v7[520]; // [rsp+30h] [rbp-210h] BYREF
unsigned long long v8; // [rsp+238h] [rbp-8h]
v8 = __readfsqword(0x28u);
v6 = a1;
v5 = a2;
if ( a2 == (_BYTE *)a1 )
{
strnmov(v7, v5, 512LL);
v5 = v7;
}
v4 = dirname_part(v6, v5, &v3);
strnmov(v3 + v6, &v5[v4], 512 - v3);
return v6;
}
| intern_filename:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x240
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x218],RDI
MOV qword ptr [RBP + -0x220],RSI
MOV RAX,qword ptr [RBP + -0x220]
CMP RAX,qword ptr [RBP + -0x218]
JNZ 0x00165f4c
LEA RDI,[RBP + -0x210]
MOV RSI,qword ptr [RBP + -0x220]
MOV EDX,0x200
CALL 0x001ae0d0
LEA RAX,[RBP + -0x210]
MOV qword ptr [RBP + -0x220],RAX
LAB_00165f4c:
MOV RDI,qword ptr [RBP + -0x218]
MOV RSI,qword ptr [RBP + -0x220]
LEA RDX,[RBP + -0x230]
CALL 0x0015a6c0
MOV qword ptr [RBP + -0x228],RAX
MOV RDI,qword ptr [RBP + -0x218]
MOV RAX,qword ptr [RBP + -0x230]
ADD RDI,RAX
MOV RSI,qword ptr [RBP + -0x220]
MOV RCX,qword ptr [RBP + -0x228]
ADD RSI,RCX
MOV EDX,0x200
SUB RDX,RAX
CALL 0x001ae0d0
MOV RAX,qword ptr [RBP + -0x218]
MOV qword ptr [RBP + -0x238],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00165fcc
MOV RAX,qword ptr [RBP + -0x238]
ADD RSP,0x240
POP RBP
RET
LAB_00165fcc:
CALL 0x00126370
|
int1 * intern_filename(int1 *param_1,int1 *param_2)
{
long in_FS_OFFSET;
long local_238;
long local_230;
int1 *local_228;
int1 *local_220;
int1 local_218 [520];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_228 = param_2;
local_220 = param_1;
if (param_2 == param_1) {
strnmov(local_218,param_2,0x200);
local_228 = local_218;
}
local_230 = dirname_part(local_220,local_228,&local_238);
strnmov(local_220 + local_238,local_228 + local_230,0x200 - local_238);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_220;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
47,224 | testing::AssertionResult testing::internal::CmpHelperEQFailure<int, int>(char const*, char const*, int const&, int const&) | yoga-mod/tests/build_O3/_deps/googletest-src/googletest/include/gtest/gtest.h | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression, const T1& lhs,
const T2& rhs) {
return EqFailure(lhs_expression, rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs), false);
} | O3 | c | testing::AssertionResult testing::internal::CmpHelperEQFailure<int, int>(char const*, char const*, int const&, int const&):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x60(%rbp), %rdi
movq %rcx, %rsi
callq 0x70a60
leaq -0x40(%rbp), %rdi
movq %r12, %rsi
callq 0x70a60
leaq -0x60(%rbp), %rcx
leaq -0x40(%rbp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x38082a
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8f262
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x32440
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8f27b
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x32440
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8f2ac
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x32440
jmp 0x8f2ac
movq %rax, %rbx
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8f2c5
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x32440
movq %rbx, %rdi
callq 0x32840
nop
| _ZN7testing8internal18CmpHelperEQFailureIP6YGNodeS3_EENS_15AssertionResultEPKcS6_RKT_RKT0_:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 40h
mov r12, r8
mov r14, rdx
mov r15, rsi
mov rbx, rdi
lea rdi, [rbp+var_60]
mov rsi, rcx
call _ZN7testing13PrintToStringIP6YGNodeEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKT_; testing::PrintToString<YGNode *>(YGNode * const&)
lea rdi, [rbp+var_40]
mov rsi, r12
call _ZN7testing13PrintToStringIP6YGNodeEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKT_; testing::PrintToString<YGNode *>(YGNode * const&)
lea rcx, [rbp+var_60]
lea r8, [rbp+var_40]
mov rdi, rbx
mov rsi, r15
mov rdx, r14
xor r9d, r9d
call _ZN7testing8internal9EqFailureEPKcS2_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESA_b; testing::internal::EqFailure(char const*,char const*,std::string const&,std::string const&,bool)
lea rax, [rbp+var_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_8F262
mov rsi, [rbp+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_8F262:
lea rax, [rbp+var_50]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_8F27B
mov rsi, [rbp+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_8F27B:
mov rax, rbx
add rsp, 40h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rax, [rbp+var_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_8F2AC
mov rsi, [rbp+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_8F2AC
mov rbx, rax
loc_8F2AC:
lea rax, [rbp+var_50]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_8F2C5
mov rsi, [rbp+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_8F2C5:
mov rdi, rbx
call __Unwind_Resume
| long long testing::internal::CmpHelperEQFailure<YGNode *,YGNode *>(
long long a1,
long long a2,
long long a3,
_QWORD *a4,
_QWORD *a5)
{
void *v8[2]; // [rsp+0h] [rbp-60h] BYREF
long long v9; // [rsp+10h] [rbp-50h] BYREF
void *v10[2]; // [rsp+20h] [rbp-40h] BYREF
long long v11; // [rsp+30h] [rbp-30h] BYREF
testing::PrintToString<YGNode *>((long long)v8, a4);
testing::PrintToString<YGNode *>((long long)v10, a5);
testing::internal::EqFailure(a1, a2, a3, v8, v10, 0LL);
if ( v10[0] != &v11 )
operator delete(v10[0], v11 + 1);
if ( v8[0] != &v9 )
operator delete(v8[0], v9 + 1);
return a1;
}
| CmpHelperEQFailure<YGNode*,YGNode*>:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV R12,R8
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
LEA RDI,[RBP + -0x60]
MOV RSI,RCX
CALL 0x00170a60
LAB_0018f224:
LEA RDI,[RBP + -0x40]
MOV RSI,R12
CALL 0x00170a60
LAB_0018f230:
LEA RCX,[RBP + -0x60]
LEA R8,[RBP + -0x40]
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
XOR R9D,R9D
CALL 0x0048082a
LAB_0018f249:
LEA RAX,[RBP + -0x30]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0018f262
MOV RSI,qword ptr [RBP + -0x30]
INC RSI
CALL 0x00132440
LAB_0018f262:
LEA RAX,[RBP + -0x50]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0018f27b
MOV RSI,qword ptr [RBP + -0x50]
INC RSI
CALL 0x00132440
LAB_0018f27b:
MOV RAX,RBX
ADD RSP,0x40
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* testing::AssertionResult testing::internal::CmpHelperEQFailure<YGNode*, YGNode*>(char const*,
char const*, YGNode* const&, YGNode* const&) */
internal * __thiscall
testing::internal::CmpHelperEQFailure<YGNode*,YGNode*>
(internal *this,char *param_1,char *param_2,YGNode **param_3,YGNode **param_4)
{
long *local_68 [2];
long local_58 [2];
long *local_48 [2];
long local_38 [2];
PrintToString<YGNode*>((testing *)local_68,param_3);
/* try { // try from 0018f224 to 0018f22f has its CatchHandler @ 0018f2a9 */
PrintToString<YGNode*>((testing *)local_48,param_4);
/* try { // try from 0018f230 to 0018f248 has its CatchHandler @ 0018f28b */
EqFailure(this,param_1,param_2,(string *)local_68,(string *)local_48,false);
if (local_48[0] != local_38) {
operator_delete(local_48[0],local_38[0] + 1);
}
if (local_68[0] != local_58) {
operator_delete(local_68[0],local_58[0] + 1);
}
return this;
}
| |
47,225 | js_thisBigIntValue | bluesky950520[P]quickjs/quickjs.c | static JSValue js_thisBigIntValue(JSContext *ctx, JSValue this_val)
{
if (JS_IsBigInt(ctx, this_val))
return js_dup(this_val);
if (JS_VALUE_GET_TAG(this_val) == JS_TAG_OBJECT) {
JSObject *p = JS_VALUE_GET_OBJ(this_val);
if (p->class_id == JS_CLASS_BIG_INT) {
if (JS_IsBigInt(ctx, p->u.object_data))
return js_dup(p->u.object_data);
}
}
return JS_ThrowTypeError(ctx, "not a BigInt");
} | O0 | c | js_thisBigIntValue:
subq $0x38, %rsp
movq %rsi, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x3f180
cmpl $0x0, %eax
je 0xc37f7
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x279c0
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
jmp 0xc3874
movq 0x20(%rsp), %rax
cmpl $-0x1, %eax
jne 0xc3857
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzwl 0x6(%rax), %eax
cmpl $0x22, %eax
jne 0xc3855
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rsi
movq 0x38(%rax), %rdx
callq 0x3f180
cmpl $0x0, %eax
je 0xc3853
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x38(%rax), %rsi
callq 0x279c0
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
jmp 0xc3874
jmp 0xc3855
jmp 0xc3857
movq 0x10(%rsp), %rdi
leaq 0x531ef(%rip), %rsi # 0x116a52
movb $0x0, %al
callq 0x335f0
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rdx
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
| js_thisBigIntValue:
sub rsp, 38h
mov [rsp+38h+var_20], rsi
mov [rsp+38h+var_18], rdx
mov [rsp+38h+var_28], rdi
mov rdi, [rsp+38h+var_28]
mov rsi, [rsp+38h+var_20]
mov rdx, [rsp+38h+var_18]
call JS_IsBigInt_0
cmp eax, 0
jz short loc_C37F7
mov rdi, [rsp+38h+var_20]
mov rsi, [rsp+38h+var_18]
call js_dup
mov [rsp+38h+var_10], rax
mov [rsp+38h+var_8], rdx
jmp short loc_C3874
loc_C37F7:
mov rax, [rsp+38h+var_18]
cmp eax, 0FFFFFFFFh
jnz short loc_C3857
mov rax, [rsp+38h+var_20]
mov [rsp+38h+var_30], rax
mov rax, [rsp+38h+var_30]
movzx eax, word ptr [rax+6]
cmp eax, 22h ; '"'
jnz short loc_C3855
mov rdi, [rsp+38h+var_28]
mov rax, [rsp+38h+var_30]
mov rsi, [rax+30h]
mov rdx, [rax+38h]
call JS_IsBigInt_0
cmp eax, 0
jz short loc_C3853
mov rax, [rsp+38h+var_30]
mov rdi, [rax+30h]
mov rsi, [rax+38h]
call js_dup
mov [rsp+38h+var_10], rax
mov [rsp+38h+var_8], rdx
jmp short loc_C3874
loc_C3853:
jmp short $+2
loc_C3855:
jmp short $+2
loc_C3857:
mov rdi, [rsp+38h+var_28]
lea rsi, aNotABigint; "not a BigInt"
mov al, 0
call JS_ThrowTypeError
mov [rsp+38h+var_10], rax
mov [rsp+38h+var_8], rdx
loc_C3874:
mov rax, [rsp+38h+var_10]
mov rdx, [rsp+38h+var_8]
add rsp, 38h
retn
| _DWORD * js_thisBigIntValue(
long long a1,
long long a2,
unsigned int a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
long long v11; // rdx
long long v12; // rcx
long long v13; // r8
long long v14; // r9
__m128 v15; // xmm4
__m128 v16; // xmm5
char v18; // [rsp+0h] [rbp-38h]
if ( JS_IsBigInt_0(a1, a2, a3) )
return js_dup((_DWORD *)a2, a3);
if ( a3 == -1 && *(_WORD *)(a2 + 6) == 34 && JS_IsBigInt_0(a1, *(_QWORD *)(a2 + 48), *(_QWORD *)(a2 + 56)) )
return js_dup(*(_DWORD **)(a2 + 48), *(_QWORD *)(a2 + 56));
return (_DWORD *)JS_ThrowTypeError(
a1,
(long long)"not a BigInt",
v11,
v12,
v13,
v14,
a4,
a5,
a6,
a7,
v15,
v16,
a10,
a11,
v18);
}
| js_thisBigIntValue:
SUB RSP,0x38
MOV qword ptr [RSP + 0x18],RSI
MOV qword ptr [RSP + 0x20],RDX
MOV qword ptr [RSP + 0x10],RDI
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x20]
CALL 0x0013f180
CMP EAX,0x0
JZ 0x001c37f7
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x20]
CALL 0x001279c0
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x30],RDX
JMP 0x001c3874
LAB_001c37f7:
MOV RAX,qword ptr [RSP + 0x20]
CMP EAX,-0x1
JNZ 0x001c3857
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOVZX EAX,word ptr [RAX + 0x6]
CMP EAX,0x22
JNZ 0x001c3855
MOV RDI,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RAX + 0x30]
MOV RDX,qword ptr [RAX + 0x38]
CALL 0x0013f180
CMP EAX,0x0
JZ 0x001c3853
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX + 0x30]
MOV RSI,qword ptr [RAX + 0x38]
CALL 0x001279c0
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x30],RDX
JMP 0x001c3874
LAB_001c3853:
JMP 0x001c3855
LAB_001c3855:
JMP 0x001c3857
LAB_001c3857:
MOV RDI,qword ptr [RSP + 0x10]
LEA RSI,[0x216a52]
MOV AL,0x0
CALL 0x001335f0
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x30],RDX
LAB_001c3874:
MOV RAX,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
ADD RSP,0x38
RET
|
int1 [16] js_thisBigIntValue(int8 param_1,long param_2,int8 param_3)
{
int iVar1;
int1 auVar2 [16];
iVar1 = JS_IsBigInt(param_1,param_2,param_3);
if (iVar1 == 0) {
if ((((int)param_3 == -1) && (*(short *)(param_2 + 6) == 0x22)) &&
(iVar1 = JS_IsBigInt(param_1,*(int8 *)(param_2 + 0x30),*(int8 *)(param_2 + 0x38))
, iVar1 != 0)) {
auVar2 = js_dup(*(int8 *)(param_2 + 0x30),*(int8 *)(param_2 + 0x38));
}
else {
auVar2 = JS_ThrowTypeError(param_1,"not a BigInt");
}
}
else {
auVar2 = js_dup(param_2,param_3);
}
return auVar2;
}
| |
47,226 | js_thisBigIntValue | bluesky950520[P]quickjs/quickjs.c | static JSValue js_thisBigIntValue(JSContext *ctx, JSValue this_val)
{
if (JS_IsBigInt(ctx, this_val))
return js_dup(this_val);
if (JS_VALUE_GET_TAG(this_val) == JS_TAG_OBJECT) {
JSObject *p = JS_VALUE_GET_OBJ(this_val);
if (p->class_id == JS_CLASS_BIG_INT) {
if (JS_IsBigInt(ctx, p->u.object_data))
return js_dup(p->u.object_data);
}
}
return JS_ThrowTypeError(ctx, "not a BigInt");
} | O2 | c | js_thisBigIntValue:
pushq %rbx
movq %rsi, %rbx
cmpl $-0x1, %edx
je 0x6193d
cmpl $-0x9, %edx
jne 0x61953
incl (%rbx)
jmp 0x61966
cmpw $0x22, 0x6(%rbx)
jne 0x61953
movq 0x38(%rbx), %rdx
cmpl $-0x9, %edx
jne 0x61953
movq 0x30(%rbx), %rbx
jmp 0x61939
leaq 0x2a046(%rip), %rsi # 0x8b9a0
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x201fd
pushq $0x6
popq %rdx
movq %rbx, %rax
popq %rbx
retq
| js_thisBigIntValue:
push rbx
mov rbx, rsi
cmp edx, 0FFFFFFFFh
jz short loc_6193D
cmp edx, 0FFFFFFF7h
jnz short loc_61953
loc_61939:
inc dword ptr [rbx]
jmp short loc_61966
loc_6193D:
cmp word ptr [rbx+6], 22h ; '"'
jnz short loc_61953
mov rdx, [rbx+38h]
cmp edx, 0FFFFFFF7h
jnz short loc_61953
mov rbx, [rbx+30h]
jmp short loc_61939
loc_61953:
lea rsi, aNotABigint; "not a BigInt"
xor ebx, ebx
xor eax, eax
call JS_ThrowTypeError
push 6
pop rdx
loc_61966:
mov rax, rbx
pop rbx
retn
| _DWORD * js_thisBigIntValue(
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)
{
_DWORD *v14; // rbx
char v16; // [rsp+0h] [rbp-8h]
v14 = (_DWORD *)a2;
if ( (_DWORD)a3 == -1 )
{
if ( *(_WORD *)(a2 + 6) == 34 )
{
a3 = *(_QWORD *)(a2 + 56);
if ( (_DWORD)a3 == -9 )
{
v14 = *(_DWORD **)(a2 + 48);
goto LABEL_3;
}
}
LABEL_7:
v14 = 0LL;
JS_ThrowTypeError(a1, (long long)"not a BigInt", a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v16);
return v14;
}
if ( (_DWORD)a3 != -9 )
goto LABEL_7;
LABEL_3:
++*v14;
return v14;
}
| js_thisBigIntValue:
PUSH RBX
MOV RBX,RSI
CMP EDX,-0x1
JZ 0x0016193d
CMP EDX,-0x9
JNZ 0x00161953
LAB_00161939:
INC dword ptr [RBX]
JMP 0x00161966
LAB_0016193d:
CMP word ptr [RBX + 0x6],0x22
JNZ 0x00161953
MOV RDX,qword ptr [RBX + 0x38]
CMP EDX,-0x9
JNZ 0x00161953
MOV RBX,qword ptr [RBX + 0x30]
JMP 0x00161939
LAB_00161953:
LEA RSI,[0x18b9a0]
XOR EBX,EBX
XOR EAX,EAX
CALL 0x001201fd
PUSH 0x6
POP RDX
LAB_00161966:
MOV RAX,RBX
POP RBX
RET
|
int1 [16] js_thisBigIntValue(int8 param_1,int *param_2,int8 param_3)
{
int1 auVar1 [16];
if ((int)param_3 == -1) {
if ((*(short *)((long)param_2 + 6) != 0x22) ||
(param_3 = *(int8 *)(param_2 + 0xe), (int)param_3 != -9)) goto LAB_00161953;
param_2 = *(int **)(param_2 + 0xc);
}
else if ((int)param_3 != -9) {
LAB_00161953:
param_2 = (int *)0x0;
JS_ThrowTypeError(param_1,"not a BigInt");
param_3 = 6;
goto LAB_00161966;
}
*param_2 = *param_2 + 1;
LAB_00161966:
auVar1._8_8_ = param_3;
auVar1._0_8_ = param_2;
return auVar1;
}
| |
47,227 | js_thisBigIntValue | bluesky950520[P]quickjs/quickjs.c | static JSValue js_thisBigIntValue(JSContext *ctx, JSValue this_val)
{
if (JS_IsBigInt(ctx, this_val))
return js_dup(this_val);
if (JS_VALUE_GET_TAG(this_val) == JS_TAG_OBJECT) {
JSObject *p = JS_VALUE_GET_OBJ(this_val);
if (p->class_id == JS_CLASS_BIG_INT) {
if (JS_IsBigInt(ctx, p->u.object_data))
return js_dup(p->u.object_data);
}
}
return JS_ThrowTypeError(ctx, "not a BigInt");
} | O3 | c | js_thisBigIntValue:
pushq %rbx
movq %rsi, %rbx
cmpl $-0x1, %edx
je 0x75c3c
cmpl $-0x9, %edx
jne 0x75c52
incl (%rbx)
jmp 0x75c67
cmpw $0x22, 0x6(%rbx)
jne 0x75c52
movq 0x38(%rbx), %rdx
cmpl $-0x9, %edx
jne 0x75c52
movq 0x30(%rbx), %rbx
jmp 0x75c38
leaq 0x32d87(%rip), %rsi # 0xa89e0
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x26d97
movl $0x6, %edx
movq %rbx, %rax
popq %rbx
retq
| js_thisBigIntValue:
push rbx
mov rbx, rsi
cmp edx, 0FFFFFFFFh
jz short loc_75C3C
cmp edx, 0FFFFFFF7h
jnz short loc_75C52
loc_75C38:
inc dword ptr [rbx]
jmp short loc_75C67
loc_75C3C:
cmp word ptr [rbx+6], 22h ; '"'
jnz short loc_75C52
mov rdx, [rbx+38h]
cmp edx, 0FFFFFFF7h
jnz short loc_75C52
mov rbx, [rbx+30h]
jmp short loc_75C38
loc_75C52:
lea rsi, aNotABigint; "not a BigInt"
xor ebx, ebx
xor eax, eax
call JS_ThrowTypeError
mov edx, 6
loc_75C67:
mov rax, rbx
pop rbx
retn
| _DWORD * js_thisBigIntValue(
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)
{
_DWORD *v14; // rbx
char v16; // [rsp+0h] [rbp-8h]
v14 = (_DWORD *)a2;
if ( (_DWORD)a3 == -1 )
{
if ( *(_WORD *)(a2 + 6) == 34 )
{
a3 = *(_QWORD *)(a2 + 56);
if ( (_DWORD)a3 == -9 )
{
v14 = *(_DWORD **)(a2 + 48);
goto LABEL_3;
}
}
LABEL_7:
v14 = 0LL;
JS_ThrowTypeError(a1, (long long)"not a BigInt", a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v16);
return v14;
}
if ( (_DWORD)a3 != -9 )
goto LABEL_7;
LABEL_3:
++*v14;
return v14;
}
| js_thisBigIntValue:
PUSH RBX
MOV RBX,RSI
CMP EDX,-0x1
JZ 0x00175c3c
CMP EDX,-0x9
JNZ 0x00175c52
LAB_00175c38:
INC dword ptr [RBX]
JMP 0x00175c67
LAB_00175c3c:
CMP word ptr [RBX + 0x6],0x22
JNZ 0x00175c52
MOV RDX,qword ptr [RBX + 0x38]
CMP EDX,-0x9
JNZ 0x00175c52
MOV RBX,qword ptr [RBX + 0x30]
JMP 0x00175c38
LAB_00175c52:
LEA RSI,[0x1a89e0]
XOR EBX,EBX
XOR EAX,EAX
CALL 0x00126d97
MOV EDX,0x6
LAB_00175c67:
MOV RAX,RBX
POP RBX
RET
|
int1 [16] js_thisBigIntValue(int8 param_1,int *param_2,int8 param_3)
{
int1 auVar1 [16];
if ((int)param_3 == -1) {
if ((*(short *)((long)param_2 + 6) != 0x22) ||
(param_3 = *(int8 *)(param_2 + 0xe), (int)param_3 != -9)) goto LAB_00175c52;
param_2 = *(int **)(param_2 + 0xc);
}
else if ((int)param_3 != -9) {
LAB_00175c52:
param_2 = (int *)0x0;
JS_ThrowTypeError(param_1,"not a BigInt");
param_3 = 6;
goto LAB_00175c67;
}
*param_2 = *param_2 + 1;
LAB_00175c67:
auVar1._8_8_ = param_3;
auVar1._0_8_ = param_2;
return auVar1;
}
| |
47,228 | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>::key() const | llama.cpp/common/json.hpp | const typename object_t::key_type& key() const
{
JSON_ASSERT(m_object != nullptr);
if (JSON_HEDLEY_LIKELY(m_object->is_object()))
{
return m_it.object_iterator->first;
}
JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators", m_object));
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>::key() const:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0xbc525
movq %rdi, %r14
cmpb $0x1, (%rax)
jne 0xbc4c7
movq 0x8(%r14), %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x20660
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x5dade(%rip), %rsi # 0x119fc2
leaq 0x5db00(%rip), %rdx # 0x119feb
leaq 0x8(%rsp), %rdi
callq 0x27960
movq (%r14), %rcx
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0xcf, %esi
callq 0xbcca8
xorl %ebp, %ebp
leaq 0xa2aea(%rip), %rsi # 0x15f000
leaq -0x46f0d(%rip), %rdx # 0x75610
movq %rbx, %rdi
callq 0x20a60
leaq 0x5c1f6(%rip), %rdi # 0x118722
leaq 0x5c22a(%rip), %rdx # 0x11875d
leaq 0x6246e(%rip), %rcx # 0x11e9a8
movl $0x3519, %esi # imm = 0x3519
xorl %eax, %eax
callq 0x20e70
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xbc560
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20190
testb %bpl, %bpl
jne 0xbc56a
jmp 0xbc572
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f00
movq %r14, %rdi
callq 0x20b00
| _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE3keyEv:
push rbp; void *
push r15; int
push r14; __int64
push rbx; int
sub rsp, 28h
mov rax, [rdi]
test rax, rax
jz short loc_BC525
mov r14, rdi
cmp byte ptr [rax], 1
jnz short loc_BC4C7
mov rax, [r14+8]
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_BC4C7:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r15, [rsp+48h+var_30]
mov [r15-10h], r15
lea rsi, aCannotUseKeyFo; "cannot use key() for non-object iterato"...
lea rdx, aCannotUseKeyFo+29h; ""
lea rdi, [rsp+48h+var_40]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rcx, [r14]
mov bpl, 1
lea rdx, [rsp+48h+var_40]
mov rdi, rbx; this
mov esi, 0CFh; int
call _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_BC525:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aAnchorMObjectN+7; "m_object != nullptr"
mov esi, 3519h
xor eax, eax
call _ggml_abort
mov r14, rax
mov rdi, [rsp+48h+var_40]; void *
cmp rdi, r15
jz short loc_BC560
mov rsi, [rsp+48h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_BC560:
test bpl, bpl
jnz short loc_BC56A
jmp short loc_BC572
mov r14, rax
loc_BC56A:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_BC572:
mov rdi, r14
call __Unwind_Resume
| key:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x001bc525
MOV R14,RDI
CMP byte ptr [RAX],0x1
JNZ 0x001bc4c7
MOV RAX,qword ptr [R14 + 0x8]
ADD RSP,0x28
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001bc4c7:
MOV EDI,0x20
CALL 0x00120660
MOV RBX,RAX
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
LAB_001bc4dd:
LEA RSI,[0x219fc2]
LEA RDX,[0x219feb]
LEA RDI,[RSP + 0x8]
CALL 0x00127960
MOV RCX,qword ptr [R14]
MOV BPL,0x1
LAB_001bc4fb:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0xcf
CALL 0x001bcca8
XOR EBP,EBP
LEA RSI,[0x25f000]
LEA RDX,[0x175610]
MOV RDI,RBX
CALL 0x00120a60
LAB_001bc525:
LEA RDI,[0x218722]
LEA RDX,[0x21875d]
LEA RCX,[0x21e9a8]
MOV ESI,0x3519
XOR EAX,EAX
CALL 0x00120e70
|
/* nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const>::key() const */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::key(iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*this)
{
int8 uVar1;
int1 *local_40 [2];
int1 local_30 [16];
if (*(char **)this == (char *)0x0) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",0x3519,
"GGML_ASSERT(%s) failed","m_object != nullptr");
}
if (**(char **)this == '\x01') {
return *(int8 *)(this + 8);
}
uVar1 = __cxa_allocate_exception(0x20);
local_40[0] = local_30;
/* try { // try from 001bc4dd to 001bc4f4 has its CatchHandler @ 001bc567 */
std::__cxx11::string::_M_construct<char_const*>
(local_40,"cannot use key() for non-object iterators","");
/* try { // try from 001bc4fb to 001bc524 has its CatchHandler @ 001bc546 */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar1,0xcf,local_40,*(int8 *)this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&invalid_iterator::typeinfo,exception::~exception);
}
| ||
47,229 | reset_partitioned_key_cache_counters | eloqsql/mysys/mf_keycache.c | static int
reset_partitioned_key_cache_counters(const char *name __attribute__((unused)),
PARTITIONED_KEY_CACHE_CB *keycache)
{
uint i;
uint partitions= keycache->partitions;
DBUG_ENTER("partitioned_reset_key_cache_counters");
for (i = 0; i < partitions; i++)
{
reset_simple_key_cache_counters(name, keycache->partition_array[i]);
}
DBUG_RETURN(0);
} | O3 | c | reset_partitioned_key_cache_counters:
movl 0x1c(%rsi), %eax
testq %rax, %rax
je 0xbbad8
pushq %rbp
movq %rsp, %rbp
xorl %ecx, %ecx
xorps %xmm0, %xmm0
movq 0x8(%rsi), %rdx
movq (%rdx,%rcx,8), %rdx
cmpb $0x0, (%rdx)
je 0xbbacf
movups %xmm0, 0x148(%rdx)
movups %xmm0, 0x138(%rdx)
movq $0x0, 0x158(%rdx)
incq %rcx
cmpq %rcx, %rax
jne 0xbbaa9
popq %rbp
xorl %eax, %eax
retq
| reset_partitioned_key_cache_counters:
mov eax, [rsi+1Ch]
test rax, rax
jz short loc_BBAD8
push rbp
mov rbp, rsp
xor ecx, ecx
xorps xmm0, xmm0
loc_BBAA9:
mov rdx, [rsi+8]
mov rdx, [rdx+rcx*8]
cmp byte ptr [rdx], 0
jz short loc_BBACF
movups xmmword ptr [rdx+148h], xmm0
movups xmmword ptr [rdx+138h], xmm0
mov qword ptr [rdx+158h], 0
loc_BBACF:
inc rcx
cmp rax, rcx
jnz short loc_BBAA9
pop rbp
loc_BBAD8:
xor eax, eax
retn
| long long reset_partitioned_key_cache_counters(long long a1, long long a2)
{
long long v2; // rax
long long v3; // rcx
long long v4; // rdx
v2 = *(unsigned int *)(a2 + 28);
if ( *(_DWORD *)(a2 + 28) )
{
v3 = 0LL;
do
{
v4 = *(_QWORD *)(*(_QWORD *)(a2 + 8) + 8 * v3);
if ( *(_BYTE *)v4 )
{
*(_OWORD *)(v4 + 328) = 0LL;
*(_OWORD *)(v4 + 312) = 0LL;
*(_QWORD *)(v4 + 344) = 0LL;
}
++v3;
}
while ( v2 != v3 );
}
return 0LL;
}
| reset_partitioned_key_cache_counters:
MOV EAX,dword ptr [RSI + 0x1c]
TEST RAX,RAX
JZ 0x001bbad8
PUSH RBP
MOV RBP,RSP
XOR ECX,ECX
XORPS XMM0,XMM0
LAB_001bbaa9:
MOV RDX,qword ptr [RSI + 0x8]
MOV RDX,qword ptr [RDX + RCX*0x8]
CMP byte ptr [RDX],0x0
JZ 0x001bbacf
MOVUPS xmmword ptr [RDX + 0x148],XMM0
MOVUPS xmmword ptr [RDX + 0x138],XMM0
MOV qword ptr [RDX + 0x158],0x0
LAB_001bbacf:
INC RCX
CMP RAX,RCX
JNZ 0x001bbaa9
POP RBP
LAB_001bbad8:
XOR EAX,EAX
RET
|
int8 reset_partitioned_key_cache_counters(int8 param_1,long param_2)
{
uint uVar1;
char *pcVar2;
ulong uVar3;
uVar1 = *(uint *)(param_2 + 0x1c);
if ((ulong)uVar1 != 0) {
uVar3 = 0;
do {
pcVar2 = *(char **)(*(long *)(param_2 + 8) + uVar3 * 8);
if (*pcVar2 != '\0') {
pcVar2[0x148] = '\0';
pcVar2[0x149] = '\0';
pcVar2[0x14a] = '\0';
pcVar2[0x14b] = '\0';
pcVar2[0x14c] = '\0';
pcVar2[0x14d] = '\0';
pcVar2[0x14e] = '\0';
pcVar2[0x14f] = '\0';
pcVar2[0x150] = '\0';
pcVar2[0x151] = '\0';
pcVar2[0x152] = '\0';
pcVar2[0x153] = '\0';
pcVar2[0x154] = '\0';
pcVar2[0x155] = '\0';
pcVar2[0x156] = '\0';
pcVar2[0x157] = '\0';
pcVar2[0x138] = '\0';
pcVar2[0x139] = '\0';
pcVar2[0x13a] = '\0';
pcVar2[0x13b] = '\0';
pcVar2[0x13c] = '\0';
pcVar2[0x13d] = '\0';
pcVar2[0x13e] = '\0';
pcVar2[0x13f] = '\0';
pcVar2[0x140] = '\0';
pcVar2[0x141] = '\0';
pcVar2[0x142] = '\0';
pcVar2[0x143] = '\0';
pcVar2[0x144] = '\0';
pcVar2[0x145] = '\0';
pcVar2[0x146] = '\0';
pcVar2[0x147] = '\0';
pcVar2[0x158] = '\0';
pcVar2[0x159] = '\0';
pcVar2[0x15a] = '\0';
pcVar2[0x15b] = '\0';
pcVar2[0x15c] = '\0';
pcVar2[0x15d] = '\0';
pcVar2[0x15e] = '\0';
pcVar2[0x15f] = '\0';
}
uVar3 = uVar3 + 1;
} while (uVar1 != uVar3);
}
return 0;
}
| |
47,230 | ggml_vec_dot_q2_K_q8_K | monkey531[P]llama/ggml/src/ggml-cpu/ggml-cpu-quants.c | void ggml_vec_dot_q2_K_q8_K(int n, float * restrict s, size_t bs, const void * restrict vx, size_t bx, const void * restrict vy, size_t by, int nrc) {
assert(nrc == 1);
UNUSED(nrc);
UNUSED(bx);
UNUSED(by);
UNUSED(bs);
const block_q2_K * restrict x = vx;
const block_q8_K * restrict y = vy;
const int nb = n / QK_K;
#ifdef __ARM_NEON
const uint8x16_t m3 = vdupq_n_u8(0x3);
const uint8x16_t m4 = vdupq_n_u8(0xF);
const int32x4_t vzero = vdupq_n_s32(0);
ggml_int8x16x2_t q2bytes;
uint8_t aux[16];
float sum = 0;
for (int i = 0; i < nb; ++i) {
const float d = y[i].d * GGML_FP16_TO_FP32(x[i].d);
const float dmin = -y[i].d * GGML_FP16_TO_FP32(x[i].dmin);
const uint8_t * restrict q2 = x[i].qs;
const int8_t * restrict q8 = y[i].qs;
const uint8_t * restrict sc = x[i].scales;
const uint8x16_t mins_and_scales = vld1q_u8(sc);
const uint8x16_t scales = vandq_u8(mins_and_scales, m4);
vst1q_u8(aux, scales);
const uint8x16_t mins = vshrq_n_u8(mins_and_scales, 4);
const ggml_int16x8x2_t q8sums = ggml_vld1q_s16_x2(y[i].bsums);
const ggml_int16x8x2_t mins16 = {{vreinterpretq_s16_u16(vmovl_u8(vget_low_u8(mins))), vreinterpretq_s16_u16(vmovl_u8(vget_high_u8(mins)))}};
const int32x4_t s0 = vaddq_s32(vmull_s16(vget_low_s16 (mins16.val[0]), vget_low_s16 (q8sums.val[0])),
vmull_s16(vget_high_s16(mins16.val[0]), vget_high_s16(q8sums.val[0])));
const int32x4_t s1 = vaddq_s32(vmull_s16(vget_low_s16 (mins16.val[1]), vget_low_s16 (q8sums.val[1])),
vmull_s16(vget_high_s16(mins16.val[1]), vget_high_s16(q8sums.val[1])));
sum += dmin * vaddvq_s32(vaddq_s32(s0, s1));
int isum = 0;
int is = 0;
// We use this macro instead of a function call because for some reason
// the code runs 2-3% slower, even if the function is declared inline
#define MULTIPLY_ACCUM_WITH_SCALE(index)\
isum += vaddvq_s32(ggml_vdotq_s32(vzero, q2bytes.val[0], q8bytes.val[0])) * aux[is+(index)];\
isum += vaddvq_s32(ggml_vdotq_s32(vzero, q2bytes.val[1], q8bytes.val[1])) * aux[is+1+(index)];
#define SHIFT_MULTIPLY_ACCUM_WITH_SCALE(shift, index)\
q8bytes = ggml_vld1q_s8_x2(q8); q8 += 32;\
q2bytes.val[0] = vreinterpretq_s8_u8(vandq_u8(vshrq_n_u8(q2bits.val[0], (shift)), m3));\
q2bytes.val[1] = vreinterpretq_s8_u8(vandq_u8(vshrq_n_u8(q2bits.val[1], (shift)), m3));\
MULTIPLY_ACCUM_WITH_SCALE((index));
for (int j = 0; j < QK_K/128; ++j) {
const ggml_uint8x16x2_t q2bits = ggml_vld1q_u8_x2(q2); q2 += 32;
ggml_int8x16x2_t q8bytes = ggml_vld1q_s8_x2(q8); q8 += 32;
q2bytes.val[0] = vreinterpretq_s8_u8(vandq_u8(q2bits.val[0], m3));
q2bytes.val[1] = vreinterpretq_s8_u8(vandq_u8(q2bits.val[1], m3));
MULTIPLY_ACCUM_WITH_SCALE(0);
SHIFT_MULTIPLY_ACCUM_WITH_SCALE(2, 2);
SHIFT_MULTIPLY_ACCUM_WITH_SCALE(4, 4);
SHIFT_MULTIPLY_ACCUM_WITH_SCALE(6, 6);
is += 8;
}
sum += d * isum;
}
*s = sum;
#elif defined __AVX2__
const __m256i m3 = _mm256_set1_epi8(3);
const __m128i m4 = _mm_set1_epi8(0xF);
__m256 acc = _mm256_setzero_ps();
for (int i = 0; i < nb; ++i) {
const float d = y[i].d * GGML_FP16_TO_FP32(x[i].d);
const float dmin = -y[i].d * GGML_FP16_TO_FP32(x[i].dmin);
const uint8_t * restrict q2 = x[i].qs;
const int8_t * restrict q8 = y[i].qs;
const __m128i mins_and_scales = _mm_loadu_si128((const __m128i*)x[i].scales);
const __m128i scales8 = _mm_and_si128(mins_and_scales, m4);
const __m128i mins8 = _mm_and_si128(_mm_srli_epi16(mins_and_scales, 4), m4);
const __m256i mins = _mm256_cvtepi8_epi16(mins8);
const __m256i prod = _mm256_madd_epi16(mins, _mm256_loadu_si256((const __m256i*)y[i].bsums));
acc = _mm256_fmadd_ps(_mm256_broadcast_ss(&dmin), _mm256_cvtepi32_ps(prod), acc);
const __m256i all_scales = _mm256_cvtepi8_epi16(scales8);
const __m128i l_scales = _mm256_extracti128_si256(all_scales, 0);
const __m128i h_scales = _mm256_extracti128_si256(all_scales, 1);
const __m256i scales[2] = {MM256_SET_M128I(l_scales, l_scales), MM256_SET_M128I(h_scales, h_scales)};
__m256i sumi = _mm256_setzero_si256();
for (int j = 0; j < QK_K/128; ++j) {
const __m256i q2bits = _mm256_loadu_si256((const __m256i*)q2); q2 += 32;
const __m256i q8_0 = _mm256_loadu_si256((const __m256i*)q8); q8 += 32;
const __m256i q8_1 = _mm256_loadu_si256((const __m256i*)q8); q8 += 32;
const __m256i q8_2 = _mm256_loadu_si256((const __m256i*)q8); q8 += 32;
const __m256i q8_3 = _mm256_loadu_si256((const __m256i*)q8); q8 += 32;
const __m256i q2_0 = _mm256_and_si256(q2bits, m3);
const __m256i q2_1 = _mm256_and_si256(_mm256_srli_epi16(q2bits, 2), m3);
const __m256i q2_2 = _mm256_and_si256(_mm256_srli_epi16(q2bits, 4), m3);
const __m256i q2_3 = _mm256_and_si256(_mm256_srli_epi16(q2bits, 6), m3);
__m256i p0 = _mm256_maddubs_epi16(q2_0, q8_0);
__m256i p1 = _mm256_maddubs_epi16(q2_1, q8_1);
__m256i p2 = _mm256_maddubs_epi16(q2_2, q8_2);
__m256i p3 = _mm256_maddubs_epi16(q2_3, q8_3);
p0 = _mm256_madd_epi16(_mm256_shuffle_epi8(scales[j], get_scale_shuffle_q3k(0)), p0);
p1 = _mm256_madd_epi16(_mm256_shuffle_epi8(scales[j], get_scale_shuffle_q3k(1)), p1);
p2 = _mm256_madd_epi16(_mm256_shuffle_epi8(scales[j], get_scale_shuffle_q3k(2)), p2);
p3 = _mm256_madd_epi16(_mm256_shuffle_epi8(scales[j], get_scale_shuffle_q3k(3)), p3);
p0 = _mm256_add_epi32(p0, p1);
p2 = _mm256_add_epi32(p2, p3);
sumi = _mm256_add_epi32(sumi, _mm256_add_epi32(p0, p2));
}
acc = _mm256_fmadd_ps(_mm256_broadcast_ss(&d), _mm256_cvtepi32_ps(sumi), acc);
}
*s = hsum_float_8(acc);
#elif defined __AVX__
const __m128i m3 = _mm_set1_epi8(0x3);
const __m128i m4 = _mm_set1_epi8(0xF);
const __m128i m2 = _mm_set1_epi8(0x2);
__m256 acc = _mm256_setzero_ps();
for (int i = 0; i < nb; ++i) {
const float dall = y[i].d * GGML_FP16_TO_FP32(x[i].d);
const float dmin = -y[i].d * GGML_FP16_TO_FP32(x[i].dmin);
const uint8_t * restrict q2 = x[i].qs;
const int8_t * restrict q8 = y[i].qs;
// load mins and scales from block_q2_K.scales[QK_K/16]
const __m128i mins_and_scales = _mm_loadu_si128((const __m128i*)x[i].scales);
const __m128i scales16 = _mm_and_si128(mins_and_scales, m4);
const __m128i mins16 = _mm_and_si128(_mm_srli_epi16(mins_and_scales, 4), m4);
const __m128i mins_0 = _mm_cvtepi8_epi16(mins16);
const __m128i mins_1 = _mm_cvtepi8_epi16(_mm_unpackhi_epi64(mins16, mins16));
// summs = y[i].bsums * (x[i].scales >> 4) in 16bits*8*2 to 32bits*4*2
const __m128i summs_0 = _mm_madd_epi16(mins_0, _mm_loadu_si128((const __m128i*)&y[i].bsums[0]));
const __m128i summs_1 = _mm_madd_epi16(mins_1, _mm_loadu_si128((const __m128i*)&y[i].bsums[8]));
// sumf += -dmin * summs in 32bits*8
acc = _mm256_add_ps(_mm256_mul_ps(_mm256_broadcast_ss(&dmin), _mm256_cvtepi32_ps(MM256_SET_M128I(summs_1, summs_0))), acc);
const __m128i scales_0 = _mm_cvtepi8_epi16(scales16);
const __m128i scales_1 = _mm_cvtepi8_epi16(_mm_unpackhi_epi64(scales16, scales16));
const __m128i scales[2] = { scales_0, scales_1 };
__m128i sumi_0 = _mm_setzero_si128();
__m128i sumi_1 = _mm_setzero_si128();
for (int j = 0; j < QK_K/128; ++j) {
// load Q8 quants int8*16*8 from block_q8_K.qs[QK_K]
const __m128i q8_0 = _mm_loadu_si128((const __m128i*)q8); q8 += 16;
const __m128i q8_1 = _mm_loadu_si128((const __m128i*)q8); q8 += 16;
const __m128i q8_2 = _mm_loadu_si128((const __m128i*)q8); q8 += 16;
const __m128i q8_3 = _mm_loadu_si128((const __m128i*)q8); q8 += 16;
const __m128i q8_4 = _mm_loadu_si128((const __m128i*)q8); q8 += 16;
const __m128i q8_5 = _mm_loadu_si128((const __m128i*)q8); q8 += 16;
const __m128i q8_6 = _mm_loadu_si128((const __m128i*)q8); q8 += 16;
const __m128i q8_7 = _mm_loadu_si128((const __m128i*)q8); q8 += 16;
// load 2bits*16*8 from block_q2_K.qs[QK_K/4]
__m128i q2bits = _mm_loadu_si128((const __m128i*)q2); q2 += 16;
const __m128i q2_0 = _mm_and_si128(q2bits, m3);
const __m128i q2_2 = _mm_and_si128(_mm_srli_epi16(q2bits, 2), m3);
const __m128i q2_4 = _mm_and_si128(_mm_srli_epi16(q2bits, 4), m3);
const __m128i q2_6 = _mm_and_si128(_mm_srli_epi16(q2bits, 6), m3);
q2bits = _mm_loadu_si128((const __m128i*)q2); q2 += 16;
const __m128i q2_1 = _mm_and_si128(q2bits, m3);
const __m128i q2_3 = _mm_and_si128(_mm_srli_epi16(q2bits, 2), m3);
const __m128i q2_5 = _mm_and_si128(_mm_srli_epi16(q2bits, 4), m3);
const __m128i q2_7 = _mm_and_si128(_mm_srli_epi16(q2bits, 6), m3);
// isuml = q8[l] * ((q2[l] >> shift) & 3) in 8bits*16*8 to 16bits*8*8
__m128i p0 = _mm_maddubs_epi16(q2_0, q8_0);
__m128i p1 = _mm_maddubs_epi16(q2_1, q8_1);
__m128i p2 = _mm_maddubs_epi16(q2_2, q8_2);
__m128i p3 = _mm_maddubs_epi16(q2_3, q8_3);
__m128i p4 = _mm_maddubs_epi16(q2_4, q8_4);
__m128i p5 = _mm_maddubs_epi16(q2_5, q8_5);
__m128i p6 = _mm_maddubs_epi16(q2_6, q8_6);
__m128i p7 = _mm_maddubs_epi16(q2_7, q8_7);
// isum += (x[i].scales[is++] & 0xF) * isuml in 16bits*8*8 to 32bits*4*8
__m128i shuffle = _mm_set1_epi16(0x0100);
p0 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p0);
shuffle = _mm_add_epi16(shuffle, m2);
p1 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p1);
shuffle = _mm_add_epi16(shuffle, m2);
p2 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p2);
shuffle = _mm_add_epi16(shuffle, m2);
p3 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p3);
shuffle = _mm_add_epi16(shuffle, m2);
p4 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p4);
shuffle = _mm_add_epi16(shuffle, m2);
p5 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p5);
shuffle = _mm_add_epi16(shuffle, m2);
p6 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p6);
shuffle = _mm_add_epi16(shuffle, m2);
p7 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p7);
p0 = _mm_add_epi32(p0, p1);
p2 = _mm_add_epi32(p2, p3);
p4 = _mm_add_epi32(p4, p5);
p6 = _mm_add_epi32(p6, p7);
// isum in 32bits*4*2
sumi_0 = _mm_add_epi32(sumi_0, _mm_add_epi32(p0, p2));
sumi_1 = _mm_add_epi32(sumi_1, _mm_add_epi32(p4, p6));
}
// sumf += dall * isum - dmin * summs in 32bits
__m256i sumi = MM256_SET_M128I(sumi_1, sumi_0);
acc = _mm256_add_ps(_mm256_mul_ps(_mm256_broadcast_ss(&dall), _mm256_cvtepi32_ps(sumi)), acc);
}
*s = hsum_float_8(acc);
#elif defined __riscv_v_intrinsic
float sumf = 0;
uint8_t temp_01[32] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
for (int i = 0; i < nb; ++i) {
const uint8_t * q2 = x[i].qs;
const int8_t * q8 = y[i].qs;
const uint8_t * sc = x[i].scales;
const float dall = y[i].d * GGML_FP16_TO_FP32(x[i].d);
const float dmin = -y[i].d * GGML_FP16_TO_FP32(x[i].dmin);
size_t vl = 16;
vuint8m1_t scales = __riscv_vle8_v_u8m1(sc, vl);
vuint8m1_t aux = __riscv_vand_vx_u8m1(scales, 0x0F, vl);
vint16m1_t q8sums = __riscv_vle16_v_i16m1(y[i].bsums, vl);
vuint8mf2_t scales_2 = __riscv_vle8_v_u8mf2(sc, vl);
vuint8mf2_t mins8 = __riscv_vsrl_vx_u8mf2(scales_2, 0x4, vl);
vint16m1_t mins = __riscv_vreinterpret_v_u16m1_i16m1(__riscv_vzext_vf2_u16m1(mins8, vl));
vint32m2_t prod = __riscv_vwmul_vv_i32m2(q8sums, mins, vl);
vint32m1_t vsums = __riscv_vredsum_vs_i32m2_i32m1(prod, __riscv_vmv_v_x_i32m1(0, 1), vl);
sumf += dmin * __riscv_vmv_x_s_i32m1_i32(vsums);
vl = 32;
vint32m1_t vzero = __riscv_vmv_v_x_i32m1(0, 1);
vuint8m1_t v_b = __riscv_vle8_v_u8m1(temp_01, vl);
uint8_t is=0;
int isum=0;
for (int j = 0; j < QK_K/128; ++j) {
// load Q2
vuint8m1_t q2_x = __riscv_vle8_v_u8m1(q2, vl);
vuint8m1_t q2_0 = __riscv_vand_vx_u8m1(q2_x, 0x03, vl);
vuint8m1_t q2_1 = __riscv_vand_vx_u8m1(__riscv_vsrl_vx_u8m1(q2_x, 0x2, vl), 0x03 , vl);
vuint8m1_t q2_2 = __riscv_vand_vx_u8m1(__riscv_vsrl_vx_u8m1(q2_x, 0x4, vl), 0x03 , vl);
vuint8m1_t q2_3 = __riscv_vand_vx_u8m1(__riscv_vsrl_vx_u8m1(q2_x, 0x6, vl), 0x03 , vl);
// duplicate scale elements for product
vuint8m1_t sc0 = __riscv_vrgather_vv_u8m1(aux, __riscv_vadd_vx_u8m1(v_b, 0+is, vl), vl);
vuint8m1_t sc1 = __riscv_vrgather_vv_u8m1(aux, __riscv_vadd_vx_u8m1(v_b, 2+is, vl), vl);
vuint8m1_t sc2 = __riscv_vrgather_vv_u8m1(aux, __riscv_vadd_vx_u8m1(v_b, 4+is, vl), vl);
vuint8m1_t sc3 = __riscv_vrgather_vv_u8m1(aux, __riscv_vadd_vx_u8m1(v_b, 6+is, vl), vl);
vint16m2_t p0 = __riscv_vreinterpret_v_u16m2_i16m2(__riscv_vwmulu_vv_u16m2(q2_0, sc0, vl));
vint16m2_t p1 = __riscv_vreinterpret_v_u16m2_i16m2(__riscv_vwmulu_vv_u16m2(q2_1, sc1, vl));
vint16m2_t p2 = __riscv_vreinterpret_v_u16m2_i16m2(__riscv_vwmulu_vv_u16m2(q2_2, sc2, vl));
vint16m2_t p3 = __riscv_vreinterpret_v_u16m2_i16m2(__riscv_vwmulu_vv_u16m2(q2_3, sc3, vl));
// load Q8
vint8m1_t q8_0 = __riscv_vle8_v_i8m1(q8, vl);
vint8m1_t q8_1 = __riscv_vle8_v_i8m1(q8+32, vl);
vint8m1_t q8_2 = __riscv_vle8_v_i8m1(q8+64, vl);
vint8m1_t q8_3 = __riscv_vle8_v_i8m1(q8+96, vl);
vint32m4_t s0 = __riscv_vwmul_vv_i32m4(p0, __riscv_vwcvt_x_x_v_i16m2(q8_0, vl), vl);
vint32m4_t s1 = __riscv_vwmul_vv_i32m4(p1, __riscv_vwcvt_x_x_v_i16m2(q8_1, vl), vl);
vint32m4_t s2 = __riscv_vwmul_vv_i32m4(p2, __riscv_vwcvt_x_x_v_i16m2(q8_2, vl), vl);
vint32m4_t s3 = __riscv_vwmul_vv_i32m4(p3, __riscv_vwcvt_x_x_v_i16m2(q8_3, vl), vl);
vint32m1_t isum0 = __riscv_vredsum_vs_i32m4_i32m1(__riscv_vadd_vv_i32m4(s0, s1, vl), vzero, vl);
vint32m1_t isum1 = __riscv_vredsum_vs_i32m4_i32m1(__riscv_vadd_vv_i32m4(s2, s3, vl), isum0, vl);
isum += __riscv_vmv_x_s_i32m1_i32(isum1);
q2+=32; q8+=128; is=8;
}
sumf += dall * isum;
}
*s = sumf;
#elif defined(__POWER9_VECTOR__)
const vector signed char lowMask = vec_splats((signed char)0x3);
const vector signed char lowScaleMask = vec_splats((signed char)0xF);
const vector int v0 = vec_splats((int32_t)0);
const vector unsigned char v2 = vec_splats((unsigned char)0x2);
const vector unsigned char v6 = vec_splats((unsigned char)0x6);
const vector unsigned char v4 = vec_splats((unsigned char)0x4);
vector float vsumf0 = vec_splats(0.0f);
vector float vsumf1 = vec_splats(0.0f);
vector float vsumf2 = vec_splats(0.0f);
vector float vsumf3 = vec_splats(0.0f);
for (int i = 0; i < nb; ++i) {
vector float vxd = vec_splats(GGML_FP16_TO_FP32(x[i].d));
vector float vyd = vec_splats(y[i].d);
vector float vd = vec_mul(vxd, vyd);
vector float vxmin = vec_splats(GGML_FP16_TO_FP32(x[i].dmin));
vector float vdmin = vec_mul(vxmin, vyd);
vector signed short q8ysums0 = vec_xl( 0, y[i].bsums);
vector signed short q8ysums1 = vec_xl(16, y[i].bsums);
vector signed char q2xmins = (vector signed char)vec_xl( 0, x[i].scales);
vector signed char vscales = vec_and(q2xmins, lowScaleMask);
q2xmins = vec_sr(q2xmins, v4);
vector signed short q2xmins0 = vec_unpackh(q2xmins);
vector signed short q2xmins1 = vec_unpackl(q2xmins);
vector signed int prod0 = vec_mule(q2xmins0, q8ysums0);
vector signed int prod1 = vec_mulo(q2xmins0, q8ysums0);
vector signed int prod2 = vec_mule(q2xmins1, q8ysums1);
vector signed int prod3 = vec_mulo(q2xmins1, q8ysums1);
vsumf0 = vec_nmsub(vec_ctf(prod0, 0), vdmin, vsumf0);
vsumf1 = vec_nmsub(vec_ctf(prod1, 0), vdmin, vsumf1);
vsumf2 = vec_nmsub(vec_ctf(prod2, 0), vdmin, vsumf2);
vsumf3 = vec_nmsub(vec_ctf(prod3, 0), vdmin, vsumf3);
vector signed int vsumi0 = v0;
vector signed int vsumi1 = v0;
vector signed int vsumi2 = v0;
vector signed int vsumi3 = v0;
vector signed int vsumi4 = v0;
vector signed int vsumi5 = v0;
vector signed int vsumi6 = v0;
vector signed int vsumi7 = v0;
const uint8_t * restrict q2 = x[i].qs;
const int8_t * restrict q8 = y[i].qs;
for (int j = 0; j < QK_K/128; ++j) {
__builtin_prefetch(q2, 0, 1);
__builtin_prefetch(q8, 0, 1);
vector signed char qxs0 = (vector signed char)vec_xl( 0, q2);
vector signed char qxs1 = (vector signed char)vec_xl(16, q2);
q2 += 32;
vector unsigned char q2x00 = (vector unsigned char)vec_and(qxs0, lowMask);
vector unsigned char q2x01 = (vector unsigned char)vec_and(vec_sr(qxs0, v2), lowMask);
vector unsigned char q2x02 = (vector unsigned char)vec_and(vec_sr(qxs0, v4), lowMask);
vector unsigned char q2x03 = (vector unsigned char)vec_and(vec_sr(qxs0, v6), lowMask);
vector unsigned char q2x10 = (vector unsigned char)vec_and(qxs1, lowMask);
vector unsigned char q2x11 = (vector unsigned char)vec_and(vec_sr(qxs1, v2), lowMask);
vector unsigned char q2x12 = (vector unsigned char)vec_and(vec_sr(qxs1, v4), lowMask);
vector unsigned char q2x13 = (vector unsigned char)vec_and(vec_sr(qxs1, v6), lowMask);
vector signed char q8y00 = vec_xl( 0, q8);
vector signed char q8y10 = vec_xl( 16, q8);
vector signed char q8y01 = vec_xl( 32, q8);
vector signed char q8y11 = vec_xl( 48, q8);
vector signed char q8y02 = vec_xl( 64, q8);
vector signed char q8y12 = vec_xl( 80, q8);
vector signed char q8y03 = vec_xl( 96, q8);
vector signed char q8y13 = vec_xl(112, q8);
q8 += 128;
vector signed int qv0 = vec_msum(q8y00, q2x00, v0);
vector signed int qv1 = vec_msum(q8y01, q2x01, v0);
vector signed int qv2 = vec_msum(q8y02, q2x02, v0);
vector signed int qv3 = vec_msum(q8y03, q2x03, v0);
vector signed int qv4 = vec_msum(q8y10, q2x10, v0);
vector signed int qv5 = vec_msum(q8y11, q2x11, v0);
vector signed int qv6 = vec_msum(q8y12, q2x12, v0);
vector signed int qv7 = vec_msum(q8y13, q2x13, v0);
vector signed short vscales_07 = vec_unpackh(vscales);
vector signed int vscales_03 = vec_unpackh(vscales_07);
vector signed int vscales_47 = vec_unpackl(vscales_07);
vector signed int vs0 = vec_splat(vscales_03, 0);
vector signed int vs1 = vec_splat(vscales_03, 1);
vector signed int vs2 = vec_splat(vscales_03, 2);
vector signed int vs3 = vec_splat(vscales_03, 3);
vector signed int vs4 = vec_splat(vscales_47, 0);
vector signed int vs5 = vec_splat(vscales_47, 1);
vector signed int vs6 = vec_splat(vscales_47, 2);
vector signed int vs7 = vec_splat(vscales_47, 3);
vscales = vec_sld(vscales, vscales, 8);
vsumi0 = vec_add(vec_mul(qv0, vs0), vsumi0);
vsumi1 = vec_add(vec_mul(qv1, vs2), vsumi1);
vsumi2 = vec_add(vec_mul(qv2, vs4), vsumi2);
vsumi3 = vec_add(vec_mul(qv3, vs6), vsumi3);
vsumi4 = vec_add(vec_mul(qv4, vs1), vsumi4);
vsumi5 = vec_add(vec_mul(qv5, vs3), vsumi5);
vsumi6 = vec_add(vec_mul(qv6, vs5), vsumi6);
vsumi7 = vec_add(vec_mul(qv7, vs7), vsumi7);
}
vsumi0 = vec_add(vsumi0, vsumi4);
vsumi1 = vec_add(vsumi1, vsumi5);
vsumi2 = vec_add(vsumi2, vsumi6);
vsumi3 = vec_add(vsumi3, vsumi7);
vsumf0 = vec_madd(vec_ctf(vsumi0, 0), vd, vsumf0);
vsumf1 = vec_madd(vec_ctf(vsumi1, 0), vd, vsumf1);
vsumf2 = vec_madd(vec_ctf(vsumi2, 0), vd, vsumf2);
vsumf3 = vec_madd(vec_ctf(vsumi3, 0), vd, vsumf3);
}
vsumf0 = vec_add(vsumf0, vsumf2);
vsumf1 = vec_add(vsumf1, vsumf3);
vsumf0 = vec_add(vsumf0, vsumf1);
vsumf0 = vec_add(vsumf0, vec_sld(vsumf0, vsumf0, 4));
vsumf0 = vec_add(vsumf0, vec_sld(vsumf0, vsumf0, 8));
*s = vec_extract(vsumf0, 0);
#elif defined __loongarch_asx
const __m256i m3 = __lasx_xvreplgr2vr_b(3);
const __m128i m4 = __lsx_vreplgr2vr_b(0xF);
__m256 acc = (__m256)__lasx_xvldi(0);
for (int i = 0; i < nb; ++i) {
const float d = y[i].d * GGML_FP16_TO_FP32(x[i].d);
const float dmin = -y[i].d * GGML_FP16_TO_FP32(x[i].dmin);
const uint8_t * restrict q2 = x[i].qs;
const int8_t * restrict q8 = y[i].qs;
const __m128i mins_and_scales = __lsx_vld((const __m128i*)x[i].scales, 0);
const __m128i scales8 = __lsx_vand_v(mins_and_scales, m4);
const __m128i mins8 = __lsx_vand_v(__lsx_vsrli_h(mins_and_scales, 4), m4);
const __m256i mins = lasx_ext8_16(mins8);
const __m256i prod = lasx_madd_h(mins, __lasx_xvld((const __m256i*)y[i].bsums, 0));
acc = __lasx_xvfmadd_s(__lasx_xvreplfr2vr_s(dmin), __lasx_xvffint_s_w(prod), acc);
const __m256i all_scales = lasx_ext8_16(scales8);
const __m128i l_scales = lasx_extracti128(all_scales, 0);
const __m128i h_scales = lasx_extracti128(all_scales, 1);
const __m256i scales[2] = {lasx_insertf128(l_scales, l_scales), lasx_insertf128(h_scales, h_scales)};
__m256i sumi = __lasx_xvldi(0);
for (int j = 0; j < QK_K/128; ++j) {
const __m256i q2bits = __lasx_xvld((const __m256i*)q2, 0); q2 += 32;
const __m256i q8_0 = __lasx_xvld((const __m256i*)q8, 0); q8 += 32;
const __m256i q8_1 = __lasx_xvld((const __m256i*)q8, 0); q8 += 32;
const __m256i q8_2 = __lasx_xvld((const __m256i*)q8, 0); q8 += 32;
const __m256i q8_3 = __lasx_xvld((const __m256i*)q8, 0); q8 += 32;
const __m256i q2_0 = __lasx_xvand_v(q2bits, m3);
const __m256i q2_1 = __lasx_xvand_v(__lasx_xvsrli_h(q2bits, 2), m3);
const __m256i q2_2 = __lasx_xvand_v(__lasx_xvsrli_h(q2bits, 4), m3);
const __m256i q2_3 = __lasx_xvand_v(__lasx_xvsrli_h(q2bits, 6), m3);
__m256i p0 = lasx_maddubs_h(q2_0, q8_0);
__m256i p1 = lasx_maddubs_h(q2_1, q8_1);
__m256i p2 = lasx_maddubs_h(q2_2, q8_2);
__m256i p3 = lasx_maddubs_h(q2_3, q8_3);
p0 = lasx_madd_h(lasx_shuffle_b(scales[j], get_scale_shuffle_q3k(0)), p0);
p1 = lasx_madd_h(lasx_shuffle_b(scales[j], get_scale_shuffle_q3k(1)), p1);
p2 = lasx_madd_h(lasx_shuffle_b(scales[j], get_scale_shuffle_q3k(2)), p2);
p3 = lasx_madd_h(lasx_shuffle_b(scales[j], get_scale_shuffle_q3k(3)), p3);
p0 = __lasx_xvadd_w(p0, p1);
p2 = __lasx_xvadd_w(p2, p3);
sumi = __lasx_xvadd_w(sumi, __lasx_xvadd_w(p0, p2));
}
acc = __lasx_xvfmadd_s(__lasx_xvreplfr2vr_s(d), __lasx_xvffint_s_w(sumi), acc);
}
*s = hsum_float_8(acc);
#else
float sumf = 0;
for (int i = 0; i < nb; ++i) {
const uint8_t * q2 = x[i].qs;
const int8_t * q8 = y[i].qs;
const uint8_t * sc = x[i].scales;
int summs = 0;
for (int j = 0; j < 16; ++j) {
summs += y[i].bsums[j] * (sc[j] >> 4);
}
const float dall = y[i].d * GGML_FP16_TO_FP32(x[i].d);
const float dmin = y[i].d * GGML_FP16_TO_FP32(x[i].dmin);
int isum = 0;
int is = 0;
int d;
for (int k = 0; k < QK_K/128; ++k) {
int shift = 0;
for (int j = 0; j < 4; ++j) {
d = sc[is++] & 0xF;
int isuml = 0;
for (int l = 0; l < 16; ++l) isuml += q8[l] * ((q2[l] >> shift) & 3);
isum += d * isuml;
d = sc[is++] & 0xF;
isuml = 0;
for (int l = 16; l < 32; ++l) isuml += q8[l] * ((q2[l] >> shift) & 3);
isum += d * isuml;
shift += 2;
q8 += 32;
}
q2 += 32;
}
sumf += dall * isum - dmin * summs;
}
*s = sumf;
#endif
} | O2 | c | ggml_vec_dot_q2_K_q8_K:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
andq $-0x20, %rsp
subq $0x40, %rsp
movl %edi, %eax
movl $0x100, %edi # imm = 0x100
cltd
idivl %edi
movl %eax, %edx
sarl $0x1f, %edx
andnl %eax, %edx, %eax
leaq 0x4(%r9), %rdx
leaq 0x10(%rcx), %rdi
vxorps %xmm0, %xmm0, %xmm0
xorl %r8d, %r8d
movq 0x2b575(%rip), %r10 # 0x58f70
vbroadcastss 0x18c4c(%rip), %xmm1 # 0x46650
vpbroadcastb 0x1aaec(%rip), %xmm2 # 0x484f9
vpbroadcastb 0x1aae4(%rip), %ymm3 # 0x484fa
vmovdqa 0x1a8e2(%rip), %ymm4 # 0x48300
vmovdqa 0x1a8fa(%rip), %ymm5 # 0x48320
vmovdqa 0x1a912(%rip), %ymm6 # 0x48340
vmovdqa 0x1a92a(%rip), %ymm7 # 0x48360
cmpq %rax, %r8
je 0x2db8e
imulq $0x124, %r8, %r11 # imm = 0x124
vmovss (%r9,%r11), %xmm8
imulq $0x54, %r8, %rbx
movzwl 0x50(%rcx,%rbx), %r14d
vmovss (%r10,%r14,4), %xmm9
vxorps %xmm1, %xmm8, %xmm10
movzwl 0x52(%rcx,%rbx), %r14d
vmulss (%r10,%r14,4), %xmm10, %xmm10
vmovdqu (%rcx,%rbx), %xmm11
vpsrlw $0x4, %xmm11, %xmm12
vpand %xmm2, %xmm12, %xmm12
vpmovzxbw %xmm12, %ymm12 # ymm12 = xmm12[0],zero,xmm12[1],zero,xmm12[2],zero,xmm12[3],zero,xmm12[4],zero,xmm12[5],zero,xmm12[6],zero,xmm12[7],zero,xmm12[8],zero,xmm12[9],zero,xmm12[10],zero,xmm12[11],zero,xmm12[12],zero,xmm12[13],zero,xmm12[14],zero,xmm12[15],zero
vpmaddwd 0x104(%r9,%r11), %ymm12, %ymm12
vpand %xmm2, %xmm11, %xmm11
vpmovzxbw %xmm11, %ymm13 # ymm13 = xmm11[0],zero,xmm11[1],zero,xmm11[2],zero,xmm11[3],zero,xmm11[4],zero,xmm11[5],zero,xmm11[6],zero,xmm11[7],zero,xmm11[8],zero,xmm11[9],zero,xmm11[10],zero,xmm11[11],zero,xmm11[12],zero,xmm11[13],zero,xmm11[14],zero,xmm11[15],zero
vpermq $0x44, %ymm13, %ymm11 # ymm11 = ymm13[0,1,0,1]
vmovdqa %ymm11, (%rsp)
vcvtdq2ps %ymm12, %ymm11
vpermq $0xee, %ymm13, %ymm12 # ymm12 = ymm13[2,3,2,3]
vmovdqa %ymm12, 0x20(%rsp)
vpxor %xmm12, %xmm12, %xmm12
xorl %r11d, %r11d
cmpq $0x40, %r11
je 0x2db5d
vmovdqu (%rdi,%r11), %ymm13
vpsrlw $0x2, %ymm13, %ymm14
vpsrlw $0x4, %ymm13, %ymm15
vpsrlw $0x6, %ymm13, %ymm16
vpand %ymm3, %ymm13, %ymm13
vpmaddubsw (%rdx,%r11,4), %ymm13, %ymm13
vpand %ymm3, %ymm14, %ymm14
vpmaddubsw 0x20(%rdx,%r11,4), %ymm14, %ymm14
vpand %ymm3, %ymm15, %ymm15
vpmaddubsw 0x40(%rdx,%r11,4), %ymm15, %ymm15
vpandq %ymm3, %ymm16, %ymm16
vpmaddubsw 0x60(%rdx,%r11,4), %ymm16, %ymm16
vmovdqa64 (%rsp,%r11), %ymm17
vpshufb %ymm4, %ymm17, %ymm18
vpmaddwd %ymm13, %ymm18, %ymm13
vpshufb %ymm5, %ymm17, %ymm18
vpmaddwd %ymm14, %ymm18, %ymm14
vpshufb %ymm6, %ymm17, %ymm18
vpmaddwd %ymm15, %ymm18, %ymm15
vpshufb %ymm7, %ymm17, %ymm17
vpmaddwd %ymm16, %ymm17, %ymm16
vpaddd %ymm16, %ymm15, %ymm15
vpaddd %ymm12, %ymm13, %ymm12
vpaddd %ymm14, %ymm12, %ymm12
vpaddd %ymm15, %ymm12, %ymm12
addq $0x20, %r11
jmp 0x2dab7
vmulss %xmm9, %xmm8, %xmm8
vbroadcastss %xmm10, %ymm9
vfmadd213ps %ymm0, %ymm9, %ymm11 # ymm11 = (ymm9 * ymm11) + ymm0
vbroadcastss %xmm8, %ymm8
vcvtdq2ps %ymm12, %ymm0
vfmadd213ps %ymm11, %ymm8, %ymm0 # ymm0 = (ymm8 * ymm0) + ymm11
incq %r8
addq $0x124, %rdx # imm = 0x124
addq $0x54, %rdi
jmp 0x2da36
vextractf128 $0x1, %ymm0, %xmm1
vaddps %xmm0, %xmm1, %xmm0
vshufpd $0x1, %xmm0, %xmm0, %xmm1 # xmm1 = xmm0[1,0]
vaddps %xmm1, %xmm0, %xmm0
vhaddps %xmm0, %xmm0, %xmm0
vmovss %xmm0, (%rsi)
leaq -0x10(%rbp), %rsp
popq %rbx
popq %r14
popq %rbp
vzeroupper
retq
| ggml_vec_dot_q2_K_q8_K:
push rbp
mov rbp, rsp
push r14
push rbx
and rsp, 0FFFFFFFFFFFFFFE0h
sub rsp, 40h
mov eax, edi
mov edi, 100h
cdq
idiv edi
mov edx, eax
sar edx, 1Fh
andn eax, edx, eax
lea rdx, [r9+4]
lea rdi, [rcx+10h]
vxorps xmm0, xmm0, xmm0
xor r8d, r8d
mov r10, cs:ggml_table_f32_f16_ptr
vbroadcastss xmm1, dword ptr cs:byte_46640+10h
vpbroadcastb xmm2, cs:byte_484F9
vpbroadcastb ymm3, cs:byte_484FA
vmovdqa ymm4, cs:ymmword_48300
vmovdqa ymm5, cs:ymmword_48320
vmovdqa ymm6, cs:ymmword_48340
vmovdqa ymm7, cs:ymmword_48360
loc_2DA36:
cmp r8, rax
jz loc_2DB8E
imul r11, r8, 124h
vmovss xmm8, dword ptr [r9+r11]
imul rbx, r8, 54h ; 'T'
movzx r14d, word ptr [rcx+rbx+50h]
vmovss xmm9, dword ptr [r10+r14*4]
vxorps xmm10, xmm8, xmm1
movzx r14d, word ptr [rcx+rbx+52h]
vmulss xmm10, xmm10, dword ptr [r10+r14*4]
vmovdqu xmm11, xmmword ptr [rcx+rbx]
vpsrlw xmm12, xmm11, 4
vpand xmm12, xmm12, xmm2
vpmovzxbw ymm12, xmm12
vpmaddwd ymm12, ymm12, ymmword ptr [r9+r11+104h]
vpand xmm11, xmm11, xmm2
vpmovzxbw ymm13, xmm11
vpermq ymm11, ymm13, 44h ; 'D'
vmovdqa [rsp+50h+var_50], ymm11
vcvtdq2ps ymm11, ymm12
vpermq ymm12, ymm13, 0EEh
vmovdqa [rsp+50h+var_30], ymm12
vpxor xmm12, xmm12, xmm12
xor r11d, r11d
loc_2DAB7:
cmp r11, 40h ; '@'
jz loc_2DB5D
vmovdqu ymm13, ymmword ptr [rdi+r11]
vpsrlw ymm14, ymm13, 2
vpsrlw ymm15, ymm13, 4
vpsrlw ymm16, ymm13, 6
vpand ymm13, ymm13, ymm3
vpmaddubsw ymm13, ymm13, ymmword ptr [rdx+r11*4]
vpand ymm14, ymm14, ymm3
vpmaddubsw ymm14, ymm14, ymmword ptr [rdx+r11*4+20h]
vpand ymm15, ymm15, ymm3
vpmaddubsw ymm15, ymm15, ymmword ptr [rdx+r11*4+40h]
vpandq ymm16, ymm16, ymm3
vpmaddubsw ymm16, ymm16, ymmword ptr [rdx+r11*4+60h]
vmovdqa64 ymm17, [rsp+r11+50h+var_50]
vpshufb ymm18, ymm17, ymm4
vpmaddwd ymm13, ymm18, ymm13
vpshufb ymm18, ymm17, ymm5
vpmaddwd ymm14, ymm18, ymm14
vpshufb ymm18, ymm17, ymm6
vpmaddwd ymm15, ymm18, ymm15
vpshufb ymm17, ymm17, ymm7
vpmaddwd ymm16, ymm17, ymm16
vpaddd ymm15, ymm15, ymm16
vpaddd ymm12, ymm13, ymm12
vpaddd ymm12, ymm12, ymm14
vpaddd ymm12, ymm12, ymm15
add r11, 20h ; ' '
jmp loc_2DAB7
loc_2DB5D:
vmulss xmm8, xmm8, xmm9
vbroadcastss ymm9, xmm10
vfmadd213ps ymm11, ymm9, ymm0
vbroadcastss ymm8, xmm8
vcvtdq2ps ymm0, ymm12
vfmadd213ps ymm0, ymm8, ymm11
inc r8
add rdx, 124h
add rdi, 54h ; 'T'
jmp loc_2DA36
loc_2DB8E:
vextractf128 xmm1, ymm0, 1
vaddps xmm0, xmm1, xmm0
vshufpd xmm1, xmm0, xmm0, 1
vaddps xmm0, xmm0, xmm1
vhaddps xmm0, xmm0, xmm0
vmovss dword ptr [rsi], xmm0
lea rsp, [rbp-10h]
pop rbx
pop r14
pop rbp
vzeroupper
retn
| long long ggml_vec_dot_q2_K_q8_K(
int a1,
long long _RSI,
__m128 _XMM0,
long long a4,
long long _RCX,
long long a6,
long long _R9)
{
long long result; // rax
long long v9; // rdx
long long v12; // r8
result = (a1 / 256) & (unsigned int)~((a1 / 256) >> 31);
v9 = _R9 + 4;
_RDI = _RCX + 16;
__asm { vxorps xmm0, xmm0, xmm0 }
v12 = 0LL;
_R10 = &ggml_table_f32_f16;
__asm
{
vbroadcastss xmm1, dword ptr cs:byte_46640+10h
vpbroadcastb xmm2, cs:byte_484F9
vpbroadcastb ymm3, cs:byte_484FA
vmovdqa ymm4, cs:ymmword_48300
vmovdqa ymm5, cs:ymmword_48320
vmovdqa ymm6, cs:ymmword_48340
vmovdqa ymm7, cs:ymmword_48360
}
while ( v12 != result )
{
_R11 = 292 * v12;
__asm { vmovss xmm8, dword ptr [r9+r11] }
_RBX = 84 * v12;
_R14 = *(unsigned __int16 *)(_RCX + 84 * v12 + 80);
__asm
{
vmovss xmm9, dword ptr [r10+r14*4]
vxorps xmm10, xmm8, xmm1
vmulss xmm10, xmm10, dword ptr [r10+r14*4]
vmovdqu xmm11, xmmword ptr [rcx+rbx]
vpsrlw xmm12, xmm11, 4
vpand xmm12, xmm12, xmm2
vpmovzxbw ymm12, xmm12
vpmaddwd ymm12, ymm12, ymmword ptr [r9+r11+104h]
vpand xmm11, xmm11, xmm2
vpmovzxbw ymm13, xmm11
vpermq ymm11, ymm13, 44h ; 'D'
vmovdqa [rsp+50h+var_50], ymm11
vcvtdq2ps ymm11, ymm12
vpermq ymm12, ymm13, 0EEh
vmovdqa [rsp+50h+var_30], ymm12
vpxor xmm12, xmm12, xmm12
}
for ( _R11 = 0LL; _R11 != 64; _R11 += 32LL )
{
__asm
{
vmovdqu ymm13, ymmword ptr [rdi+r11]
vpsrlw ymm14, ymm13, 2
vpsrlw ymm15, ymm13, 4
vpsrlw ymm16, ymm13, 6
vpand ymm13, ymm13, ymm3
vpmaddubsw ymm13, ymm13, ymmword ptr [rdx+r11*4]
vpand ymm14, ymm14, ymm3
vpmaddubsw ymm14, ymm14, ymmword ptr [rdx+r11*4+20h]
vpand ymm15, ymm15, ymm3
vpmaddubsw ymm15, ymm15, ymmword ptr [rdx+r11*4+40h]
vpandq ymm16, ymm16, ymm3
vpmaddubsw ymm16, ymm16, ymmword ptr [rdx+r11*4+60h]
vmovdqa64 ymm17, [rsp+r11+50h+var_50]
vpshufb ymm18, ymm17, ymm4
vpmaddwd ymm13, ymm18, ymm13
vpshufb ymm18, ymm17, ymm5
vpmaddwd ymm14, ymm18, ymm14
vpshufb ymm18, ymm17, ymm6
vpmaddwd ymm15, ymm18, ymm15
vpshufb ymm17, ymm17, ymm7
vpmaddwd ymm16, ymm17, ymm16
vpaddd ymm15, ymm15, ymm16
vpaddd ymm12, ymm13, ymm12
vpaddd ymm12, ymm12, ymm14
vpaddd ymm12, ymm12, ymm15
}
}
__asm
{
vmulss xmm8, xmm8, xmm9
vbroadcastss ymm9, xmm10
vfmadd213ps ymm11, ymm9, ymm0
vbroadcastss ymm8, xmm8
vcvtdq2ps ymm0, ymm12
vfmadd213ps ymm0, ymm8, ymm11
}
++v12;
v9 += 292LL;
_RDI += 84LL;
}
__asm
{
vextractf128 xmm1, ymm0, 1
vaddps xmm0, xmm1, xmm0
vshufpd xmm1, xmm0, xmm0, 1
vaddps xmm0, xmm0, xmm1
vhaddps xmm0, xmm0, xmm0
vmovss dword ptr [rsi], xmm0
vzeroupper
}
return result;
}
| ggml_vec_dot_q2_K_q8_K:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
AND RSP,-0x20
SUB RSP,0x40
MOV EAX,EDI
MOV EDI,0x100
CDQ
IDIV EDI
MOV EDX,EAX
SAR EDX,0x1f
ANDN EAX,EDX,EAX
LEA RDX,[R9 + 0x4]
LEA RDI,[RCX + 0x10]
VXORPS XMM0,XMM0,XMM0
XOR R8D,R8D
MOV R10,qword ptr [0x00158f70]
VBROADCASTSS XMM1,dword ptr [0x00146650]
VPBROADCASTB XMM2,byte ptr [0x001484f9]
VPBROADCASTB YMM3,byte ptr [0x001484fa]
VMOVDQA YMM4,ymmword ptr [0x00148300]
VMOVDQA YMM5,ymmword ptr [0x00148320]
VMOVDQA YMM6,ymmword ptr [0x00148340]
VMOVDQA YMM7,ymmword ptr [0x00148360]
LAB_0012da36:
CMP R8,RAX
JZ 0x0012db8e
IMUL R11,R8,0x124
VMOVSS XMM8,dword ptr [R9 + R11*0x1]
IMUL RBX,R8,0x54
MOVZX R14D,word ptr [RCX + RBX*0x1 + 0x50]
VMOVSS XMM9,dword ptr [R10 + R14*0x4]
VXORPS XMM10,XMM8,XMM1
MOVZX R14D,word ptr [RCX + RBX*0x1 + 0x52]
VMULSS XMM10,XMM10,dword ptr [R10 + R14*0x4]
VMOVDQU XMM11,xmmword ptr [RCX + RBX*0x1]
VPSRLW XMM12,XMM11,0x4
VPAND XMM12,XMM12,XMM2
VPMOVZXBW YMM12,XMM12
VPMADDWD YMM12,YMM12,ymmword ptr [R9 + R11*0x1 + 0x104]
VPAND XMM11,XMM11,XMM2
VPMOVZXBW YMM13,XMM11
VPERMQ YMM11,YMM13,0x44
VMOVDQA ymmword ptr [RSP],YMM11
VCVTDQ2PS YMM11,YMM12
VPERMQ YMM12,YMM13,0xee
VMOVDQA ymmword ptr [RSP + 0x20],YMM12
VPXOR XMM12,XMM12,XMM12
XOR R11D,R11D
LAB_0012dab7:
CMP R11,0x40
JZ 0x0012db5d
VMOVDQU YMM13,ymmword ptr [RDI + R11*0x1]
VPSRLW YMM14,YMM13,0x2
VPSRLW YMM15,YMM13,0x4
VPSRLW YMM0,YMM13,0x6
VPAND YMM13,YMM13,YMM3
VPMADDUBSW YMM13,YMM13,ymmword ptr [RDX + R11*0x4]
VPAND YMM14,YMM14,YMM3
VPMADDUBSW YMM14,YMM14,ymmword ptr [RDX + R11*0x4 + 0x20]
VPAND YMM15,YMM15,YMM3
VPMADDUBSW YMM15,YMM15,ymmword ptr [RDX + R11*0x4 + 0x40]
VPANDQ YMM0,YMM0,YMM3
VPMADDUBSW YMM0,YMM0,ymmword ptr [RDX + R11*0x4 + 0x60]
VMOVDQA64 YMM1,ymmword ptr [RSP + R11*0x1]
VPSHUFB YMM2,YMM1,YMM4
VPMADDWD YMM13,YMM2,YMM13
VPSHUFB YMM2,YMM1,YMM5
VPMADDWD YMM14,YMM2,YMM14
VPSHUFB YMM2,YMM1,YMM6
VPMADDWD YMM15,YMM2,YMM15
VPSHUFB YMM1,YMM1,YMM7
VPMADDWD YMM0,YMM1,YMM0
VPADDD YMM15,YMM15,YMM0
VPADDD YMM12,YMM13,YMM12
VPADDD YMM12,YMM12,YMM14
VPADDD YMM12,YMM12,YMM15
ADD R11,0x20
JMP 0x0012dab7
LAB_0012db5d:
VMULSS XMM8,XMM8,XMM9
VBROADCASTSS YMM9,XMM10
VFMADD213PS YMM11,YMM9,YMM0
VBROADCASTSS YMM8,XMM8
VCVTDQ2PS YMM0,YMM12
VFMADD213PS YMM0,YMM8,YMM11
INC R8
ADD RDX,0x124
ADD RDI,0x54
JMP 0x0012da36
LAB_0012db8e:
VEXTRACTF128 XMM1,YMM0,0x1
VADDPS XMM0,XMM1,XMM0
VSHUFPD XMM1,XMM0,XMM0,0x1
VADDPS XMM0,XMM0,XMM1
VHADDPS XMM0,XMM0,XMM0
VMOVSS dword ptr [RSI],XMM0
LEA RSP,[RBP + -0x10]
POP RBX
POP R14
POP RBP
VZEROUPPER
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void ggml_vec_dot_q2_K_q8_K
(int param_1,int4 *param_2,int8 param_3,long param_4,int8 param_5,
long param_6)
{
float fVar1;
float fVar2;
int1 auVar3 [32];
long lVar4;
long lVar5;
long lVar6;
ulong uVar7;
long lVar8;
int1 auVar9 [32];
int1 auVar10 [32];
int1 auVar11 [32];
int1 auVar12 [32];
int1 auVar13 [16];
int1 auVar14 [16];
int1 auVar15 [64];
int1 auVar16 [64];
int1 auVar17 [64];
int1 auVar18 [32];
int1 auVar19 [16];
int1 auVar20 [64];
int1 auVar21 [32];
int1 auVar22 [32];
int1 local_60 [32];
int1 local_40 [32];
lVar4 = param_6 + 4;
lVar6 = param_4 + 0x10;
auVar19 = ZEXT816(0) << 0x40;
auVar16 = ZEXT1664(CONCAT412(DAT_00146650,
CONCAT48(DAT_00146650,CONCAT44(DAT_00146650,DAT_00146650))));
auVar17 = ZEXT1664(CONCAT115(DAT_001484f9,
CONCAT114(DAT_001484f9,
CONCAT113(DAT_001484f9,
CONCAT112(DAT_001484f9,
CONCAT111(DAT_001484f9,
CONCAT110(DAT_001484f9,
CONCAT19(
DAT_001484f9,
CONCAT18(DAT_001484f9,
CONCAT17(DAT_001484f9,
CONCAT16(DAT_001484f9,
CONCAT15(DAT_001484f9,
CONCAT14(
DAT_001484f9,
CONCAT13(DAT_001484f9,
CONCAT12(DAT_001484f9,
CONCAT11(DAT_001484f9,
DAT_001484f9)))))))))))
)))));
auVar18[1] = DAT_001484fa;
auVar18[0] = DAT_001484fa;
auVar18[2] = DAT_001484fa;
auVar18[3] = DAT_001484fa;
auVar18[4] = DAT_001484fa;
auVar18[5] = DAT_001484fa;
auVar18[6] = DAT_001484fa;
auVar18[7] = DAT_001484fa;
auVar18[8] = DAT_001484fa;
auVar18[9] = DAT_001484fa;
auVar18[10] = DAT_001484fa;
auVar18[0xb] = DAT_001484fa;
auVar18[0xc] = DAT_001484fa;
auVar18[0xd] = DAT_001484fa;
auVar18[0xe] = DAT_001484fa;
auVar18[0xf] = DAT_001484fa;
auVar18[0x10] = DAT_001484fa;
auVar18[0x11] = DAT_001484fa;
auVar18[0x12] = DAT_001484fa;
auVar18[0x13] = DAT_001484fa;
auVar18[0x14] = DAT_001484fa;
auVar18[0x15] = DAT_001484fa;
auVar18[0x16] = DAT_001484fa;
auVar18[0x17] = DAT_001484fa;
auVar18[0x18] = DAT_001484fa;
auVar18[0x19] = DAT_001484fa;
auVar18[0x1a] = DAT_001484fa;
auVar18[0x1b] = DAT_001484fa;
auVar18[0x1c] = DAT_001484fa;
auVar18[0x1d] = DAT_001484fa;
auVar18[0x1e] = DAT_001484fa;
auVar18[0x1f] = DAT_001484fa;
for (uVar7 = 0; auVar15 = ZEXT1664(auVar19),
uVar7 != (uint)(~(param_1 / 0x100 >> 0x1f) & param_1 / 0x100); uVar7 = uVar7 + 1) {
fVar1 = *(float *)(param_6 + uVar7 * 0x124);
lVar5 = uVar7 * 0x54;
fVar2 = (float)((uint)fVar1 ^ auVar16._0_4_) *
*(float *)(PTR_ggml_table_f32_f16_00158f70 +
(ulong)*(ushort *)(param_4 + 0x52 + lVar5) * 4);
auVar19 = vpsrlw_avx(*(int1 (*) [16])(param_4 + lVar5),4);
auVar19 = vpand_avx(auVar19,auVar17._0_16_);
auVar3 = vpmovzxbw_avx2(auVar19);
auVar3 = vpmaddwd_avx2(auVar3,*(int1 (*) [32])(param_6 + 0x104 + uVar7 * 0x124));
auVar19 = vpand_avx(*(int1 (*) [16])(param_4 + lVar5),auVar17._0_16_);
auVar12 = vpmovzxbw_avx2(auVar19);
local_60 = vpermq_avx2(auVar12,0x44);
auVar3 = vcvtdq2ps_avx(auVar3);
local_40 = vpermq_avx2(auVar12,0xee);
auVar20 = ZEXT1664((int1 [16])0x0);
for (lVar8 = 0; lVar8 != 0x40; lVar8 = lVar8 + 0x20) {
auVar12 = *(int1 (*) [32])(lVar6 + lVar8);
auVar21 = vpsrlw_avx2(auVar12,2);
auVar22 = vpsrlw_avx2(auVar12,4);
auVar9 = vpsrlw_avx512vl(auVar12,6);
auVar12 = vpand_avx2(auVar12,auVar18);
auVar11 = vpmaddubsw_avx2(auVar12,*(int1 (*) [32])(lVar4 + lVar8 * 4));
auVar12 = vpand_avx2(auVar21,auVar18);
auVar21 = vpmaddubsw_avx2(auVar12,*(int1 (*) [32])(lVar4 + 0x20 + lVar8 * 4));
auVar12 = vpand_avx2(auVar22,auVar18);
auVar12 = vpmaddubsw_avx2(auVar12,*(int1 (*) [32])(lVar4 + 0x40 + lVar8 * 4));
auVar9 = vpandq_avx512vl(auVar9,auVar18);
auVar9 = vpmaddubsw_avx512vl(auVar9,*(int1 (*) [32])(lVar4 + 0x60 + lVar8 * 4));
auVar22 = vmovdqa64_avx512vl(*(int1 (*) [32])(local_60 + lVar8));
auVar10 = vpshufb_avx512vl(auVar22,_DAT_00148300);
auVar11 = vpmaddwd_avx512vl(auVar10,auVar11);
auVar10 = vpshufb_avx512vl(auVar22,_DAT_00148320);
auVar21 = vpmaddwd_avx512vl(auVar10,auVar21);
auVar10 = vpshufb_avx512vl(auVar22,_DAT_00148340);
auVar17 = ZEXT3264(auVar10);
auVar12 = vpmaddwd_avx512vl(auVar10,auVar12);
auVar22 = vpshufb_avx512vl(auVar22,_DAT_00148360);
auVar16 = ZEXT3264(auVar22);
auVar9 = vpmaddwd_avx512vl(auVar22,auVar9);
auVar15 = ZEXT3264(auVar9);
auVar9 = vpaddd_avx512vl(auVar12,auVar9);
auVar12 = vpaddd_avx2(auVar11,auVar20._0_32_);
auVar12 = vpaddd_avx2(auVar12,auVar21);
auVar12 = vpaddd_avx2(auVar12,auVar9);
auVar20 = ZEXT3264(auVar12);
}
fVar1 = fVar1 * *(float *)(PTR_ggml_table_f32_f16_00158f70 +
(ulong)*(ushort *)(param_4 + 0x50 + lVar5) * 4);
auVar11._4_4_ = fVar2;
auVar11._0_4_ = fVar2;
auVar11._8_4_ = fVar2;
auVar11._12_4_ = fVar2;
auVar11._16_4_ = fVar2;
auVar11._20_4_ = fVar2;
auVar11._24_4_ = fVar2;
auVar11._28_4_ = fVar2;
auVar19 = vfmadd213ps_fma(auVar3,auVar11,auVar15._0_32_);
auVar12._4_4_ = fVar1;
auVar12._0_4_ = fVar1;
auVar12._8_4_ = fVar1;
auVar12._12_4_ = fVar1;
auVar12._16_4_ = fVar1;
auVar12._20_4_ = fVar1;
auVar12._24_4_ = fVar1;
auVar12._28_4_ = fVar1;
auVar3 = vcvtdq2ps_avx(auVar20._0_32_);
auVar19 = vfmadd213ps_fma(auVar3,auVar12,ZEXT1632(auVar19));
lVar4 = lVar4 + 0x124;
lVar6 = lVar6 + 0x54;
}
auVar13._0_4_ = auVar19._0_4_ + 0.0;
auVar13._4_4_ = auVar19._4_4_ + 0.0;
auVar13._8_4_ = auVar19._8_4_ + 0.0;
auVar13._12_4_ = auVar19._12_4_ + 0.0;
auVar19 = vshufpd_avx(auVar13,auVar13,1);
auVar14._0_4_ = auVar13._0_4_ + auVar19._0_4_;
auVar14._4_4_ = auVar13._4_4_ + auVar19._4_4_;
auVar14._8_4_ = auVar13._8_4_ + auVar19._8_4_;
auVar14._12_4_ = auVar13._12_4_ + auVar19._12_4_;
auVar19 = vhaddps_avx(auVar14,auVar14);
*param_2 = auVar19._0_4_;
return;
}
| |
47,231 | my_time_init | eloqsql/mysys/my_getsystime.c | void my_time_init()
{
#ifdef _WIN32
compile_time_assert(sizeof(LARGE_INTEGER) ==
sizeof(query_performance_frequency));
QueryPerformanceFrequency((LARGE_INTEGER *)&query_performance_frequency);
DBUG_ASSERT(query_performance_frequency);
#endif
} | O0 | c | my_time_init:
pushq %rbp
movq %rsp, %rbp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_time_init:
push rbp
mov rbp, rsp
pop rbp
retn
| void my_time_init()
{
;
}
| my_time_init:
PUSH RBP
MOV RBP,RSP
POP RBP
RET
|
void my_time_init(void)
{
return;
}
| |
47,232 | intx::result_with_carry<intx::uint<256u>> intx::addc<256u>(intx::uint<256u> const&, intx::uint<256u> const&, bool) | corpus-core[P]colibri-stateless/build_O0/_deps/intx-src/include/intx/intx.hpp | inline constexpr result_with_carry<uint<N>> addc(
const uint<N>& x, const uint<N>& y, bool carry = false) noexcept
{
uint<N> s;
bool k = carry;
for (size_t i = 0; i < uint<N>::num_words; ++i)
{
auto t = addc(x[i], y[i], k);
s[i] = t.value;
k = t.carry;
}
return {s, k};
} | O0 | cpp | intx::result_with_carry<intx::uint<256u>> intx::addc<256u>(intx::uint<256u> const&, intx::uint<256u> const&, bool):
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movb %cl, %al
movq %rdi, -0x50(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x618a0
movb -0x11(%rbp), %al
andb $0x1, %al
movb %al, -0x29(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x2, -0x38(%rbp)
jae 0x6186d
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x618e0
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x618e0
movq -0x68(%rbp), %rdi
movq (%rax), %rsi
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x613d0
movq %rax, -0x48(%rbp)
movb %dl, -0x40(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x38(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x617a0
movq -0x60(%rbp), %rcx
movq %rcx, (%rax)
movb -0x40(%rbp), %al
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x617f8
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rcx
movq -0x28(%rbp), %rdx
movq %rdx, (%rcx)
movq -0x20(%rbp), %rdx
movq %rdx, 0x8(%rcx)
movb -0x29(%rbp), %dl
andb $0x1, %dl
movb %dl, 0x10(%rcx)
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| _ZN4intx4addcILj128EEENS_17result_with_carryINS_4uintIXT_EEEEERKS3_S6_b:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_58], rdi
mov al, cl
mov [rbp+var_50], rdi
mov [rbp+var_8], rsi
mov [rbp+var_10], rdx
and al, 1
mov [rbp+var_11], al
lea rdi, [rbp+var_28]
call _ZN4intx4uintILj128EEC2Ev; intx::uint<128u>::uint(void)
mov al, [rbp+var_11]
and al, 1
mov [rbp+var_29], al
mov [rbp+var_38], 0
loc_617F8:
cmp [rbp+var_38], 2
jnb short loc_6186D
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_38]
call _ZNK4intx4uintILj128EEixEm; intx::uint<128u>::operator[](ulong)
mov rax, [rax]
mov [rbp+var_68], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_38]
call _ZNK4intx4uintILj128EEixEm; intx::uint<128u>::operator[](ulong)
mov rdi, [rbp+var_68]; this
mov rsi, [rax]; unsigned __int64
mov al, [rbp+var_29]
and al, 1
movzx edx, al; unsigned __int64
call _ZN4intx4addcEmmb; intx::addc(ulong,ulong,bool)
mov [rbp+var_48], rax
mov [rbp+var_40], dl
mov rax, [rbp+var_48]
mov [rbp+var_60], rax
mov rsi, [rbp+var_38]
lea rdi, [rbp+var_28]
call _ZN4intx4uintILj128EEixEm; intx::uint<128u>::operator[](ulong)
mov rcx, [rbp+var_60]
mov [rax], rcx
mov al, [rbp+var_40]
and al, 1
mov [rbp+var_29], al
mov rax, [rbp+var_38]
add rax, 1
mov [rbp+var_38], rax
jmp short loc_617F8
loc_6186D:
mov rax, [rbp+var_50]
mov rcx, [rbp+var_58]
mov rdx, [rbp+var_28]
mov [rcx], rdx
mov rdx, [rbp+var_20]
mov [rcx+8], rdx
mov dl, [rbp+var_29]
and dl, 1
mov [rcx+10h], dl
add rsp, 70h
pop rbp
retn
| long long intx::addc<128u>(long long a1, long long a2, long long a3, char a4)
{
long long *v4; // rax
char v5; // dl
long long result; // rax
intx *v7; // [rsp+8h] [rbp-68h]
long long v8; // [rsp+28h] [rbp-48h]
char v9; // [rsp+30h] [rbp-40h]
unsigned long long i; // [rsp+38h] [rbp-38h]
char v11; // [rsp+47h] [rbp-29h]
_QWORD v12[2]; // [rsp+48h] [rbp-28h] BYREF
char v13; // [rsp+5Fh] [rbp-11h]
long long v14; // [rsp+60h] [rbp-10h]
long long v15; // [rsp+68h] [rbp-8h]
v15 = a2;
v14 = a3;
v13 = a4 & 1;
intx::uint<128u>::uint(v12);
v11 = v13 & 1;
for ( i = 0LL; i < 2; ++i )
{
v7 = *(intx **)intx::uint<128u>::operator[](v15, i);
v4 = (long long *)intx::uint<128u>::operator[](v14, i);
v8 = intx::addc(v7, *v4, v11 & 1);
v9 = v5;
*(_QWORD *)intx::uint<128u>::operator[]((long long)v12, i) = v8;
v11 = v9 & 1;
}
result = a1;
*(_QWORD *)a1 = v12[0];
*(_QWORD *)(a1 + 8) = v12[1];
*(_BYTE *)(a1 + 16) = v11 & 1;
return result;
}
| addc<128u>:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x58],RDI
MOV AL,CL
MOV qword ptr [RBP + -0x50],RDI
MOV qword ptr [RBP + -0x8],RSI
MOV qword ptr [RBP + -0x10],RDX
AND AL,0x1
MOV byte ptr [RBP + -0x11],AL
LEA RDI,[RBP + -0x28]
CALL 0x001618a0
MOV AL,byte ptr [RBP + -0x11]
AND AL,0x1
MOV byte ptr [RBP + -0x29],AL
MOV qword ptr [RBP + -0x38],0x0
LAB_001617f8:
CMP qword ptr [RBP + -0x38],0x2
JNC 0x0016186d
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x001618e0
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x68],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x001618e0
MOV RDI,qword ptr [RBP + -0x68]
MOV RSI,qword ptr [RAX]
MOV AL,byte ptr [RBP + -0x29]
AND AL,0x1
MOVZX EDX,AL
CALL 0x001613d0
MOV qword ptr [RBP + -0x48],RAX
MOV byte ptr [RBP + -0x40],DL
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x60],RAX
MOV RSI,qword ptr [RBP + -0x38]
LEA RDI,[RBP + -0x28]
CALL 0x001617a0
MOV RCX,qword ptr [RBP + -0x60]
MOV qword ptr [RAX],RCX
MOV AL,byte ptr [RBP + -0x40]
AND AL,0x1
MOV byte ptr [RBP + -0x29],AL
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x1
MOV qword ptr [RBP + -0x38],RAX
JMP 0x001617f8
LAB_0016186d:
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RBP + -0x58]
MOV RDX,qword ptr [RBP + -0x28]
MOV qword ptr [RCX],RDX
MOV RDX,qword ptr [RBP + -0x20]
MOV qword ptr [RCX + 0x8],RDX
MOV DL,byte ptr [RBP + -0x29]
AND DL,0x1
MOV byte ptr [RCX + 0x10],DL
ADD RSP,0x70
POP RBP
RET
|
/* intx::result_with_carry<intx::uint<128u> > intx::addc<128u>(intx::uint<128u> const&,
intx::uint<128u> const&, bool) */
intx * __thiscall intx::addc<128u>(intx *this,uint *param_1,uint *param_2,bool param_3)
{
ulong uVar1;
byte bVar2;
ulong *puVar3;
int8 uVar4;
int8 *puVar5;
byte extraout_DL;
ulong local_40;
intx local_31;
int8 local_30;
int8 local_28;
byte local_19;
uint *local_18;
uint *local_10;
local_19 = param_3;
local_18 = param_2;
local_10 = param_1;
uint<128u>::uint((uint<128u> *)&local_30);
bVar2 = local_19;
for (local_40 = 0; local_31 = (intx)(bVar2 & 1), local_40 < 2; local_40 = local_40 + 1) {
puVar3 = (ulong *)uint<128u>::operator[]((uint<128u> *)local_10,local_40);
uVar1 = *puVar3;
puVar3 = (ulong *)uint<128u>::operator[]((uint<128u> *)local_18,local_40);
uVar4 = addc(uVar1,*puVar3,(bool)local_31);
puVar5 = (int8 *)uint<128u>::operator[]((uint<128u> *)&local_30,local_40);
*puVar5 = uVar4;
bVar2 = extraout_DL;
}
*(int8 *)this = local_30;
*(int8 *)(this + 8) = local_28;
this[0x10] = local_31;
return this;
}
| |
47,233 | maria_page_crc_set_index | eloqsql/storage/maria/ma_pagecrc.c | my_bool maria_page_crc_set_index(PAGECACHE_IO_HOOK_ARGS *args)
{
uchar *page= args->page;
pgcache_page_no_t page_no= args->pageno;
MARIA_SHARE *share= (MARIA_SHARE *)args->data;
int data_length= _ma_get_page_used(share, page);
uint32 crc= maria_page_crc((uint32) page_no, page, data_length);
DBUG_ENTER("maria_page_crc_set_index");
DBUG_PRINT("info", ("Page %lu crc: %lu",
(ulong) page_no, (ulong) crc));
DBUG_ASSERT((uint)data_length <= share->block_size - CRC_SIZE);
/* crc is on the stack so it is aligned, pagecache buffer is aligned, too */
int4store_aligned(page + share->block_size - CRC_SIZE, crc);
DBUG_RETURN(0);
} | O3 | c | maria_page_crc_set_index:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rbx
movl 0x8(%rdi), %eax
movq 0x10(%rdi), %r14
movl 0x744(%r14), %ecx
movzwl -0x2(%rbx,%rcx), %ecx
rolw $0x8, %cx
movzwl %cx, %edx
movl %eax, %edi
movq %rbx, %rsi
callq 0xa7fe0
cmpl $-0x3, %eax
movl $0xfffffffd, %ecx # imm = 0xFFFFFFFD
cmovbl %eax, %ecx
movl 0x7bc(%r14), %eax
movl %ecx, -0x4(%rbx,%rax)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
| maria_page_crc_set_index:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, [rdi]
mov eax, [rdi+8]
mov r14, [rdi+10h]
mov ecx, [r14+744h]
movzx ecx, word ptr [rbx+rcx-2]
rol cx, 8
movzx edx, cx
mov edi, eax
mov rsi, rbx
call my_checksum
cmp eax, 0FFFFFFFDh
mov ecx, 0FFFFFFFDh
cmovb ecx, eax
mov eax, [r14+7BCh]
mov [rbx+rax-4], ecx
xor eax, eax
pop rbx
pop r14
pop rbp
retn
| long long maria_page_crc_set_index(long long *a1)
{
long long v1; // rbx
long long v2; // r14
unsigned int v3; // eax
int v4; // ecx
v1 = *a1;
v2 = a1[2];
v3 = my_checksum(
*((unsigned int *)a1 + 2),
*a1,
(unsigned __int16)__ROL2__(*(_WORD *)(*a1 + *(unsigned int *)(v2 + 1860) - 2), 8));
v4 = -3;
if ( v3 < 0xFFFFFFFD )
v4 = v3;
*(_DWORD *)(v1 + *(unsigned int *)(v2 + 1980) - 4) = v4;
return 0LL;
}
| maria_page_crc_set_index:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,qword ptr [RDI]
MOV EAX,dword ptr [RDI + 0x8]
MOV R14,qword ptr [RDI + 0x10]
MOV ECX,dword ptr [R14 + 0x744]
MOVZX ECX,word ptr [RBX + RCX*0x1 + -0x2]
ROL CX,0x8
MOVZX EDX,CX
MOV EDI,EAX
MOV RSI,RBX
CALL 0x001a7fe0
CMP EAX,-0x3
MOV ECX,0xfffffffd
CMOVC ECX,EAX
MOV EAX,dword ptr [R14 + 0x7bc]
MOV dword ptr [RBX + RAX*0x1 + -0x4],ECX
XOR EAX,EAX
POP RBX
POP R14
POP RBP
RET
|
int8 maria_page_crc_set_index(long *param_1)
{
ushort uVar1;
long lVar2;
long lVar3;
uint uVar4;
uint uVar5;
lVar2 = *param_1;
lVar3 = param_1[2];
uVar1 = *(ushort *)(lVar2 + -2 + (ulong)*(uint *)(lVar3 + 0x744));
uVar4 = my_checksum((int)param_1[1],lVar2,uVar1 << 8 | uVar1 >> 8);
uVar5 = 0xfffffffd;
if (uVar4 < 0xfffffffd) {
uVar5 = uVar4;
}
*(uint *)(lVar2 + -4 + (ulong)*(uint *)(lVar3 + 0x7bc)) = uVar5;
return 0;
}
| |
47,234 | nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>>::key() const | llama.cpp/common/json.hpp | const string_type& key() const
{
JSON_ASSERT(anchor.m_object != nullptr);
switch (anchor.m_object->type())
{
// use integer array index as key
case value_t::array:
{
if (array_index != array_index_last)
{
int_to_string( array_index_str, array_index );
array_index_last = array_index;
}
return array_index_str;
}
// use key from the object
case value_t::object:
return anchor.key();
// use an empty key for all primitive types
case value_t::null:
case value_t::string:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::binary:
case value_t::discarded:
default:
return empty_str;
}
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>>::key() const:
pushq %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x72af6
movq %rdi, %rbx
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x72ae4
cmpl $0x2, %eax
jne 0x72aed
movq 0x20(%rbx), %rsi
cmpq 0x28(%rbx), %rsi
je 0x72ade
leaq 0x30(%rbx), %rdi
callq 0x7a0ed
movq 0x20(%rbx), %rax
movq %rax, 0x28(%rbx)
addq $0x30, %rbx
jmp 0x72af1
movq %rbx, %rdi
popq %rbx
jmp 0x7436e
addq $0x50, %rbx
movq %rbx, %rax
popq %rbx
retq
leaq 0x5913e(%rip), %rdi # 0xcbc3b
leaq 0x5558c(%rip), %rdx # 0xc8090
leaq 0x5991b(%rip), %rcx # 0xcc426
movl $0x1491, %esi # imm = 0x1491
xorl %eax, %eax
callq 0x1ca40
nop
| _ZNK8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEE3keyEv:
push rbx
mov rax, [rdi]
test rax, rax
jz short loc_72AF6
mov rbx, rdi
movzx eax, byte ptr [rax]
cmp eax, 1
jz short loc_72AE4
cmp eax, 2
jnz short loc_72AED
mov rsi, [rbx+20h]
cmp rsi, [rbx+28h]
jz short loc_72ADE
lea rdi, [rbx+30h]
call _ZN8nlohmann16json_abi_v3_11_36detail13int_to_stringINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEvRT_m; nlohmann::json_abi_v3_11_3::detail::int_to_string<std::string>(std::string &,ulong)
mov rax, [rbx+20h]
mov [rbx+28h], rax
loc_72ADE:
add rbx, 30h ; '0'
jmp short loc_72AF1
loc_72AE4:
mov rdi, rbx
pop rbx
jmp _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE3keyEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::key(void)
loc_72AED:
add rbx, 50h ; 'P'
loc_72AF1:
mov rax, rbx
pop rbx
retn
loc_72AF6:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aAnchorMObjectN; "anchor.m_object != nullptr"
mov esi, 1491h
xor eax, eax
call _ggml_abort
nop
| long long nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>>::key(
unsigned __int8 **a1)
{
int v1; // eax
if ( *a1 )
{
v1 = **a1;
if ( v1 == 1 )
{
return nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::key(a1);
}
else
{
if ( v1 != 2 )
return (long long)(a1 + 10);
if ( a1[4] != a1[5] )
{
nlohmann::json_abi_v3_11_3::detail::int_to_string<std::string>(a1 + 6);
a1[5] = a1[4];
}
return (long long)(a1 + 6);
}
}
else
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
5265LL,
"GGML_ASSERT(%s) failed",
"anchor.m_object != nullptr");
return nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>>::~iteration_proxy_value("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp");
}
}
| key:
PUSH RBX
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x00172af6
MOV RBX,RDI
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x1
JZ 0x00172ae4
CMP EAX,0x2
JNZ 0x00172aed
MOV RSI,qword ptr [RBX + 0x20]
CMP RSI,qword ptr [RBX + 0x28]
JZ 0x00172ade
LEA RDI,[RBX + 0x30]
CALL 0x0017a0ed
MOV RAX,qword ptr [RBX + 0x20]
MOV qword ptr [RBX + 0x28],RAX
LAB_00172ade:
ADD RBX,0x30
JMP 0x00172af1
LAB_00172ae4:
MOV RDI,RBX
POP RBX
JMP 0x0017436e
LAB_00172aed:
ADD RBX,0x50
LAB_00172af1:
MOV RAX,RBX
POP RBX
RET
LAB_00172af6:
LEA RDI,[0x1cbc3b]
LEA RDX,[0x1c8090]
LEA RCX,[0x1cc426]
MOV ESI,0x1491
XOR EAX,EAX
CALL 0x0011ca40
|
/* nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const> >::key() const */
iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
* __thiscall
nlohmann::json_abi_v3_11_3::detail::
iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
::key(iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
*this)
{
char cVar1;
iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
*piVar2;
if (*(char **)this == (char *)0x0) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",0x1491,
"GGML_ASSERT(%s) failed","anchor.m_object != nullptr");
}
cVar1 = **(char **)this;
if (cVar1 != '\x01') {
if (cVar1 == '\x02') {
if (*(ulong *)(this + 0x20) != *(ulong *)(this + 0x28)) {
int_to_string<std::__cxx11::string>((string *)(this + 0x30),*(ulong *)(this + 0x20));
*(int8 *)(this + 0x28) = *(int8 *)(this + 0x20);
}
piVar2 = this + 0x30;
}
else {
piVar2 = this + 0x50;
}
return piVar2;
}
piVar2 = (iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
*)iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::key((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)this);
return piVar2;
}
| |
47,235 | mysql_select_db | eloqsql/libmariadb/libmariadb/mariadb_lib.c | int STDCALL
mysql_select_db(MYSQL *mysql, const char *db)
{
int error;
if (!db)
return 1;
if ((error=ma_simple_command(mysql, COM_INIT_DB, db,
(uint) strlen(db),0,0)))
return(error);
free(mysql->db);
mysql->db=strdup(db);
return(0);
} | O3 | c | mysql_select_db:
testq %rsi, %rsi
je 0x205fc
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x131c0
movl %eax, %ecx
movq 0x4d0(%rbx), %rax
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq *0x10(%rax)
testl %eax, %eax
jne 0x205f7
movq 0x2e8(%rbx), %rdi
callq 0x135a0
movq %r14, %rdi
callq 0x13820
movq %rax, 0x2e8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x1, %eax
retq
| mysql_select_db:
test rsi, rsi
jz short loc_205FC
push rbp
mov rbp, rsp
push r14
push rbx
mov r14, rsi
mov rbx, rdi
mov rdi, rsi
call _strlen
mov ecx, eax
mov rax, [rbx+4D0h]
mov rdi, rbx
mov esi, 2
mov rdx, r14
xor r8d, r8d
xor r9d, r9d
call qword ptr [rax+10h]
test eax, eax
jnz short loc_205F7
mov rdi, [rbx+2E8h]
call _free
mov rdi, r14
call _strdup
mov [rbx+2E8h], rax
xor eax, eax
loc_205F7:
pop rbx
pop r14
pop rbp
retn
loc_205FC:
mov eax, 1
retn
| long long mysql_select_db(long long a1, long long a2)
{
unsigned int v2; // eax
long long result; // rax
if ( !a2 )
return 1LL;
v2 = strlen(a2);
result = (*(long long ( **)(long long, long long, long long, _QWORD, _QWORD, _QWORD))(*(_QWORD *)(a1 + 1232) + 16LL))(
a1,
2LL,
a2,
v2,
0LL,
0LL);
if ( !(_DWORD)result )
{
free(*(_QWORD *)(a1 + 744));
*(_QWORD *)(a1 + 744) = strdup(a2);
return 0LL;
}
return result;
}
| mysql_select_db:
TEST RSI,RSI
JZ 0x001205fc
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
MOV RDI,RSI
CALL 0x001131c0
MOV ECX,EAX
MOV RAX,qword ptr [RBX + 0x4d0]
MOV RDI,RBX
MOV ESI,0x2
MOV RDX,R14
XOR R8D,R8D
XOR R9D,R9D
CALL qword ptr [RAX + 0x10]
TEST EAX,EAX
JNZ 0x001205f7
MOV RDI,qword ptr [RBX + 0x2e8]
CALL 0x001135a0
MOV RDI,R14
CALL 0x00113820
MOV qword ptr [RBX + 0x2e8],RAX
XOR EAX,EAX
LAB_001205f7:
POP RBX
POP R14
POP RBP
RET
LAB_001205fc:
MOV EAX,0x1
RET
|
int8 mysql_select_db(long param_1,char *param_2)
{
size_t sVar1;
int8 uVar2;
char *pcVar3;
if (param_2 != (char *)0x0) {
sVar1 = strlen(param_2);
uVar2 = (**(code **)(*(long *)(param_1 + 0x4d0) + 0x10))
(param_1,2,param_2,sVar1 & 0xffffffff,0,0);
if ((int)uVar2 == 0) {
free(*(void **)(param_1 + 0x2e8));
pcVar3 = strdup(param_2);
*(char **)(param_1 + 0x2e8) = pcVar3;
uVar2 = 0;
}
return uVar2;
}
return 1;
}
| |
47,236 | init_tree | eloqsql/mysys/tree.c | void init_tree(TREE *tree, size_t default_alloc_size, size_t memory_limit,
int size, qsort_cmp2 compare,
tree_element_free free_element, void *custom_arg,
myf my_flags)
{
DBUG_ENTER("init_tree");
DBUG_PRINT("enter",("tree: %p size: %d", tree, size));
if (default_alloc_size < DEFAULT_ALLOC_SIZE)
default_alloc_size= DEFAULT_ALLOC_SIZE;
default_alloc_size= MY_ALIGN(default_alloc_size, DEFAULT_ALIGN_SIZE);
tree->root= &null_element;
tree->compare=compare;
tree->size_of_element= size > 0 ? (uint) size : 0;
tree->memory_limit=memory_limit;
tree->free=free_element;
tree->allocated=0;
tree->elements_in_tree=0;
tree->custom_arg = custom_arg;
tree->my_flags= my_flags;
tree->flag= 0;
if (!free_element && size >= 0 &&
((uint) size <= sizeof(void*) || ((uint) size & (sizeof(void*)-1))))
{
/*
We know that the data doesn't have to be aligned (like if the key
contains a double), so we can store the data combined with the
TREE_ELEMENT.
*/
tree->offset_to_key=sizeof(TREE_ELEMENT); /* Put key after element */
/* Fix allocation size so that we don't lose any memory */
default_alloc_size/=(sizeof(TREE_ELEMENT)+size);
if (!default_alloc_size)
default_alloc_size=1;
default_alloc_size*=(sizeof(TREE_ELEMENT)+size);
}
else
{
tree->offset_to_key=0; /* use key through pointer */
tree->size_of_element+=sizeof(void*);
}
if (!(tree->with_delete= MY_TEST(my_flags & MY_TREE_WITH_DELETE)))
{
init_alloc_root(key_memory_TREE, &tree->mem_root, default_alloc_size, 0,
MYF(my_flags));
tree->mem_root.min_malloc= sizeof(TREE_ELEMENT)+tree->size_of_element;
}
DBUG_VOID_RETURN;
} | O0 | c | init_tree:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
jmp 0x34c99
cmpq $0x2000, -0x10(%rbp) # imm = 0x2000
jae 0x34cab
movq $0x2000, -0x10(%rbp) # imm = 0x2000
movq -0x10(%rbp), %rax
addq $0x2000, %rax # imm = 0x2000
subq $0x1, %rax
andq $-0x2000, %rax # imm = 0xE000
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
leaq 0x1a879a(%rip), %rcx # 0x1dd468
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x228(%rax)
cmpl $0x0, -0x1c(%rbp)
jle 0x34cee
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x34cf5
xorl %eax, %eax
movl %eax, -0x34(%rbp)
jmp 0x34cf5
movl -0x34(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x210(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x218(%rax)
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x280(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x220(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x20c(%rax)
movq 0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x230(%rax)
movq 0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x288(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x290(%rax)
cmpq $0x0, -0x30(%rbp)
jne 0x34dd1
cmpl $0x0, -0x1c(%rbp)
jl 0x34dd1
movl -0x1c(%rbp), %eax
cmpq $0x8, %rax
jbe 0x34d8c
movl -0x1c(%rbp), %eax
andq $0x7, %rax
cmpq $0x0, %rax
je 0x34dd1
movq -0x8(%rbp), %rax
movl $0x18, 0x208(%rax)
movslq -0x1c(%rbp), %rcx
addq $0x18, %rcx
movq -0x10(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x34dbe
movq $0x1, -0x10(%rbp)
movslq -0x1c(%rbp), %rax
addq $0x18, %rax
imulq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x34df3
movq -0x8(%rbp), %rax
movl $0x0, 0x208(%rax)
movq -0x8(%rbp), %rax
movl 0x210(%rax), %ecx
addq $0x8, %rcx
movl %ecx, 0x210(%rax)
movq 0x18(%rbp), %rdx
andq $0x40000, %rdx # imm = 0x40000
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movq -0x8(%rbp), %rcx
movb %al, 0x278(%rcx)
cmpb $0x0, %al
jne 0x34e5a
leaq 0x37922b(%rip), %rax # 0x3ae04c
movl (%rax), %edi
movq -0x8(%rbp), %rsi
addq $0x238, %rsi # imm = 0x238
movq -0x10(%rbp), %rdx
movq 0x18(%rbp), %r8
xorl %eax, %eax
movl %eax, %ecx
callq 0x3cab0
movq -0x8(%rbp), %rax
movl 0x210(%rax), %eax
movl %eax, %ecx
addq $0x18, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x250(%rax)
jmp 0x34e5c
jmp 0x34e5e
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| init_tree:
push rbp
mov rbp, rsp
sub rsp, 40h
mov rax, [rbp+arg_8]
mov rax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
jmp short $+2
loc_34C99:
cmp [rbp+var_10], 2000h
jnb short loc_34CAB
mov [rbp+var_10], 2000h
loc_34CAB:
mov rax, [rbp+var_10]
add rax, 2000h
sub rax, 1
and rax, 0FFFFFFFFFFFFE000h
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
lea rcx, null_element
mov [rax], rcx
mov rcx, [rbp+var_28]
mov rax, [rbp+var_8]
mov [rax+228h], rcx
cmp [rbp+var_1C], 0
jle short loc_34CEE
mov eax, [rbp+var_1C]
mov [rbp+var_34], eax
jmp short loc_34CF5
loc_34CEE:
xor eax, eax
mov [rbp+var_34], eax
jmp short $+2
loc_34CF5:
mov ecx, [rbp+var_34]
mov rax, [rbp+var_8]
mov [rax+210h], ecx
mov rcx, [rbp+var_18]
mov rax, [rbp+var_8]
mov [rax+218h], rcx
mov rcx, [rbp+var_30]
mov rax, [rbp+var_8]
mov [rax+280h], rcx
mov rax, [rbp+var_8]
mov qword ptr [rax+220h], 0
mov rax, [rbp+var_8]
mov dword ptr [rax+20Ch], 0
mov rcx, [rbp+arg_0]
mov rax, [rbp+var_8]
mov [rax+230h], rcx
mov rcx, [rbp+arg_8]
mov rax, [rbp+var_8]
mov [rax+288h], rcx
mov rax, [rbp+var_8]
mov dword ptr [rax+290h], 0
cmp [rbp+var_30], 0
jnz short loc_34DD1
cmp [rbp+var_1C], 0
jl short loc_34DD1
mov eax, [rbp+var_1C]
cmp rax, 8
jbe short loc_34D8C
mov eax, [rbp+var_1C]
and rax, 7
cmp rax, 0
jz short loc_34DD1
loc_34D8C:
mov rax, [rbp+var_8]
mov dword ptr [rax+208h], 18h
movsxd rcx, [rbp+var_1C]
add rcx, 18h
mov rax, [rbp+var_10]
xor edx, edx
div rcx
mov [rbp+var_10], rax
cmp [rbp+var_10], 0
jnz short loc_34DBE
mov [rbp+var_10], 1
loc_34DBE:
movsxd rax, [rbp+var_1C]
add rax, 18h
imul rax, [rbp+var_10]
mov [rbp+var_10], rax
jmp short loc_34DF3
loc_34DD1:
mov rax, [rbp+var_8]
mov dword ptr [rax+208h], 0
mov rax, [rbp+var_8]
mov ecx, [rax+210h]
add rcx, 8
mov [rax+210h], ecx
loc_34DF3:
mov rdx, [rbp+arg_8]
and rdx, 40000h
xor eax, eax
mov ecx, 1
cmp rdx, 0
cmovnz eax, ecx
mov rcx, [rbp+var_8]
mov [rcx+278h], al
cmp al, 0
jnz short loc_34E5A
lea rax, key_memory_TREE
mov edi, [rax]
mov rsi, [rbp+var_8]
add rsi, 238h
mov rdx, [rbp+var_10]
mov r8, [rbp+arg_8]
xor eax, eax
mov ecx, eax
call init_alloc_root
mov rax, [rbp+var_8]
mov eax, [rax+210h]
mov ecx, eax
add rcx, 18h
mov rax, [rbp+var_8]
mov [rax+250h], rcx
loc_34E5A:
jmp short $+2
loc_34E5C:
jmp short $+2
loc_34E5E:
add rsp, 40h
pop rbp
retn
| _BOOL8 init_tree(
long long a1,
unsigned long long a2,
long long a3,
int a4,
long long a5,
long long a6,
long long a7,
long long a8)
{
_BOOL8 result; // rax
int v9; // [rsp+Ch] [rbp-34h]
long long v10; // [rsp+30h] [rbp-10h]
unsigned long long v11; // [rsp+30h] [rbp-10h]
unsigned long long v12; // [rsp+30h] [rbp-10h]
v10 = a2;
if ( a2 < 0x2000 )
v10 = 0x2000LL;
v11 = (v10 + 0x1FFF) & 0xFFFFFFFFFFFFE000LL;
*(_QWORD *)a1 = &null_element;
*(_QWORD *)(a1 + 552) = a5;
if ( a4 <= 0 )
v9 = 0;
else
v9 = a4;
*(_DWORD *)(a1 + 528) = v9;
*(_QWORD *)(a1 + 536) = a3;
*(_QWORD *)(a1 + 640) = a6;
*(_QWORD *)(a1 + 544) = 0LL;
*(_DWORD *)(a1 + 524) = 0;
*(_QWORD *)(a1 + 560) = a7;
*(_QWORD *)(a1 + 648) = a8;
*(_DWORD *)(a1 + 656) = 0;
if ( a6 || a4 < 0 || (unsigned int)a4 > 8uLL && (a4 & 7) == 0 )
{
*(_DWORD *)(a1 + 520) = 0;
*(_DWORD *)(a1 + 528) += 8;
}
else
{
*(_DWORD *)(a1 + 520) = 24;
v12 = v11 / (a4 + 24LL);
if ( !v12 )
v12 = 1LL;
v11 = v12 * (a4 + 24LL);
}
result = (a8 & 0x40000) != 0;
*(_BYTE *)(a1 + 632) = result;
if ( (a8 & 0x40000) == 0 )
{
init_alloc_root(key_memory_TREE, a1 + 568, v11, 0LL, a8);
result = a1;
*(_QWORD *)(a1 + 592) = *(unsigned int *)(a1 + 528) + 24LL;
}
return result;
}
| init_tree:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV RAX,qword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
JMP 0x00134c99
LAB_00134c99:
CMP qword ptr [RBP + -0x10],0x2000
JNC 0x00134cab
MOV qword ptr [RBP + -0x10],0x2000
LAB_00134cab:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x2000
SUB RAX,0x1
AND RAX,-0x2000
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x2dd468]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x228],RCX
CMP dword ptr [RBP + -0x1c],0x0
JLE 0x00134cee
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x34],EAX
JMP 0x00134cf5
LAB_00134cee:
XOR EAX,EAX
MOV dword ptr [RBP + -0x34],EAX
JMP 0x00134cf5
LAB_00134cf5:
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x210],ECX
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x218],RCX
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x280],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x220],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x20c],0x0
MOV RCX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x230],RCX
MOV RCX,qword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x288],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x290],0x0
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x00134dd1
CMP dword ptr [RBP + -0x1c],0x0
JL 0x00134dd1
MOV EAX,dword ptr [RBP + -0x1c]
CMP RAX,0x8
JBE 0x00134d8c
MOV EAX,dword ptr [RBP + -0x1c]
AND RAX,0x7
CMP RAX,0x0
JZ 0x00134dd1
LAB_00134d8c:
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x208],0x18
MOVSXD RCX,dword ptr [RBP + -0x1c]
ADD RCX,0x18
MOV RAX,qword ptr [RBP + -0x10]
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x10],RAX
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x00134dbe
MOV qword ptr [RBP + -0x10],0x1
LAB_00134dbe:
MOVSXD RAX,dword ptr [RBP + -0x1c]
ADD RAX,0x18
IMUL RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00134df3
LAB_00134dd1:
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x208],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x210]
ADD RCX,0x8
MOV dword ptr [RAX + 0x210],ECX
LAB_00134df3:
MOV RDX,qword ptr [RBP + 0x18]
AND RDX,0x40000
XOR EAX,EAX
MOV ECX,0x1
CMP RDX,0x0
CMOVNZ EAX,ECX
MOV RCX,qword ptr [RBP + -0x8]
MOV byte ptr [RCX + 0x278],AL
CMP AL,0x0
JNZ 0x00134e5a
LEA RAX,[0x4ae04c]
MOV EDI,dword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x8]
ADD RSI,0x238
MOV RDX,qword ptr [RBP + -0x10]
MOV R8,qword ptr [RBP + 0x18]
XOR EAX,EAX
MOV ECX,EAX
CALL 0x0013cab0
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x210]
MOV ECX,EAX
ADD RCX,0x18
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x250],RCX
LAB_00134e5a:
JMP 0x00134e5c
LAB_00134e5c:
JMP 0x00134e5e
LAB_00134e5e:
ADD RSP,0x40
POP RBP
RET
|
void init_tree(int8 *param_1,ulong param_2,int8 param_3,uint param_4,int8 param_5,
long param_6,int8 param_7,ulong param_8)
{
bool bVar1;
uint local_3c;
ulong local_18;
local_18 = param_2;
if (param_2 < 0x2000) {
local_18 = 0x2000;
}
local_18 = local_18 + 0x1fff & 0xffffffffffffe000;
*param_1 = null_element;
param_1[0x45] = param_5;
local_3c = param_4;
if ((int)param_4 < 1) {
local_3c = 0;
}
*(uint *)(param_1 + 0x42) = local_3c;
param_1[0x43] = param_3;
param_1[0x50] = param_6;
param_1[0x44] = 0;
*(int4 *)((long)param_1 + 0x20c) = 0;
param_1[0x46] = param_7;
param_1[0x51] = param_8;
*(int4 *)(param_1 + 0x52) = 0;
if (((param_6 == 0) && (-1 < (int)param_4)) && ((param_4 < 9 || ((param_4 & 7) != 0)))) {
*(int4 *)(param_1 + 0x41) = 0x18;
local_18 = local_18 / ((long)(int)param_4 + 0x18U);
if (local_18 == 0) {
local_18 = 1;
}
local_18 = ((long)(int)param_4 + 0x18) * local_18;
}
else {
*(int4 *)(param_1 + 0x41) = 0;
*(int *)(param_1 + 0x42) = *(int *)(param_1 + 0x42) + 8;
}
bVar1 = (param_8 & 0x40000) != 0;
*(bool *)(param_1 + 0x4f) = bVar1;
if (!bVar1) {
init_alloc_root(key_memory_TREE,param_1 + 0x47,local_18,0,param_8);
param_1[0x4a] = (ulong)*(uint *)(param_1 + 0x42) + 0x18;
}
return;
}
| |
47,237 | cmp | eloqsql/strings/dtoa.c | static int cmp(Bigint *a, Bigint *b)
{
ULong *xa, *xa0, *xb, *xb0;
int i, j;
i= a->wds;
j= b->wds;
if (i-= j)
return i;
xa0= a->p.x;
xa= xa0 + j;
xb0= b->p.x;
xb= xb0 + j;
for (;;)
{
if (*--xa != *--xb)
return *xa < *xb ? -1 : 1;
if (xa <= xa0)
break;
}
return 0;
} | O0 | c | cmp:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %ecx
movl -0x3c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
je 0x730bb
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x73152
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movslq -0x40(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movslq -0x40(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $-0x4, %rcx
movq %rcx, -0x20(%rbp)
movl -0x4(%rax), %eax
movq -0x30(%rbp), %rcx
movq %rcx, %rdx
addq $-0x4, %rdx
movq %rdx, -0x30(%rbp)
cmpl -0x4(%rcx), %eax
je 0x7313d
movq -0x20(%rbp), %rax
movl (%rax), %edx
movq -0x30(%rbp), %rax
movl (%rax), %esi
movl $0x1, %eax
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
cmpl %esi, %edx
cmovbl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x73152
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
ja 0x73149
jmp 0x7314b
jmp 0x730f7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
| cmp:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov eax, [rax+14h]
mov [rbp+var_3C], eax
mov rax, [rbp+var_18]
mov eax, [rax+14h]
mov [rbp+var_40], eax
mov ecx, [rbp+var_40]
mov eax, [rbp+var_3C]
sub eax, ecx
mov [rbp+var_3C], eax
cmp eax, 0
jz short loc_730BB
mov eax, [rbp+var_3C]
mov [rbp+var_4], eax
jmp loc_73152
loc_730BB:
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
movsxd rcx, [rbp+var_40]
shl rcx, 2
add rax, rcx
mov [rbp+var_20], rax
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
movsxd rcx, [rbp+var_40]
shl rcx, 2
add rax, rcx
mov [rbp+var_30], rax
loc_730F7:
mov rax, [rbp+var_20]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_20], rcx
mov eax, [rax-4]
mov rcx, [rbp+var_30]
mov rdx, rcx
add rdx, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_30], rdx
cmp eax, [rcx-4]
jz short loc_7313D
mov rax, [rbp+var_20]
mov edx, [rax]
mov rax, [rbp+var_30]
mov esi, [rax]
mov eax, 1
mov ecx, 0FFFFFFFFh
cmp edx, esi
cmovb eax, ecx
mov [rbp+var_4], eax
jmp short loc_73152
loc_7313D:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
ja short loc_73149
jmp short loc_7314B
loc_73149:
jmp short loc_730F7
loc_7314B:
mov [rbp+var_4], 0
loc_73152:
mov eax, [rbp+var_4]
pop rbp
retn
| long long cmp(long long a1, long long a2)
{
_DWORD *v2; // rax
_DWORD *v3; // rcx
unsigned int v4; // eax
int v6; // [rsp+0h] [rbp-40h]
_DWORD *v7; // [rsp+10h] [rbp-30h]
_DWORD *v8; // [rsp+20h] [rbp-20h]
v6 = *(_DWORD *)(a2 + 20);
if ( *(_DWORD *)(a1 + 20) == v6 )
{
v8 = (_DWORD *)(4LL * v6 + *(_QWORD *)a1);
v7 = (_DWORD *)(4LL * v6 + *(_QWORD *)a2);
while ( 1 )
{
v2 = v8--;
v3 = v7--;
if ( *(v2 - 1) != *(v3 - 1) )
break;
if ( (unsigned long long)v8 <= *(_QWORD *)a1 )
return 0;
}
v4 = 1;
if ( *v8 < *v7 )
return (unsigned int)-1;
return v4;
}
else
{
return (unsigned int)(*(_DWORD *)(a1 + 20) - v6);
}
}
| cmp:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x14]
MOV dword ptr [RBP + -0x3c],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x14]
MOV dword ptr [RBP + -0x40],EAX
MOV ECX,dword ptr [RBP + -0x40]
MOV EAX,dword ptr [RBP + -0x3c]
SUB EAX,ECX
MOV dword ptr [RBP + -0x3c],EAX
CMP EAX,0x0
JZ 0x001730bb
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00173152
LAB_001730bb:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOVSXD RCX,dword ptr [RBP + -0x40]
SHL RCX,0x2
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOVSXD RCX,dword ptr [RBP + -0x40]
SHL RCX,0x2
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
LAB_001730f7:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,RAX
ADD RCX,-0x4
MOV qword ptr [RBP + -0x20],RCX
MOV EAX,dword ptr [RAX + -0x4]
MOV RCX,qword ptr [RBP + -0x30]
MOV RDX,RCX
ADD RDX,-0x4
MOV qword ptr [RBP + -0x30],RDX
CMP EAX,dword ptr [RCX + -0x4]
JZ 0x0017313d
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x30]
MOV ESI,dword ptr [RAX]
MOV EAX,0x1
MOV ECX,0xffffffff
CMP EDX,ESI
CMOVC EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00173152
LAB_0017313d:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JA 0x00173149
JMP 0x0017314b
LAB_00173149:
JMP 0x001730f7
LAB_0017314b:
MOV dword ptr [RBP + -0x4],0x0
LAB_00173152:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int cmp(void *param_1,void *param_2)
{
int iVar1;
uint *puVar2;
uint *local_38;
uint *local_28;
int local_c;
iVar1 = *(int *)((long)param_2 + 0x14);
local_c = *(int *)((long)param_1 + 0x14) - iVar1;
if (local_c == 0) {
/* WARNING: Load size is inaccurate */
/* WARNING: Load size is inaccurate */
local_38 = (uint *)(*param_2 + (long)iVar1 * 4);
local_28 = *param_1 + iVar1;
do {
puVar2 = local_28 + -1;
if (local_28[-1] != local_38[-1]) {
if (local_38[-1] <= *puVar2) {
return 1;
}
return -1;
}
local_38 = local_38 + -1;
local_28 = puVar2;
} while (*param_1 < puVar2);
local_c = 0;
}
return local_c;
}
| |
47,238 | convert_dirname | eloqsql/mysys/mf_dirname.c | char *convert_dirname(char *to, const char *from, const char *from_end)
{
char *to_org=to;
#ifdef BACKSLASH_MBTAIL
CHARSET_INFO *fs= fs_character_set();
#endif
DBUG_ENTER("convert_dirname");
/* We use -2 here, becasue we need place for the last FN_LIBCHAR */
if (!from_end || (from_end - from) > FN_REFLEN-2)
from_end=from+FN_REFLEN -2;
#if FN_LIBCHAR != '/'
{
for (; from != from_end && *from ; from++)
{
if (*from == '/')
*to++= FN_LIBCHAR;
else
{
#ifdef BACKSLASH_MBTAIL
uint l;
if (my_ci_use_mb(fs) && (l= my_ismbchar(fs, from, from + 3)))
{
memmove(to, from, l);
to+= l;
from+= l - 1;
to_org= to; /* Don't look inside mbchar */
}
else
#endif
{
*to++= *from;
}
}
}
*to=0;
}
#else
/* This is ok even if to == from, becasue we need to cut the string */
to= strmake(to, from, (size_t) (from_end-from));
#endif
/* Add FN_LIBCHAR to the end of directory path */
if (to != to_org && (to[-1] != FN_LIBCHAR && to[-1] != FN_DEVCHAR))
{
*to++=FN_LIBCHAR;
*to=0;
}
DBUG_RETURN(to); /* Pointer to end of dir */
} | O0 | c | convert_dirname:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2c8b6
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
cmpq $0x1fe, %rax # imm = 0x1FE
jle 0x2c8c8
movq -0x10(%rbp), %rax
addq $0x200, %rax # imm = 0x200
addq $-0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
subq %rax, %rdx
callq 0x76780
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x2c921
movq -0x8(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x2f, %eax
je 0x2c921
movq -0x8(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x0, %eax
je 0x2c921
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x2f, (%rax)
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
jmp 0x2c923
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| convert_dirname:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov [rbp+var_20], rax
cmp [rbp+var_18], 0
jz short loc_2C8B6
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
sub rax, rcx
cmp rax, 1FEh
jle short loc_2C8C8
loc_2C8B6:
mov rax, [rbp+var_10]
add rax, 200h
add rax, 0FFFFFFFFFFFFFFFEh
mov [rbp+var_18], rax
loc_2C8C8:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rax, [rbp+var_10]
sub rdx, rax
call strmake
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
cmp rax, [rbp+var_20]
jz short loc_2C921
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax-1]
cmp eax, 2Fh ; '/'
jz short loc_2C921
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax-1]
cmp eax, 0
jz short loc_2C921
mov rax, [rbp+var_8]
mov rcx, rax
add rcx, 1
mov [rbp+var_8], rcx
mov byte ptr [rax], 2Fh ; '/'
mov rax, [rbp+var_8]
mov byte ptr [rax], 0
loc_2C921:
jmp short $+2
loc_2C923:
mov rax, [rbp+var_8]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
add rsp, 30h
pop rbp
retn
| _BYTE * convert_dirname(_BYTE *a1, long long a2, long long a3)
{
_BYTE *v3; // rax
long long v5; // [rsp+18h] [rbp-18h]
_BYTE *v6; // [rsp+28h] [rbp-8h]
v5 = a3;
if ( !a3 || a3 - a2 > 510 )
v5 = a2 + 510;
v6 = (_BYTE *)strmake(a1, a2, v5 - a2);
if ( v6 != a1 && *(v6 - 1) != 47 && *(v6 - 1) )
{
v3 = v6++;
*v3 = 47;
*v6 = 0;
}
return v6;
}
| convert_dirname:
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 RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x18],0x0
JZ 0x0012c8b6
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
SUB RAX,RCX
CMP RAX,0x1fe
JLE 0x0012c8c8
LAB_0012c8b6:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x200
ADD RAX,-0x2
MOV qword ptr [RBP + -0x18],RAX
LAB_0012c8c8:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
SUB RDX,RAX
CALL 0x00176780
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x20]
JZ 0x0012c921
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX + -0x1]
CMP EAX,0x2f
JZ 0x0012c921
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX + -0x1]
CMP EAX,0x0
JZ 0x0012c921
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x8],RCX
MOV byte ptr [RAX],0x2f
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX],0x0
LAB_0012c921:
JMP 0x0012c923
LAB_0012c923:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RSP,0x30
POP RBP
RET
|
int1 * convert_dirname(int1 *param_1,long param_2,long param_3)
{
int1 *puVar1;
long local_20;
int1 *local_10;
if ((param_3 == 0) || (local_20 = param_3, 0x1fe < param_3 - param_2)) {
local_20 = param_2 + 0x1fe;
}
puVar1 = (int1 *)strmake(param_1,param_2,local_20 - param_2);
local_10 = puVar1;
if (((puVar1 != param_1) && (puVar1[-1] != '/')) && (puVar1[-1] != '\0')) {
local_10 = puVar1 + 1;
*puVar1 = 0x2f;
*local_10 = 0;
}
return local_10;
}
| |
47,239 | int minja::Value::get<int>() const | monkey531[P]llama/common/minja.hpp | T get() const {
if (is_primitive()) return primitive_.get<T>();
throw std::runtime_error("get<T> not defined for this value type: " + dump());
} | O0 | cpp | int minja::Value::get<int>() const:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x112670
testb $0x1, %al
jne 0x12b7de
jmp 0x12b7f1
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
callq 0x12b9b0
addq $0x68, %rsp
retq
movb $0x1, 0x13(%rsp)
movl $0x10, %edi
callq 0x5a680
movq 0x8(%rsp), %rsi
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x1126f0
jmp 0x12b81c
leaq 0xe4f0b(%rip), %rsi # 0x21072e
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0xf6d00
jmp 0x12b834
movq (%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x5a4b0
jmp 0x12b844
movq (%rsp), %rdi
movb $0x0, 0x13(%rsp)
movq 0x17675c(%rip), %rsi # 0x2a1fb0
movq 0x17671d(%rip), %rdx # 0x2a1f78
callq 0x5aae0
jmp 0x12b8c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x12b8a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x12b89a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x5b528
leaq 0x20(%rsp), %rdi
callq 0x5b528
testb $0x1, 0x13(%rsp)
jne 0x12b8ad
jmp 0x12b8b6
movq (%rsp), %rdi
callq 0x5af50
jmp 0x12b8b8
movq 0x18(%rsp), %rdi
callq 0x5aba0
nopw %cs:(%rax,%rax)
nopl (%rax)
| _ZNK5minja5Value3getIiEET_v:
sub rsp, 68h
mov [rsp+68h+var_8], rdi
mov rdi, [rsp+68h+var_8]; this
mov [rsp+68h+var_60], rdi
call _ZNK5minja5Value12is_primitiveEv; minja::Value::is_primitive(void)
test al, 1
jnz short loc_12B7DE
jmp short loc_12B7F1
loc_12B7DE:
mov rdi, [rsp+68h+var_60]
add rdi, 40h ; '@'
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE3getIiiEEDTcldtclL_ZSt7declvalIRKSD_EDTcl9__declvalIT_ELi0EEEvEE8get_implIT0_EtlNS0_6detail12priority_tagILj4EEEEEEv
add rsp, 68h
retn
loc_12B7F1:
mov [rsp+68h+var_55], 1
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rsi, [rsp+68h+var_60]
mov [rsp+68h+var_68], rax
lea rdi, [rsp+68h+var_48]
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
jmp short $+2
loc_12B81C:
lea rsi, aGetTNotDefined; "get<T> not defined for this value type:"...
lea rdi, [rsp+68h+var_28]
lea rdx, [rsp+68h+var_48]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
jmp short $+2
loc_12B834:
mov rdi, [rsp+68h+var_68]
lea rsi, [rsp+68h+var_28]
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
jmp short $+2
loc_12B844:
mov rdi, [rsp+68h+var_68]; void *
mov [rsp+68h+var_55], 0
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
| long long minja::Value::get<int>(minja::Value *a1)
{
void *exception; // [rsp+0h] [rbp-68h]
_BYTE v3[32]; // [rsp+20h] [rbp-48h] BYREF
_BYTE v4[32]; // [rsp+40h] [rbp-28h] BYREF
minja::Value *v5; // [rsp+60h] [rbp-8h]
v5 = a1;
if ( (minja::Value::is_primitive(a1) & 1) == 0 )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v3, (long long)a1, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v4, (long long)"get<T> not defined for this value type: ", (long long)v3);
std::runtime_error::runtime_error(exception, v4);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::get<int,int>((char *)a1 + 64);
}
| |||
47,240 | int minja::Value::get<int>() const | monkey531[P]llama/common/minja.hpp | T get() const {
if (is_primitive()) return primitive_.get<T>();
throw std::runtime_error("get<T> not defined for this value type: " + dump());
} | O2 | cpp | int minja::Value::get<int>() const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
callq 0x62ccc
testb %al, %al
je 0x6aefe
addq $0x40, %r14
movq %r14, %rdi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x6afc2
pushq $0x10
popq %rdi
callq 0x23450
movq %rax, %rbx
movq %rsp, %rdi
pushq $-0x1
popq %rdx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x62cdc
leaq 0x47e17(%rip), %rsi # 0xb2d37
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x58306
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x23e10
xorl %ebp, %ebp
movq 0x920aa(%rip), %rsi # 0xfcff0
movq 0x9200b(%rip), %rdx # 0xfcf58
movq %rbx, %rdi
callq 0x23ee0
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x241a8
jmp 0x6af6a
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0x241a8
testb %bpl, %bpl
jne 0x6af7c
jmp 0x6af84
movq %rax, %r14
movq %rbx, %rdi
callq 0x23680
movq %r14, %rdi
callq 0x23f70
| _ZNK5minja5Value3getIiEET_v:
push rbp
push r14
push rbx
sub rsp, 40h
mov r14, rdi
call _ZNK5minja5Value12is_primitiveEv; minja::Value::is_primitive(void)
test al, al
jz short loc_6AEFE
add r14, 40h ; '@'
mov rdi, r14
add rsp, 40h
pop rbx
pop r14
pop rbp
jmp _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIiTnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE
loc_6AEFE:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, rsp
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rsi, r14
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aGetTNotDefined; "get<T> not defined for this value type:"...
lea rdi, [rsp+58h+var_38]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+58h+var_38]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rdi, [rsp+58h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_6AF6A
mov r14, rax
mov bpl, 1
loc_6AF6A:
mov rdi, rsp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_6AF7C
jmp short loc_6AF84
mov r14, rax
loc_6AF7C:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_6AF84:
mov rdi, r14
call __Unwind_Resume
| long long minja::Value::get<int>(minja::Value *a1)
{
void *exception; // rbx
_BYTE v3[32]; // [rsp+0h] [rbp-58h] BYREF
_BYTE v4[56]; // [rsp+20h] [rbp-38h] BYREF
if ( !minja::Value::is_primitive(a1) )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v3, (long long)a1, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v4, (long long)"get<T> not defined for this value type: ", (long long)v3);
std::runtime_error::runtime_error(exception, v4);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIiTnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE((char *)a1 + 64);
}
| get<int>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RDI
CALL 0x00162ccc
TEST AL,AL
JZ 0x0016aefe
ADD R14,0x40
MOV RDI,R14
ADD RSP,0x40
POP RBX
POP R14
POP RBP
JMP 0x0016afc2
LAB_0016aefe:
PUSH 0x10
POP RDI
CALL 0x00123450
MOV RBX,RAX
LAB_0016af09:
MOV RDI,RSP
PUSH -0x1
POP RDX
MOV RSI,R14
XOR ECX,ECX
CALL 0x00162cdc
LAB_0016af19:
LEA RSI,[0x1b2d37]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x00158306
MOV BPL,0x1
LAB_0016af30:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x00123e10
XOR EBP,EBP
MOV RSI,qword ptr [0x001fcff0]
MOV RDX,qword ptr [0x001fcf58]
MOV RDI,RBX
CALL 0x00123ee0
|
/* int minja::Value::get<int>() const */
int __thiscall minja::Value::get<int>(Value *this)
{
runtime_error *this_00;
char cVar1;
int iVar2;
int1 auStack_58 [32];
string local_38 [32];
cVar1 = is_primitive(this);
if (cVar1 != '\0') {
iVar2 = _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIiTnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE
(this + 0x40);
return iVar2;
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0016af09 to 0016af18 has its CatchHandler @ 0016af79 */
dump_abi_cxx11_((int)auStack_58,SUB81(this,0));
/* try { // try from 0016af19 to 0016af2c has its CatchHandler @ 0016af64 */
std::operator+((char *)local_38,(string *)"get<T> not defined for this value type: ");
/* try { // try from 0016af30 to 0016af54 has its CatchHandler @ 0016af55 */
std::runtime_error::runtime_error(this_00,local_38);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_001fcff0,PTR__runtime_error_001fcf58);
}
| |
47,241 | int minja::Value::get<int>() const | monkey531[P]llama/common/minja.hpp | T get() const {
if (is_primitive()) return primitive_.get<T>();
throw std::runtime_error("get<T> not defined for this value type: " + dump());
} | O3 | cpp | int minja::Value::get<int>() const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
jne 0x90473
cmpq $0x0, 0x20(%r14)
jne 0x90473
cmpq $0x0, 0x30(%r14)
jne 0x90473
addq $0x40, %r14
leaq 0x20(%rsp), %rbx
movl $0x0, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x90541
movl (%rbx), %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x1a430
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x860aa
leaq 0x5e8be(%rip), %rsi # 0xeed57
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x78771
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x1adf0
xorl %ebp, %ebp
movq 0x9ab31(%rip), %rsi # 0x12aff0
movq 0x9aa9a(%rip), %rdx # 0x12af60
movq %rbx, %rdi
callq 0x1aee0
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x904ec
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a8b0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x90507
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a8b0
testb %bpl, %bpl
jne 0x90531
jmp 0x90539
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x90531
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a8b0
jmp 0x90531
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a660
movq %r14, %rdi
callq 0x1af70
| _ZNK5minja5Value3getIiEET_v:
push rbp
push r14
push rbx
sub rsp, 40h
mov r14, rdi
cmp qword ptr [rdi+10h], 0
jnz short loc_90473
cmp qword ptr [r14+20h], 0
jnz short loc_90473
cmp qword ptr [r14+30h], 0
jnz short loc_90473
add r14, 40h ; '@'
lea rbx, [rsp+58h+var_38]
mov dword ptr [rbx], 0
mov rdi, r14
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEiTnNSt9enable_ifIXaaaaaaaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_17number_unsigned_tEEE5valuentsr3std7is_sameISH_NSI_16number_integer_tEEE5valuentsr3std7is_sameISH_NSI_14number_float_tEEE5valuentsr3std7is_sameISH_NSI_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_
mov eax, [rbx]
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
loc_90473:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, rsp
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aGetTNotDefined; "get<T> not defined for this value type:"...
lea rdi, [rsp+58h+var_38]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+58h+var_38]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+58h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_904EC
mov rsi, [rsp+58h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_904EC:
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_90507
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_90507:
test bpl, bpl
jnz short loc_90531
jmp short loc_90539
mov r14, rax
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_90531
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_90531
mov r14, rax
loc_90531:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_90539:
mov rdi, r14
call __Unwind_Resume
| long long minja::Value::get<int>(_QWORD *a1)
{
void *exception; // rbx
_BYTE v3[16]; // [rsp+0h] [rbp-58h] BYREF
_DWORD v4[4]; // [rsp+20h] [rbp-38h] BYREF
if ( a1[2] || a1[4] || a1[6] )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v3, (long long)a1, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v4, (long long)"get<T> not defined for this value type: ", (long long)v3);
std::runtime_error::runtime_error(exception, v4);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v4[0] = 0;
ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEiTnNSt9enable_ifIXaaaaaaaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_17number_unsigned_tEEE5valuentsr3std7is_sameISH_NSI_16number_integer_tEEE5valuentsr3std7is_sameISH_NSI_14number_float_tEEE5valuentsr3std7is_sameISH_NSI_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_(
a1 + 8,
v4);
return v4[0];
}
| get<int>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RDI
CMP qword ptr [RDI + 0x10],0x0
JNZ 0x00190473
CMP qword ptr [R14 + 0x20],0x0
JNZ 0x00190473
CMP qword ptr [R14 + 0x30],0x0
JNZ 0x00190473
ADD R14,0x40
LEA RBX,[RSP + 0x20]
MOV dword ptr [RBX],0x0
MOV RDI,R14
MOV RSI,RBX
CALL 0x00190541
MOV EAX,dword ptr [RBX]
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
LAB_00190473:
MOV EDI,0x10
CALL 0x0011a430
MOV RBX,RAX
LAB_00190480:
MOV RDI,RSP
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x001860aa
LAB_00190492:
LEA RSI,[0x1eed57]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x00178771
MOV BPL,0x1
LAB_001904a9:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x0011adf0
XOR EBP,EBP
MOV RSI,qword ptr [0x0022aff0]
MOV RDX,qword ptr [0x0022af60]
MOV RDI,RBX
CALL 0x0011aee0
|
/* int minja::Value::get<int>() const */
int __thiscall minja::Value::get<int>(Value *this)
{
runtime_error *this_00;
int1 auStack_58 [32];
int local_38 [8];
if (((*(long *)(this + 0x10) == 0) && (*(long *)(this + 0x20) == 0)) &&
(*(long *)(this + 0x30) == 0)) {
local_38[0] = 0;
_ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEiTnNSt9enable_ifIXaaaaaaaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_17number_unsigned_tEEE5valuentsr3std7is_sameISH_NSI_16number_integer_tEEE5valuentsr3std7is_sameISH_NSI_14number_float_tEEE5valuentsr3std7is_sameISH_NSI_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_
(this + 0x40,local_38);
return local_38[0];
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00190480 to 00190491 has its CatchHandler @ 0019052e */
dump_abi_cxx11_((int)auStack_58,SUB81(this,0));
/* try { // try from 00190492 to 001904a5 has its CatchHandler @ 0019050e */
std::operator+((char *)local_38,(string *)"get<T> not defined for this value type: ");
/* try { // try from 001904a9 to 001904cd has its CatchHandler @ 001904ce */
std::runtime_error::runtime_error(this_00,(string *)local_38);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_0022aff0,PTR__runtime_error_0022af60);
}
| |
47,242 | Item_func_neg::fix_length_and_dec_int() | eloqsql/sql/item_func.cc | void Item_func_neg::fix_length_and_dec_int()
{
max_length= args[0]->max_length + 1;
set_handler(type_handler_long_or_longlong());
/*
If this is in integer context keep the context as integer if possible
(This is how multiplication and other integer functions works)
Use val() to get value as arg_type doesn't mean that item is
Item_int or Item_float due to existence of Item_param.
*/
if (args[0]->const_item())
{
longlong val= args[0]->val_int();
if ((ulonglong) val >= (ulonglong) LONGLONG_MIN &&
((ulonglong) val != (ulonglong) LONGLONG_MIN ||
!args[0]->is_of_type(CONST_ITEM, INT_RESULT)))
{
/*
Ensure that result is converted to DECIMAL, as longlong can't hold
the negated number
*/
set_handler(&type_handler_newdecimal);
DBUG_PRINT("info", ("Type changed: DECIMAL_RESULT"));
}
}
unsigned_flag= false;
} | O0 | cpp | Item_func_neg::fix_length_and_dec_int():
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq 0x70(%rdi), %rax
movq (%rax), %rax
movl 0x8(%rax), %eax
addl $0x1, %eax
movl %eax, 0x8(%rdi)
movq %rdi, %rax
addq $0xa8, %rax
movq %rax, -0x20(%rbp)
callq 0xb0f030
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x827d20
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x208(%rax)
testb $0x1, %al
jne 0xc96cac
jmp 0xc96d1f
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0xf0(%rax)
movq %rax, -0x10(%rbp)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
cmpq %rax, -0x10(%rbp)
jb 0xc96d1d
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
cmpq %rax, -0x10(%rbp)
jne 0xc96d02
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
movq (%rax), %rdi
movl $0x4, %esi
movl $0x2, %edx
callq 0xc08100
testb $0x1, %al
jne 0xc96d1d
movq -0x18(%rbp), %rdi
addq $0xa8, %rdi
leaq 0x106487c(%rip), %rsi # 0x1cfb590
callq 0x827d20
jmp 0xc96d1b
jmp 0xc96d1d
jmp 0xc96d1f
movq -0x18(%rbp), %rax
movb $0x0, 0xe(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| _ZN13Item_func_neg22fix_length_and_dec_intEv:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]; this
mov [rbp+var_18], rdi
mov rax, [rdi+70h]
mov rax, [rax]
mov eax, [rax+8]
add eax, 1
mov [rdi+8], eax
mov rax, rdi
add rax, 0A8h
mov [rbp+var_20], rax
call _ZNK4Item29type_handler_long_or_longlongEv; Item::type_handler_long_or_longlong(void)
mov rdi, [rbp+var_20]; this
mov rsi, rax; Type_handler *
call _ZN30Type_handler_hybrid_field_type11set_handlerEPK12Type_handler; Type_handler_hybrid_field_type::set_handler(Type_handler const*)
mov rax, [rbp+var_18]
mov rax, [rax+70h]
mov rdi, [rax]
mov rax, [rdi]
call qword ptr [rax+208h]
test al, 1
jnz short loc_C96CAC
jmp short loc_C96D1F
loc_C96CAC:
mov rax, [rbp+var_18]
mov rax, [rax+70h]
mov rdi, [rax]
mov rax, [rdi]
call qword ptr [rax+0F0h]
mov [rbp+var_10], rax
mov rax, 8000000000000000h
cmp [rbp+var_10], rax
jb short loc_C96D1D
mov rax, 8000000000000000h
cmp [rbp+var_10], rax
jnz short loc_C96D02
mov rax, [rbp+var_18]
mov rax, [rax+70h]
mov rdi, [rax]
mov esi, 4
mov edx, 2
call _ZNK4Item10is_of_typeENS_4TypeE11Item_result; Item::is_of_type(Item::Type,Item_result)
test al, 1
jnz short loc_C96D1D
loc_C96D02:
mov rdi, [rbp+var_18]
add rdi, 0A8h; this
lea rsi, type_handler_newdecimal; Type_handler *
call _ZN30Type_handler_hybrid_field_type11set_handlerEPK12Type_handler; Type_handler_hybrid_field_type::set_handler(Type_handler const*)
jmp short $+2
loc_C96D1B:
jmp short $+2
loc_C96D1D:
jmp short $+2
loc_C96D1F:
mov rax, [rbp+var_18]
mov byte ptr [rax+0Eh], 0
add rsp, 20h
pop rbp
retn
| Item_func_neg * Item_func_neg::fix_length_and_dec_int(Item_func_neg *this)
{
const Type_handler *v1; // rsi
Item_func_neg *result; // rax
unsigned long long v3; // [rsp+10h] [rbp-10h]
*((_DWORD *)this + 2) = *(_DWORD *)(**((_QWORD **)this + 14) + 8LL) + 1;
v1 = (const Type_handler *)Item::type_handler_long_or_longlong(this);
Type_handler_hybrid_field_type::set_handler((Item_func_neg *)((char *)this + 168), v1);
if ( ((*(long long ( **)(_QWORD))(***((_QWORD ***)this + 14) + 520LL))(**((_QWORD **)this + 14)) & 1) != 0 )
{
v3 = (*(long long ( **)(_QWORD))(***((_QWORD ***)this + 14) + 240LL))(**((_QWORD **)this + 14));
if ( v3 >= 0x8000000000000000LL && (v3 != 0x8000000000000000LL || !Item::is_of_type(**((Item ***)this + 14), 4, 2)) )
Type_handler_hybrid_field_type::set_handler(
(Item_func_neg *)((char *)this + 168),
(const Type_handler *)&type_handler_newdecimal);
}
result = this;
*((_BYTE *)this + 14) = 0;
return result;
}
| Item_func_coalesce:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RDI
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x00c9b050
MOV RAX,qword ptr [RBP + -0x20]
LEA RCX,[0x1b0a1f8]
ADD RCX,0x10
MOV qword ptr [RAX],RCX
ADD RSP,0x20
POP RBP
RET
|
/* Item_func_coalesce::Item_func_coalesce(THD*, List<Item>&) */
void __thiscall
Item_func_coalesce::Item_func_coalesce(Item_func_coalesce *this,THD *param_1,List *param_2)
{
Item_func_case_expression::Item_func_case_expression
((Item_func_case_expression *)this,param_1,param_2);
*(int ***)this = &PTR__Item_func_coalesce_01b0a208;
return;
}
| |
47,243 | 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::input_stream_adapter>::scan_comment() | llama.cpp/common/json.hpp | bool scan_comment()
{
switch (get())
{
// single-line comments skip input until a newline or EOF is read
case '/':
{
while (true)
{
switch (get())
{
case '\n':
case '\r':
case char_traits<char_type>::eof():
case '\0':
return true;
default:
break;
}
}
}
// multi-line comments skip input until */ is read
case '*':
{
while (true)
{
switch (get())
{
case char_traits<char_type>::eof():
case '\0':
{
error_message = "invalid comment; missing closing '*/'";
return false;
}
case '*':
{
switch (get())
{
case '/':
return true;
default:
{
unget();
continue;
}
}
}
default:
continue;
}
}
}
// unexpected character after reading '/'
default:
{
error_message = "invalid comment; expecting '/' or '*' after '/'";
return false;
}
}
} | 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::input_stream_adapter>::scan_comment():
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x27332
cmpl $0x2f, %eax
je 0xe6fd1
cmpl $0x2a, %eax
jne 0xe6fee
movq %rbx, %rdi
callq 0x27332
leal 0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0xe6ff7
cmpl $0x2a, %eax
jne 0xe6fa5
movq %rbx, %rdi
callq 0x27332
cmpl $0x2f, %eax
je 0xe6fea
movq %rbx, %rdi
callq 0xe7860
jmp 0xe6fa5
movl $0x4803, %ebp # imm = 0x4803
movq %rbx, %rdi
callq 0x27332
incl %eax
cmpl $0xf, %eax
jae 0xe6fd6
btl %eax, %ebp
jae 0xe6fd6
movb $0x1, %al
jmp 0xe7004
leaq 0x8e5c8(%rip), %rax # 0x1755bd
jmp 0xe6ffe
leaq 0x8e599(%rip), %rax # 0x175597
movq %rax, 0x70(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
| _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE12scan_commentEv:
push rbp
push rbx
push rax
mov rbx, rdi
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE3getEv; 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::input_stream_adapter>::get(void)
cmp eax, 2Fh ; '/'
jz short loc_E6FD1
cmp eax, 2Ah ; '*'
jnz short loc_E6FEE
loc_E6FA5:
mov rdi, rbx; this
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE3getEv; 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::input_stream_adapter>::get(void)
lea ecx, [rax+1]
cmp ecx, 2
jb short loc_E6FF7
cmp eax, 2Ah ; '*'
jnz short loc_E6FA5
mov rdi, rbx; this
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE3getEv; 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::input_stream_adapter>::get(void)
cmp eax, 2Fh ; '/'
jz short loc_E6FEA
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE5ungetEv; 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::input_stream_adapter>::unget(void)
jmp short loc_E6FA5
loc_E6FD1:
mov ebp, 4803h
loc_E6FD6:
mov rdi, rbx; this
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE3getEv; 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::input_stream_adapter>::get(void)
inc eax
cmp eax, 0Fh
jnb short loc_E6FD6
bt ebp, eax
jnb short loc_E6FD6
loc_E6FEA:
mov al, 1
jmp short loc_E7004
loc_E6FEE:
lea rax, aInvalidComment; "invalid comment; expecting '/' or '*' a"...
jmp short loc_E6FFE
loc_E6FF7:
lea rax, aInvalidComment_0; "invalid comment; missing closing '*/'"
loc_E6FFE:
mov [rbx+70h], rax
xor eax, eax
loc_E7004:
add rsp, 8
pop rbx
pop rbp
retn
| char 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::input_stream_adapter>::scan_comment(
__m128i *this)
{
int v1; // eax
int v2; // eax
int v3; // ebp
unsigned int v4; // eax
const char *v6; // rax
v1 = 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::input_stream_adapter>::get(this);
if ( v1 == 47 )
{
v3 = 18435;
do
{
do
v4 = 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::input_stream_adapter>::get(this)
+ 1;
while ( v4 >= 0xF );
}
while ( !_bittest(&v3, v4) );
return 1;
}
else
{
if ( v1 == 42 )
{
while ( 1 )
{
v2 = 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::input_stream_adapter>::get(this);
if ( (unsigned int)(v2 + 1) < 2 )
break;
if ( v2 == 42 )
{
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::input_stream_adapter>::get(this) == 47 )
return 1;
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::input_stream_adapter>::unget(this);
}
}
v6 = "invalid comment; missing closing '*/'";
}
else
{
v6 = "invalid comment; expecting '/' or '*' after '/'";
}
this[7].m128i_i64[0] = (long long)v6;
return 0;
}
}
| scan_comment:
PUSH RBP
PUSH RBX
PUSH RAX
MOV RBX,RDI
CALL 0x00127332
CMP EAX,0x2f
JZ 0x001e6fd1
CMP EAX,0x2a
JNZ 0x001e6fee
LAB_001e6fa5:
MOV RDI,RBX
CALL 0x00127332
LEA ECX,[RAX + 0x1]
CMP ECX,0x2
JC 0x001e6ff7
CMP EAX,0x2a
JNZ 0x001e6fa5
MOV RDI,RBX
CALL 0x00127332
CMP EAX,0x2f
JZ 0x001e6fea
MOV RDI,RBX
CALL 0x001e7860
JMP 0x001e6fa5
LAB_001e6fd1:
MOV EBP,0x4803
LAB_001e6fd6:
MOV RDI,RBX
CALL 0x00127332
INC EAX
CMP EAX,0xf
JNC 0x001e6fd6
BT EBP,EAX
JNC 0x001e6fd6
LAB_001e6fea:
MOV AL,0x1
JMP 0x001e7004
LAB_001e6fee:
LEA RAX,[0x2755bd]
JMP 0x001e6ffe
LAB_001e6ff7:
LEA RAX,[0x275597]
LAB_001e6ffe:
MOV qword ptr [RBX + 0x70],RAX
XOR EAX,EAX
LAB_001e7004:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
/* 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::input_stream_adapter>::scan_comment() */
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::input_stream_adapter>
::scan_comment(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::input_stream_adapter>
*this)
{
int iVar1;
int8 uVar2;
char *pcVar3;
iVar1 = get(this);
if (iVar1 == 0x2f) {
do {
do {
iVar1 = get(this);
} while (0xe < iVar1 + 1U);
} while ((0x4803U >> (iVar1 + 1U & 0x1f) & 1) == 0);
LAB_001e6fea:
uVar2 = 1;
}
else {
if (iVar1 == 0x2a) {
while (iVar1 = get(this), 1 < iVar1 + 1U) {
if (iVar1 == 0x2a) {
iVar1 = get(this);
if (iVar1 == 0x2f) goto LAB_001e6fea;
unget(this);
}
}
pcVar3 = "invalid comment; missing closing \'*/\'";
}
else {
pcVar3 = "invalid comment; expecting \'/\' or \'*\' after \'/\'";
}
*(char **)(this + 0x70) = pcVar3;
uVar2 = 0;
}
return uVar2;
}
| |
47,244 | my_l10tostr_mb2_or_mb4 | eloqsql/strings/ctype-ucs2.c | static size_t
my_l10tostr_mb2_or_mb4(CHARSET_INFO *cs,
char *dst, size_t len, int radix, long int val)
{
char buffer[66];
register char *p, *db, *de;
long int new_val;
int sl= 0;
unsigned long int uval = (unsigned long int) val;
p= &buffer[sizeof(buffer) - 1];
*p= '\0';
if (radix < 0)
{
if (val < 0)
{
sl= 1;
/* Avoid integer overflow in (-val) for LONGLONG_MIN (BUG#31799). */
uval = (unsigned long int)0 - uval;
}
}
new_val = (long) (uval / 10);
*--p = '0'+ (char) (uval - (unsigned long) new_val * 10);
val= new_val;
while (val != 0)
{
new_val= val / 10;
*--p= '0' + (char) (val - new_val * 10);
val= new_val;
}
if (sl)
{
*--p= '-';
}
for ( db= dst, de= dst + len ; (dst < de) && *p ; p++)
{
int cnvres= my_ci_wc_mb(cs, (my_wc_t) p[0], (uchar*) dst, (uchar*) de);
if (cnvres > 0)
dst+= cnvres;
else
break;
}
return (int) (dst - db);
} | O0 | c | my_l10tostr_mb2_or_mb4:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x58(%rbp)
movq %rsi, -0x60(%rbp)
movq %rdx, -0x68(%rbp)
movl %ecx, -0x6c(%rbp)
movq %r8, -0x78(%rbp)
movl $0x0, -0x9c(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x50(%rbp), %rax
addq $0x41, %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movb $0x0, (%rax)
cmpl $0x0, -0x6c(%rbp)
jge 0x58abc
cmpq $0x0, -0x78(%rbp)
jge 0x58aba
movl $0x1, -0x9c(%rbp)
xorl %eax, %eax
subq -0xa8(%rbp), %rax
movq %rax, -0xa8(%rbp)
jmp 0x58abc
movq -0xa8(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x98(%rbp)
movq -0xa8(%rbp), %rax
imulq $0xa, -0x98(%rbp), %rcx
subq %rcx, %rax
movsbl %al, %eax
addl $0x30, %eax
movb %al, %cl
movq -0x80(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x80(%rbp)
movb %cl, -0x1(%rax)
movq -0x98(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpq $0x0, -0x78(%rbp)
je 0x58b5d
movq -0x78(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0x98(%rbp)
movq -0x78(%rbp), %rax
imulq $0xa, -0x98(%rbp), %rcx
subq %rcx, %rax
movsbl %al, %eax
addl $0x30, %eax
movb %al, %cl
movq -0x80(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x80(%rbp)
movb %cl, -0x1(%rax)
movq -0x98(%rbp), %rax
movq %rax, -0x78(%rbp)
jmp 0x58b0b
cmpl $0x0, -0x9c(%rbp)
je 0x58b79
movq -0x80(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x80(%rbp)
movb $0x2d, -0x1(%rax)
movq -0x60(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x60(%rbp), %rax
addq -0x68(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x60(%rbp), %rcx
xorl %eax, %eax
cmpq -0x90(%rbp), %rcx
movb %al, -0xad(%rbp)
jae 0x58bbb
movq -0x80(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0xad(%rbp)
movb -0xad(%rbp), %al
testb $0x1, %al
jne 0x58bc7
jmp 0x58c29
movq -0x58(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x30(%rax), %rax
movq -0x58(%rbp), %rdi
movq -0x80(%rbp), %rcx
movsbq (%rcx), %rsi
movq -0x60(%rbp), %rdx
movq -0x90(%rbp), %rcx
callq *%rax
movl %eax, -0xac(%rbp)
cmpl $0x0, -0xac(%rbp)
jle 0x58c14
movl -0xac(%rbp), %ecx
movq -0x60(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
jmp 0x58c16
jmp 0x58c29
jmp 0x58c18
movq -0x80(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x80(%rbp)
jmp 0x58b93
movl -0x60(%rbp), %eax
movl -0x88(%rbp), %ecx
subl %ecx, %eax
cltq
movq %rax, -0xb8(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x58c5f
movq -0xb8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
callq 0x242f0
nopw %cs:(%rax,%rax)
| my_l10tostr_mb2_or_mb4:
push rbp
mov rbp, rsp
sub rsp, 0C0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov [rbp+var_68], rdx
mov [rbp+var_6C], ecx
mov [rbp+var_78], r8
mov [rbp+var_9C], 0
mov rax, [rbp+var_78]
mov [rbp+var_A8], rax
lea rax, [rbp+var_50]
add rax, 41h ; 'A'
mov [rbp+var_80], rax
mov rax, [rbp+var_80]
mov byte ptr [rax], 0
cmp [rbp+var_6C], 0
jge short loc_58ABC
cmp [rbp+var_78], 0
jge short loc_58ABA
mov [rbp+var_9C], 1
xor eax, eax
sub rax, [rbp+var_A8]
mov [rbp+var_A8], rax
loc_58ABA:
jmp short $+2
loc_58ABC:
mov rax, [rbp+var_A8]
mov ecx, 0Ah
xor edx, edx
div rcx
mov [rbp+var_98], rax
mov rax, [rbp+var_A8]
imul rcx, [rbp+var_98], 0Ah
sub rax, rcx
movsx eax, al
add eax, 30h ; '0'
mov cl, al
mov rax, [rbp+var_80]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_80], rdx
mov [rax-1], cl
mov rax, [rbp+var_98]
mov [rbp+var_78], rax
loc_58B0B:
cmp [rbp+var_78], 0
jz short loc_58B5D
mov rax, [rbp+var_78]
mov ecx, 0Ah
cqo
idiv rcx
mov [rbp+var_98], rax
mov rax, [rbp+var_78]
imul rcx, [rbp+var_98], 0Ah
sub rax, rcx
movsx eax, al
add eax, 30h ; '0'
mov cl, al
mov rax, [rbp+var_80]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_80], rdx
mov [rax-1], cl
mov rax, [rbp+var_98]
mov [rbp+var_78], rax
jmp short loc_58B0B
loc_58B5D:
cmp [rbp+var_9C], 0
jz short loc_58B79
mov rax, [rbp+var_80]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_80], rcx
mov byte ptr [rax-1], 2Dh ; '-'
loc_58B79:
mov rax, [rbp+var_60]
mov [rbp+var_88], rax
mov rax, [rbp+var_60]
add rax, [rbp+var_68]
mov [rbp+var_90], rax
loc_58B93:
mov rcx, [rbp+var_60]
xor eax, eax
cmp rcx, [rbp+var_90]
mov [rbp+var_AD], al
jnb short loc_58BBB
mov rax, [rbp+var_80]
movsx eax, byte ptr [rax]
cmp eax, 0
setnz al
mov [rbp+var_AD], al
loc_58BBB:
mov al, [rbp+var_AD]
test al, 1
jnz short loc_58BC7
jmp short loc_58C29
loc_58BC7:
mov rax, [rbp+var_58]
mov rax, [rax+0B8h]
mov rax, [rax+30h]
mov rdi, [rbp+var_58]
mov rcx, [rbp+var_80]
movsx rsi, byte ptr [rcx]
mov rdx, [rbp+var_60]
mov rcx, [rbp+var_90]
call rax
mov [rbp+var_AC], eax
cmp [rbp+var_AC], 0
jle short loc_58C14
mov ecx, [rbp+var_AC]
mov rax, [rbp+var_60]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_60], rax
jmp short loc_58C16
loc_58C14:
jmp short loc_58C29
loc_58C16:
jmp short $+2
loc_58C18:
mov rax, [rbp+var_80]
add rax, 1
mov [rbp+var_80], rax
jmp loc_58B93
loc_58C29:
mov eax, dword ptr [rbp+var_60]
mov ecx, dword ptr [rbp+var_88]
sub eax, ecx
cdqe
mov [rbp+var_B8], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_58C5F
mov rax, [rbp+var_B8]
add rsp, 0C0h
pop rbp
retn
loc_58C5F:
call ___stack_chk_fail
| long long my_l10tostr_mb2_or_mb4(long long a1, unsigned long long a2, long long a3, int a4, long long a5)
{
_BYTE *v5; // rax
_BYTE *v6; // rax
bool v8; // [rsp+13h] [rbp-ADh]
int v9; // [rsp+14h] [rbp-ACh]
unsigned long long v10; // [rsp+18h] [rbp-A8h]
int v11; // [rsp+24h] [rbp-9Ch]
unsigned long long v12; // [rsp+30h] [rbp-90h]
_BYTE *v13; // [rsp+40h] [rbp-80h]
signed long long i; // [rsp+48h] [rbp-78h]
unsigned long long v15; // [rsp+60h] [rbp-60h]
_BYTE v16[8]; // [rsp+B0h] [rbp-10h] BYREF
unsigned long long v17; // [rsp+B8h] [rbp-8h]
v17 = __readfsqword(0x28u);
v15 = a2;
v11 = 0;
v10 = a5;
v16[1] = 0;
if ( a4 < 0 && a5 < 0 )
{
v11 = 1;
v10 = -a5;
}
v13 = v16;
v16[0] = v10 % 0xA + 48;
for ( i = v10 / 0xA; i; i /= 10LL )
{
v5 = v13--;
*(v5 - 1) = i % 10 + 48;
}
if ( v11 )
{
v6 = v13--;
*(v6 - 1) = 45;
}
v12 = a3 + a2;
while ( 1 )
{
v8 = 0;
if ( v15 < v12 )
v8 = *v13 != 0;
if ( !v8 )
break;
v9 = (*(long long ( **)(long long, _QWORD, unsigned long long, unsigned long long))(*(_QWORD *)(a1 + 184) + 48LL))(
a1,
(char)*v13,
v15,
v12);
if ( v9 <= 0 )
break;
v15 += v9;
++v13;
}
return (int)v15 - (int)a2;
}
| my_l10tostr_mb2_or_mb4:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xc0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x60],RSI
MOV qword ptr [RBP + -0x68],RDX
MOV dword ptr [RBP + -0x6c],ECX
MOV qword ptr [RBP + -0x78],R8
MOV dword ptr [RBP + -0x9c],0x0
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0xa8],RAX
LEA RAX,[RBP + -0x50]
ADD RAX,0x41
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x80]
MOV byte ptr [RAX],0x0
CMP dword ptr [RBP + -0x6c],0x0
JGE 0x00158abc
CMP qword ptr [RBP + -0x78],0x0
JGE 0x00158aba
MOV dword ptr [RBP + -0x9c],0x1
XOR EAX,EAX
SUB RAX,qword ptr [RBP + -0xa8]
MOV qword ptr [RBP + -0xa8],RAX
LAB_00158aba:
JMP 0x00158abc
LAB_00158abc:
MOV RAX,qword ptr [RBP + -0xa8]
MOV ECX,0xa
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x98],RAX
MOV RAX,qword ptr [RBP + -0xa8]
IMUL RCX,qword ptr [RBP + -0x98],0xa
SUB RAX,RCX
MOVSX EAX,AL
ADD EAX,0x30
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x80]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RBP + -0x80],RDX
MOV byte ptr [RAX + -0x1],CL
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x78],RAX
LAB_00158b0b:
CMP qword ptr [RBP + -0x78],0x0
JZ 0x00158b5d
MOV RAX,qword ptr [RBP + -0x78]
MOV ECX,0xa
CQO
IDIV RCX
MOV qword ptr [RBP + -0x98],RAX
MOV RAX,qword ptr [RBP + -0x78]
IMUL RCX,qword ptr [RBP + -0x98],0xa
SUB RAX,RCX
MOVSX EAX,AL
ADD EAX,0x30
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x80]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RBP + -0x80],RDX
MOV byte ptr [RAX + -0x1],CL
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x78],RAX
JMP 0x00158b0b
LAB_00158b5d:
CMP dword ptr [RBP + -0x9c],0x0
JZ 0x00158b79
MOV RAX,qword ptr [RBP + -0x80]
MOV RCX,RAX
ADD RCX,-0x1
MOV qword ptr [RBP + -0x80],RCX
MOV byte ptr [RAX + -0x1],0x2d
LAB_00158b79:
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RBP + -0x90],RAX
LAB_00158b93:
MOV RCX,qword ptr [RBP + -0x60]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x90]
MOV byte ptr [RBP + -0xad],AL
JNC 0x00158bbb
MOV RAX,qword ptr [RBP + -0x80]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0xad],AL
LAB_00158bbb:
MOV AL,byte ptr [RBP + -0xad]
TEST AL,0x1
JNZ 0x00158bc7
JMP 0x00158c29
LAB_00158bc7:
MOV RAX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x30]
MOV RDI,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x80]
MOVSX RSI,byte ptr [RCX]
MOV RDX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x90]
CALL RAX
MOV dword ptr [RBP + -0xac],EAX
CMP dword ptr [RBP + -0xac],0x0
JLE 0x00158c14
MOV ECX,dword ptr [RBP + -0xac]
MOV RAX,qword ptr [RBP + -0x60]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x60],RAX
JMP 0x00158c16
LAB_00158c14:
JMP 0x00158c29
LAB_00158c16:
JMP 0x00158c18
LAB_00158c18:
MOV RAX,qword ptr [RBP + -0x80]
ADD RAX,0x1
MOV qword ptr [RBP + -0x80],RAX
JMP 0x00158b93
LAB_00158c29:
MOV EAX,dword ptr [RBP + -0x60]
MOV ECX,dword ptr [RBP + -0x88]
SUB EAX,ECX
CDQE
MOV qword ptr [RBP + -0xb8],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00158c5f
MOV RAX,qword ptr [RBP + -0xb8]
ADD RSP,0xc0
POP RBP
RET
LAB_00158c5f:
CALL 0x001242f0
|
long my_l10tostr_mb2_or_mb4(long param_1,ulong param_2,long param_3,int param_4,ulong param_5)
{
int iVar1;
long in_FS_OFFSET;
bool bVar2;
ulong local_b0;
int local_90;
char *local_88;
ulong local_80;
ulong local_68;
char local_19 [9];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
bVar2 = false;
local_19[2] = 0;
local_b0 = param_5;
if ((param_4 < 0) && (bVar2 = (long)param_5 < 0, bVar2)) {
local_b0 = -param_5;
}
local_19[1] = (char)local_b0 + (char)(local_b0 / 10) * -10 + '0';
local_88 = local_19 + 1;
local_80 = local_b0 / 10;
while (local_80 != 0) {
local_88[-1] = (char)local_80 + (char)((long)local_80 / 10) * -10 + '0';
local_88 = local_88 + -1;
local_80 = (long)local_80 / 10;
}
if (bVar2) {
local_88[-1] = '-';
local_88 = local_88 + -1;
}
local_68 = param_2;
while( true ) {
bVar2 = false;
if (local_68 < param_2 + param_3) {
bVar2 = *local_88 != '\0';
}
if ((!bVar2) ||
(iVar1 = (**(code **)(*(long *)(param_1 + 0xb8) + 0x30))
(param_1,(long)*local_88,local_68,param_2 + param_3), iVar1 < 1)) break;
local_68 = local_68 + (long)iVar1;
local_88 = local_88 + 1;
}
local_90 = (int)param_2;
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return (long)((int)local_68 - local_90);
}
| |
47,245 | apply_chat_template_with_error_handling(minja::chat_template const&, LlamaData&, bool, int&, bool) | monkey531[P]llama/examples/run/run.cpp | static int apply_chat_template_with_error_handling(const common_chat_template & tmpl, LlamaData & llama_data, const bool append, int & output_length, bool use_jinja) {
const int new_len = apply_chat_template(tmpl, llama_data, append, use_jinja);
if (new_len < 0) {
printe("failed to apply the chat template\n");
return -1;
}
output_length = new_len;
return 0;
} | O2 | cpp | apply_chat_template_with_error_handling(minja::chat_template const&, LlamaData&, bool, int&, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rcx, %r14
movl %edx, %ecx
movq %rsi, %rbx
testl %r8d, %r8d
je 0x241a5
movl %ecx, 0x14(%rsp)
movq %rdi, 0x30(%rsp)
movq %r14, 0x38(%rsp)
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2afce
movq %rbx, %rax
movq 0x18(%rbx), %rbx
movq %rax, 0x28(%rsp)
movq 0x20(%rax), %rax
movq %rax, 0x40(%rsp)
leaq 0xc0(%rsp), %r15
leaq 0xa8(%rsp), %rbp
pushq $0x2
popq %r14
pushq $0x18
popq %r12
cmpq 0x40(%rsp), %rbx
je 0x24234
leaq 0x78(%rsp), %rdi
leaq 0x7120d(%rip), %rsi # 0x952ee
callq 0x2b0f8
leaq 0x90(%rsp), %rdi
movq %rbx, %rsi
callq 0x2b108
movq %rbp, %rdi
leaq 0x78(%rsp), %rsi
movq %r14, %rdx
callq 0x2b118
leaq 0x48(%rsp), %rdi
leaq 0x711e1(%rip), %rsi # 0x952f3
callq 0x2b130
leaq 0x8(%rbx), %rsi
leaq 0x60(%rsp), %rdi
callq 0x2b108
movq %r15, %rdi
leaq 0x48(%rsp), %rsi
movq %r14, %rdx
callq 0x2b118
leaq 0x18(%rsp), %rdi
movq %rbp, %r13
movq %rbp, %rsi
movq %r14, %rdx
callq 0x2afe2
movq %r12, %rbp
leaq (%rsp,%rbp), %rdi
addq $0xa8, %rdi
callq 0x2cd5a
addq $-0x18, %rbp
cmpq $-0x18, %rbp
jne 0x2414b
movq %r12, %rbp
leaq (%rsp,%rbp), %rdi
addq $0x48, %rdi
callq 0x2cd5a
addq $-0x18, %rbp
cmpq $-0x18, %rbp
jne 0x24168
movq %r12, %rbp
leaq (%rsp,%rbp), %rdi
addq $0x78, %rdi
callq 0x2cd5a
addq $-0x18, %rbp
cmpq $-0x18, %rbp
jne 0x24182
addq $0x10, %rbx
movq %r13, %rbp
jmp 0x240ca
movq %rdi, %r12
movq 0x10(%rdi), %rdi
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rdx
subq %rsi, %rdx
sarq $0x4, %rdx
movq 0x48(%rbx), %r8
movl 0x50(%rbx), %r9d
subl %r8d, %r9d
xorl %eax, %eax
testb %cl, %cl
cmoveq %rax, %r8
cmovel %eax, %r9d
movzbl %cl, %ebp
movl %ebp, %ecx
callq 0x21c50
movq %rbx, %r15
movl %eax, %ebx
testb %bpl, %bpl
je 0x242e1
movl 0x50(%r15), %eax
subl 0x48(%r15), %eax
cmpl %eax, %ebx
jle 0x242e1
leaq 0x48(%r15), %rdi
movslq %ebx, %rsi
callq 0x2ac28
movq 0x10(%r12), %rdi
movq 0x18(%r15), %rsi
movq 0x20(%r15), %rdx
subq %rsi, %rdx
sarq $0x4, %rdx
movq 0x48(%r15), %r8
movl 0x50(%r15), %r9d
subl %r8d, %r9d
pushq $0x1
popq %rcx
callq 0x21c50
movl %eax, %ebx
jmp 0x242e1
leaq 0x78(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2c9ae
leaq 0x48(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x2c9ae
movl $0x1, (%rsp)
movzbl 0x14(%rsp), %r8d
leaq 0xa8(%rsp), %rdi
leaq 0x18(%rsp), %rdx
movq 0x30(%rsp), %rsi
movq %rbx, %rcx
movq %r14, %r9
callq 0x2b140
leaq 0x48(%rsp), %rdi
callq 0x2cd5a
leaq 0x78(%rsp), %rdi
callq 0x2cd5a
movq 0x28(%rsp), %rbx
addq $0x48, %rbx
movq 0xb0(%rsp), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x2ac28
movq (%rbx), %rdi
leaq 0xa8(%rsp), %r14
movq (%r14), %rsi
movq 0x8(%r14), %rdx
incq %rdx
callq 0x21680
movl 0x8(%r14), %ebx
movq %r14, %rdi
callq 0x22078
leaq 0x18(%rsp), %rdi
callq 0x2cd5a
movq 0x38(%rsp), %r14
testl %ebx, %ebx
js 0x242ec
movl %ebx, (%r14)
xorl %ebx, %ebx
jmp 0x242fd
pushq $-0x1
popq %rbx
leaq 0x70fd5(%rip), %rdi # 0x952cb
xorl %eax, %eax
callq 0x23f0f
movl %ebx, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %rbx
movq %rax, %r14
leaq 0xa8(%rsp), %rdi
callq 0x22078
jmp 0x24340
movq %rdx, %rbx
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x2cd5a
leaq 0x78(%rsp), %rdi
callq 0x2cd5a
cmpl $0x1, %ebx
jne 0x24433
movq %r14, %rdi
callq 0x21310
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
leaq 0x70f9a(%rip), %rdi # 0x952fb
movq %rax, %rsi
xorl %eax, %eax
callq 0x23f0f
callq 0x21d50
pushq $-0x1
popq %rbx
jmp 0x242d2
jmp 0x243d6
movq %rax, %r14
jmp 0x2438c
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x2cd5a
movb $0x1, %bl
jmp 0x243f2
movq %rax, %r14
movb $0x1, %bl
jmp 0x243b9
movq %rax, %r14
pushq $0x18
popq %rbx
leaq (%rsp,%rbx), %rdi
addq $0xa8, %rdi
callq 0x2cd5a
addq $-0x18, %rbx
cmpq $-0x18, %rbx
jne 0x2439d
xorl %ebx, %ebx
pushq $0x18
popq %r12
leaq (%rsp,%r12), %rdi
addq $0x48, %rdi
callq 0x2cd5a
addq $-0x18, %r12
cmpq $-0x18, %r12
jne 0x243bd
jmp 0x243f2
movq %rax, %r14
jmp 0x24433
movq %rax, %r14
leaq 0x78(%rsp), %rdi
callq 0x2cd5a
jmp 0x24433
movq %rax, %r14
movb $0x1, %bl
movq %rbp, %r15
pushq $0x18
popq %r12
leaq (%rsp,%r12), %rdi
addq $0x78, %rdi
callq 0x2cd5a
addq $-0x18, %r12
cmpq $-0x18, %r12
jne 0x243f6
leaq 0xa8(%rsp), %r12
cmpq %r15, %r12
setne %al
andb %al, %bl
cmpb $0x1, %bl
jne 0x24433
addq $-0x18, %r15
movq %r15, %rdi
callq 0x2cd5a
cmpq %r12, %r15
jne 0x24422
leaq 0x18(%rsp), %rdi
callq 0x2cd5a
movq %r14, %rdi
callq 0x21e50
| _ZL39apply_chat_template_with_error_handlingRKN5minja13chat_templateER9LlamaDatabRib:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0D8h
mov r14, rcx
mov ecx, edx
mov rbx, rsi
test r8d, r8d
jz loc_241A5
mov [rsp+108h+var_F4], ecx
mov [rsp+108h+var_D8], rdi
mov [rsp+108h+var_D0], r14
lea rdi, [rsp+108h+var_F0]
xor esi, esi
xor edx, edx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5arrayESt16initializer_listINS0_6detail8json_refISD_EEE; 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>::array(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>)
mov rax, rbx
mov rbx, [rbx+18h]
mov [rsp+108h+var_E0], rax
mov rax, [rax+20h]
mov [rsp+108h+var_C8], rax
lea r15, [rsp+108h+var_48]
lea rbp, [rsp+108h+var_60]
push 2
pop r14
push 18h
pop r12
loc_240CA:
cmp rbx, [rsp+108h+var_C8]
jz loc_24234
lea rdi, [rsp+108h+var_90]
lea rsi, aRole; "role"
call _ZN8nlohmann16json_abi_v3_11_36detail8json_refINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEC2IJRA5_KcETnNSt9enable_ifIXsr3std16is_constructibleISF_DpT_EE5valueEiE4typeELi0EEEDpOSM_
lea rdi, [rsp+108h+var_78]
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail8json_refINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEC2IJRKPKcETnNSt9enable_ifIXsr3std16is_constructibleISF_DpT_EE5valueEiE4typeELi0EEEDpOSN_
mov rdi, rbp
lea rsi, [rsp+108h+var_90]
mov rdx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail8json_refINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEC2ESt16initializer_listISG_E; nlohmann::json_abi_v3_11_3::detail::json_ref<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>>::json_ref(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>)
lea rdi, [rsp+108h+var_C0]
lea rsi, aContent; "content"
call _ZN8nlohmann16json_abi_v3_11_36detail8json_refINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEC2IJRA8_KcETnNSt9enable_ifIXsr3std16is_constructibleISF_DpT_EE5valueEiE4typeELi0EEEDpOSM_
lea rsi, [rbx+8]
lea rdi, [rsp+108h+var_A8]
call _ZN8nlohmann16json_abi_v3_11_36detail8json_refINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEC2IJRKPKcETnNSt9enable_ifIXsr3std16is_constructibleISF_DpT_EE5valueEiE4typeELi0EEEDpOSN_
mov rdi, r15
lea rsi, [rsp+108h+var_C0]
mov rdx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail8json_refINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEC2ESt16initializer_listISG_E; nlohmann::json_abi_v3_11_3::detail::json_ref<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>>::json_ref(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>)
lea rdi, [rsp+108h+var_F0]
mov r13, rbp
mov rsi, rbp
mov rdx, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9push_backESt16initializer_listINS0_6detail8json_refISD_EEE; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::push_back(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>)
mov rbp, r12
loc_2414B:
lea rdi, [rsp+rbp+108h+var_108]
add rdi, 0A8h
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()
add rbp, 0FFFFFFFFFFFFFFE8h
cmp rbp, 0FFFFFFFFFFFFFFE8h
jnz short loc_2414B
mov rbp, r12
loc_24168:
lea rdi, [rsp+rbp+108h+var_108]
add rdi, 48h ; 'H'
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()
add rbp, 0FFFFFFFFFFFFFFE8h
cmp rbp, 0FFFFFFFFFFFFFFE8h
jnz short loc_24168
mov rbp, r12
loc_24182:
lea rdi, [rsp+rbp+108h+var_108]
add rdi, 78h ; 'x'
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()
add rbp, 0FFFFFFFFFFFFFFE8h
cmp rbp, 0FFFFFFFFFFFFFFE8h
jnz short loc_24182
add rbx, 10h
mov rbp, r13
jmp loc_240CA
loc_241A5:
mov r12, rdi
mov rdi, [rdi+10h]
mov rsi, [rbx+18h]
mov rdx, [rbx+20h]
sub rdx, rsi
sar rdx, 4
mov r8, [rbx+48h]
mov r9d, [rbx+50h]
sub r9d, r8d
xor eax, eax
test cl, cl
cmovz r8, rax
cmovz r9d, eax
movzx ebp, cl
mov ecx, ebp
call _llama_chat_apply_template
mov r15, rbx
mov ebx, eax
test bpl, bpl
jz loc_242E1
mov eax, [r15+50h]
sub eax, [r15+48h]
cmp ebx, eax
jle loc_242E1
lea rdi, [r15+48h]
movsxd rsi, ebx
call _ZNSt6vectorIcSaIcEE6resizeEm; std::vector<char>::resize(ulong)
mov rdi, [r12+10h]
mov rsi, [r15+18h]
mov rdx, [r15+20h]
sub rdx, rsi
sar rdx, 4
mov r8, [r15+48h]
mov r9d, [r15+50h]
sub r9d, r8d
push 1
pop rcx
call _llama_chat_apply_template
mov ebx, eax
jmp loc_242E1
loc_24234:
lea rbx, [rsp+108h+var_90]
mov rdi, rbx
xor esi, esi
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EDn; 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>::basic_json(decltype(nullptr))
lea r14, [rsp+108h+var_C0]
mov rdi, r14
xor esi, esi
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EDn; 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>::basic_json(decltype(nullptr))
mov [rsp+108h+var_108], 1
movzx r8d, byte ptr [rsp+108h+var_F4]
lea rdi, [rsp+108h+var_60]
lea rdx, [rsp+108h+var_F0]
mov rsi, [rsp+108h+var_D8]
mov rcx, rbx
mov r9, r14
call _ZNK5minja13chat_template5applyERKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES5_IhSaIhEEvEESH_bSH_b; minja::chat_template::apply(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&,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&,bool,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&,bool)
lea rdi, [rsp+108h+var_C0]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
lea rdi, [rsp+108h+var_90]
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 rbx, [rsp+108h+var_E0]
add rbx, 48h ; 'H'
mov rsi, [rsp+108h+var_58]
inc rsi
mov rdi, rbx
call _ZNSt6vectorIcSaIcEE6resizeEm; std::vector<char>::resize(ulong)
mov rdi, [rbx]
lea r14, [rsp+108h+var_60]
mov rsi, [r14]
mov rdx, [r14+8]
inc rdx
call _memcpy
mov ebx, [r14+8]
mov rdi, r14; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_242D2:
lea rdi, [rsp+108h+var_F0]
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 r14, [rsp+108h+var_D0]
loc_242E1:
test ebx, ebx
js short loc_242EC
mov [r14], ebx
xor ebx, ebx
jmp short loc_242FD
loc_242EC:
push 0FFFFFFFFFFFFFFFFh
pop rbx
lea rdi, aFailedToApplyT; "failed to apply the chat template\n"
xor eax, eax
call _ZL6printePKcz; printe(char const*,...)
loc_242FD:
mov eax, ebx
add rsp, 0D8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rdx
mov r14, rax
lea rdi, [rsp+108h+var_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_24340
mov rbx, rdx
mov r14, rax
lea rdi, [rsp+108h+var_C0]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
lea rdi, [rsp+108h+var_90]
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()
loc_24340:
cmp ebx, 1
jnz loc_24433
mov rdi, r14; void *
call ___cxa_begin_catch
mov rcx, [rax]
mov rdi, rax
call qword ptr [rcx+10h]
lea rdi, aFailedToRender; "failed to render the chat template: %s"...
mov rsi, rax
xor eax, eax
call _ZL6printePKcz; printe(char const*,...)
call ___cxa_end_catch
push 0FFFFFFFFFFFFFFFFh
pop rbx
jmp loc_242D2
jmp short loc_243D6
mov r14, rax
jmp short loc_2438C
mov r14, rax
lea rdi, [rsp+108h+var_C0]
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()
loc_2438C:
mov bl, 1
jmp short loc_243F2
mov r14, rax
mov bl, 1
jmp short loc_243B9
mov r14, rax
push 18h
pop rbx
loc_2439D:
lea rdi, [rsp+rbx+108h+var_108]
add rdi, 0A8h
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()
add rbx, 0FFFFFFFFFFFFFFE8h
cmp rbx, 0FFFFFFFFFFFFFFE8h
jnz short loc_2439D
xor ebx, ebx
loc_243B9:
push 18h
pop r12
loc_243BD:
lea rdi, [rsp+r12+108h+var_108]
add rdi, 48h ; 'H'
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()
add r12, 0FFFFFFFFFFFFFFE8h
cmp r12, 0FFFFFFFFFFFFFFE8h
jnz short loc_243BD
jmp short loc_243F2
loc_243D6:
mov r14, rax
jmp short loc_24433
mov r14, rax
lea rdi, [rsp+108h+var_90]
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()
jmp short loc_24433
mov r14, rax
mov bl, 1
mov r15, rbp
loc_243F2:
push 18h
pop r12
loc_243F6:
lea rdi, [rsp+r12+108h+var_108]
add rdi, 78h ; 'x'
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()
add r12, 0FFFFFFFFFFFFFFE8h
cmp r12, 0FFFFFFFFFFFFFFE8h
jnz short loc_243F6
lea r12, [rsp+108h+var_60]
cmp r12, r15
setnz al
and bl, al
cmp bl, 1
jnz short loc_24433
loc_24422:
add r15, 0FFFFFFFFFFFFFFE8h
mov rdi, r15
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()
cmp r15, r12
jnz short loc_24422
loc_24433:
lea rdi, [rsp+108h+var_F0]
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
call __Unwind_Resume
| long long apply_chat_template_with_error_handling(
const minja::chat_template *a1,
LlamaData *a2,
unsigned __int8 a3,
int *a4,
int a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
int *v13; // r14
long long v15; // rbx
long long *v16; // rbp
long long *v17; // r13
int v18; // ecx
int v19; // r8d
int v20; // r9d
long long i; // rbp
long long j; // rbp
long long k; // rbp
long long v25; // rdi
long long v26; // rsi
long long v27; // r8
long long v28; // r9
LlamaData *v30; // r15
long long v31; // rdx
long long v32; // rcx
int v33; // ebx
long long v34; // r8
long long v35; // r9
__m128 v36; // xmm4
__m128 v37; // xmm5
_QWORD *v38; // rbx
unsigned int v39; // ebx
int v41; // [rsp+0h] [rbp-108h]
char v42; // [rsp+8h] [rbp-100h]
int v43; // [rsp+10h] [rbp-F8h]
unsigned __int8 v44; // [rsp+14h] [rbp-F4h]
char v45[16]; // [rsp+18h] [rbp-F0h] BYREF
LlamaData *v46; // [rsp+28h] [rbp-E0h]
const minja::chat_template *v47; // [rsp+30h] [rbp-D8h]
int *v48; // [rsp+38h] [rbp-D0h]
long long v49; // [rsp+40h] [rbp-C8h]
_BYTE v50[24]; // [rsp+48h] [rbp-C0h] BYREF
_BYTE v51[24]; // [rsp+60h] [rbp-A8h] BYREF
_BYTE v52[24]; // [rsp+78h] [rbp-90h] BYREF
_BYTE v53[24]; // [rsp+90h] [rbp-78h] BYREF
long long v54; // [rsp+A8h] [rbp-60h] BYREF
long long v55; // [rsp+B0h] [rbp-58h]
_BYTE v56[72]; // [rsp+C0h] [rbp-48h] BYREF
v13 = a4;
if ( a5 )
{
v44 = a3;
v47 = a1;
v48 = a4;
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>::array(
v45,
0LL,
0LL);
v15 = *((_QWORD *)a2 + 3);
v46 = a2;
v49 = *((_QWORD *)a2 + 4);
v16 = &v54;
while ( v15 != v49 )
{
ZN8nlohmann16json_abi_v3_11_36detail8json_refINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEC2IJRA5_KcETnNSt9enable_ifIXsr3std16is_constructibleISF_DpT_EE5valueEiE4typeELi0EEEDpOSM_(
v52,
"role");
ZN8nlohmann16json_abi_v3_11_36detail8json_refINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEC2IJRKPKcETnNSt9enable_ifIXsr3std16is_constructibleISF_DpT_EE5valueEiE4typeELi0EEEDpOSN_(
v53,
v15);
nlohmann::json_abi_v3_11_3::detail::json_ref<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>>::json_ref(
v16,
v52,
2LL);
ZN8nlohmann16json_abi_v3_11_36detail8json_refINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEC2IJRA8_KcETnNSt9enable_ifIXsr3std16is_constructibleISF_DpT_EE5valueEiE4typeELi0EEEDpOSM_(
v50,
"content");
ZN8nlohmann16json_abi_v3_11_36detail8json_refINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEC2IJRKPKcETnNSt9enable_ifIXsr3std16is_constructibleISF_DpT_EE5valueEiE4typeELi0EEEDpOSN_(
v51,
v15 + 8);
nlohmann::json_abi_v3_11_3::detail::json_ref<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>>::json_ref(
v56,
v50,
2LL);
v17 = v16;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::push_back(
(unsigned int)v45,
(_DWORD)v16,
2,
v18,
v19,
v20,
v41,
v42,
v43,
v45[0]);
for ( i = 24LL; i != -24; i -= 24LL )
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((char *)&v54 + i);
for ( j = 24LL; j != -24; j -= 24LL )
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(&v50[j]);
for ( k = 24LL; k != -24; k -= 24LL )
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(&v52[k]);
v15 += 16LL;
v16 = v17;
}
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>::basic_json(
v52,
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>::basic_json(
v50,
0LL);
minja::chat_template::apply(
(unsigned int)&v54,
(_DWORD)v47,
(unsigned int)v45,
(unsigned int)v52,
v44,
(unsigned int)v50,
1);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v50);
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(v52);
v38 = (_QWORD *)((char *)v46 + 72);
std::vector<char>::resize((char *)v46 + 72, v55 + 1);
v26 = v54;
memcpy(*v38, v54, v55 + 1);
v33 = v55;
std::string::~string(&v54);
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(v45);
v13 = v48;
}
else
{
v25 = *((_QWORD *)a1 + 2);
v26 = *((_QWORD *)a2 + 3);
v27 = *((_QWORD *)a2 + 9);
v28 = (unsigned int)(*((_DWORD *)a2 + 20) - v27);
if ( !a3 )
{
v27 = 0LL;
v28 = 0LL;
}
v30 = a2;
v33 = llama_chat_apply_template(v25, v26, (*((_QWORD *)a2 + 4) - v26) >> 4, a3, v27, v28);
if ( a3 && v33 > *((_DWORD *)v30 + 20) - *((_DWORD *)v30 + 18) )
{
std::vector<char>::resize((char *)v30 + 72, v33);
v26 = *((_QWORD *)v30 + 3);
v33 = llama_chat_apply_template(
*((_QWORD *)a1 + 2),
v26,
(*((_QWORD *)v30 + 4) - v26) >> 4,
1LL,
*((_QWORD *)v30 + 9),
*((_DWORD *)v30 + 20) - (unsigned int)*((_QWORD *)v30 + 9));
}
}
if ( v33 < 0 )
{
v39 = -1;
printe("failed to apply the chat template\n", v26, v31, v32, v34, v35, a6, a7, a8, a9, v36, v37, a12, a13, v41);
}
else
{
*v13 = v33;
return 0;
}
return v39;
}
| apply_chat_template_with_error_handling:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xd8
MOV R14,RCX
MOV ECX,EDX
MOV RBX,RSI
TEST R8D,R8D
JZ 0x001241a5
MOV dword ptr [RSP + 0x14],ECX
MOV qword ptr [RSP + 0x30],RDI
MOV qword ptr [RSP + 0x38],R14
LEA RDI,[RSP + 0x18]
XOR ESI,ESI
XOR EDX,EDX
CALL 0x0012afce
MOV RAX,RBX
MOV RBX,qword ptr [RBX + 0x18]
MOV qword ptr [RSP + 0x28],RAX
MOV RAX,qword ptr [RAX + 0x20]
MOV qword ptr [RSP + 0x40],RAX
LEA R15,[RSP + 0xc0]
LEA RBP,[RSP + 0xa8]
PUSH 0x2
POP R14
PUSH 0x18
POP R12
LAB_001240ca:
CMP RBX,qword ptr [RSP + 0x40]
JZ 0x00124234
LAB_001240d5:
LEA RDI,[RSP + 0x78]
LEA RSI,[0x1952ee]
CALL 0x0012b0f8
LAB_001240e6:
LEA RDI,[RSP + 0x90]
MOV RSI,RBX
CALL 0x0012b108
LAB_001240f6:
MOV RDI,RBP
LEA RSI,[RSP + 0x78]
MOV RDX,R14
CALL 0x0012b118
LAB_00124106:
LEA RDI,[RSP + 0x48]
LEA RSI,[0x1952f3]
CALL 0x0012b130
LEA RSI,[RBX + 0x8]
LAB_0012411b:
LEA RDI,[RSP + 0x60]
CALL 0x0012b108
LAB_00124125:
MOV RDI,R15
LEA RSI,[RSP + 0x48]
MOV RDX,R14
CALL 0x0012b118
LAB_00124135:
LEA RDI,[RSP + 0x18]
MOV R13,RBP
MOV RSI,RBP
MOV RDX,R14
CALL 0x0012afe2
LAB_00124148:
MOV RBP,R12
LAB_0012414b:
LEA RDI,[RSP + RBP*0x1]
ADD RDI,0xa8
CALL 0x0012cd5a
ADD RBP,-0x18
CMP RBP,-0x18
JNZ 0x0012414b
MOV RBP,R12
LAB_00124168:
LEA RDI,[RSP + RBP*0x1]
ADD RDI,0x48
CALL 0x0012cd5a
ADD RBP,-0x18
CMP RBP,-0x18
JNZ 0x00124168
MOV RBP,R12
LAB_00124182:
LEA RDI,[RSP + RBP*0x1]
ADD RDI,0x78
CALL 0x0012cd5a
ADD RBP,-0x18
CMP RBP,-0x18
JNZ 0x00124182
ADD RBX,0x10
MOV RBP,R13
JMP 0x001240ca
LAB_001241a5:
MOV R12,RDI
MOV RDI,qword ptr [RDI + 0x10]
MOV RSI,qword ptr [RBX + 0x18]
MOV RDX,qword ptr [RBX + 0x20]
SUB RDX,RSI
SAR RDX,0x4
MOV R8,qword ptr [RBX + 0x48]
MOV R9D,dword ptr [RBX + 0x50]
SUB R9D,R8D
XOR EAX,EAX
TEST CL,CL
CMOVZ R8,RAX
CMOVZ R9D,EAX
MOVZX EBP,CL
MOV ECX,EBP
CALL 0x00121c50
MOV R15,RBX
MOV EBX,EAX
TEST BPL,BPL
JZ 0x001242e1
MOV EAX,dword ptr [R15 + 0x50]
SUB EAX,dword ptr [R15 + 0x48]
CMP EBX,EAX
JLE 0x001242e1
LEA RDI,[R15 + 0x48]
MOVSXD RSI,EBX
CALL 0x0012ac28
MOV RDI,qword ptr [R12 + 0x10]
MOV RSI,qword ptr [R15 + 0x18]
MOV RDX,qword ptr [R15 + 0x20]
SUB RDX,RSI
SAR RDX,0x4
MOV R8,qword ptr [R15 + 0x48]
MOV R9D,dword ptr [R15 + 0x50]
SUB R9D,R8D
PUSH 0x1
POP RCX
CALL 0x00121c50
MOV EBX,EAX
JMP 0x001242e1
LAB_00124234:
LEA RBX,[RSP + 0x78]
MOV RDI,RBX
XOR ESI,ESI
CALL 0x0012c9ae
LEA R14,[RSP + 0x48]
MOV RDI,R14
XOR ESI,ESI
CALL 0x0012c9ae
LAB_00124252:
MOV dword ptr [RSP],0x1
MOVZX R8D,byte ptr [RSP + 0x14]
LEA RDI,[RSP + 0xa8]
LEA RDX,[RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x30]
MOV RCX,RBX
MOV R9,R14
CALL 0x0012b140
LEA RDI,[RSP + 0x48]
CALL 0x0012cd5a
LEA RDI,[RSP + 0x78]
CALL 0x0012cd5a
MOV RBX,qword ptr [RSP + 0x28]
ADD RBX,0x48
MOV RSI,qword ptr [RSP + 0xb0]
INC RSI
LAB_001242a4:
MOV RDI,RBX
CALL 0x0012ac28
LAB_001242ac:
MOV RDI,qword ptr [RBX]
LEA R14,[RSP + 0xa8]
MOV RSI,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
INC RDX
CALL 0x00121680
MOV EBX,dword ptr [R14 + 0x8]
MOV RDI,R14
CALL 0x00122078
LAB_001242d2:
LEA RDI,[RSP + 0x18]
CALL 0x0012cd5a
MOV R14,qword ptr [RSP + 0x38]
LAB_001242e1:
TEST EBX,EBX
JS 0x001242ec
MOV dword ptr [R14],EBX
XOR EBX,EBX
JMP 0x001242fd
LAB_001242ec:
PUSH -0x1
POP RBX
LEA RDI,[0x1952cb]
XOR EAX,EAX
CALL 0x00123f0f
LAB_001242fd:
MOV EAX,EBX
ADD RSP,0xd8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* apply_chat_template_with_error_handling(minja::chat_template const&, LlamaData&, bool, int&,
bool) */
int4
apply_chat_template_with_error_handling
(chat_template *param_1,LlamaData *param_2,bool param_3,int *param_4,bool param_5)
{
long lVar1;
int4 uVar2;
long lVar3;
vector<char,std::allocator<char>> *this;
long lVar4;
long lVar5;
int7 in_register_00000081;
ulong uVar6;
ulong uVar7;
data local_f0 [16];
LlamaData *local_e0;
chat_template *local_d8;
int *local_d0;
long local_c8;
data local_c0 [24];
int1 local_a8 [24];
basic_json local_90 [24];
int1 local_78 [24];
void *local_60;
int local_58;
int4 uStack_54;
int1 local_48 [24];
if ((int)CONCAT71(in_register_00000081,param_5) == 0) {
uVar6 = *(ulong *)(param_2 + 0x48);
if (!param_3) {
uVar6 = 0;
}
uVar7 = (ulong)(uint)(*(int *)(param_2 + 0x50) - (int)*(ulong *)(param_2 + 0x48));
if (!param_3) {
uVar7 = 0;
}
local_58 = llama_chat_apply_template
(*(int8 *)(param_1 + 0x10),*(long *)(param_2 + 0x18),
*(long *)(param_2 + 0x20) - *(long *)(param_2 + 0x18) >> 4,param_3,uVar6,
uVar7);
if ((param_3) && (*(int *)(param_2 + 0x50) - *(int *)(param_2 + 0x48) < local_58)) {
std::vector<char,std::allocator<char>>::resize
((vector<char,std::allocator<char>> *)(param_2 + 0x48),(long)local_58);
local_58 = llama_chat_apply_template
(*(int8 *)(param_1 + 0x10),*(long *)(param_2 + 0x18),
*(long *)(param_2 + 0x20) - *(long *)(param_2 + 0x18) >> 4,1,
*(int8 *)(param_2 + 0x48),
*(int *)(param_2 + 0x50) - (int)*(int8 *)(param_2 + 0x48));
}
}
else {
local_d8 = param_1;
local_d0 = param_4;
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>
::array(local_f0,0,0);
local_c8 = *(long *)(param_2 + 0x20);
lVar1 = 0x18;
local_e0 = param_2;
for (lVar3 = *(long *)(param_2 + 0x18); lVar3 != local_c8; lVar3 = lVar3 + 0x10) {
/* try { // try from 001240d5 to 001240e5 has its CatchHandler @ 001243d6 */
_ZN8nlohmann16json_abi_v3_11_36detail8json_refINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEC2IJRA5_KcETnNSt9enable_ifIXsr3std16is_constructibleISF_DpT_EE5valueEiE4typeELi0EEEDpOSM_
(local_90,&DAT_001952ee);
/* try { // try from 001240e6 to 001240f5 has its CatchHandler @ 001243db */
_ZN8nlohmann16json_abi_v3_11_36detail8json_refINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEC2IJRKPKcETnNSt9enable_ifIXsr3std16is_constructibleISF_DpT_EE5valueEiE4typeELi0EEEDpOSN_
(local_78,lVar3);
/* try { // try from 001240f6 to 00124105 has its CatchHandler @ 001243ea */
nlohmann::json_abi_v3_11_3::detail::
json_ref<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>>
::json_ref(&local_60,local_90,2);
/* try { // try from 00124106 to 00124116 has its CatchHandler @ 0012437a */
_ZN8nlohmann16json_abi_v3_11_36detail8json_refINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEC2IJRA8_KcETnNSt9enable_ifIXsr3std16is_constructibleISF_DpT_EE5valueEiE4typeELi0EEEDpOSM_
(local_c0,"content");
/* try { // try from 0012411b to 00124124 has its CatchHandler @ 0012437f */
_ZN8nlohmann16json_abi_v3_11_36detail8json_refINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEC2IJRKPKcETnNSt9enable_ifIXsr3std16is_constructibleISF_DpT_EE5valueEiE4typeELi0EEEDpOSN_
(local_a8,lVar3 + 8);
/* try { // try from 00124125 to 00124134 has its CatchHandler @ 00124390 */
nlohmann::json_abi_v3_11_3::detail::
json_ref<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>>
::json_ref(local_48,local_c0,2);
/* try { // try from 00124135 to 00124147 has its CatchHandler @ 00124397 */
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::push_back(local_f0,&local_60,2);
lVar4 = lVar1;
do {
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((data *)((long)&local_60 + lVar4));
lVar4 = lVar4 + -0x18;
lVar5 = lVar1;
} while (lVar4 != -0x18);
do {
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_c0 + lVar5);
lVar5 = lVar5 + -0x18;
lVar4 = lVar1;
} while (lVar5 != -0x18);
do {
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((data *)(local_90 + lVar4));
lVar4 = lVar4 + -0x18;
} while (lVar4 != -0x18);
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json((_func_decltype_nullptr *)local_90);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json((_func_decltype_nullptr *)local_c0);
/* try { // try from 00124252 to 0012427b has its CatchHandler @ 00124326 */
minja::chat_template::apply
((basic_json *)&local_60,(basic_json *)local_d8,SUB81(local_f0,0),local_90,param_3);
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_c0);
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((data *)local_90);
this = (vector<char,std::allocator<char>> *)(local_e0 + 0x48);
/* try { // try from 001242a4 to 001242ab has its CatchHandler @ 00124311 */
std::vector<char,std::allocator<char>>::resize(this,CONCAT44(uStack_54,local_58) + 1);
memcpy(*(void **)this,local_60,CONCAT44(uStack_54,local_58) + 1);
std::__cxx11::string::~string((string *)&local_60);
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_f0);
param_4 = local_d0;
}
if (local_58 < 0) {
uVar2 = 0xffffffff;
printe("failed to apply the chat template\n");
}
else {
*param_4 = local_58;
uVar2 = 0;
}
return uVar2;
}
| |
47,246 | JS_SetOpaque | bluesky950520[P]quickjs/quickjs.c | int JS_SetOpaque(JSValue obj, void *opaque)
{
JSObject *p;
if (JS_VALUE_GET_TAG(obj) == JS_TAG_OBJECT) {
p = JS_VALUE_GET_OBJ(obj);
// User code can't set the opaque of internal objects.
if (p->class_id >= JS_CLASS_INIT_COUNT) {
p->u.opaque = opaque;
return 0;
}
}
return -1;
} | O0 | c | JS_SetOpaque:
movq %rdi, -0x18(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x10(%rsp), %rax
cmpl $-0x1, %eax
jne 0x3707b
movq -0x18(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movzwl 0x6(%rax), %eax
cmpl $0x3d, %eax
jl 0x37079
movq -0x20(%rsp), %rcx
movq -0x28(%rsp), %rax
movq %rcx, 0x30(%rax)
movl $0x0, -0x4(%rsp)
jmp 0x37083
jmp 0x3707b
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
movl -0x4(%rsp), %eax
retq
nopl (%rax,%rax)
| JS_SetOpaque:
mov [rsp+var_18], rdi
mov [rsp+var_10], rsi
mov [rsp+var_20], rdx
mov rax, [rsp+var_10]
cmp eax, 0FFFFFFFFh
jnz short loc_3707B
mov rax, [rsp+var_18]
mov [rsp+var_28], rax
mov rax, [rsp+var_28]
movzx eax, word ptr [rax+6]
cmp eax, 3Dh ; '='
jl short loc_37079
mov rcx, [rsp+var_20]
mov rax, [rsp+var_28]
mov [rax+30h], rcx
mov [rsp+var_4], 0
jmp short loc_37083
loc_37079:
jmp short $+2
loc_3707B:
mov [rsp+var_4], 0FFFFFFFFh
loc_37083:
mov eax, [rsp+var_4]
retn
| long long JS_SetOpaque(long long a1, int a2, long long a3)
{
if ( a2 == -1 && *(unsigned __int16 *)(a1 + 6) >= 0x3Du )
{
*(_QWORD *)(a1 + 48) = a3;
return 0;
}
else
{
return (unsigned int)-1;
}
}
| JS_SetOpaque:
MOV qword ptr [RSP + -0x18],RDI
MOV qword ptr [RSP + -0x10],RSI
MOV qword ptr [RSP + -0x20],RDX
MOV RAX,qword ptr [RSP + -0x10]
CMP EAX,-0x1
JNZ 0x0013707b
MOV RAX,qword ptr [RSP + -0x18]
MOV qword ptr [RSP + -0x28],RAX
MOV RAX,qword ptr [RSP + -0x28]
MOVZX EAX,word ptr [RAX + 0x6]
CMP EAX,0x3d
JL 0x00137079
MOV RCX,qword ptr [RSP + -0x20]
MOV RAX,qword ptr [RSP + -0x28]
MOV qword ptr [RAX + 0x30],RCX
MOV dword ptr [RSP + -0x4],0x0
JMP 0x00137083
LAB_00137079:
JMP 0x0013707b
LAB_0013707b:
MOV dword ptr [RSP + -0x4],0xffffffff
LAB_00137083:
MOV EAX,dword ptr [RSP + -0x4]
RET
|
int4 JS_SetOpaque(long param_1,int param_2,int8 param_3)
{
int4 local_4;
if ((param_2 == -1) && (0x3c < *(ushort *)(param_1 + 6))) {
*(int8 *)(param_1 + 0x30) = param_3;
local_4 = 0;
}
else {
local_4 = 0xffffffff;
}
return local_4;
}
| |
47,247 | JS_SetOpaque | bluesky950520[P]quickjs/quickjs.c | int JS_SetOpaque(JSValue obj, void *opaque)
{
JSObject *p;
if (JS_VALUE_GET_TAG(obj) == JS_TAG_OBJECT) {
p = JS_VALUE_GET_OBJ(obj);
// User code can't set the opaque of internal objects.
if (p->class_id >= JS_CLASS_INIT_COUNT) {
p->u.opaque = opaque;
return 0;
}
}
return -1;
} | O1 | c | JS_SetOpaque:
movq %rdi, -0x8(%rsp)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpl $-0x1, %esi
jne 0x26981
movq -0x8(%rsp), %rcx
cmpw $0x3d, 0x6(%rcx)
jb 0x26981
movq %rdx, 0x30(%rcx)
xorl %eax, %eax
retq
| JS_SetOpaque:
mov [rsp+var_8], rdi
mov eax, 0FFFFFFFFh
cmp esi, 0FFFFFFFFh
jnz short locret_26981
mov rcx, [rsp+var_8]
cmp word ptr [rcx+6], 3Dh ; '='
jb short locret_26981
mov [rcx+30h], rdx
xor eax, eax
locret_26981:
retn
| long long JS_SetOpaque(long long a1, int a2, long long a3)
{
long long result; // rax
result = 0xFFFFFFFFLL;
if ( a2 == -1 && *(_WORD *)(a1 + 6) >= 0x3Du )
{
*(_QWORD *)(a1 + 48) = a3;
return 0LL;
}
return result;
}
| JS_SetOpaque:
MOV qword ptr [RSP + -0x8],RDI
MOV EAX,0xffffffff
CMP ESI,-0x1
JNZ 0x00126981
MOV RCX,qword ptr [RSP + -0x8]
CMP word ptr [RCX + 0x6],0x3d
JC 0x00126981
MOV qword ptr [RCX + 0x30],RDX
XOR EAX,EAX
LAB_00126981:
RET
|
int8 JS_SetOpaque(long param_1,int param_2,int8 param_3)
{
int8 uVar1;
uVar1 = 0xffffffff;
if ((param_2 == -1) && (0x3c < *(ushort *)(param_1 + 6))) {
*(int8 *)(param_1 + 0x30) = param_3;
uVar1 = 0;
}
return uVar1;
}
| |
47,248 | JS_SetOpaque | bluesky950520[P]quickjs/quickjs.c | int JS_SetOpaque(JSValue obj, void *opaque)
{
JSObject *p;
if (JS_VALUE_GET_TAG(obj) == JS_TAG_OBJECT) {
p = JS_VALUE_GET_OBJ(obj);
// User code can't set the opaque of internal objects.
if (p->class_id >= JS_CLASS_INIT_COUNT) {
p->u.opaque = opaque;
return 0;
}
}
return -1;
} | O2 | c | JS_SetOpaque:
pushq $-0x1
popq %rax
cmpl $-0x1, %esi
jne 0x20675
cmpw $0x3d, 0x6(%rdi)
jb 0x20675
movq %rdx, 0x30(%rdi)
xorl %eax, %eax
retq
| JS_SetOpaque:
push 0FFFFFFFFFFFFFFFFh
pop rax
cmp esi, 0FFFFFFFFh
jnz short locret_20675
cmp word ptr [rdi+6], 3Dh ; '='
jb short locret_20675
mov [rdi+30h], rdx
xor eax, eax
locret_20675:
retn
| long long JS_SetOpaque(long long a1, int a2, long long a3)
{
long long result; // rax
result = -1LL;
if ( a2 == -1 && *(_WORD *)(a1 + 6) >= 0x3Du )
{
*(_QWORD *)(a1 + 48) = a3;
return 0LL;
}
return result;
}
| JS_SetOpaque:
PUSH -0x1
POP RAX
CMP ESI,-0x1
JNZ 0x00120675
CMP word ptr [RDI + 0x6],0x3d
JC 0x00120675
MOV qword ptr [RDI + 0x30],RDX
XOR EAX,EAX
LAB_00120675:
RET
|
int8 JS_SetOpaque(long param_1,int param_2,int8 param_3)
{
int8 uVar1;
uVar1 = 0xffffffffffffffff;
if ((param_2 == -1) && (0x3c < *(ushort *)(param_1 + 6))) {
*(int8 *)(param_1 + 0x30) = param_3;
uVar1 = 0;
}
return uVar1;
}
| |
47,249 | mi_enable_indexes | eloqsql/storage/myisam/mi_open.c | int mi_enable_indexes(MI_INFO *info)
{
int error= 0;
MYISAM_SHARE *share= info->s;
if (share->state.state.data_file_length ||
(share->state.state.key_file_length != share->base.keystart))
{
mi_print_error(info->s, HA_ERR_CRASHED);
error= HA_ERR_CRASHED;
}
else
mi_set_all_keys_active(share->state.key_map, share->base.keys);
return error;
} | O0 | c | mi_enable_indexes:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0xdd44e
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x108(%rcx), %rax
je 0xdd46f
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x268(%rax), %rsi
movl $0x7e, %edi
callq 0xd1aa0
movl $0x7e, -0xc(%rbp)
jmp 0xdd4b6
movq -0x18(%rbp), %rax
cmpl $0x40, 0x180(%rax)
jae 0xdd49a
movq -0x18(%rbp), %rax
movl 0x180(%rax), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xdd4a7
movq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xdd4a7
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xc0(%rax)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
| mi_enable_indexes:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_C], 0
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
cmp qword ptr [rax+40h], 0
jnz short loc_DD44E
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov rcx, [rbp+var_18]
cmp rax, [rcx+108h]
jz short loc_DD46F
loc_DD44E:
mov rax, [rbp+var_8]
mov rax, [rax]
mov rsi, [rax+268h]
mov edi, 7Eh ; '~'
call mi_report_error
mov [rbp+var_C], 7Eh ; '~'
jmp short loc_DD4B6
loc_DD46F:
mov rax, [rbp+var_18]
cmp dword ptr [rax+180h], 40h ; '@'
jnb short loc_DD49A
mov rax, [rbp+var_18]
mov eax, [rax+180h]
mov ecx, eax
mov eax, 1
shl rax, cl
sub rax, 1
mov [rbp+var_20], rax
jmp short loc_DD4A7
loc_DD49A:
mov rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_20], rax
jmp short $+2
loc_DD4A7:
mov rcx, [rbp+var_20]
mov rax, [rbp+var_18]
mov [rax+0C0h], rcx
loc_DD4B6:
mov eax, [rbp+var_C]
add rsp, 20h
pop rbp
retn
| long long mi_enable_indexes(long long *a1)
{
long long v2; // [rsp+0h] [rbp-20h]
long long v3; // [rsp+8h] [rbp-18h]
unsigned int v4; // [rsp+14h] [rbp-Ch]
v4 = 0;
v3 = *a1;
if ( !*(_QWORD *)(*a1 + 64) && *(_QWORD *)(v3 + 56) == *(_QWORD *)(v3 + 264) )
{
if ( *(_DWORD *)(v3 + 384) >= 0x40u )
v2 = -1LL;
else
v2 = (1LL << *(_DWORD *)(v3 + 384)) - 1;
*(_QWORD *)(v3 + 192) = v2;
}
else
{
mi_report_error(126, *(_QWORD *)(*a1 + 616));
return 126;
}
return v4;
}
| mi_enable_indexes:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x40],0x0
JNZ 0x001dd44e
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV RCX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RCX + 0x108]
JZ 0x001dd46f
LAB_001dd44e:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x268]
MOV EDI,0x7e
CALL 0x001d1aa0
MOV dword ptr [RBP + -0xc],0x7e
JMP 0x001dd4b6
LAB_001dd46f:
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX + 0x180],0x40
JNC 0x001dd49a
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x180]
MOV ECX,EAX
MOV EAX,0x1
SHL RAX,CL
SUB RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001dd4a7
LAB_001dd49a:
MOV RAX,-0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001dd4a7
LAB_001dd4a7:
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0xc0],RCX
LAB_001dd4b6:
MOV EAX,dword ptr [RBP + -0xc]
ADD RSP,0x20
POP RBP
RET
|
int4 mi_enable_indexes(long *param_1)
{
long lVar1;
int8 local_28;
int4 local_14;
local_14 = 0;
lVar1 = *param_1;
if ((*(long *)(lVar1 + 0x40) == 0) && (*(long *)(lVar1 + 0x38) == *(long *)(lVar1 + 0x108))) {
if (*(uint *)(lVar1 + 0x180) < 0x40) {
local_28 = (1L << ((byte)*(int4 *)(lVar1 + 0x180) & 0x3f)) + -1;
}
else {
local_28 = -1;
}
*(long *)(lVar1 + 0xc0) = local_28;
}
else {
mi_report_error(0x7e,*(int8 *)(*param_1 + 0x268));
local_14 = 0x7e;
}
return local_14;
}
| |
47,250 | uf_space_endspace | eloqsql/storage/maria/ma_packrec.c | static void uf_space_endspace(MARIA_COLUMNDEF *rec, MARIA_BIT_BUFF *bit_buff,
uchar *to, uchar *end)
{
uint spaces;
if (get_bit(bit_buff))
bfill(to, (end-to), ' ');
else
{
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(end - spaces, spaces, ' ');
}
} | O0 | c | uf_space_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
cmpl $0x0, 0x4(%rax)
je 0x3a057
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rdx
movl 0x4(%rdx), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rdx)
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x3a07b
jmp 0x3a099
movq -0x10(%rbp), %rdi
callq 0x39690
movq -0x10(%rbp), %rax
movl $0x1f, 0x4(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x0, %eax
je 0x3a099
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
subq %rax, %rdx
movl $0x20, %esi
callq 0x2a2c0
jmp 0x3a164
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x24(%rcx), %eax
jb 0x3a0dc
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x24(%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 0x24(%rcx), %ecx
movl %ecx, %edx
leaq 0x28320c(%rip), %rcx # 0x2bd2e0
andl (%rcx,%rdx,4), %eax
movl %eax, -0x28(%rbp)
jmp 0x3a0ef
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x24(%rax), %esi
callq 0x38e40
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 0x3a111
movq -0x10(%rbp), %rax
movl $0x1, 0x28(%rax)
jmp 0x3a164
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
addq %rcx, %rax
cmpq -0x20(%rbp), %rax
je 0x3a144
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 0x399d0
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
nopw (%rax,%rax)
| uf_space_endspace:
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]
cmp dword ptr [rax+4], 0
jz short loc_3A057
mov rax, [rbp+var_10]
mov eax, [rax]
mov rdx, [rbp+var_10]
mov ecx, [rdx+4]
add ecx, 0FFFFFFFFh
mov [rdx+4], ecx
mov edx, 1
shl edx, cl
mov ecx, edx
and eax, ecx
cmp eax, 0
jnz short loc_3A07B
jmp short loc_3A099
loc_3A057:
mov rdi, [rbp+var_10]
call fill_buffer
mov rax, [rbp+var_10]
mov dword ptr [rax+4], 1Fh
mov rax, [rbp+var_10]
mov eax, [rax]
and eax, 80000000h
cmp eax, 0
jz short loc_3A099
loc_3A07B:
mov rdi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov rax, [rbp+var_18]
sub rdx, rax
mov esi, 20h ; ' '
call _memset
jmp loc_3A164
loc_3A099:
mov rax, [rbp+var_10]
mov eax, [rax+4]
mov rcx, [rbp+var_8]
cmp eax, [rcx+24h]
jb short loc_3A0DC
mov rax, [rbp+var_10]
mov eax, [rax]
mov rcx, [rbp+var_8]
mov esi, [rcx+24h]
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+24h]
mov edx, ecx
lea rcx, mask
and eax, [rcx+rdx*4]
mov [rbp+var_28], eax
jmp short loc_3A0EF
loc_3A0DC:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_8]
mov esi, [rax+24h]
call fill_and_get_bits
mov [rbp+var_28], eax
loc_3A0EF:
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_3A111
mov rax, [rbp+var_10]
mov dword ptr [rax+28h], 1
jmp short loc_3A164
loc_3A111:
mov rax, [rbp+var_18]
mov ecx, [rbp+var_24]
add rax, rcx
cmp rax, [rbp+var_20]
jz short loc_3A144
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
loc_3A144:
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_3A164:
add rsp, 30h
pop rbp
retn
| long long uf_space_endspace(long long a1, int *a2, _BYTE *a3, _BYTE *a4)
{
int v4; // eax
int v5; // ecx
long long result; // rax
unsigned int v7; // eax
int v8; // ecx
unsigned int bits; // [rsp+8h] [rbp-28h]
if ( a2[1] )
{
v4 = *a2;
v5 = a2[1] - 1;
a2[1] = v5;
if ( ((1 << v5) & v4) == 0 )
goto LABEL_6;
return memset(a3, 32LL, a4 - a3);
}
fill_buffer((long long)a2);
a2[1] = 31;
if ( *a2 < 0 )
return memset(a3, 32LL, a4 - a3);
LABEL_6:
if ( (unsigned int)a2[1] < *(_DWORD *)(a1 + 36) )
{
bits = fill_and_get_bits(a2, *(_DWORD *)(a1 + 36));
}
else
{
v7 = *a2;
v8 = a2[1] - *(_DWORD *)(a1 + 36);
a2[1] = v8;
bits = mask[*(unsigned int *)(a1 + 36)] & (v7 >> v8);
}
if ( &a3[bits] <= a4 )
{
if ( &a3[bits] != a4 )
decode_bytes(a1, (long long)a2, a3, &a4[-bits]);
return memset(&a4[-bits], 32LL, bits);
}
else
{
result = (long long)a2;
a2[10] = 1;
}
return result;
}
| uf_space_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]
CMP dword ptr [RAX + 0x4],0x0
JZ 0x0013a057
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RDX + 0x4]
ADD ECX,-0x1
MOV dword ptr [RDX + 0x4],ECX
MOV EDX,0x1
SHL EDX,CL
MOV ECX,EDX
AND EAX,ECX
CMP EAX,0x0
JNZ 0x0013a07b
JMP 0x0013a099
LAB_0013a057:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00139690
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x4],0x1f
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
AND EAX,0x80000000
CMP EAX,0x0
JZ 0x0013a099
LAB_0013a07b:
MOV RDI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
SUB RDX,RAX
MOV ESI,0x20
CALL 0x0012a2c0
JMP 0x0013a164
LAB_0013a099:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x4]
MOV RCX,qword ptr [RBP + -0x8]
CMP EAX,dword ptr [RCX + 0x24]
JC 0x0013a0dc
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RCX + 0x24]
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 + 0x24]
MOV EDX,ECX
LEA RCX,[0x3bd2e0]
AND EAX,dword ptr [RCX + RDX*0x4]
MOV dword ptr [RBP + -0x28],EAX
JMP 0x0013a0ef
LAB_0013a0dc:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RAX + 0x24]
CALL 0x00138e40
MOV dword ptr [RBP + -0x28],EAX
LAB_0013a0ef:
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 0x0013a111
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x28],0x1
JMP 0x0013a164
LAB_0013a111:
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x24]
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x20]
JZ 0x0013a144
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 0x001399d0
LAB_0013a144:
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_0013a164:
ADD RSP,0x30
POP RBP
RET
|
void uf_space_endspace(long param_1,uint *param_2,void *param_3,ulong param_4)
{
uint uVar1;
uint local_30;
if (param_2[1] == 0) {
fill_buffer(param_2);
param_2[1] = 0x1f;
uVar1 = *param_2 & 0x80000000;
}
else {
uVar1 = param_2[1];
param_2[1] = uVar1 - 1;
uVar1 = *param_2 & 1 << ((byte)(uVar1 - 1) & 0x1f);
}
if (uVar1 == 0) {
if (param_2[1] < *(uint *)(param_1 + 0x24)) {
local_30 = fill_and_get_bits(param_2,*(int4 *)(param_1 + 0x24));
}
else {
uVar1 = param_2[1] - *(int *)(param_1 + 0x24);
param_2[1] = uVar1;
local_30 = *param_2 >> ((byte)uVar1 & 0x1f) &
*(uint *)(mask + (ulong)*(uint *)(param_1 + 0x24) * 4);
}
if (param_4 < (long)param_3 + (ulong)local_30) {
param_2[10] = 1;
}
else {
if ((long)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);
}
}
else {
memset(param_3,0x20,param_4 - (long)param_3);
}
return;
}
| |
47,251 | SchemaConverter::_add_primitive(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, BuiltinRule const&) | monkey531[P]llama/common/json-schema-to-grammar.cpp | std::string _add_primitive(const std::string & name, const BuiltinRule & rule) {
auto n = _add_rule(name, rule.content);
for (const auto & dep : rule.deps) {
BuiltinRule dep_rule;
auto it = PRIMITIVE_RULES.find(dep);
if (it == PRIMITIVE_RULES.end()) {
it = STRING_FORMAT_RULES.find(dep);
if (it == STRING_FORMAT_RULES.end()) {
_errors.push_back("Rule " + dep + " not known");
continue;
}
}
if (_rules.find(dep) == _rules.end()) {
_add_primitive(dep, it->second);
}
}
return n;
} | O3 | cpp | SchemaConverter::_add_primitive(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, BuiltinRule const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, %rbx
movq %rdi, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
callq 0xc09e0
movq 0x20(%rbx), %r15
movq 0x28(%rbx), %r14
cmpq %r14, %r15
je 0xc5f86
leaq 0x80(%rsp), %rbx
leaq 0x90(%rsp), %r12
movq 0x10(%rsp), %rax
leaq 0x28(%rax), %rcx
movq %rcx, 0x48(%rsp)
leaq 0x30(%rax), %rcx
movq %rcx, 0x40(%rsp)
addq $0xc8, %rax
movq %rax, 0x38(%rsp)
xorl %r13d, %r13d
movq %rbx, 0x70(%rsp)
movq %r13, 0x78(%rsp)
movb $0x0, 0x80(%rsp)
movq %r13, 0x10(%r12)
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
leaq 0x69449(%rip), %rdi # 0x12f270
movq %r15, %rsi
callq 0xcb55c
movq %rax, %rbp
testq %rax, %rax
jne 0xc5e4e
leaq 0x6946a(%rip), %rdi # 0x12f2a8
movq %r15, %rsi
callq 0xcb55c
movq %rax, %rbp
testq %rax, %rax
je 0xc5ea8
movq 0x48(%rsp), %rdi
movq %r15, %rsi
callq 0xc1080
cmpq 0x40(%rsp), %rax
jne 0xc5f57
addq $0x28, %rbp
leaq 0xa8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %r15, %rdx
movq %rbp, %rcx
callq 0xc5d98
movq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
cmpq %rax, %rdi
je 0xc5f57
movq 0xb8(%rsp), %rsi
jmp 0xc5f4f
leaq 0x50(%rsp), %rbp
movq %rbp, %rdi
leaq 0x30af3(%rip), %rsi # 0xf69aa
movq %r15, %rdx
callq 0x54b5d
movq %rbp, %rdi
leaq 0x30ae7(%rip), %rsi # 0xf69b0
callq 0x1c0f0
leaq 0x28(%rsp), %rbp
movq %rbp, 0x18(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xc5ef6
movq %rdx, 0x18(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x28(%rsp)
jmp 0xc5efd
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
movq 0x8(%rax), %rdx
movq %rdx, 0x20(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x56246
movq 0x18(%rsp), %rdi
cmpq %rbp, %rdi
je 0xc5f3b
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1b8c0
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0xc5f57
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1b8c0
movq %r12, %rdi
callq 0x21ff8
movq 0x70(%rsp), %rdi
cmpq %rbx, %rdi
je 0xc5f79
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x1b8c0
addq $0x20, %r15
cmpq %r14, %r15
jne 0xc5e01
movq 0x8(%rsp), %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %rbp, %rdi
je 0xc5fbc
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1b8c0
jmp 0xc5fbc
movq %rax, %rbx
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0xc5fe3
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1b8c0
jmp 0xc5fe3
jmp 0xc5fe0
jmp 0xc5fe0
jmp 0xc5fe0
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xbed4a
movq 0x8(%rsp), %rcx
movq (%rcx), %rdi
addq $0x10, %rcx
cmpq %rcx, %rdi
je 0xc6009
movq (%rcx), %rsi
incq %rsi
callq 0x1b8c0
movq %rbx, %rdi
callq 0x1bf90
nop
| _ZN15SchemaConverter14_add_primitiveERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERK11BuiltinRule:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0C8h
mov rbx, rcx
mov [rsp+0F8h+var_F0], rdi; int
mov [rsp+0F8h+var_E8], rsi; void *
call _ZN15SchemaConverter9_add_ruleERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES7_; SchemaConverter::_add_rule(std::string const&,std::string const&)
mov r15, [rbx+20h]
mov r14, [rbx+28h]
cmp r15, r14
jz loc_C5F86
lea rbx, [rsp+0F8h+var_78]
lea r12, [rsp+0F8h+var_68]
mov rax, [rsp+0F8h+var_E8]
lea rcx, [rax+28h]
mov [rsp+0F8h+var_B0], rcx; void *
lea rcx, [rax+30h]
mov qword ptr [rsp+0F8h+var_B8], rcx; int
add rax, 0C8h
mov [rsp+0F8h+var_C0], rax; int
xor r13d, r13d
loc_C5E01:
mov [rsp+0F8h+var_88], rbx; int
mov [rsp+0F8h+var_80], r13; __int64
mov byte ptr [rsp+0F8h+var_78], 0; int
mov [r12+10h], r13
xorps xmm0, xmm0
movups xmmword ptr [r12], xmm0
lea rdi, _Z15PRIMITIVE_RULESB5cxx11; PRIMITIVE_RULES
mov rsi, r15
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_11BuiltinRuleESaIS9_ENSt8__detail10_Select1stESt8equal_toIS5_ESt4hashIS5_ENSB_18_Mod_range_hashingENSB_20_Default_ranged_hashENSB_20_Prime_rehash_policyENSB_17_Hashtable_traitsILb1ELb0ELb1EEEE4findERS7_; std::_Hashtable<std::string,std::pair<std::string const,BuiltinRule>,std::allocator<std::pair<std::string const,BuiltinRule>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(std::string const&)
mov rbp, rax
test rax, rax
jnz short loc_C5E4E
lea rdi, _Z19STRING_FORMAT_RULESB5cxx11; STRING_FORMAT_RULES
mov rsi, r15
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_11BuiltinRuleESaIS9_ENSt8__detail10_Select1stESt8equal_toIS5_ESt4hashIS5_ENSB_18_Mod_range_hashingENSB_20_Default_ranged_hashENSB_20_Prime_rehash_policyENSB_17_Hashtable_traitsILb1ELb0ELb1EEEE4findERS7_; std::_Hashtable<std::string,std::pair<std::string const,BuiltinRule>,std::allocator<std::pair<std::string const,BuiltinRule>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(std::string const&)
mov rbp, rax
test rax, rax
jz short loc_C5EA8
loc_C5E4E:
mov rdi, [rsp+0F8h+var_B0]
mov rsi, r15
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_S5_ESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EE4findERS7_; std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::string>>>::find(std::string const&)
cmp rax, qword ptr [rsp+0F8h+var_B8]
jnz loc_C5F57
add rbp, 28h ; '('
lea rdi, [rsp+0F8h+var_50]; int
mov rsi, [rsp+0F8h+var_E8]; int
mov rdx, r15; int
mov rcx, rbp; int
call _ZN15SchemaConverter14_add_primitiveERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERK11BuiltinRule; SchemaConverter::_add_primitive(std::string const&,BuiltinRule const&)
mov rdi, qword ptr [rsp+0F8h+var_50]
lea rax, [rsp+0F8h+var_40]
cmp rdi, rax
jz loc_C5F57
mov rsi, [rsp+0F8h+var_40]
jmp loc_C5F4F
loc_C5EA8:
lea rbp, [rsp+0F8h+var_A8]
mov rdi, rbp
lea rsi, aRule; "Rule "
mov rdx, r15
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
mov rdi, rbp
lea rsi, aNotKnown; " not known"
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea rbp, [rsp+0F8h+var_D0]
mov [rsp+0F8h+var_E0], rbp
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_C5EF6
mov [rsp+0F8h+var_E0], rdx
mov rdx, [rcx]
mov [rsp+0F8h+var_D0], rdx
jmp short loc_C5EFD
loc_C5EF6:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rbp+0], xmm0
loc_C5EFD:
mov rdx, [rax+8]
mov [rsp+0F8h+var_D8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rdi, [rsp+0F8h+var_C0]
lea rsi, [rsp+0F8h+var_E0]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJS5_EEERS5_DpOT_; std::vector<std::string>::emplace_back<std::string>(std::string &&)
mov rdi, [rsp+0F8h+var_E0]; void *
cmp rdi, rbp
jz short loc_C5F3B
mov rsi, [rsp+0F8h+var_D0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C5F3B:
mov rdi, [rsp+0F8h+var_A8]; void *
lea rax, [rsp+0F8h+var_98]
cmp rdi, rax
jz short loc_C5F57
mov rsi, [rsp+0F8h+var_98]
loc_C5F4F:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C5F57:
mov rdi, r12
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, [rsp+0F8h+var_88]; void *
cmp rdi, rbx
jz short loc_C5F79
mov rsi, qword ptr [rsp+0F8h+var_78]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C5F79:
add r15, 20h ; ' '
cmp r15, r14
jnz loc_C5E01
loc_C5F86:
mov rax, [rsp+0F8h+var_F0]
add rsp, 0C8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, [rsp+arg_10]; void *
cmp rdi, rbp
jz short loc_C5FBC
mov rsi, [rsp+arg_20]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_C5FBC
mov rbx, rax
loc_C5FBC:
mov rdi, [rsp+arg_48]; void *
lea rax, [rsp+arg_58]
cmp rdi, rax
jz short loc_C5FE3
mov rsi, [rsp+arg_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_C5FE3
jmp short loc_C5FE0
jmp short loc_C5FE0
jmp short $+2
loc_C5FE0:
mov rbx, rax
loc_C5FE3:
lea rdi, [rsp+arg_68]; this
call _ZN11BuiltinRuleD2Ev; BuiltinRule::~BuiltinRule()
mov rcx, [rsp+arg_0]
mov rdi, [rcx]; void *
add rcx, 10h
cmp rdi, rcx
jz short loc_C6009
mov rsi, [rcx]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C6009:
mov rdi, rbx
call __Unwind_Resume
| void * SchemaConverter::_add_primitive(long long a1, long long a2, long long *a3, _QWORD *a4)
{
_QWORD *v5; // r15
_QWORD *v6; // r14
long long v7; // rax
int v8; // ebp
long long v9; // rax
long long v10; // rax
int v11; // r8d
int v12; // r9d
void *v13; // rdi
long long v14; // rsi
long long v15; // rax
__int128 *v16; // rcx
long long v18; // [rsp+0h] [rbp-F8h]
void *v19; // [rsp+8h] [rbp-F0h]
void *v20; // [rsp+10h] [rbp-E8h]
void *v21; // [rsp+18h] [rbp-E0h] BYREF
long long v22; // [rsp+20h] [rbp-D8h]
__int128 v23; // [rsp+28h] [rbp-D0h] BYREF
long long v24; // [rsp+38h] [rbp-C0h]
int v25[2]; // [rsp+40h] [rbp-B8h]
void *v26; // [rsp+48h] [rbp-B0h]
void *v27[2]; // [rsp+50h] [rbp-A8h] BYREF
long long v28; // [rsp+60h] [rbp-98h] BYREF
char v29; // [rsp+68h] [rbp-90h]
void *v30; // [rsp+70h] [rbp-88h]
long long v31; // [rsp+78h] [rbp-80h]
int v32[2]; // [rsp+80h] [rbp-78h] BYREF
__int128 v33; // [rsp+90h] [rbp-68h] BYREF
long long v34; // [rsp+A0h] [rbp-58h]
int v35[2]; // [rsp+A8h] [rbp-50h] BYREF
long long v36; // [rsp+B8h] [rbp-40h] BYREF
v19 = (void *)a1;
v20 = (void *)a2;
SchemaConverter::_add_rule(a1, a2, a3, a4);
v5 = (_QWORD *)a4[4];
v6 = (_QWORD *)a4[5];
if ( v5 != v6 )
{
v26 = (void *)(a2 + 40);
*(_QWORD *)v25 = a2 + 48;
v24 = a2 + 200;
do
{
v30 = v32;
v31 = 0LL;
LOBYTE(v32[0]) = 0;
v34 = 0LL;
v33 = 0LL;
v7 = std::_Hashtable<std::string,std::pair<std::string const,BuiltinRule>,std::allocator<std::pair<std::string const,BuiltinRule>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(
PRIMITIVE_RULES[abi:cxx11],
v5);
v8 = v7;
if ( v7
|| (v9 = std::_Hashtable<std::string,std::pair<std::string const,BuiltinRule>,std::allocator<std::pair<std::string const,BuiltinRule>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(
STRING_FORMAT_RULES[abi:cxx11],
v5),
v8 = v9,
v9) )
{
v10 = std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::string>>>::find(
(long long)v26,
(long long)v5);
if ( v10 != *(_QWORD *)v25 )
goto LABEL_16;
SchemaConverter::_add_primitive(
(int)v35,
(int)v20,
(int)v5,
v8 + 40,
v11,
v12,
v18,
(int)v19,
v20,
(int)v21,
v22,
v23,
SDWORD2(v23),
v24,
v25[0],
v26,
(int)v27[0],
(long long)v27[1],
v28,
v29);
v13 = *(void **)v35;
if ( *(long long **)v35 == &v36 )
goto LABEL_16;
v14 = v36;
}
else
{
std::operator+<char>((long long)v27, (long long)"Rule ", v5);
v15 = std::string::append(v27, " not known");
v21 = &v23;
v16 = (__int128 *)(v15 + 16);
if ( *(_QWORD *)v15 == v15 + 16 )
{
v23 = *v16;
}
else
{
v21 = *(void **)v15;
*(_QWORD *)&v23 = *(_QWORD *)v16;
}
v22 = *(_QWORD *)(v15 + 8);
*(_QWORD *)v15 = v16;
*(_QWORD *)(v15 + 8) = 0LL;
*(_BYTE *)(v15 + 16) = 0;
std::vector<std::string>::emplace_back<std::string>(v24, (long long)&v21);
if ( v21 != &v23 )
operator delete(v21, v23 + 1);
v13 = v27[0];
if ( v27[0] == &v28 )
goto LABEL_16;
v14 = v28;
}
operator delete(v13, v14 + 1);
LABEL_16:
std::vector<std::string>::~vector((long long)&v33);
if ( v30 != v32 )
operator delete(v30, *(_QWORD *)v32 + 1LL);
v5 += 4;
}
while ( v5 != v6 );
}
return v19;
}
| _add_primitive:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xc8
MOV RBX,RCX
MOV qword ptr [RSP + 0x8],RDI
MOV qword ptr [RSP + 0x10],RSI
CALL 0x001c09e0
MOV R15,qword ptr [RBX + 0x20]
MOV R14,qword ptr [RBX + 0x28]
CMP R15,R14
JZ 0x001c5f86
LEA RBX,[RSP + 0x80]
LEA R12,[RSP + 0x90]
MOV RAX,qword ptr [RSP + 0x10]
LEA RCX,[RAX + 0x28]
MOV qword ptr [RSP + 0x48],RCX
LEA RCX,[RAX + 0x30]
MOV qword ptr [RSP + 0x40],RCX
ADD RAX,0xc8
MOV qword ptr [RSP + 0x38],RAX
XOR R13D,R13D
LAB_001c5e01:
MOV qword ptr [RSP + 0x70],RBX
MOV qword ptr [RSP + 0x78],R13
MOV byte ptr [RSP + 0x80],0x0
MOV qword ptr [R12 + 0x10],R13
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R12],XMM0
LAB_001c5e20:
LEA RDI,[0x22f270]
MOV RSI,R15
CALL 0x001cb55c
MOV RBP,RAX
TEST RAX,RAX
JNZ 0x001c5e4e
LAB_001c5e37:
LEA RDI,[0x22f2a8]
MOV RSI,R15
CALL 0x001cb55c
MOV RBP,RAX
TEST RAX,RAX
JZ 0x001c5ea8
LAB_001c5e4e:
MOV RDI,qword ptr [RSP + 0x48]
MOV RSI,R15
CALL 0x001c1080
CMP RAX,qword ptr [RSP + 0x40]
JNZ 0x001c5f57
ADD RBP,0x28
LAB_001c5e6a:
LEA RDI,[RSP + 0xa8]
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,R15
MOV RCX,RBP
CALL 0x001c5d98
MOV RDI,qword ptr [RSP + 0xa8]
LEA RAX,[RSP + 0xb8]
CMP RDI,RAX
JZ 0x001c5f57
MOV RSI,qword ptr [RSP + 0xb8]
JMP 0x001c5f4f
LAB_001c5ea8:
LEA RBP,[RSP + 0x50]
MOV RDI,RBP
LEA RSI,[0x1f69aa]
MOV RDX,R15
CALL 0x00154b5d
LAB_001c5ebf:
MOV RDI,RBP
LEA RSI,[0x1f69b0]
CALL 0x0011c0f0
LEA RBP,[RSP + 0x28]
MOV qword ptr [RSP + 0x18],RBP
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x001c5ef6
MOV qword ptr [RSP + 0x18],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x28],RDX
JMP 0x001c5efd
LAB_001c5ef6:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RBP],XMM0
LAB_001c5efd:
MOV RDX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x20],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
LAB_001c5f15:
MOV RDI,qword ptr [RSP + 0x38]
LEA RSI,[RSP + 0x18]
CALL 0x00156246
LAB_001c5f24:
MOV RDI,qword ptr [RSP + 0x18]
CMP RDI,RBP
JZ 0x001c5f3b
MOV RSI,qword ptr [RSP + 0x28]
INC RSI
CALL 0x0011b8c0
LAB_001c5f3b:
MOV RDI,qword ptr [RSP + 0x50]
LEA RAX,[RSP + 0x60]
CMP RDI,RAX
JZ 0x001c5f57
MOV RSI,qword ptr [RSP + 0x60]
LAB_001c5f4f:
INC RSI
CALL 0x0011b8c0
LAB_001c5f57:
MOV RDI,R12
CALL 0x00121ff8
MOV RDI,qword ptr [RSP + 0x70]
CMP RDI,RBX
JZ 0x001c5f79
MOV RSI,qword ptr [RSP + 0x80]
INC RSI
CALL 0x0011b8c0
LAB_001c5f79:
ADD R15,0x20
CMP R15,R14
JNZ 0x001c5e01
LAB_001c5f86:
MOV RAX,qword ptr [RSP + 0x8]
ADD RSP,0xc8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* SchemaConverter::_add_primitive(std::__cxx11::string const&, BuiltinRule const&) */
string * SchemaConverter::_add_primitive(string *param_1,BuiltinRule *param_2)
{
string *psVar1;
long lVar2;
BuiltinRule *pBVar3;
long *plVar4;
long in_RCX;
long *plVar5;
string *psVar6;
long *local_e0;
long local_d8;
long local_d0;
long lStack_c8;
BuiltinRule *local_c0;
BuiltinRule *local_b8;
BuiltinRule *local_b0;
long *local_a8 [2];
long local_98 [2];
int1 *local_88;
int8 local_80;
int1 local_78;
int7 uStack_77;
int8 local_68;
int8 uStack_60;
int8 local_58;
long *local_50 [2];
long local_40 [2];
_add_rule(param_1,(string *)param_2);
psVar6 = *(string **)(in_RCX + 0x20);
psVar1 = *(string **)(in_RCX + 0x28);
if (psVar6 != psVar1) {
local_b0 = param_2 + 0x28;
local_b8 = param_2 + 0x30;
local_c0 = param_2 + 200;
do {
local_80 = 0;
local_78 = 0;
local_58 = 0;
local_68 = 0;
uStack_60 = 0;
local_88 = &local_78;
/* try { // try from 001c5e20 to 001c5e2e has its CatchHandler @ 001c5fe0 */
lVar2 = std::
_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,BuiltinRule>,std::allocator<std::pair<std::__cxx11::string_const,BuiltinRule>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
::find((_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,BuiltinRule>,std::allocator<std::pair<std::__cxx11::string_const,BuiltinRule>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
*)PRIMITIVE_RULES_abi_cxx11_,psVar6);
/* try { // try from 001c5e37 to 001c5e45 has its CatchHandler @ 001c5fdc */
if ((lVar2 == 0) &&
(lVar2 = std::
_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,BuiltinRule>,std::allocator<std::pair<std::__cxx11::string_const,BuiltinRule>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
::find((_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,BuiltinRule>,std::allocator<std::pair<std::__cxx11::string_const,BuiltinRule>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
*)STRING_FORMAT_RULES_abi_cxx11_,psVar6), lVar2 == 0)) {
/* try { // try from 001c5ea8 to 001c5ebe has its CatchHandler @ 001c5fda */
std::operator+((char *)local_a8,(string *)"Rule ");
/* try { // try from 001c5ebf to 001c5ecd has its CatchHandler @ 001c5fb9 */
plVar4 = (long *)std::__cxx11::string::append((char *)local_a8);
plVar5 = plVar4 + 2;
if ((long *)*plVar4 == plVar5) {
local_d0 = *plVar5;
lStack_c8 = plVar4[3];
local_e0 = &local_d0;
}
else {
local_d0 = *plVar5;
local_e0 = (long *)*plVar4;
}
local_d8 = plVar4[1];
*plVar4 = (long)plVar5;
plVar4[1] = 0;
*(int1 *)(plVar4 + 2) = 0;
/* try { // try from 001c5f15 to 001c5f23 has its CatchHandler @ 001c5f9d */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<std::__cxx11::string>
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)local_c0,
(string *)&local_e0);
if (local_e0 != &local_d0) {
operator_delete(local_e0,local_d0 + 1);
}
lVar2 = local_98[0];
plVar4 = local_a8[0];
if (local_a8[0] != local_98) {
LAB_001c5f4f:
operator_delete(plVar4,lVar2 + 1);
}
}
else {
/* try { // try from 001c5e4e to 001c5e5a has its CatchHandler @ 001c5fde */
pBVar3 = (BuiltinRule *)
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::__cxx11::string>,std::_Select1st<std::pair<std::__cxx11::string_const,std::__cxx11::string>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
::find((_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::__cxx11::string>,std::_Select1st<std::pair<std::__cxx11::string_const,std::__cxx11::string>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
*)local_b0,psVar6);
/* try { // try from 001c5e6a to 001c5e81 has its CatchHandler @ 001c5fe0 */
if ((pBVar3 == local_b8) &&
(_add_primitive((string *)local_50,param_2), lVar2 = local_40[0], plVar4 = local_50[0],
local_50[0] != local_40)) goto LAB_001c5f4f;
}
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)&local_68);
if (local_88 != &local_78) {
operator_delete(local_88,CONCAT71(uStack_77,local_78) + 1);
}
psVar6 = psVar6 + 0x20;
} while (psVar6 != psVar1);
}
return param_1;
}
| |
47,252 | ma_ft_store | eloqsql/storage/maria/ma_ft_update.c | static int _ma_ft_store(MARIA_HA *info, uint keynr, uchar *keybuf,
FT_WORD *wlist, my_off_t filepos)
{
DBUG_ENTER("_ma_ft_store");
for (; wlist->pos; wlist++)
{
MARIA_KEY key;
_ma_ft_make_key(info, &key, keynr, keybuf, wlist, filepos);
if (_ma_ck_write(info, &key))
DBUG_RETURN(1);
}
DBUG_RETURN(0);
} | O0 | c | ma_ft_store:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0x8e24d
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
leaq -0x50(%rbp), %rsi
callq 0x8dfe0
movq -0x10(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x83950
cmpb $0x0, %al
je 0x8e23d
jmp 0x8e234
movl $0x1, -0x4(%rbp)
jmp 0x8e256
jmp 0x8e23f
movq -0x28(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
jmp 0x8e1fb
jmp 0x8e24f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
| _ma_ft_store:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
loc_8E1FB:
mov rax, [rbp+var_28]
cmp qword ptr [rax], 0
jz short loc_8E24D
mov rdi, [rbp+var_10]
mov edx, [rbp+var_14]
mov rcx, [rbp+var_20]
mov r8, [rbp+var_28]
mov r9, [rbp+var_30]
lea rsi, [rbp+var_50]
call _ma_ft_make_key
mov rdi, [rbp+var_10]
lea rsi, [rbp+var_50]
call _ma_ck_write
cmp al, 0
jz short loc_8E23D
jmp short $+2
loc_8E234:
mov [rbp+var_4], 1
jmp short loc_8E256
loc_8E23D:
jmp short $+2
loc_8E23F:
mov rax, [rbp+var_28]
add rax, 18h
mov [rbp+var_28], rax
jmp short loc_8E1FB
loc_8E24D:
jmp short $+2
loc_8E24F:
mov [rbp+var_4], 0
loc_8E256:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
| long long ma_ft_store(_DWORD *a1, unsigned int a2, _BYTE *a3, _QWORD *a4, long long a5)
{
_BYTE v6[32]; // [rsp+0h] [rbp-50h] BYREF
long long v7; // [rsp+20h] [rbp-30h]
_QWORD *v8; // [rsp+28h] [rbp-28h]
_BYTE *v9; // [rsp+30h] [rbp-20h]
unsigned int v10; // [rsp+3Ch] [rbp-14h]
_DWORD *v11; // [rsp+40h] [rbp-10h]
v11 = a1;
v10 = a2;
v9 = a3;
v8 = a4;
v7 = a5;
while ( *v8 )
{
ma_ft_make_key(v11, (long long)v6, v10, v9, (long long)v8, v7);
if ( ma_ck_write((long long)v11, (long long)v6) )
return 1;
v8 += 3;
}
return 0;
}
| _ma_ft_store:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
LAB_0018e1fb:
MOV RAX,qword ptr [RBP + -0x28]
CMP qword ptr [RAX],0x0
JZ 0x0018e24d
MOV RDI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x14]
MOV RCX,qword ptr [RBP + -0x20]
MOV R8,qword ptr [RBP + -0x28]
MOV R9,qword ptr [RBP + -0x30]
LEA RSI,[RBP + -0x50]
CALL 0x0018dfe0
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[RBP + -0x50]
CALL 0x00183950
CMP AL,0x0
JZ 0x0018e23d
JMP 0x0018e234
LAB_0018e234:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0018e256
LAB_0018e23d:
JMP 0x0018e23f
LAB_0018e23f:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x18
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0018e1fb
LAB_0018e24d:
JMP 0x0018e24f
LAB_0018e24f:
MOV dword ptr [RBP + -0x4],0x0
LAB_0018e256:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
int4
_ma_ft_store(int8 param_1,int4 param_2,int8 param_3,long *param_4,
int8 param_5)
{
char cVar1;
int1 local_58 [32];
int8 local_38;
long *local_30;
int8 local_28;
int4 local_1c;
int8 local_18;
local_38 = param_5;
local_30 = param_4;
local_28 = param_3;
local_1c = param_2;
local_18 = param_1;
while( true ) {
if (*local_30 == 0) {
return 0;
}
_ma_ft_make_key(local_18,local_58,local_1c,local_28,local_30,local_38);
cVar1 = _ma_ck_write(local_18,local_58);
if (cVar1 != '\0') break;
local_30 = local_30 + 3;
}
return 1;
}
| |
47,253 | ma_ft_store | eloqsql/storage/maria/ma_ft_update.c | static int _ma_ft_store(MARIA_HA *info, uint keynr, uchar *keybuf,
FT_WORD *wlist, my_off_t filepos)
{
DBUG_ENTER("_ma_ft_store");
for (; wlist->pos; wlist++)
{
MARIA_KEY key;
_ma_ft_make_key(info, &key, keynr, keybuf, wlist, filepos);
if (_ma_ck_write(info, &key))
DBUG_RETURN(1);
}
DBUG_RETURN(0);
} | O3 | c | ma_ft_store:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, -0x30(%rbp)
xorl %eax, %eax
cmpq $0x0, (%rcx)
je 0x6b9d4
movq %rcx, %r12
movq %rdx, %r15
movl %esi, %r13d
movq %rdi, %rbx
leaq -0x50(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl %r13d, %edx
movq %r15, %rcx
movq %r12, %r8
movq -0x30(%rbp), %r9
callq 0x6b83d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6575c
testb %al, %al
jne 0x6b9cf
cmpq $0x0, 0x18(%r12)
leaq 0x18(%r12), %r12
jne 0x6b997
xorl %eax, %eax
jmp 0x6b9d4
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ma_ft_store:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov [rbp+var_30], r8
xor eax, eax
cmp qword ptr [rcx], 0
jz short loc_6B9D4
mov r12, rcx
mov r15, rdx
mov r13d, esi
mov rbx, rdi
lea r14, [rbp+var_50]
loc_6B997:
mov rdi, rbx
mov rsi, r14
mov edx, r13d
mov rcx, r15
mov r8, r12
mov r9, [rbp+var_30]
call _ma_ft_make_key
mov rdi, rbx
mov rsi, r14
call _ma_ck_write
test al, al
jnz short loc_6B9CF
cmp qword ptr [r12+18h], 0
lea r12, [r12+18h]
jnz short loc_6B997
xor eax, eax
jmp short loc_6B9D4
loc_6B9CF:
mov eax, 1
loc_6B9D4:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ma_ft_store(_DWORD *a1, unsigned int a2, char *a3, _QWORD *a4, long long a5, __m128i a6)
{
long long result; // rax
long long i; // r12
_BYTE v10[32]; // [rsp+0h] [rbp-50h] BYREF
long long v11; // [rsp+20h] [rbp-30h]
v11 = a5;
result = 0LL;
if ( *a4 )
{
for ( i = (long long)a4; ; i += 24LL )
{
ma_ft_make_key(a1, (long long)v10, a2, a3, i, v11, a6);
if ( ma_ck_write((long long)a1, (long long)v10) )
break;
if ( *(_QWORD *)(i + 24) == 0LL )
return 0LL;
}
return 1LL;
}
return result;
}
| _ma_ft_store:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x30],R8
XOR EAX,EAX
CMP qword ptr [RCX],0x0
JZ 0x0016b9d4
MOV R12,RCX
MOV R15,RDX
MOV R13D,ESI
MOV RBX,RDI
LEA R14,[RBP + -0x50]
LAB_0016b997:
MOV RDI,RBX
MOV RSI,R14
MOV EDX,R13D
MOV RCX,R15
MOV R8,R12
MOV R9,qword ptr [RBP + -0x30]
CALL 0x0016b83d
MOV RDI,RBX
MOV RSI,R14
CALL 0x0016575c
TEST AL,AL
JNZ 0x0016b9cf
CMP qword ptr [R12 + 0x18],0x0
LEA R12,[R12 + 0x18]
JNZ 0x0016b997
XOR EAX,EAX
JMP 0x0016b9d4
LAB_0016b9cf:
MOV EAX,0x1
LAB_0016b9d4:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
_ma_ft_store(int8 param_1,int4 param_2,int8 param_3,long *param_4,
int8 param_5)
{
long *plVar1;
char cVar2;
int1 local_58 [32];
int8 local_38;
if (*param_4 != 0) {
local_38 = param_5;
do {
_ma_ft_make_key(param_1,local_58,param_2,param_3,param_4,local_38);
cVar2 = _ma_ck_write(param_1,local_58);
if (cVar2 != '\0') {
return 1;
}
plVar1 = param_4 + 3;
param_4 = param_4 + 3;
} while (*plVar1 != 0);
}
return 0;
}
| |
47,254 | LoadWaveSamples | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/raudio.c | float *LoadWaveSamples(Wave wave)
{
float *samples = (float *)RL_MALLOC(wave.frameCount*wave.channels*sizeof(float));
// NOTE: sampleCount is the total number of interlaced samples (including channels)
for (unsigned int i = 0; i < wave.frameCount*wave.channels; i++)
{
if (wave.sampleSize == 8) samples[i] = (float)(((unsigned char *)wave.data)[i] - 128)/128.0f;
else if (wave.sampleSize == 16) samples[i] = (float)(((short *)wave.data)[i])/32768.0f;
else if (wave.sampleSize == 32) samples[i] = ((float *)wave.data)[i];
}
return samples;
} | O1 | c | LoadWaveSamples:
pushq %rbx
movl 0x1c(%rsp), %ebx
imull 0x10(%rsp), %ebx
leaq (,%rbx,4), %rdi
callq 0x96f0
testl %ebx, %ebx
je 0x446ac
leaq 0x10(%rsp), %rdx
movl 0x8(%rdx), %ecx
movq 0x10(%rdx), %rdx
movl %ebx, %esi
xorl %edi, %edi
movss 0x952fb(%rip), %xmm0 # 0xd9954
movss 0x9536b(%rip), %xmm1 # 0xd99cc
cmpl $0x20, %ecx
je 0x4469a
cmpl $0x10, %ecx
je 0x44687
cmpl $0x8, %ecx
jne 0x446a4
movzbl (%rdx,%rdi), %r8d
addl $-0x80, %r8d
xorps %xmm2, %xmm2
cvtsi2ss %r8d, %xmm2
mulss %xmm1, %xmm2
jmp 0x4469f
movswl (%rdx,%rdi,2), %r8d
xorps %xmm2, %xmm2
cvtsi2ss %r8d, %xmm2
mulss %xmm0, %xmm2
jmp 0x4469f
movss (%rdx,%rdi,4), %xmm2
movss %xmm2, (%rax,%rdi,4)
incq %rdi
cmpq %rdi, %rsi
jne 0x44661
popq %rbx
retq
| LoadWaveSamples:
push rbx
mov ebx, [rsp+8+arg_C]
imul ebx, [rsp+8+arg_0]
lea rdi, ds:0[rbx*4]
call _malloc
test ebx, ebx
jz short loc_446AC
lea rdx, [rsp+8+arg_0]
mov ecx, [rdx+8]
mov rdx, [rdx+10h]
mov esi, ebx
xor edi, edi
movss xmm0, cs:dword_D9954
movss xmm1, cs:dword_D99CC
loc_44661:
cmp ecx, 20h ; ' '
jz short loc_4469A
cmp ecx, 10h
jz short loc_44687
cmp ecx, 8
jnz short loc_446A4
movzx r8d, byte ptr [rdx+rdi]
add r8d, 0FFFFFF80h
xorps xmm2, xmm2
cvtsi2ss xmm2, r8d
mulss xmm2, xmm1
jmp short loc_4469F
loc_44687:
movsx r8d, word ptr [rdx+rdi*2]
xorps xmm2, xmm2
cvtsi2ss xmm2, r8d
mulss xmm2, xmm0
jmp short loc_4469F
loc_4469A:
movss xmm2, dword ptr [rdx+rdi*4]
loc_4469F:
movss dword ptr [rax+rdi*4], xmm2
loc_446A4:
inc rdi
cmp rsi, rdi
jnz short loc_44661
loc_446AC:
pop rbx
retn
| long long LoadWaveSamples(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
int a7,
long long a8,
long long a9)
{
long long v9; // rbx
long long result; // rax
long long v11; // rdi
float v12; // xmm2_4
v9 = (unsigned int)(a7 * HIDWORD(a8));
result = malloc(4 * v9);
if ( (_DWORD)v9 )
{
v11 = 0LL;
while ( 1 )
{
if ( (_DWORD)a8 == 32 )
{
v12 = *(float *)(a9 + 4 * v11);
goto LABEL_9;
}
if ( (_DWORD)a8 == 16 )
break;
if ( (_DWORD)a8 == 8 )
{
v12 = (float)(*(unsigned __int8 *)(a9 + v11) - 128) * 0.0078125;
LABEL_9:
*(float *)(result + 4 * v11) = v12;
}
if ( (unsigned int)v9 == ++v11 )
return result;
}
v12 = (float)*(__int16 *)(a9 + 2 * v11) * 0.000030517578;
goto LABEL_9;
}
return result;
}
| LoadWaveSamples:
PUSH RBX
MOV EBX,dword ptr [RSP + 0x1c]
IMUL EBX,dword ptr [RSP + 0x10]
LEA RDI,[RBX*0x4]
CALL 0x001096f0
TEST EBX,EBX
JZ 0x001446ac
LEA RDX,[RSP + 0x10]
MOV ECX,dword ptr [RDX + 0x8]
MOV RDX,qword ptr [RDX + 0x10]
MOV ESI,EBX
XOR EDI,EDI
MOVSS XMM0,dword ptr [0x001d9954]
MOVSS XMM1,dword ptr [0x001d99cc]
LAB_00144661:
CMP ECX,0x20
JZ 0x0014469a
CMP ECX,0x10
JZ 0x00144687
CMP ECX,0x8
JNZ 0x001446a4
MOVZX R8D,byte ptr [RDX + RDI*0x1]
ADD R8D,-0x80
XORPS XMM2,XMM2
CVTSI2SS XMM2,R8D
MULSS XMM2,XMM1
JMP 0x0014469f
LAB_00144687:
MOVSX R8D,word ptr [RDX + RDI*0x2]
XORPS XMM2,XMM2
CVTSI2SS XMM2,R8D
MULSS XMM2,XMM0
JMP 0x0014469f
LAB_0014469a:
MOVSS XMM2,dword ptr [RDX + RDI*0x4]
LAB_0014469f:
MOVSS dword ptr [RAX + RDI*0x4],XMM2
LAB_001446a4:
INC RDI
CMP RSI,RDI
JNZ 0x00144661
LAB_001446ac:
POP RBX
RET
|
void LoadWaveSamples(void)
{
float fVar1;
float fVar2;
void *pvVar3;
uint uVar4;
ulong uVar5;
float fVar6;
int in_stack_00000008;
int iStack0000000000000010;
int iStack0000000000000014;
long in_stack_00000018;
uVar4 = iStack0000000000000014 * in_stack_00000008;
pvVar3 = malloc((ulong)uVar4 * 4);
fVar2 = DAT_001d99cc;
fVar1 = DAT_001d9954;
if (uVar4 != 0) {
uVar5 = 0;
do {
if (iStack0000000000000010 == 0x20) {
fVar6 = *(float *)(in_stack_00000018 + uVar5 * 4);
LAB_0014469f:
*(float *)((long)pvVar3 + uVar5 * 4) = fVar6;
}
else {
if (iStack0000000000000010 == 0x10) {
fVar6 = (float)(int)*(short *)(in_stack_00000018 + uVar5 * 2) * fVar1;
goto LAB_0014469f;
}
if (iStack0000000000000010 == 8) {
fVar6 = (float)(int)(*(byte *)(in_stack_00000018 + uVar5) - 0x80) * fVar2;
goto LAB_0014469f;
}
}
uVar5 = uVar5 + 1;
} while (uVar4 != uVar5);
}
return;
}
| |
47,255 | LoadWaveSamples | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/raudio.c | float *LoadWaveSamples(Wave wave)
{
float *samples = (float *)RL_MALLOC(wave.frameCount*wave.channels*sizeof(float));
// NOTE: sampleCount is the total number of interlaced samples (including channels)
for (unsigned int i = 0; i < wave.frameCount*wave.channels; i++)
{
if (wave.sampleSize == 8) samples[i] = (float)(((unsigned char *)wave.data)[i] - 128)/128.0f;
else if (wave.sampleSize == 16) samples[i] = (float)(((short *)wave.data)[i])/32768.0f;
else if (wave.sampleSize == 32) samples[i] = ((float *)wave.data)[i];
}
return samples;
} | O3 | c | LoadWaveSamples:
pushq %rbx
movl 0x1c(%rsp), %ebx
imull 0x10(%rsp), %ebx
leaq (,%rbx,4), %rdi
callq 0xa6f0
testl %ebx, %ebx
je 0x43f20
leaq 0x10(%rsp), %rdx
movl 0x8(%rdx), %ecx
movq 0x10(%rdx), %rdx
xorl %esi, %esi
movss 0x8fc5a(%rip), %xmm0 # 0xd3b2c
movss 0x8fcbe(%rip), %xmm1 # 0xd3b98
cmpl $0x20, %ecx
je 0x43f0e
cmpl $0x10, %ecx
je 0x43efd
cmpl $0x8, %ecx
jne 0x43f18
movzbl (%rdx,%rsi), %edi
addl $-0x80, %edi
xorps %xmm2, %xmm2
cvtsi2ss %edi, %xmm2
mulss %xmm1, %xmm2
jmp 0x43f13
movswl (%rdx,%rsi,2), %edi
xorps %xmm2, %xmm2
cvtsi2ss %edi, %xmm2
mulss %xmm0, %xmm2
jmp 0x43f13
movss (%rdx,%rsi,4), %xmm2
movss %xmm2, (%rax,%rsi,4)
incq %rsi
cmpq %rsi, %rbx
jne 0x43eda
popq %rbx
retq
| LoadWaveSamples:
push rbx
mov ebx, [rsp+8+arg_C]
imul ebx, [rsp+8+arg_0]
lea rdi, ds:0[rbx*4]
call _malloc
test ebx, ebx
jz short loc_43F20
lea rdx, [rsp+8+arg_0]
mov ecx, [rdx+8]
mov rdx, [rdx+10h]
xor esi, esi
movss xmm0, cs:dword_D3B2C
movss xmm1, cs:dword_D3B98
loc_43EDA:
cmp ecx, 20h ; ' '
jz short loc_43F0E
cmp ecx, 10h
jz short loc_43EFD
cmp ecx, 8
jnz short loc_43F18
movzx edi, byte ptr [rdx+rsi]
add edi, 0FFFFFF80h
xorps xmm2, xmm2
cvtsi2ss xmm2, edi
mulss xmm2, xmm1
jmp short loc_43F13
loc_43EFD:
movsx edi, word ptr [rdx+rsi*2]
xorps xmm2, xmm2
cvtsi2ss xmm2, edi
mulss xmm2, xmm0
jmp short loc_43F13
loc_43F0E:
movss xmm2, dword ptr [rdx+rsi*4]
loc_43F13:
movss dword ptr [rax+rsi*4], xmm2
loc_43F18:
inc rsi
cmp rbx, rsi
jnz short loc_43EDA
loc_43F20:
pop rbx
retn
| long long LoadWaveSamples(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
int a7,
long long a8,
long long a9)
{
long long v9; // rbx
long long result; // rax
long long v11; // rsi
float v12; // xmm2_4
v9 = (unsigned int)(a7 * HIDWORD(a8));
result = malloc(4 * v9);
if ( (_DWORD)v9 )
{
v11 = 0LL;
while ( 1 )
{
if ( (_DWORD)a8 == 32 )
{
v12 = *(float *)(a9 + 4 * v11);
goto LABEL_9;
}
if ( (_DWORD)a8 == 16 )
break;
if ( (_DWORD)a8 == 8 )
{
v12 = (float)(*(unsigned __int8 *)(a9 + v11) - 128) * 0.0078125;
LABEL_9:
*(float *)(result + 4 * v11) = v12;
}
if ( v9 == ++v11 )
return result;
}
v12 = (float)*(__int16 *)(a9 + 2 * v11) * 0.000030517578;
goto LABEL_9;
}
return result;
}
| LoadWaveSamples:
PUSH RBX
MOV EBX,dword ptr [RSP + 0x1c]
IMUL EBX,dword ptr [RSP + 0x10]
LEA RDI,[RBX*0x4]
CALL 0x0010a6f0
TEST EBX,EBX
JZ 0x00143f20
LEA RDX,[RSP + 0x10]
MOV ECX,dword ptr [RDX + 0x8]
MOV RDX,qword ptr [RDX + 0x10]
XOR ESI,ESI
MOVSS XMM0,dword ptr [0x001d3b2c]
MOVSS XMM1,dword ptr [0x001d3b98]
LAB_00143eda:
CMP ECX,0x20
JZ 0x00143f0e
CMP ECX,0x10
JZ 0x00143efd
CMP ECX,0x8
JNZ 0x00143f18
MOVZX EDI,byte ptr [RDX + RSI*0x1]
ADD EDI,-0x80
XORPS XMM2,XMM2
CVTSI2SS XMM2,EDI
MULSS XMM2,XMM1
JMP 0x00143f13
LAB_00143efd:
MOVSX EDI,word ptr [RDX + RSI*0x2]
XORPS XMM2,XMM2
CVTSI2SS XMM2,EDI
MULSS XMM2,XMM0
JMP 0x00143f13
LAB_00143f0e:
MOVSS XMM2,dword ptr [RDX + RSI*0x4]
LAB_00143f13:
MOVSS dword ptr [RAX + RSI*0x4],XMM2
LAB_00143f18:
INC RSI
CMP RBX,RSI
JNZ 0x00143eda
LAB_00143f20:
POP RBX
RET
|
void LoadWaveSamples(void)
{
float fVar1;
float fVar2;
void *pvVar3;
uint uVar4;
ulong uVar5;
float fVar6;
int in_stack_00000008;
int iStack0000000000000010;
int iStack0000000000000014;
long in_stack_00000018;
uVar4 = iStack0000000000000014 * in_stack_00000008;
pvVar3 = malloc((ulong)uVar4 * 4);
fVar2 = DAT_001d3b98;
fVar1 = DAT_001d3b2c;
if (uVar4 != 0) {
uVar5 = 0;
do {
if (iStack0000000000000010 == 0x20) {
fVar6 = *(float *)(in_stack_00000018 + uVar5 * 4);
LAB_00143f13:
*(float *)((long)pvVar3 + uVar5 * 4) = fVar6;
}
else {
if (iStack0000000000000010 == 0x10) {
fVar6 = (float)(int)*(short *)(in_stack_00000018 + uVar5 * 2) * fVar1;
goto LAB_00143f13;
}
if (iStack0000000000000010 == 8) {
fVar6 = (float)(int)(*(byte *)(in_stack_00000018 + uVar5) - 0x80) * fVar2;
goto LAB_00143f13;
}
}
uVar5 = uVar5 + 1;
} while (uVar4 != uVar5);
}
return;
}
| |
47,256 | baz(Employee) | slashdotted[P]corsocpp_tp_2025/S9/main.cpp | void baz(Employee e)
{
std::cout << "In baz(Employee) = " << e.classname() << '\n';
} | O1 | cpp | baz(Employee):
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x3c9d(%rip), %r14 # 0x4fd8
leaq 0x1cf2(%rip), %rsi # 0x3034
movl $0x13, %edx
movq %r14, %rdi
callq 0x1070
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1f72
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x1070
leaq 0xf(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x1070
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x139e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1060
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13c6
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1060
movq %rbx, %rdi
callq 0x1090
| _Z3baz8Employee:
push r15
push r14
push rbx
sub rsp, 30h
mov rbx, rdi
mov r14, cs:_ZSt4cout_ptr
lea rsi, aInBazEmployee; "In baz(Employee) = "
mov edx, 13h
mov rdi, r14
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea r15, [rsp+48h+var_38]
mov rdi, r15
mov rsi, rbx
call _ZNK8Employee9classnameB5cxx11Ev; Employee::classname(void)
mov rsi, [r15]
mov rdx, [r15+8]
mov rdi, r14
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, [rsp+48h+var_39]
mov byte ptr [rsi], 0Ah
mov edx, 1
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_139E
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_139E:
add rsp, 30h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
lea rax, [rsp+arg_18]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_13C6
mov rsi, [rsp+arg_18]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_13C6:
mov rdi, rbx
call __Unwind_Resume
| void baz(long long a1)
{
long long v1; // rax
char v2; // [rsp+Fh] [rbp-39h] BYREF
void *v3[2]; // [rsp+10h] [rbp-38h] BYREF
long long v4; // [rsp+20h] [rbp-28h] BYREF
std::__ostream_insert<char,std::char_traits<char>>(&std::cout, "In baz(Employee) = ", 19LL);
Employee::classname[abi:cxx11](v3, a1);
v1 = std::__ostream_insert<char,std::char_traits<char>>(&std::cout, v3[0], v3[1]);
v2 = 10;
std::__ostream_insert<char,std::char_traits<char>>(v1, &v2, 1LL);
if ( v3[0] != &v4 )
operator delete(v3[0], v4 + 1);
}
| baz:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV RBX,RDI
MOV R14,qword ptr [0x00104fd8]
LEA RSI,[0x103034]
MOV EDX,0x13
MOV RDI,R14
CALL 0x00101070
LEA R15,[RSP + 0x10]
MOV RDI,R15
MOV RSI,RBX
CALL 0x00101f72
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
LAB_00101366:
MOV RDI,R14
CALL 0x00101070
LEA RSI,[RSP + 0xf]
MOV byte ptr [RSI],0xa
MOV EDX,0x1
MOV RDI,RAX
CALL 0x00101070
LAB_00101383:
LEA RAX,[RSP + 0x20]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0010139e
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
CALL 0x00101060
LAB_0010139e:
ADD RSP,0x30
POP RBX
POP R14
POP R15
RET
|
/* baz(Employee) */
void baz(void)
{
int *puVar1;
ostream *poVar2;
char local_39;
long *local_38;
long local_30;
long local_28 [2];
puVar1 = PTR_cout_00104fd8;
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cout_00104fd8,"In baz(Employee) = ",0x13);
Employee::classname_abi_cxx11_((Employee *)&local_38);
/* try { // try from 00101366 to 00101382 has its CatchHandler @ 001013a8 */
poVar2 = std::__ostream_insert<char,std::char_traits<char>>
((ostream *)puVar1,(char *)local_38,local_30);
local_39 = '\n';
std::__ostream_insert<char,std::char_traits<char>>(poVar2,&local_39,1);
if (local_38 != local_28) {
operator_delete(local_38,local_28[0] + 1);
}
return;
}
| |
47,257 | testing::internal::GTestLog::GTestLog(testing::internal::GTestLogSeverity, char const*, int) | seiftnesse[P]memoryallocator/build_O1/_deps/googletest-src/googletest/src/gtest-port.cc | GTestLog::GTestLog(GTestLogSeverity severity, const char* file, int line)
: severity_(severity) {
const char* const marker = severity == GTEST_INFO ? "[ INFO ]"
: severity == GTEST_WARNING ? "[WARNING]"
: severity == GTEST_ERROR ? "[ ERROR ]"
: "[ FATAL ]";
GetStream() << ::std::endl
<< marker << " " << FormatFileLocation(file, line).c_str()
<< ": ";
} | O1 | cpp | testing::internal::GTestLog::GTestLog(testing::internal::GTestLogSeverity, char const*, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, (%rdi)
cmpl $0x2, %esi
leaq 0x275e5(%rip), %rax # 0x4273e
leaq 0x275e8(%rip), %rcx # 0x42748
cmoveq %rax, %rcx
cmpl $0x1, %esi
leaq 0x275c6(%rip), %rax # 0x42734
cmovneq %rcx, %rax
testl %esi, %esi
leaq 0x275af(%rip), %r15 # 0x4272a
cmovneq %rax, %r15
movq 0x3ee62(%rip), %rbx # 0x59fe8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x9470
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9050
movq %rax, %rdi
callq 0x9310
movq %rax, %rbx
movl $0x9, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x95a0
leaq 0x27c73(%rip), %rsi # 0x42e3a
movl $0x1, %edx
movq %rbx, %rdi
callq 0x95a0
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x1ac71
movq (%r15), %r14
testq %r14, %r14
je 0x1b206
movq %r14, %rdi
callq 0x91f0
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x95a0
jmp 0x1b21f
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq %rbx, %rdi
addq %rax, %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x9940
leaq 0x2876a(%rip), %rsi # 0x43990
movl $0x2, %edx
movq %rbx, %rdi
callq 0x95a0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b24e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x94c0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b277
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x94c0
movq %rbx, %rdi
callq 0x99a0
nop
| _ZN7testing8internal8GTestLogC2ENS0_16GTestLogSeverityEPKci:
push rbp; int
push r15; int
push r14; __int64
push rbx; int
sub rsp, 28h
mov ebp, ecx
mov r14, rdx
mov [rdi], esi
cmp esi, 2
lea rax, aError; "[ ERROR ]"
lea rcx, aFatal; "[ FATAL ]"
cmovz rcx, rax
cmp esi, 1
lea rax, aWarning; "[WARNING]"
cmovnz rax, rcx
test esi, esi
lea r15, aInfo; "[ INFO ]"
cmovnz r15, rax
mov rbx, cs:_ZSt4cerr_ptr
mov rax, [rbx]
mov rdi, [rax-18h]
add rdi, rbx
mov esi, 0Ah
call __ZNKSt9basic_iosIcSt11char_traitsIcEE5widenEc; std::ios::widen(char)
movsx esi, al; char
mov rdi, rbx; this
call __ZNSo3putEc; std::ostream::put(char)
mov rdi, rax; this
call __ZNSo5flushEv; std::ostream::flush(void)
mov rbx, rax
mov edx, 9
mov rdi, rax
mov rsi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, asc_42E38+2; " "
mov edx, 1
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea r15, [rsp+48h+var_40]
mov rdi, r15; int
mov rsi, r14; int
mov edx, ebp; int
call _ZN7testing8internal18FormatFileLocationB5cxx11EPKci; testing::internal::FormatFileLocation(char const*,int)
mov r14, [r15]
test r14, r14
jz short loc_1B206
mov rdi, r14
call _strlen
mov rdi, rbx
mov rsi, r14
mov rdx, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
jmp short loc_1B21F
loc_1B206:
mov rax, [rbx]
mov rax, [rax-18h]
mov rdi, rbx
add rdi, rax
mov esi, [rbx+rax+20h]
or esi, 1
call __ZNSt9basic_iosIcSt11char_traitsIcEE5clearESt12_Ios_Iostate; std::ios::clear(std::_Ios_Iostate)
loc_1B21F:
lea rsi, asc_4398F+1; ": "
mov edx, 2
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rax, [rsp+48h+var_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_1B24E
mov rsi, [rsp+48h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1B24E:
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_1B277
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1B277:
mov rdi, rbx
call __Unwind_Resume
| void testing::internal::GTestLog::GTestLog(_DWORD *a1, int a2, char *a3, int a4)
{
const char *v6; // rcx
const char *v7; // rax
const char *v8; // r15
char v9; // al
std::ostream *v10; // rax
_QWORD *v11; // rbx
long long *v12; // r14
long long v13; // rax
long long *v14; // [rsp+8h] [rbp-40h] BYREF
long long v15; // [rsp+18h] [rbp-30h] BYREF
*a1 = a2;
v6 = "[ FATAL ]";
if ( a2 == 2 )
v6 = "[ ERROR ]";
v7 = "[WARNING]";
if ( a2 != 1 )
v7 = v6;
v8 = "[ INFO ]";
if ( a2 )
v8 = v7;
v9 = std::ios::widen((char *)&std::cerr + *(_QWORD *)(std::cerr - 24LL), 10LL);
v10 = (std::ostream *)std::ostream::put((std::ostream *)&std::cerr, v9);
v11 = (_QWORD *)std::ostream::flush(v10);
std::__ostream_insert<char,std::char_traits<char>>(v11, v8, 9LL);
std::__ostream_insert<char,std::char_traits<char>>(v11, " ", 1LL);
testing::internal::FormatFileLocation[abi:cxx11]((long long)&v14, a3, a4);
v12 = v14;
if ( v14 )
{
v13 = strlen(v14);
std::__ostream_insert<char,std::char_traits<char>>(v11, v12, v13);
}
else
{
std::ios::clear(
(char *)v11 + *(_QWORD *)(*v11 - 24LL),
*(_DWORD *)((char *)v11 + *(_QWORD *)(*v11 - 24LL) + 32) | 1u);
}
std::__ostream_insert<char,std::char_traits<char>>(v11, ": ", 2LL);
if ( v14 != &v15 )
operator delete(v14, v15 + 1);
}
| GTestLog:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV EBP,ECX
MOV R14,RDX
MOV dword ptr [RDI],ESI
CMP ESI,0x2
LEA RAX,[0x14273e]
LEA RCX,[0x142748]
CMOVZ RCX,RAX
CMP ESI,0x1
LEA RAX,[0x142734]
CMOVNZ RAX,RCX
TEST ESI,ESI
LEA R15,[0x14272a]
CMOVNZ R15,RAX
MOV RBX,qword ptr [0x00159fe8]
MOV RAX,qword ptr [RBX]
MOV RDI,qword ptr [RAX + -0x18]
ADD RDI,RBX
MOV ESI,0xa
CALL 0x00109470
MOVSX ESI,AL
MOV RDI,RBX
CALL 0x00109050
MOV RDI,RAX
CALL 0x00109310
MOV RBX,RAX
MOV EDX,0x9
MOV RDI,RAX
MOV RSI,R15
CALL 0x001095a0
LEA RSI,[0x142e3a]
MOV EDX,0x1
MOV RDI,RBX
CALL 0x001095a0
LEA R15,[RSP + 0x8]
MOV RDI,R15
MOV RSI,R14
MOV EDX,EBP
CALL 0x0011ac71
MOV R14,qword ptr [R15]
TEST R14,R14
JZ 0x0011b206
MOV RDI,R14
CALL 0x001091f0
LAB_0011b1f6:
MOV RDI,RBX
MOV RSI,R14
MOV RDX,RAX
CALL 0x001095a0
JMP 0x0011b21f
LAB_0011b206:
MOV RAX,qword ptr [RBX]
MOV RAX,qword ptr [RAX + -0x18]
MOV RDI,RBX
ADD RDI,RAX
MOV ESI,dword ptr [RBX + RAX*0x1 + 0x20]
OR ESI,0x1
CALL 0x00109940
LAB_0011b21f:
LEA RSI,[0x143990]
MOV EDX,0x2
MOV RDI,RBX
CALL 0x001095a0
LAB_0011b233:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0011b24e
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001094c0
LAB_0011b24e:
ADD RSP,0x28
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* testing::internal::GTestLog::GTestLog(testing::internal::GTestLogSeverity, char const*, int) */
void __thiscall
testing::internal::GTestLog::GTestLog(GTestLog *this,int param_2,char *param_3,int param_4)
{
char cVar1;
long *plVar2;
char *pcVar3;
ostream *poVar4;
size_t sVar5;
char *pcVar6;
long *local_40 [2];
long local_30 [2];
*(int *)this = param_2;
pcVar6 = "[ FATAL ]";
if (param_2 == 2) {
pcVar6 = "[ ERROR ]";
}
pcVar3 = "[WARNING]";
if (param_2 != 1) {
pcVar3 = pcVar6;
}
pcVar6 = "[ INFO ]";
if (param_2 != 0) {
pcVar6 = pcVar3;
}
cVar1 = (char)PTR_cerr_00159fe8;
std::ios::widen((char)*(int8 *)(*(long *)PTR_cerr_00159fe8 + -0x18) + cVar1);
std::ostream::put(cVar1);
poVar4 = (ostream *)std::ostream::flush();
std::__ostream_insert<char,std::char_traits<char>>(poVar4,pcVar6,9);
std::__ostream_insert<char,std::char_traits<char>>(poVar4," ",1);
FormatFileLocation_abi_cxx11_((internal *)local_40,param_3,param_4);
plVar2 = local_40[0];
if (local_40[0] == (long *)0x0) {
std::ios::clear(poVar4 + *(long *)(*(long *)poVar4 + -0x18),
*(uint *)(poVar4 + *(long *)(*(long *)poVar4 + -0x18) + 0x20) | 1);
}
else {
sVar5 = strlen((char *)local_40[0]);
/* try { // try from 0011b1f6 to 0011b232 has its CatchHandler @ 0011b259 */
std::__ostream_insert<char,std::char_traits<char>>(poVar4,(char *)plVar2,sVar5);
}
std::__ostream_insert<char,std::char_traits<char>>(poVar4,": ",2);
if (local_40[0] != local_30) {
operator_delete(local_40[0],local_30[0] + 1);
}
return;
}
| |
47,258 | load_image(llava_context*, common_params*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/examples/llava/llava-cli.cpp | static struct llava_image_embed * load_image(llava_context * ctx_llava, common_params * params, const std::string & fname) {
// load and preprocess the image
llava_image_embed * embed = NULL;
auto prompt = params->prompt;
if (prompt_contains_image(prompt)) {
if (!params->image.empty()) {
LOG_INF("using base64 encoded image instead of command line image path\n");
}
embed = llava_image_embed_make_with_prompt_base64(ctx_llava->ctx_clip, params->cpuparams.n_threads, prompt);
if (!embed) {
LOG_ERR("%s: can't load image from prompt\n", __func__);
return NULL;
}
params->prompt = remove_image_from_prompt(prompt);
} else {
embed = llava_image_embed_make_with_filename(ctx_llava->ctx_clip, params->cpuparams.n_threads, fname.c_str());
if (!embed) {
fprintf(stderr, "%s: is %s really an image file?\n", __func__, fname.c_str());
return NULL;
}
}
return embed;
} | O2 | cpp | load_image(llava_context*, common_params*, 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 $0xb8, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
leaq 0xe18(%rsi), %rbx
leaq 0x48(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0x27120
movq %r13, %rdi
callq 0x293be
testb %al, %al
je 0x29609
movq 0x1020(%r15), %rax
leaq 0xf9398(%rip), %r13 # 0x1228f0
cmpq 0x1028(%r15), %rax
je 0x29581
cmpl $0x0, (%r13)
js 0x29581
callq 0xb23f2
leaq 0x9be90(%rip), %rdx # 0xc5404
pushq $0x2
popq %rsi
movq %rax, %rdi
xorl %eax, %eax
callq 0xb248a
movq (%r14), %r14
movl 0x274(%r15), %ebp
leaq 0x48(%rsp), %rdi
leaq 0x70(%rsp), %r15
leaq 0x90(%rsp), %r12
movq %r15, %rsi
movq %r12, %rdx
callq 0x2a08a
movq (%r15), %rdx
cmpq $-0x1, %rdx
sete %al
movq (%r12), %rcx
cmpq $-0x1, %rcx
sete %sil
orb %al, %sil
cmpb $0x1, %sil
jne 0x29653
cmpl $0x0, (%r13)
js 0x2975e
callq 0xb23f2
leaq 0x9beaf(%rip), %rdx # 0xc5491
leaq 0x9bee8(%rip), %rcx # 0xc54d1
leaq 0x9bd71(%rip), %r8 # 0xc5361
leaq 0x9bd8c(%rip), %r9 # 0xc5383
pushq $0x4
popq %rsi
movq %rax, %rdi
xorl %eax, %eax
callq 0xb248a
jmp 0x2975e
movq (%r14), %rdi
movl 0x274(%r15), %esi
movq (%r12), %rdx
callq 0x2ced9
movq %rax, %r14
testq %rax, %rax
jne 0x29825
movq 0xf7959(%rip), %rax # 0x120f88
movq (%rax), %rdi
movq (%r12), %rcx
leaq 0x9be33(%rip), %rsi # 0xc5470
leaq 0x9be21(%rip), %rdx # 0xc5465
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x271f0
jmp 0x29825
addq $0x21, %rdx
subq %rdx, %rcx
leaq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x26ce0
movq 0x30(%rsp), %rax
pushq $0x3
popq %rcx
xorl %edx, %edx
divq %rcx
cmpq $0x1, %rdx
sbbq $-0x1, %rax
leaq (,%rax,4), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rdx
callq 0x2b906
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
addq %rdi, %rsi
movq 0x8(%rsp), %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2b958
movq 0x8(%rsp), %rdx
movl 0x10(%rsp), %ecx
subl %edx, %ecx
movq %r14, %rdi
movl %ebp, %esi
callq 0x2ce12
movq %rax, %r14
testq %rax, %rax
jne 0x296f5
cmpl $0x0, (%r13)
js 0x296f5
callq 0xb23f2
leaq 0x9be1a(%rip), %rdx # 0xc54fb
leaq 0x9bde9(%rip), %rcx # 0xc54d1
pushq $0x4
popq %rsi
movq %rax, %rdi
xorl %eax, %eax
callq 0xb248a
leaq 0x8(%rsp), %rdi
callq 0x2bb1e
leaq 0x28(%rsp), %rdi
callq 0x27998
testq %r14, %r14
je 0x2975e
leaq 0x48(%rsp), %rdi
leaq 0x68(%rsp), %r15
leaq 0xb0(%rsp), %r12
movq %r15, %rsi
movq %r12, %rdx
callq 0x2a08a
movq (%r15), %rcx
cmpq $-0x1, %rcx
sete %al
movq (%r12), %r15
cmpq $-0x1, %r15
sete %dl
orb %al, %dl
cmpb $0x1, %dl
jne 0x29795
leaq 0x90(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x27120
jmp 0x2980a
cmpl $0x0, (%r13)
js 0x2978d
callq 0xb23f2
xorl %r14d, %r14d
leaq 0x9bccf(%rip), %rdx # 0xc5443
leaq 0x9bcea(%rip), %rcx # 0xc5465
pushq $0x4
popq %rsi
movq %rax, %rdi
xorl %eax, %eax
callq 0xb248a
jmp 0x29825
xorl %r14d, %r14d
jmp 0x29825
leaq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rsi
xorl %edx, %edx
callq 0x26ce0
addq $0x2, %r15
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
pushq $-0x1
popq %rcx
movq %r15, %rdx
callq 0x26ce0
leaq 0x9b974(%rip), %rdx # 0xc513a
leaq 0x70(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2bcbe
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x2bc9f
leaq 0x70(%rsp), %rdi
callq 0x27998
leaq 0x8(%rsp), %rdi
callq 0x27998
leaq 0x28(%rsp), %rdi
callq 0x27998
leaq 0x90(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x26f10
movq %r15, %rdi
callq 0x27998
leaq 0x48(%rsp), %rdi
callq 0x27998
movq %r14, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x27998
jmp 0x29856
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x27998
jmp 0x2987a
jmp 0x29868
jmp 0x29886
jmp 0x2986d
movq %rax, %rbx
jmp 0x2987a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2bb1e
leaq 0x28(%rsp), %rdi
callq 0x27998
jmp 0x29889
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x27998
movq %rbx, %rdi
callq 0x27660
| _ZL10load_imageP13llava_contextP13common_paramsRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0B8h
mov r12, rdx
mov r15, rsi
mov r14, rdi
lea rbx, [rsi+0E18h]
lea r13, [rsp+0E8h+var_A0]
mov rdi, r13
mov rsi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
mov rdi, r13
call _ZL21prompt_contains_imageRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; prompt_contains_image(std::string const&)
test al, al
jz loc_29609
mov rax, [r15+1020h]
lea r13, common_log_verbosity_thold
cmp rax, [r15+1028h]
jz short loc_29581
cmp dword ptr [r13+0], 0
js short loc_29581
call _Z15common_log_mainv; common_log_main(void)
lea rdx, aUsingBase64Enc; "using base64 encoded image instead of c"...
push 2
pop rsi
mov rdi, rax
xor eax, eax
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
loc_29581:
mov r14, [r14]
mov ebp, [r15+274h]
lea rdi, [rsp+0E8h+var_A0]
lea r15, [rsp+0E8h+var_78]
lea r12, [rsp+0E8h+var_58]
mov rsi, r15
mov rdx, r12
call _ZL24find_image_tag_in_promptRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERmS7_; find_image_tag_in_prompt(std::string const&,ulong &,ulong &)
mov rdx, [r15]
cmp rdx, 0FFFFFFFFFFFFFFFFh
setz al
mov rcx, [r12]
cmp rcx, 0FFFFFFFFFFFFFFFFh
setz sil
or sil, al
cmp sil, 1
jnz loc_29653
cmp dword ptr [r13+0], 0
js loc_2975E
call _Z15common_log_mainv; common_log_main(void)
lea rdx, aSInvalidBase64; "%s: invalid base64 image tag. must be %"...
lea rcx, aLlavaImageEmbe; "llava_image_embed_make_with_prompt_base"...
lea r8, aImgSrcDataImag; "<img src=\"data:image/jpeg;base64,"
lea r9, asc_C5383; "\">"
push 4
pop rsi
mov rdi, rax
xor eax, eax
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
jmp loc_2975E
loc_29609:
mov rdi, [r14]
mov esi, [r15+274h]
mov rdx, [r12]
call llava_image_embed_make_with_filename
mov r14, rax
test rax, rax
jnz loc_29825
mov rax, cs:stderr_ptr
mov rdi, [rax]
mov rcx, [r12]
lea rsi, aSIsSReallyAnIm; "%s: is %s really an image file?\n"
lea rdx, aLoadImage; "load_image"
xor r14d, r14d
xor eax, eax
call _fprintf
jmp loc_29825
loc_29653:
add rdx, 21h ; '!'
sub rcx, rdx
lea rdi, [rsp+0E8h+var_C0]
lea rsi, [rsp+0E8h+var_A0]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
mov rax, [rsp+0E8h+var_B8]
push 3
pop rcx
xor edx, edx
div rcx
cmp rdx, 1
sbb rax, 0FFFFFFFFFFFFFFFFh
lea rsi, ds:0[rax*4]
lea rdi, [rsp+0E8h+var_E0]
lea rdx, [rsp+0E8h+var_80]
call _ZNSt6vectorIhSaIhEEC2EmRKS0_; std::vector<uchar>::vector(ulong,std::allocator<uchar> const&)
mov rdi, [rsp+0E8h+var_C0]
mov rsi, [rsp+0E8h+var_B8]
add rsi, rdi
mov rdx, [rsp+0E8h+var_E0]
xor ecx, ecx
xor r8d, r8d
call _ZN6base646decodeIN9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEENS2_IPhSt6vectorIhSaIhEEEEEET0_T_SH_SG_NS_8alphabetENS_17decoding_behaviorE; base64::decode<__gnu_cxx::__normal_iterator<char *,std::string>,__gnu_cxx::__normal_iterator<uchar *,std::vector<uchar>>>(__gnu_cxx::__normal_iterator<char *,std::string>,__gnu_cxx::__normal_iterator<char *,std::string>,__gnu_cxx::__normal_iterator<uchar *,std::vector<uchar>>,base64::alphabet,base64::decoding_behavior)
mov rdx, [rsp+0E8h+var_E0]
mov ecx, [rsp+0E8h+var_D8]
sub ecx, edx
mov rdi, r14
mov esi, ebp
call llava_image_embed_make_with_bytes
mov r14, rax
test rax, rax
jnz short loc_296F5
cmp dword ptr [r13+0], 0
js short loc_296F5
call _Z15common_log_mainv; common_log_main(void)
lea rdx, aSCouldNotLoadI; "%s: could not load image from base64 st"...
lea rcx, aLlavaImageEmbe; "llava_image_embed_make_with_prompt_base"...
push 4
pop rsi
mov rdi, rax
xor eax, eax
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
loc_296F5:
lea rdi, [rsp+0E8h+var_E0]
call _ZNSt12_Vector_baseIhSaIhEED2Ev; std::_Vector_base<uchar>::~_Vector_base()
lea rdi, [rsp+0E8h+var_C0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test r14, r14
jz short loc_2975E
lea rdi, [rsp+0E8h+var_A0]
lea r15, [rsp+0E8h+var_80]
lea r12, [rsp+0E8h+var_38]
mov rsi, r15
mov rdx, r12
call _ZL24find_image_tag_in_promptRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERmS7_; find_image_tag_in_prompt(std::string const&,ulong &,ulong &)
mov rcx, [r15]
cmp rcx, 0FFFFFFFFFFFFFFFFh
setz al
mov r15, [r12]
cmp r15, 0FFFFFFFFFFFFFFFFh
setz dl
or dl, al
cmp dl, 1
jnz short loc_29795
lea rdi, [rsp+0E8h+var_58]
lea rsi, [rsp+0E8h+var_A0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
jmp loc_2980A
loc_2975E:
cmp dword ptr [r13+0], 0
js short loc_2978D
call _Z15common_log_mainv; common_log_main(void)
xor r14d, r14d
lea rdx, aSCanTLoadImage; "%s: can't load image from prompt\n"
lea rcx, aLoadImage; "load_image"
push 4
pop rsi
mov rdi, rax
xor eax, eax
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
jmp loc_29825
loc_2978D:
xor r14d, r14d
jmp loc_29825
loc_29795:
lea rdi, [rsp+0E8h+var_C0]
lea rsi, [rsp+0E8h+var_A0]
xor edx, edx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
add r15, 2
lea rdi, [rsp+0E8h+var_E0]
lea rsi, [rsp+0E8h+var_A0]
push 0FFFFFFFFFFFFFFFFh
pop rcx
mov rdx, r15
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
lea rdx, aSFailedToLoadI+2Ah; ""
lea rdi, [rsp+0E8h+var_78]
lea rsi, [rsp+0E8h+var_C0]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EERKS8_PKS5_; std::operator+<char>(std::string const&,char const*)
lea rdi, [rsp+0E8h+var_58]
lea rsi, [rsp+0E8h+var_78]
lea rdx, [rsp+0E8h+var_E0]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_RKS8_; std::operator+<char>(std::string&&,std::string const&)
lea rdi, [rsp+0E8h+var_78]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+0E8h+var_E0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+0E8h+var_C0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_2980A:
lea r15, [rsp+0E8h+var_58]
mov rdi, rbx
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, r15; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_29825:
lea rdi, [rsp+0E8h+var_A0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rax, r14
add rsp, 0B8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rdi, [rsp+arg_68]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_29856
mov rbx, rax
loc_29856:
lea rdi, [rsp+arg_0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_2987A
jmp short loc_29868
jmp short loc_29886
jmp short loc_2986D
loc_29868:
mov rbx, rax
jmp short loc_2987A
loc_2986D:
mov rbx, rax
lea rdi, [rsp+arg_0]
call _ZNSt12_Vector_baseIhSaIhEED2Ev; std::_Vector_base<uchar>::~_Vector_base()
loc_2987A:
lea rdi, [rsp+arg_20]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_29889
loc_29886:
mov rbx, rax
loc_29889:
lea rdi, [rsp+arg_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
call __Unwind_Resume
| long long load_image(_QWORD *a1, long long a2, const char **a3)
{
int v4; // eax
int v5; // ecx
int v6; // r8d
int v7; // r9d
long long v8; // r14
unsigned int v9; // ebp
int v10; // eax
long long v11; // r14
int v12; // eax
int v13; // r8d
int v14; // r9d
long long v15; // r15
int v16; // eax
int v17; // r8d
int v18; // r9d
long long v20; // [rsp+8h] [rbp-E0h] BYREF
int v21; // [rsp+10h] [rbp-D8h]
long long v22; // [rsp+28h] [rbp-C0h] BYREF
unsigned long long v23; // [rsp+30h] [rbp-B8h]
_BYTE v24[32]; // [rsp+48h] [rbp-A0h] BYREF
long long v25; // [rsp+68h] [rbp-80h] BYREF
_QWORD v26[4]; // [rsp+70h] [rbp-78h] BYREF
_QWORD v27[4]; // [rsp+90h] [rbp-58h] BYREF
_QWORD v28[7]; // [rsp+B0h] [rbp-38h] BYREF
std::string::basic_string(v24, a2 + 3608);
if ( prompt_contains_image((long long)v24) )
{
if ( *(_QWORD *)(a2 + 4128) != *(_QWORD *)(a2 + 4136) && common_log_verbosity_thold >= 0 )
{
v4 = common_log_main();
common_log_add(v4, 2, (unsigned int)"using base64 encoded image instead of command line image path\n", v5, v6, v7);
}
v8 = *a1;
v9 = *(_DWORD *)(a2 + 628);
find_image_tag_in_prompt(v24, v26, v27);
if ( v26[0] == -1LL || v27[0] == -1LL )
{
if ( common_log_verbosity_thold >= 0 )
{
v10 = common_log_main();
common_log_add(
v10,
4,
(unsigned int)"%s: invalid base64 image tag. must be %s<base64 byte string>%s\n",
(unsigned int)"llava_image_embed_make_with_prompt_base64",
(unsigned int)"<img src=\"data:image/jpeg;base64,",
(unsigned int)"\">");
}
LABEL_16:
if ( common_log_verbosity_thold < 0 )
{
v11 = 0LL;
}
else
{
v16 = common_log_main();
v11 = 0LL;
common_log_add(v16, 4, (unsigned int)"%s: can't load image from prompt\n", (unsigned int)"load_image", v17, v18);
}
goto LABEL_21;
}
std::string::substr(&v22, v24, v26[0] + 33LL, v27[0] - (v26[0] + 33LL));
std::vector<unsigned char>::vector(&v20, 4 * (v23 / 3 - ((v23 % 3 == 0) - 1LL)), &v25);
base64::decode<__gnu_cxx::__normal_iterator<char *,std::string>,__gnu_cxx::__normal_iterator<unsigned char *,std::vector<unsigned char>>>(
v22,
v22 + v23,
v20,
0LL,
0LL);
v11 = llava_image_embed_make_with_bytes(v8, v9, v20, (unsigned int)(v21 - v20));
if ( !v11 && common_log_verbosity_thold >= 0 )
{
v12 = common_log_main();
common_log_add(
v12,
4,
(unsigned int)"%s: could not load image from base64 string.\n",
(unsigned int)"llava_image_embed_make_with_prompt_base64",
v13,
v14);
}
std::_Vector_base<unsigned char>::~_Vector_base(&v20);
std::string::~string(&v22);
if ( !v11 )
goto LABEL_16;
find_image_tag_in_prompt(v24, &v25, v28);
v15 = v28[0];
if ( v25 == -1 || v28[0] == -1LL )
{
std::string::basic_string(v27, v24);
}
else
{
std::string::substr(&v22, v24, 0LL, v25);
std::string::substr(&v20, v24, v15 + 2, -1LL);
std::operator+<char>(v26, &v22, "");
std::operator+<char>(v27, v26, &v20);
std::string::~string(v26);
std::string::~string(&v20);
std::string::~string(&v22);
}
std::string::operator=(a2 + 3608, v27);
std::string::~string(v27);
}
else
{
v11 = llava_image_embed_make_with_filename(*a1, *(unsigned int *)(a2 + 628), *a3);
if ( !v11 )
{
v11 = 0LL;
fprintf(stderr, "%s: is %s really an image file?\n", "load_image", *a3);
}
}
LABEL_21:
std::string::~string(v24);
return v11;
}
| load_image:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xb8
MOV R12,RDX
MOV R15,RSI
MOV R14,RDI
LEA RBX,[RSI + 0xe18]
LEA R13,[RSP + 0x48]
MOV RDI,R13
MOV RSI,RBX
CALL 0x00127120
MOV RDI,R13
CALL 0x001293be
TEST AL,AL
JZ 0x00129609
MOV RAX,qword ptr [R15 + 0x1020]
LEA R13,[0x2228f0]
CMP RAX,qword ptr [R15 + 0x1028]
JZ 0x00129581
CMP dword ptr [R13],0x0
JS 0x00129581
LAB_00129568:
CALL 0x001b23f2
LEA RDX,[0x1c5404]
PUSH 0x2
POP RSI
MOV RDI,RAX
XOR EAX,EAX
CALL 0x001b248a
LAB_00129581:
MOV R14,qword ptr [R14]
MOV EBP,dword ptr [R15 + 0x274]
LEA RDI,[RSP + 0x48]
LEA R15,[RSP + 0x70]
LEA R12,[RSP + 0x90]
MOV RSI,R15
MOV RDX,R12
CALL 0x0012a08a
MOV RDX,qword ptr [R15]
CMP RDX,-0x1
SETZ AL
MOV RCX,qword ptr [R12]
CMP RCX,-0x1
SETZ SIL
OR SIL,AL
CMP SIL,0x1
JNZ 0x00129653
CMP dword ptr [R13],0x0
JS 0x0012975e
CALL 0x001b23f2
LEA RDX,[0x1c5491]
LEA RCX,[0x1c54d1]
LEA R8,[0x1c5361]
LEA R9,[0x1c5383]
PUSH 0x4
POP RSI
MOV RDI,RAX
XOR EAX,EAX
CALL 0x001b248a
JMP 0x0012975e
LAB_00129609:
MOV RDI,qword ptr [R14]
MOV ESI,dword ptr [R15 + 0x274]
MOV RDX,qword ptr [R12]
CALL 0x0012ced9
MOV R14,RAX
TEST RAX,RAX
JNZ 0x00129825
MOV RAX,qword ptr [0x00220f88]
MOV RDI,qword ptr [RAX]
MOV RCX,qword ptr [R12]
LEA RSI,[0x1c5470]
LEA RDX,[0x1c5465]
XOR R14D,R14D
XOR EAX,EAX
CALL 0x001271f0
JMP 0x00129825
LAB_00129653:
ADD RDX,0x21
SUB RCX,RDX
LEA RDI,[RSP + 0x28]
LEA RSI,[RSP + 0x48]
CALL 0x00126ce0
MOV RAX,qword ptr [RSP + 0x30]
PUSH 0x3
POP RCX
XOR EDX,EDX
DIV RCX
CMP RDX,0x1
SBB RAX,-0x1
LEA RSI,[RAX*0x4]
LAB_00129686:
LEA RDI,[RSP + 0x8]
LEA RDX,[RSP + 0x68]
CALL 0x0012b906
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x30]
ADD RSI,RDI
MOV RDX,qword ptr [RSP + 0x8]
LAB_001296a7:
XOR ECX,ECX
XOR R8D,R8D
CALL 0x0012b958
MOV RDX,qword ptr [RSP + 0x8]
MOV ECX,dword ptr [RSP + 0x10]
SUB ECX,EDX
LAB_001296bc:
MOV RDI,R14
MOV ESI,EBP
CALL 0x0012ce12
MOV R14,RAX
TEST RAX,RAX
JNZ 0x001296f5
CMP dword ptr [R13],0x0
JS 0x001296f5
CALL 0x001b23f2
LEA RDX,[0x1c54fb]
LEA RCX,[0x1c54d1]
PUSH 0x4
POP RSI
MOV RDI,RAX
XOR EAX,EAX
CALL 0x001b248a
LAB_001296f5:
LEA RDI,[RSP + 0x8]
CALL 0x0012bb1e
LEA RDI,[RSP + 0x28]
CALL 0x00127998
TEST R14,R14
JZ 0x0012975e
LEA RDI,[RSP + 0x48]
LEA R15,[RSP + 0x68]
LEA R12,[RSP + 0xb0]
MOV RSI,R15
MOV RDX,R12
CALL 0x0012a08a
MOV RCX,qword ptr [R15]
CMP RCX,-0x1
SETZ AL
MOV R15,qword ptr [R12]
CMP R15,-0x1
SETZ DL
OR DL,AL
CMP DL,0x1
JNZ 0x00129795
LAB_00129747:
LEA RDI,[RSP + 0x90]
LEA RSI,[RSP + 0x48]
CALL 0x00127120
JMP 0x0012980a
LAB_0012975e:
CMP dword ptr [R13],0x0
JS 0x0012978d
LAB_00129765:
CALL 0x001b23f2
XOR R14D,R14D
LEA RDX,[0x1c5443]
LEA RCX,[0x1c5465]
PUSH 0x4
POP RSI
MOV RDI,RAX
XOR EAX,EAX
CALL 0x001b248a
JMP 0x00129825
LAB_0012978d:
XOR R14D,R14D
JMP 0x00129825
LAB_00129795:
LEA RDI,[RSP + 0x28]
LEA RSI,[RSP + 0x48]
XOR EDX,EDX
CALL 0x00126ce0
ADD R15,0x2
LAB_001297aa:
LEA RDI,[RSP + 0x8]
LEA RSI,[RSP + 0x48]
PUSH -0x1
POP RCX
MOV RDX,R15
CALL 0x00126ce0
LAB_001297bf:
LEA RDX,[0x1c513a]
LEA RDI,[RSP + 0x70]
LEA RSI,[RSP + 0x28]
CALL 0x0012bcbe
LAB_001297d5:
LEA RDI,[RSP + 0x90]
LEA RSI,[RSP + 0x70]
LEA RDX,[RSP + 0x8]
CALL 0x0012bc9f
LAB_001297ec:
LEA RDI,[RSP + 0x70]
CALL 0x00127998
LEA RDI,[RSP + 0x8]
CALL 0x00127998
LEA RDI,[RSP + 0x28]
CALL 0x00127998
LAB_0012980a:
LEA R15,[RSP + 0x90]
MOV RDI,RBX
MOV RSI,R15
CALL 0x00126f10
MOV RDI,R15
CALL 0x00127998
LAB_00129825:
LEA RDI,[RSP + 0x48]
CALL 0x00127998
MOV RAX,R14
ADD RSP,0xb8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* load_image(llava_context*, common_params*, std::__cxx11::string const&) */
long load_image(llava_context *param_1,common_params *param_2,string *param_3)
{
int4 uVar1;
char cVar2;
int8 uVar3;
long lVar4;
int8 local_e0;
int local_d8;
long local_c0;
ulong local_b8;
string local_a0 [32];
ulong local_80;
ulong local_78 [4];
ulong local_58 [4];
ulong local_38;
std::__cxx11::string::string(local_a0,(string *)(param_2 + 0xe18));
cVar2 = prompt_contains_image(local_a0);
if (cVar2 == '\0') {
lVar4 = llava_image_embed_make_with_filename
(*(int8 *)param_1,*(int4 *)(param_2 + 0x274),
*(int8 *)param_3);
if (lVar4 == 0) {
lVar4 = 0;
fprintf(*(FILE **)PTR_stderr_00220f88,"%s: is %s really an image file?\n","load_image",
*(int8 *)param_3);
}
}
else {
if ((*(long *)(param_2 + 0x1020) != *(long *)(param_2 + 0x1028)) &&
(-1 < common_log_verbosity_thold)) {
/* try { // try from 00129568 to 00129668 has its CatchHandler @ 00129886 */
uVar3 = common_log_main();
common_log_add(uVar3,2,"using base64 encoded image instead of command line image path\n");
}
uVar3 = *(int8 *)param_1;
uVar1 = *(int4 *)(param_2 + 0x274);
find_image_tag_in_prompt(local_a0,local_78,local_58);
if (local_58[0] == 0xffffffffffffffff || local_78[0] == 0xffffffffffffffff) {
if (-1 < common_log_verbosity_thold) {
uVar3 = common_log_main();
common_log_add(uVar3,4,"%s: invalid base64 image tag. must be %s<base64 byte string>%s\n",
"llava_image_embed_make_with_prompt_base64",
"<img src=\"data:image/jpeg;base64,",&DAT_001c5383);
}
}
else {
std::__cxx11::string::substr((ulong)&local_c0,(ulong)local_a0);
/* try { // try from 00129686 to 00129694 has its CatchHandler @ 00129868 */
std::vector<unsigned_char,std::allocator<unsigned_char>>::vector
((vector<unsigned_char,std::allocator<unsigned_char>> *)&local_e0,
((local_b8 / 3 + 1) - (ulong)(local_b8 % 3 == 0)) * 4,(allocator *)&local_80);
/* try { // try from 001296a7 to 001296b0 has its CatchHandler @ 00129866 */
base64::
decode<__gnu_cxx::__normal_iterator<char*,std::__cxx11::string>,__gnu_cxx::__normal_iterator<unsigned_char*,std::vector<unsigned_char,std::allocator<unsigned_char>>>>
(local_c0,local_b8 + local_c0,local_e0,0,0);
/* try { // try from 001296bc to 001296f4 has its CatchHandler @ 0012986d */
lVar4 = llava_image_embed_make_with_bytes(uVar3,uVar1,local_e0,local_d8 - (int)local_e0);
if ((lVar4 == 0) && (-1 < common_log_verbosity_thold)) {
uVar3 = common_log_main();
common_log_add(uVar3,4,"%s: could not load image from base64 string.\n",
"llava_image_embed_make_with_prompt_base64");
}
std::_Vector_base<unsigned_char,std::allocator<unsigned_char>>::~_Vector_base
((_Vector_base<unsigned_char,std::allocator<unsigned_char>> *)&local_e0);
std::__cxx11::string::~string((string *)&local_c0);
if (lVar4 != 0) {
find_image_tag_in_prompt(local_a0,&local_80,&local_38);
if (local_38 == 0xffffffffffffffff || local_80 == 0xffffffffffffffff) {
/* try { // try from 00129747 to 00129758 has its CatchHandler @ 00129864 */
std::__cxx11::string::string((string *)local_58,local_a0);
}
else {
/* try { // try from 00129795 to 001297a5 has its CatchHandler @ 00129864 */
std::__cxx11::string::substr((ulong)&local_c0,(ulong)local_a0);
/* try { // try from 001297aa to 001297be has its CatchHandler @ 00129862 */
std::__cxx11::string::substr((ulong)&local_e0,(ulong)local_a0);
/* try { // try from 001297bf to 001297d4 has its CatchHandler @ 00129853 */
std::operator+((string *)local_78,(char *)&local_c0);
/* try { // try from 001297d5 to 001297eb has its CatchHandler @ 00129844 */
std::operator+((string *)local_58,(string *)local_78);
std::__cxx11::string::~string((string *)local_78);
std::__cxx11::string::~string((string *)&local_e0);
std::__cxx11::string::~string((string *)&local_c0);
}
std::__cxx11::string::operator=((string *)(param_2 + 0xe18),(string *)local_58);
std::__cxx11::string::~string((string *)local_58);
goto LAB_00129825;
}
}
if (common_log_verbosity_thold < 0) {
lVar4 = 0;
}
else {
/* try { // try from 00129765 to 00129787 has its CatchHandler @ 00129886 */
uVar3 = common_log_main();
lVar4 = 0;
common_log_add(uVar3,4,"%s: can\'t load image from prompt\n","load_image");
}
}
LAB_00129825:
std::__cxx11::string::~string(local_a0);
return lVar4;
}
| |
47,259 | translog_destroy | eloqsql/storage/maria/ma_loghandler.c | void translog_destroy()
{
TRANSLOG_FILE **file;
uint i;
uint8 current_buffer;
DBUG_ENTER("translog_destroy");
DBUG_ASSERT(translog_status == TRANSLOG_OK ||
translog_status == TRANSLOG_READONLY);
translog_lock();
current_buffer= log_descriptor.bc.buffer_no;
translog_status= (translog_status == TRANSLOG_READONLY ?
TRANSLOG_UNINITED :
TRANSLOG_SHUTDOWN);
if (log_descriptor.bc.buffer->file != NULL)
translog_finish_page(&log_descriptor.horizon, &log_descriptor.bc);
translog_unlock();
for (i= 0; i < TRANSLOG_BUFFERS_NO; i++)
{
struct st_translog_buffer *buffer= (log_descriptor.buffers +
((i + current_buffer + 1) %
TRANSLOG_BUFFERS_NO));
translog_buffer_destroy(buffer);
}
translog_status= TRANSLOG_UNINITED;
/* close files */
while ((file= (TRANSLOG_FILE **)pop_dynamic(&log_descriptor.open_files)))
translog_close_log_file(*file);
mysql_mutex_destroy(&log_descriptor.sent_to_disk_lock);
mysql_mutex_destroy(&log_descriptor.file_header_lock);
mysql_mutex_destroy(&log_descriptor.unfinished_files_lock);
mysql_mutex_destroy(&log_descriptor.purger_lock);
mysql_mutex_destroy(&log_descriptor.log_flush_lock);
mysql_mutex_destroy(&log_descriptor.dirty_buffer_mask_lock);
mysql_cond_destroy(&log_descriptor.log_flush_cond);
mysql_cond_destroy(&log_descriptor.new_goal_cond);
mysql_rwlock_destroy(&log_descriptor.open_files_lock);
delete_dynamic(&log_descriptor.open_files);
delete_dynamic(&log_descriptor.unfinished_files);
if (log_descriptor.directory_fd >= 0)
mysql_file_close(log_descriptor.directory_fd, MYF(MY_WME));
if (id_to_share != NULL)
my_free(id_to_share + 1);
DBUG_VOID_RETURN;
} | O0 | c | translog_destroy:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
jmp 0x3181a
callq 0x2df30
movb 0xc480d1(%rip), %al # 0xc798f6
movb %al, -0xd(%rbp)
movl 0x446232(%rip), %edx # 0x477a60
movl $0x3, %eax
xorl %ecx, %ecx
cmpl $0x2, %edx
cmovel %ecx, %eax
movl %eax, 0x44621f(%rip) # 0x477a60
movq 0xc480a0(%rip), %rax # 0xc798e8
cmpq $0x0, 0x100038(%rax)
je 0x3186f
leaq 0x447417(%rip), %rsi # 0x478c70
movq %rsi, %rdi
addq $0x800c48, %rdi # imm = 0x800C48
addq $0x800c50, %rsi # imm = 0x800C50
callq 0x31a20
callq 0x2e020
movl $0x0, -0xc(%rbp)
cmpl $0x8, -0xc(%rbp)
jae 0x318c3
movl -0xc(%rbp), %eax
movzbl -0xd(%rbp), %ecx
addl %ecx, %eax
addl $0x1, %eax
andl $0x7, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x4473d5(%rip), %rax # 0x478c70
addq $0x2f8, %rax # imm = 0x2F8
imulq $0x100120, %rcx, %rcx # imm = 0x100120
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x31bd0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3187b
movl $0x0, 0x446193(%rip) # 0x477a60
leaq 0x44739c(%rip), %rdi # 0x478c70
addq $0x228, %rdi # imm = 0x228
callq 0xda860
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
je 0x318f8
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x31c40
jmp 0x318cd
leaq 0x447371(%rip), %rdi # 0x478c70
addq $0x800cc0, %rdi # imm = 0x800CC0
callq 0x31d00
leaq 0x44735e(%rip), %rdi # 0x478c70
addq $0x800dc0, %rdi # imm = 0x800DC0
callq 0x31d00
leaq 0x44734b(%rip), %rdi # 0x478c70
addq $0x800e08, %rdi # imm = 0x800E08
callq 0x31d00
leaq 0x447338(%rip), %rdi # 0x478c70
addq $0x800e80, %rdi # imm = 0x800E80
callq 0x31d00
leaq 0x447325(%rip), %rdi # 0x478c70
addq $0x800d08, %rdi # imm = 0x800D08
callq 0x31d00
leaq 0x447312(%rip), %rdi # 0x478c70
addq $0x800c00, %rdi # imm = 0x800C00
callq 0x31d00
leaq 0x4472ff(%rip), %rdi # 0x478c70
addq $0x800d50, %rdi # imm = 0x800D50
callq 0x31d50
leaq 0x4472ec(%rip), %rdi # 0x478c70
addq $0x800d88, %rdi # imm = 0x800D88
callq 0x31d50
leaq 0x4472d9(%rip), %rdi # 0x478c70
addq $0x258, %rdi # imm = 0x258
callq 0x31dc0
leaq 0x4472c6(%rip), %rdi # 0x478c70
addq $0x228, %rdi # imm = 0x228
callq 0xdab20
leaq 0x4472b3(%rip), %rdi # 0x478c70
addq $0x800e50, %rdi # imm = 0x800E50
callq 0xdab20
cmpl $0x0, 0x447590(%rip) # 0x478f60
jl 0x319ee
movl 0x447588(%rip), %edx # 0x478f60
leaq 0x11fcce(%rip), %rdi # 0x1516ad
movl $0x10e9, %esi # imm = 0x10E9
movl $0x10, %ecx
callq 0x2dd00
cmpq $0x0, 0xc48192(%rip) # 0xc79b88
je 0x31a08
movq 0xc48189(%rip), %rdi # 0xc79b88
addq $0x8, %rdi
callq 0xf3b80
jmp 0x31a0a
jmp 0x31a0c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| translog_destroy:
push rbp
mov rbp, rsp
sub rsp, 20h
jmp short $+2
loc_3181A:
call translog_lock
mov al, cs:byte_C798F6
mov [rbp+var_D], al
mov edx, cs:translog_status
mov eax, 3
xor ecx, ecx
cmp edx, 2
cmovz eax, ecx
mov cs:translog_status, eax
mov rax, cs:qword_C798E8
cmp qword ptr [rax+100038h], 0
jz short loc_3186F
lea rsi, log_descriptor
mov rdi, rsi
add rdi, 800C48h
add rsi, 800C50h
call translog_finish_page
loc_3186F:
call translog_unlock
mov [rbp+var_C], 0
loc_3187B:
cmp [rbp+var_C], 8
jnb short loc_318C3
mov eax, [rbp+var_C]
movzx ecx, [rbp+var_D]
add eax, ecx
add eax, 1
and eax, 7
mov eax, eax
mov ecx, eax
lea rax, log_descriptor
add rax, 2F8h
imul rcx, 100120h
add rax, rcx
mov [rbp+var_18], rax
mov rdi, [rbp+var_18]
call translog_buffer_destroy
mov eax, [rbp+var_C]
add eax, 1
mov [rbp+var_C], eax
jmp short loc_3187B
loc_318C3:
mov cs:translog_status, 0
loc_318CD:
lea rdi, log_descriptor
add rdi, 228h
call pop_dynamic
mov [rbp+var_8], rax
cmp rax, 0
jz short loc_318F8
mov rax, [rbp+var_8]
mov rdi, [rax]
call translog_close_log_file
jmp short loc_318CD
loc_318F8:
lea rdi, log_descriptor
add rdi, 800CC0h
call inline_mysql_mutex_destroy
lea rdi, log_descriptor
add rdi, 800DC0h
call inline_mysql_mutex_destroy
lea rdi, log_descriptor
add rdi, 800E08h
call inline_mysql_mutex_destroy
lea rdi, log_descriptor
add rdi, 800E80h
call inline_mysql_mutex_destroy
lea rdi, log_descriptor
add rdi, 800D08h
call inline_mysql_mutex_destroy
lea rdi, log_descriptor
add rdi, 800C00h
call inline_mysql_mutex_destroy
lea rdi, log_descriptor
add rdi, 800D50h
call inline_mysql_cond_destroy
lea rdi, log_descriptor
add rdi, 800D88h
call inline_mysql_cond_destroy
lea rdi, log_descriptor
add rdi, 258h
call inline_mysql_rwlock_destroy
lea rdi, log_descriptor
add rdi, 228h
call delete_dynamic
lea rdi, log_descriptor
add rdi, 800E50h
call delete_dynamic
cmp cs:dword_478F60, 0
jl short loc_319EE
mov edx, cs:dword_478F60
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 10E9h
mov ecx, 10h
call inline_mysql_file_close_0
loc_319EE:
cmp cs:id_to_share, 0
jz short loc_31A08
mov rdi, cs:id_to_share
add rdi, 8
call my_free
loc_31A08:
jmp short $+2
loc_31A0A:
jmp short $+2
loc_31A0C:
add rsp, 20h
pop rbp
retn
| long long translog_destroy()
{
int v0; // eax
long long result; // rax
char v2; // [rsp+13h] [rbp-Dh]
unsigned int i; // [rsp+14h] [rbp-Ch]
_QWORD *v4; // [rsp+18h] [rbp-8h]
translog_lock();
v2 = byte_C798F6;
v0 = 3;
if ( translog_status == 2 )
v0 = 0;
translog_status = v0;
if ( *(_QWORD *)(qword_C798E8 + 1048632) )
translog_finish_page(&log_descriptor[1048969], &log_descriptor[1048970]);
translog_unlock();
for ( i = 0; i < 8; ++i )
translog_buffer_destroy(&log_descriptor[131108 * ((v2 + (unsigned __int8)i + 1) & 7) + 95]);
translog_status = 0;
while ( 1 )
{
v4 = (_QWORD *)pop_dynamic(&log_descriptor[69]);
if ( !v4 )
break;
translog_close_log_file(*v4);
}
inline_mysql_mutex_destroy(&log_descriptor[1048984]);
inline_mysql_mutex_destroy(&log_descriptor[1049016]);
inline_mysql_mutex_destroy(&log_descriptor[1049025]);
inline_mysql_mutex_destroy(&log_descriptor[1049040]);
inline_mysql_mutex_destroy(&log_descriptor[1048993]);
inline_mysql_mutex_destroy(&log_descriptor[1048960]);
inline_mysql_cond_destroy(&log_descriptor[1049002]);
inline_mysql_cond_destroy(&log_descriptor[1049009]);
inline_mysql_rwlock_destroy(&log_descriptor[75]);
delete_dynamic(&log_descriptor[69]);
result = delete_dynamic(&log_descriptor[1049034]);
if ( dword_478F60 >= 0 )
result = inline_mysql_file_close_0(
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x10E9u,
dword_478F60,
16LL);
if ( id_to_share )
return my_free(id_to_share + 8);
return result;
}
| translog_destroy:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
JMP 0x0013181a
LAB_0013181a:
CALL 0x0012df30
MOV AL,byte ptr [0x00d798f6]
MOV byte ptr [RBP + -0xd],AL
MOV EDX,dword ptr [0x00577a60]
MOV EAX,0x3
XOR ECX,ECX
CMP EDX,0x2
CMOVZ EAX,ECX
MOV dword ptr [0x00577a60],EAX
MOV RAX,qword ptr [0x00d798e8]
CMP qword ptr [RAX + 0x100038],0x0
JZ 0x0013186f
LEA RSI,[0x578c70]
MOV RDI,RSI
ADD RDI,0x800c48
ADD RSI,0x800c50
CALL 0x00131a20
LAB_0013186f:
CALL 0x0012e020
MOV dword ptr [RBP + -0xc],0x0
LAB_0013187b:
CMP dword ptr [RBP + -0xc],0x8
JNC 0x001318c3
MOV EAX,dword ptr [RBP + -0xc]
MOVZX ECX,byte ptr [RBP + -0xd]
ADD EAX,ECX
ADD EAX,0x1
AND EAX,0x7
MOV EAX,EAX
MOV ECX,EAX
LEA RAX,[0x578c70]
ADD RAX,0x2f8
IMUL RCX,RCX,0x100120
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00131bd0
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
JMP 0x0013187b
LAB_001318c3:
MOV dword ptr [0x00577a60],0x0
LAB_001318cd:
LEA RDI,[0x578c70]
ADD RDI,0x228
CALL 0x001da860
MOV qword ptr [RBP + -0x8],RAX
CMP RAX,0x0
JZ 0x001318f8
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX]
CALL 0x00131c40
JMP 0x001318cd
LAB_001318f8:
LEA RDI,[0x578c70]
ADD RDI,0x800cc0
CALL 0x00131d00
LEA RDI,[0x578c70]
ADD RDI,0x800dc0
CALL 0x00131d00
LEA RDI,[0x578c70]
ADD RDI,0x800e08
CALL 0x00131d00
LEA RDI,[0x578c70]
ADD RDI,0x800e80
CALL 0x00131d00
LEA RDI,[0x578c70]
ADD RDI,0x800d08
CALL 0x00131d00
LEA RDI,[0x578c70]
ADD RDI,0x800c00
CALL 0x00131d00
LEA RDI,[0x578c70]
ADD RDI,0x800d50
CALL 0x00131d50
LEA RDI,[0x578c70]
ADD RDI,0x800d88
CALL 0x00131d50
LEA RDI,[0x578c70]
ADD RDI,0x258
CALL 0x00131dc0
LEA RDI,[0x578c70]
ADD RDI,0x228
CALL 0x001dab20
LEA RDI,[0x578c70]
ADD RDI,0x800e50
CALL 0x001dab20
CMP dword ptr [0x00578f60],0x0
JL 0x001319ee
MOV EDX,dword ptr [0x00578f60]
LEA RDI,[0x2516ad]
MOV ESI,0x10e9
MOV ECX,0x10
CALL 0x0012dd00
LAB_001319ee:
CMP qword ptr [0x00d79b88],0x0
JZ 0x00131a08
MOV RDI,qword ptr [0x00d79b88]
ADD RDI,0x8
CALL 0x001f3b80
LAB_00131a08:
JMP 0x00131a0a
LAB_00131a0a:
JMP 0x00131a0c
LAB_00131a0c:
ADD RSP,0x20
POP RBP
RET
|
void translog_destroy(void)
{
byte bVar1;
int8 *puVar2;
bool bVar3;
uint local_14;
translog_lock();
bVar1 = DAT_00d798f6;
bVar3 = translog_status == 2;
translog_status = 3;
if (bVar3) {
translog_status = 0;
}
if (*(long *)(Elf64_Ehdr_00100000.e_ident_pad + DAT_00d798e8 + 0x2f) != 0) {
translog_finish_page(&DAT_00d798b8,&DAT_00d798c0);
}
translog_unlock();
for (local_14 = 0; local_14 < 8; local_14 = local_14 + 1) {
translog_buffer_destroy((local_14 + bVar1 + 1 & 7) * 0x100120 + 0x578f68);
}
translog_status = 0;
while( true ) {
puVar2 = (int8 *)pop_dynamic(&DAT_00578e98);
if (puVar2 == (int8 *)0x0) break;
translog_close_log_file(*puVar2);
}
inline_mysql_mutex_destroy(&DAT_00d79930);
inline_mysql_mutex_destroy(&DAT_00d79a30);
inline_mysql_mutex_destroy(&DAT_00d79a78);
inline_mysql_mutex_destroy(&DAT_00d79af0);
inline_mysql_mutex_destroy(&DAT_00d79978);
inline_mysql_mutex_destroy(&DAT_00d79870);
inline_mysql_cond_destroy(&DAT_00d799c0);
inline_mysql_cond_destroy(&DAT_00d799f8);
inline_mysql_rwlock_destroy(&DAT_00578ec8);
delete_dynamic(&DAT_00578e98);
delete_dynamic(&DAT_00d79ac0);
if (-1 < DAT_00578f60) {
inline_mysql_file_close
("/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",0x10e9,
DAT_00578f60,0x10);
}
if (id_to_share != 0) {
my_free(id_to_share + 8);
}
return;
}
| |
47,260 | read_long_data | eloqsql/storage/maria/ma_blockrec.c | static inline my_bool read_long_data(MARIA_HA *info, uchar *to, ulong length,
MARIA_EXTENT_CURSOR *extent,
uchar **data, uchar **end_of_data)
{
uint left_length= (uint) (*end_of_data - *data);
if (likely(left_length >= length))
{
memcpy(to, *data, length);
(*data)+= length;
return 0;
}
return read_long_data2(info, to, length, extent, data, end_of_data);
} | O0 | c | read_long_data:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %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)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpq -0x20(%rbp), %rax
setae %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x5496e
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x2a0c0
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movb $0x0, -0x1(%rbp)
jmp 0x5498e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
callq 0x5cba0
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| read_long_data:
push rbp
mov rbp, rsp
sub rsp, 40h
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 rax, [rbp+var_38]
mov rax, [rax]
mov rcx, [rbp+var_30]
mov rcx, [rcx]
sub rax, rcx
mov [rbp+var_3C], eax
mov eax, [rbp+var_3C]
cmp rax, [rbp+var_20]
setnb 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_5496E
mov rdi, [rbp+var_18]
mov rax, [rbp+var_30]
mov rsi, [rax]
mov rdx, [rbp+var_20]
call _memcpy
mov rcx, [rbp+var_20]
mov rax, [rbp+var_30]
add rcx, [rax]
mov [rax], rcx
mov [rbp+var_1], 0
jmp short loc_5498E
loc_5496E:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_28]
mov r8, [rbp+var_30]
mov r9, [rbp+var_38]
call read_long_data2
mov [rbp+var_1], al
loc_5498E:
mov al, [rbp+var_1]
add rsp, 40h
pop rbp
retn
| char read_long_data(long long a1, long long a2, unsigned long long a3, long long a4, _QWORD *a5, _QWORD *a6)
{
if ( (unsigned int)*a6 - (unsigned int)*a5 < a3 )
return read_long_data2(a1, a2, a3, a4, a5, a6);
memcpy(a2, *a5, a3);
*a5 += a3;
return 0;
}
| read_long_data:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
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 RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RCX]
SUB RAX,RCX
MOV dword ptr [RBP + -0x3c],EAX
MOV EAX,dword ptr [RBP + -0x3c]
CMP RAX,qword ptr [RBP + -0x20]
SETNC AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0015496e
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0012a0c0
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x30]
ADD RCX,qword ptr [RAX]
MOV qword ptr [RAX],RCX
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0015498e
LAB_0015496e:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8,qword ptr [RBP + -0x30]
MOV R9,qword ptr [RBP + -0x38]
CALL 0x0015cba0
MOV byte ptr [RBP + -0x1],AL
LAB_0015498e:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x40
POP RBP
RET
|
int1
read_long_data(int8 param_1,void *param_2,ulong param_3,int8 param_4,long *param_5,
int8 *param_6)
{
int1 local_9;
if ((uint)((int)*param_6 - (int)*param_5) < param_3) {
local_9 = read_long_data2(param_1,param_2,param_3,param_4,param_5,param_6);
}
else {
memcpy(param_2,(void *)*param_5,param_3);
*param_5 = param_3 + *param_5;
local_9 = 0;
}
return local_9;
}
| |
47,261 | ModbusRtuPort::writeBuffer(unsigned char, unsigned char, unsigned char*, unsigned short) | serhmarch[P]ModbusBridge/modbus/src/ModbusRtuPort.cpp | StatusCode ModbusRtuPort::writeBuffer(uint8_t unit, uint8_t func, uint8_t *buff, uint16_t szInBuff)
{
ModbusSerialPortPrivate *d = d_ModbusSerialPort(d_ptr);
uint16_t crc;
// 2 is unit and function bytes + 2 bytes CRC16
if (szInBuff > MB_RTU_IO_BUFF_SZ-(sizeof(crc)+2))
return d->setError(Status_BadWriteBufferOverflow, StringLiteral("RTU. Write-buffer overflow"));
d->buff[0] = unit;
d->buff[1] = func;
memcpy(&d->buff[2], buff, szInBuff);
d->sz = szInBuff + 2;
crc = Modbus::crc16(d->buff, d->sz);
d->buff[d->sz ] = reinterpret_cast<uint8_t*>(&crc)[0];
d->buff[d->sz+1] = reinterpret_cast<uint8_t*>(&crc)[1];
d->sz += 2;
return Status_Good;
} | O0 | cpp | ModbusRtuPort::writeBuffer(unsigned char, unsigned char, unsigned char*, unsigned short):
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movw %r8w, %ax
movq %rdi, -0x10(%rbp)
movb %sil, -0x11(%rbp)
movb %dl, -0x12(%rbp)
movq %rcx, -0x20(%rbp)
movw %ax, -0x22(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x11c50
movq %rax, -0x30(%rbp)
movzwl -0x22(%rbp), %eax
cmpq $0x104, %rax # imm = 0x104
jbe 0x11ee9
movq -0x30(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x6720
movq -0x78(%rbp), %rdx
leaq 0x15c66(%rip), %rsi # 0x27ad9
leaq -0x58(%rbp), %rdi
callq 0x11440
jmp 0x11e7e
movq -0x80(%rbp), %rdi
movl $0x1000104, %esi # imm = 0x1000104
leaq -0x58(%rbp), %rdx
callq 0x11400
movl %eax, -0x84(%rbp)
jmp 0x11e98
movl -0x84(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x62a0
leaq -0x59(%rbp), %rdi
callq 0x6460
jmp 0x11fa4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x11edb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x62a0
leaq -0x59(%rbp), %rdi
callq 0x6460
jmp 0x11fb0
movb -0x11(%rbp), %cl
movq -0x30(%rbp), %rax
movq 0x78(%rax), %rax
movb %cl, (%rax)
movb -0x12(%rbp), %cl
movq -0x30(%rbp), %rax
movq 0x78(%rax), %rax
movb %cl, 0x1(%rax)
movq -0x30(%rbp), %rax
movq 0x78(%rax), %rdi
addq $0x2, %rdi
movq -0x20(%rbp), %rsi
movzwl -0x22(%rbp), %eax
movl %eax, %edx
callq 0x6390
movzwl -0x22(%rbp), %eax
addl $0x2, %eax
movw %ax, %cx
movq -0x30(%rbp), %rax
movw %cx, 0x82(%rax)
movq -0x30(%rbp), %rax
movq 0x78(%rax), %rdi
movq -0x30(%rbp), %rax
movzwl 0x82(%rax), %esi
callq 0x9d60
movw %ax, -0x32(%rbp)
movb -0x32(%rbp), %dl
movq -0x30(%rbp), %rax
movq 0x78(%rax), %rax
movq -0x30(%rbp), %rcx
movzwl 0x82(%rcx), %ecx
movb %dl, (%rax,%rcx)
movb -0x31(%rbp), %dl
movq -0x30(%rbp), %rax
movq 0x78(%rax), %rax
movq -0x30(%rbp), %rcx
movzwl 0x82(%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x30(%rbp), %rax
movzwl 0x82(%rax), %ecx
addl $0x2, %ecx
movw %cx, 0x82(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x6710
nopl (%rax)
| _ZN13ModbusRtuPort11writeBufferEhhPht:
push rbp
mov rbp, rsp
sub rsp, 90h
mov ax, r8w
mov [rbp+var_10], rdi
mov [rbp+var_11], sil
mov [rbp+var_12], dl
mov [rbp+var_20], rcx
mov [rbp+var_22], ax
mov rax, [rbp+var_10]
mov rdi, [rax+8]; ModbusPortPrivate *
call _Z18d_ModbusSerialPortP17ModbusPortPrivate; d_ModbusSerialPort(ModbusPortPrivate *)
mov [rbp+var_30], rax
movzx eax, [rbp+var_22]
cmp rax, 104h
jbe loc_11EE9
mov rax, [rbp+var_30]
mov [rbp+var_80], rax
lea rdi, [rbp+var_59]
mov [rbp+var_78], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdx, [rbp+var_78]
lea rsi, aRtuWriteBuffer; "RTU. Write-buffer overflow"
lea rdi, [rbp+var_58]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_11E7E:
mov rdi, [rbp+var_80]
mov esi, 1000104h
lea rdx, [rbp+var_58]
call _ZN17ModbusPortPrivate8setErrorEN6Modbus10StatusCodeEONSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; ModbusPortPrivate::setError(Modbus::StatusCode,std::string &&)
mov [rbp+var_84], eax
jmp short $+2
loc_11E98:
mov eax, [rbp+var_84]
mov [rbp+var_4], eax
lea rdi, [rbp+var_58]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rbp+var_59]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_11FA4
mov rcx, rax
mov eax, edx
mov [rbp+var_68], rcx
mov [rbp+var_6C], eax
jmp short loc_11EDB
mov rcx, rax
mov eax, edx
mov [rbp+var_68], rcx
mov [rbp+var_6C], eax
lea rdi, [rbp+var_58]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_11EDB:
lea rdi, [rbp+var_59]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_11FB0
loc_11EE9:
mov cl, [rbp+var_11]
mov rax, [rbp+var_30]
mov rax, [rax+78h]
mov [rax], cl
mov cl, [rbp+var_12]
mov rax, [rbp+var_30]
mov rax, [rax+78h]
mov [rax+1], cl
mov rax, [rbp+var_30]
mov rdi, [rax+78h]
add rdi, 2
mov rsi, [rbp+var_20]
movzx eax, [rbp+var_22]
mov edx, eax
call _memcpy
movzx eax, [rbp+var_22]
add eax, 2
mov cx, ax
mov rax, [rbp+var_30]
mov [rax+82h], cx
mov rax, [rbp+var_30]
mov rdi, [rax+78h]
mov rax, [rbp+var_30]
movzx esi, word ptr [rax+82h]
call crc16
mov [rbp+var_32], ax
mov dl, byte ptr [rbp+var_32]
mov rax, [rbp+var_30]
mov rax, [rax+78h]
mov rcx, [rbp+var_30]
movzx ecx, word ptr [rcx+82h]
mov [rax+rcx], dl
mov dl, byte ptr [rbp+var_32+1]
mov rax, [rbp+var_30]
mov rax, [rax+78h]
mov rcx, [rbp+var_30]
movzx ecx, word ptr [rcx+82h]
add ecx, 1
movsxd rcx, ecx
mov [rax+rcx], dl
mov rax, [rbp+var_30]
movzx ecx, word ptr [rax+82h]
add ecx, 2
mov [rax+82h], cx
mov [rbp+var_4], 0
loc_11FA4:
mov eax, [rbp+var_4]
add rsp, 90h
pop rbp
retn
loc_11FB0:
mov rdi, [rbp+var_68]
call __Unwind_Resume
| long long ModbusRtuPort::writeBuffer(
ModbusPortPrivate **this,
char a2,
char a3,
unsigned __int8 *a4,
unsigned __int16 a5)
{
long long v6; // [rsp+10h] [rbp-80h]
char v7; // [rsp+37h] [rbp-59h] BYREF
_BYTE v8[38]; // [rsp+38h] [rbp-58h] BYREF
unsigned __int16 v9; // [rsp+5Eh] [rbp-32h]
ModbusPortPrivate *v10; // [rsp+60h] [rbp-30h]
unsigned __int16 v11; // [rsp+6Eh] [rbp-22h]
unsigned __int8 *v12; // [rsp+70h] [rbp-20h]
char v13; // [rsp+7Eh] [rbp-12h]
char v14; // [rsp+7Fh] [rbp-11h]
ModbusPortPrivate **v15; // [rsp+80h] [rbp-10h]
unsigned int v16; // [rsp+8Ch] [rbp-4h]
v15 = this;
v14 = a2;
v13 = a3;
v12 = a4;
v11 = a5;
v10 = d_ModbusSerialPort(this[1]);
if ( v11 <= 0x104uLL )
{
**((_BYTE **)v10 + 15) = v14;
*(_BYTE *)(*((_QWORD *)v10 + 15) + 1LL) = v13;
memcpy(*((_QWORD *)v10 + 15) + 2LL, v12, v11);
*((_WORD *)v10 + 65) = v11 + 2;
v9 = crc16(*((_QWORD *)v10 + 15), *((unsigned __int16 *)v10 + 65));
*(_BYTE *)(*((_QWORD *)v10 + 15) + *((unsigned __int16 *)v10 + 65)) = v9;
*(_BYTE *)(*((_QWORD *)v10 + 15) + *((unsigned __int16 *)v10 + 65) + 1) = HIBYTE(v9);
*((_WORD *)v10 + 65) += 2;
return 0;
}
else
{
v6 = (long long)v10;
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>((long long)v8, (long long)"RTU. Write-buffer overflow", (long long)&v7);
v16 = ModbusPortPrivate::setError(v6, 0x1000104u, (long long)v8);
std::string::~string(v8);
std::allocator<char>::~allocator(&v7);
}
return v16;
}
| writeBuffer:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV AX,R8W
MOV qword ptr [RBP + -0x10],RDI
MOV byte ptr [RBP + -0x11],SIL
MOV byte ptr [RBP + -0x12],DL
MOV qword ptr [RBP + -0x20],RCX
MOV word ptr [RBP + -0x22],AX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x00111c50
MOV qword ptr [RBP + -0x30],RAX
MOVZX EAX,word ptr [RBP + -0x22]
CMP RAX,0x104
JBE 0x00111ee9
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x80],RAX
LEA RDI,[RBP + -0x59]
MOV qword ptr [RBP + -0x78],RDI
CALL 0x00106720
MOV RDX,qword ptr [RBP + -0x78]
LAB_00111e6c:
LEA RSI,[0x127ad9]
LEA RDI,[RBP + -0x58]
CALL 0x00111440
JMP 0x00111e7e
LAB_00111e7e:
MOV RDI,qword ptr [RBP + -0x80]
MOV ESI,0x1000104
LEA RDX,[RBP + -0x58]
CALL 0x00111400
LAB_00111e90:
MOV dword ptr [RBP + -0x84],EAX
JMP 0x00111e98
LAB_00111e98:
MOV EAX,dword ptr [RBP + -0x84]
MOV dword ptr [RBP + -0x4],EAX
LEA RDI,[RBP + -0x58]
CALL 0x001062a0
LEA RDI,[RBP + -0x59]
CALL 0x00106460
JMP 0x00111fa4
LAB_00111ee9:
MOV CL,byte ptr [RBP + -0x11]
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x78]
MOV byte ptr [RAX],CL
MOV CL,byte ptr [RBP + -0x12]
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x78]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RAX + 0x78]
ADD RDI,0x2
MOV RSI,qword ptr [RBP + -0x20]
MOVZX EAX,word ptr [RBP + -0x22]
MOV EDX,EAX
CALL 0x00106390
MOVZX EAX,word ptr [RBP + -0x22]
ADD EAX,0x2
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x30]
MOV word ptr [RAX + 0x82],CX
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RAX + 0x78]
MOV RAX,qword ptr [RBP + -0x30]
MOVZX ESI,word ptr [RAX + 0x82]
CALL 0x00109d60
MOV word ptr [RBP + -0x32],AX
MOV DL,byte ptr [RBP + -0x32]
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x78]
MOV RCX,qword ptr [RBP + -0x30]
MOVZX ECX,word ptr [RCX + 0x82]
MOV byte ptr [RAX + RCX*0x1],DL
MOV DL,byte ptr [RBP + -0x31]
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x78]
MOV RCX,qword ptr [RBP + -0x30]
MOVZX ECX,word ptr [RCX + 0x82]
ADD ECX,0x1
MOVSXD RCX,ECX
MOV byte ptr [RAX + RCX*0x1],DL
MOV RAX,qword ptr [RBP + -0x30]
MOVZX ECX,word ptr [RAX + 0x82]
ADD ECX,0x2
MOV word ptr [RAX + 0x82],CX
MOV dword ptr [RBP + -0x4],0x0
LAB_00111fa4:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x90
POP RBP
RET
|
/* ModbusRtuPort::writeBuffer(unsigned char, unsigned char, unsigned char*, unsigned short) */
int4 __thiscall
ModbusRtuPort::writeBuffer
(ModbusRtuPort *this,uchar param_1,uchar param_2,uchar *param_3,ushort param_4)
{
int2 uVar1;
ModbusPortPrivate *pMVar2;
allocator local_61;
string local_60 [38];
int1 local_3a;
int1 uStack_39;
ModbusPortPrivate *local_38;
ushort local_2a;
uchar *local_28;
uchar local_1a;
uchar local_19;
ModbusRtuPort *local_18;
int4 local_c;
local_2a = param_4;
local_28 = param_3;
local_1a = param_2;
local_19 = param_1;
local_18 = this;
pMVar2 = (ModbusPortPrivate *)d_ModbusSerialPort(*(ModbusPortPrivate **)(this + 8));
local_38 = pMVar2;
if (local_2a < 0x105) {
**(uchar **)(pMVar2 + 0x78) = local_19;
*(uchar *)(*(long *)(pMVar2 + 0x78) + 1) = local_1a;
memcpy((void *)(*(long *)(pMVar2 + 0x78) + 2),local_28,(ulong)local_2a);
*(ushort *)(local_38 + 0x82) = local_2a + 2;
uVar1 = crc16(*(int8 *)(local_38 + 0x78),*(int2 *)(local_38 + 0x82));
local_3a = (int1)uVar1;
*(int1 *)(*(long *)(local_38 + 0x78) + (ulong)*(ushort *)(local_38 + 0x82)) = local_3a;
uStack_39 = (int1)((ushort)uVar1 >> 8);
*(int1 *)(*(long *)(local_38 + 0x78) + (long)(int)(*(ushort *)(local_38 + 0x82) + 1)) =
uStack_39;
*(short *)(local_38 + 0x82) = *(short *)(local_38 + 0x82) + 2;
local_c = 0;
}
else {
std::allocator<char>::allocator();
/* try { // try from 00111e6c to 00111e7b has its CatchHandler @ 00111eb8 */
std::__cxx11::string::string<std::allocator<char>>
(local_60,"RTU. Write-buffer overflow",&local_61);
/* try { // try from 00111e7e to 00111e8f has its CatchHandler @ 00111ec6 */
local_c = ModbusPortPrivate::setError(pMVar2,0x1000104,local_60);
std::__cxx11::string::~string(local_60);
std::allocator<char>::~allocator((allocator<char> *)&local_61);
}
return local_c;
}
| |
47,262 | ModbusRtuPort::writeBuffer(unsigned char, unsigned char, unsigned char*, unsigned short) | serhmarch[P]ModbusBridge/modbus/src/ModbusRtuPort.cpp | StatusCode ModbusRtuPort::writeBuffer(uint8_t unit, uint8_t func, uint8_t *buff, uint16_t szInBuff)
{
ModbusSerialPortPrivate *d = d_ModbusSerialPort(d_ptr);
uint16_t crc;
// 2 is unit and function bytes + 2 bytes CRC16
if (szInBuff > MB_RTU_IO_BUFF_SZ-(sizeof(crc)+2))
return d->setError(Status_BadWriteBufferOverflow, StringLiteral("RTU. Write-buffer overflow"));
d->buff[0] = unit;
d->buff[1] = func;
memcpy(&d->buff[2], buff, szInBuff);
d->sz = szInBuff + 2;
crc = Modbus::crc16(d->buff, d->sz);
d->buff[d->sz ] = reinterpret_cast<uint8_t*>(&crc)[0];
d->buff[d->sz+1] = reinterpret_cast<uint8_t*>(&crc)[1];
d->sz += 2;
return Status_Good;
} | O3 | cpp | ModbusRtuPort::writeBuffer(unsigned char, unsigned char, unsigned char*, unsigned short):
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0x8(%rdi), %rbx
cmpl $0x105, %r8d # imm = 0x105
jb 0x95e1
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xf530(%rip), %rsi # 0x18acc
leaq 0xf543(%rip), %rdx # 0x18ae6
movq %rsp, %r14
movq %r14, %rdi
callq 0x92a8
movl $0x1000104, 0x10(%rbx) # imm = 0x1000104
addq $0x18, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x51c0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x95da
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5310
movl $0x1000104, %eax # imm = 0x1000104
jmp 0x9647
movl %r8d, %r14d
movzwl %r14w, %eax
movq 0x78(%rbx), %rdi
movb %sil, (%rdi)
movq 0x78(%rbx), %rsi
movb %dl, 0x1(%rsi)
movq 0x78(%rbx), %rdi
addq $0x2, %rdi
movq %rcx, %rsi
movq %rax, %rdx
callq 0x52a0
leal 0x2(%r14), %eax
movw %ax, 0x82(%rbx)
movq 0x78(%rbx), %rdi
movzwl %ax, %esi
callq 0x7a7a
movq 0x78(%rbx), %rcx
movzwl 0x82(%rbx), %edx
movb %al, (%rcx,%rdx)
movq 0x78(%rbx), %rcx
movzwl 0x82(%rbx), %edx
movb %ah, 0x1(%rcx,%rdx)
addw $0x2, 0x82(%rbx)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x966a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5310
movq %rbx, %rdi
callq 0x5550
| _ZN13ModbusRtuPort11writeBufferEhhPht:
push r15
push r14
push rbx
sub rsp, 20h
mov rbx, [rdi+8]
cmp r8d, 105h
jb short loc_95E1
lea r15, [rsp+38h+var_28]
mov [r15-10h], r15
lea rsi, aRtuWriteBuffer; "RTU. Write-buffer overflow"
lea rdx, aRtuWriteBuffer+1Ah; ""
mov r14, rsp
mov rdi, r14
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov dword ptr [rbx+10h], 1000104h
add rbx, 18h
mov rdi, rbx
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_assignERKS4_; std::string::_M_assign(std::string const&)
mov rdi, [rsp+38h+var_38]; void *
cmp rdi, r15
jz short loc_95DA
mov rsi, [rsp+38h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_95DA:
mov eax, 1000104h
jmp short loc_9647
loc_95E1:
mov r14d, r8d
movzx eax, r14w
mov rdi, [rbx+78h]
mov [rdi], sil
mov rsi, [rbx+78h]
mov [rsi+1], dl
mov rdi, [rbx+78h]
add rdi, 2
mov rsi, rcx
mov rdx, rax
call _memcpy
lea eax, [r14+2]
mov [rbx+82h], ax
mov rdi, [rbx+78h]
movzx esi, ax
call crc16
mov rcx, [rbx+78h]
movzx edx, word ptr [rbx+82h]
mov [rcx+rdx], al
mov rcx, [rbx+78h]
movzx edx, word ptr [rbx+82h]
mov [rcx+rdx+1], ah
add word ptr [rbx+82h], 2
xor eax, eax
loc_9647:
add rsp, 20h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
mov rdi, [rsp+0]; void *
cmp rdi, r15
jz short loc_966A
mov rsi, [rsp+arg_8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_966A:
mov rdi, rbx
call __Unwind_Resume
| long long ModbusRtuPort::writeBuffer(
ModbusRtuPort *this,
char a2,
char a3,
unsigned __int8 *a4,
unsigned int a5)
{
long long v5; // rbx
__int16 v7; // r14
void *v8[2]; // [rsp+0h] [rbp-38h] BYREF
_QWORD v9[5]; // [rsp+10h] [rbp-28h] BYREF
v5 = *((_QWORD *)this + 1);
if ( a5 < 0x105 )
{
v7 = a5;
**(_BYTE **)(v5 + 120) = a2;
*(_BYTE *)(*(_QWORD *)(v5 + 120) + 1LL) = a3;
memcpy(*(_QWORD *)(v5 + 120) + 2LL, a4, (unsigned __int16)a5);
*(_WORD *)(v5 + 130) = v7 + 2;
*(_WORD *)(*(_QWORD *)(v5 + 120) + *(unsigned __int16 *)(v5 + 130)) = crc16(
*(_QWORD *)(v5 + 120),
(unsigned __int16)(v7 + 2));
*(_WORD *)(v5 + 130) += 2;
return 0LL;
}
else
{
v8[0] = v9;
std::string::_M_construct<char const*>((long long)v8, "RTU. Write-buffer overflow", (long long)"");
*(_DWORD *)(v5 + 16) = 16777476;
std::string::_M_assign(v5 + 24, v8);
if ( v8[0] != v9 )
operator delete(v8[0], v9[0] + 1LL);
return 16777476LL;
}
}
| writeBuffer:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x20
MOV RBX,qword ptr [RDI + 0x8]
CMP R8D,0x105
JC 0x001095e1
LEA R15,[RSP + 0x10]
MOV qword ptr [R15 + -0x10],R15
LEA RSI,[0x118acc]
LEA RDX,[0x118ae6]
MOV R14,RSP
MOV RDI,R14
CALL 0x001092a8
MOV dword ptr [RBX + 0x10],0x1000104
ADD RBX,0x18
LAB_001095b9:
MOV RDI,RBX
MOV RSI,R14
CALL 0x001051c0
LAB_001095c4:
MOV RDI,qword ptr [RSP]
CMP RDI,R15
JZ 0x001095da
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x00105310
LAB_001095da:
MOV EAX,0x1000104
JMP 0x00109647
LAB_001095e1:
MOV R14D,R8D
MOVZX EAX,R14W
MOV RDI,qword ptr [RBX + 0x78]
MOV byte ptr [RDI],SIL
MOV RSI,qword ptr [RBX + 0x78]
MOV byte ptr [RSI + 0x1],DL
MOV RDI,qword ptr [RBX + 0x78]
ADD RDI,0x2
MOV RSI,RCX
MOV RDX,RAX
CALL 0x001052a0
LEA EAX,[R14 + 0x2]
MOV word ptr [RBX + 0x82],AX
MOV RDI,qword ptr [RBX + 0x78]
MOVZX ESI,AX
CALL 0x00107a7a
MOV RCX,qword ptr [RBX + 0x78]
MOVZX EDX,word ptr [RBX + 0x82]
MOV byte ptr [RCX + RDX*0x1],AL
MOV RCX,qword ptr [RBX + 0x78]
MOVZX EDX,word ptr [RBX + 0x82]
MOV byte ptr [RCX + RDX*0x1 + 0x1],AH
ADD word ptr [RBX + 0x82],0x2
XOR EAX,EAX
LAB_00109647:
ADD RSP,0x20
POP RBX
POP R14
POP R15
RET
|
/* ModbusRtuPort::writeBuffer(unsigned char, unsigned char, unsigned char*, unsigned short) */
int8 __thiscall
ModbusRtuPort::writeBuffer
(ModbusRtuPort *this,uchar param_1,uchar param_2,uchar *param_3,ushort param_4)
{
uint uVar1;
long lVar2;
int2 uVar3;
int8 uVar4;
int2 in_register_00000082;
long *local_38 [2];
long local_28 [2];
lVar2 = *(long *)(this + 8);
if (CONCAT22(in_register_00000082,param_4) < 0x105) {
**(uchar **)(lVar2 + 0x78) = param_1;
*(uchar *)(*(long *)(lVar2 + 0x78) + 1) = param_2;
memcpy((void *)(*(long *)(lVar2 + 0x78) + 2),param_3,(ulong)param_4);
uVar1 = CONCAT22(in_register_00000082,param_4) + 2;
*(short *)(lVar2 + 0x82) = (short)uVar1;
uVar3 = crc16(*(int8 *)(lVar2 + 0x78),uVar1 & 0xffff);
*(char *)(*(long *)(lVar2 + 0x78) + (ulong)*(ushort *)(lVar2 + 0x82)) = (char)uVar3;
*(char *)(*(long *)(lVar2 + 0x78) + 1 + (ulong)*(ushort *)(lVar2 + 0x82)) =
(char)((ushort)uVar3 >> 8);
*(short *)(lVar2 + 0x82) = *(short *)(lVar2 + 0x82) + 2;
uVar4 = 0;
}
else {
local_38[0] = local_28;
std::__cxx11::string::_M_construct<char_const*>(local_38,"RTU. Write-buffer overflow","");
*(int4 *)(lVar2 + 0x10) = 0x1000104;
/* try { // try from 001095b9 to 001095c3 has its CatchHandler @ 00109651 */
std::__cxx11::string::_M_assign((string *)(lVar2 + 0x18));
if (local_38[0] != local_28) {
operator_delete(local_38[0],local_28[0] + 1);
}
uVar4 = 0x1000104;
}
return uVar4;
}
| |
47,263 | link_into_queue | eloqsql/mysys/mf_keycache.c | static void link_into_queue(KEYCACHE_WQUEUE *wqueue,
struct st_my_thread_var *thread)
{
struct st_my_thread_var *last;
DBUG_ASSERT(!thread->next && !thread->prev);
if (! (last= wqueue->last_thread))
{
/* Queue is empty */
thread->next= thread;
thread->prev= &thread->next;
}
else
{
DBUG_ASSERT(last->next->prev == &last->next);
/* Add backlink to previous element */
thread->prev= last->next->prev;
/* Fix first in list to point backwords to current */
last->next->prev= &thread->next;
/* Next should point to the first element in list */
thread->next= last->next;
/* Fix old element to point to new one */
last->next= thread;
}
wqueue->last_thread= thread;
} | O0 | c | link_into_queue:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0xe528e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xe52c6
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x10(%rbp), %rcx
addq $0x88, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x90(%rax)
jmp 0xe5329
jmp 0xe52c8
jmp 0xe52ca
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rax
movq 0x90(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x10(%rbp), %rcx
addq $0x88, %rcx
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rax
movq %rcx, 0x90(%rax)
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
| link_into_queue:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
jmp short $+2
loc_E528E:
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_E52C6
mov rcx, [rbp+var_10]
mov rax, [rbp+var_10]
mov [rax+88h], rcx
mov rcx, [rbp+var_10]
add rcx, 88h
mov rax, [rbp+var_10]
mov [rax+90h], rcx
jmp short loc_E5329
loc_E52C6:
jmp short $+2
loc_E52C8:
jmp short $+2
loc_E52CA:
mov rax, [rbp+var_18]
mov rax, [rax+88h]
mov rcx, [rax+90h]
mov rax, [rbp+var_10]
mov [rax+90h], rcx
mov rcx, [rbp+var_10]
add rcx, 88h
mov rax, [rbp+var_18]
mov rax, [rax+88h]
mov [rax+90h], rcx
mov rax, [rbp+var_18]
mov rcx, [rax+88h]
mov rax, [rbp+var_10]
mov [rax+88h], rcx
mov rcx, [rbp+var_10]
mov rax, [rbp+var_18]
mov [rax+88h], rcx
loc_E5329:
mov rcx, [rbp+var_10]
mov rax, [rbp+var_8]
mov [rax], rcx
pop rbp
retn
| _QWORD * link_into_queue(_QWORD *a1, long long a2)
{
_QWORD *result; // rax
long long v3; // [rsp+0h] [rbp-18h]
v3 = *a1;
if ( *a1 )
{
*(_QWORD *)(a2 + 144) = *(_QWORD *)(*(_QWORD *)(v3 + 136) + 144LL);
*(_QWORD *)(*(_QWORD *)(v3 + 136) + 144LL) = a2 + 136;
*(_QWORD *)(a2 + 136) = *(_QWORD *)(v3 + 136);
*(_QWORD *)(v3 + 136) = a2;
}
else
{
*(_QWORD *)(a2 + 136) = a2;
*(_QWORD *)(a2 + 144) = a2 + 136;
}
result = a1;
*a1 = a2;
return result;
}
| link_into_queue:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
JMP 0x001e528e
LAB_001e528e:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x001e52c6
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x88],RCX
MOV RCX,qword ptr [RBP + -0x10]
ADD RCX,0x88
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x90],RCX
JMP 0x001e5329
LAB_001e52c6:
JMP 0x001e52c8
LAB_001e52c8:
JMP 0x001e52ca
LAB_001e52ca:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x88]
MOV RCX,qword ptr [RAX + 0x90]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x90],RCX
MOV RCX,qword ptr [RBP + -0x10]
ADD RCX,0x88
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x88]
MOV qword ptr [RAX + 0x90],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX + 0x88]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x88],RCX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x88],RCX
LAB_001e5329:
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],RCX
POP RBP
RET
|
void link_into_queue(long *param_1,long param_2)
{
long lVar1;
lVar1 = *param_1;
if (lVar1 == 0) {
*(long *)(param_2 + 0x88) = param_2;
*(long *)(param_2 + 0x90) = param_2 + 0x88;
}
else {
*(int8 *)(param_2 + 0x90) = *(int8 *)(*(long *)(lVar1 + 0x88) + 0x90);
*(long *)(*(long *)(lVar1 + 0x88) + 0x90) = param_2 + 0x88;
*(int8 *)(param_2 + 0x88) = *(int8 *)(lVar1 + 0x88);
*(long *)(lVar1 + 0x88) = param_2;
}
*param_1 = param_2;
return;
}
| |
47,264 | get_first_set | eloqsql/mysys/my_bitmap.c | static inline uint get_first_set(my_bitmap_map value, uint word_pos)
{
uchar *byte_ptr= (uchar*)&value;
uchar byte_value;
uint byte_pos, bit_pos;
DBUG_ASSERT(value);
for (byte_pos=0; ; byte_pos++, byte_ptr++)
{
if ((byte_value= *byte_ptr))
{
for (bit_pos=0; ; bit_pos++)
if (byte_value & (1 << bit_pos))
return (word_pos*32) + (byte_pos*8) + bit_pos;
}
}
return MY_BIT_NONE; /* Impossible */
} | O0 | c | get_first_set:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq -0x4(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xf6c54
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x11(%rbp)
cmpb $0x0, %al
je 0xf6ca6
movl $0x0, -0x1c(%rbp)
movzbl -0x11(%rbp), %eax
movl -0x1c(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0xf6c99
movl -0x8(%rbp), %eax
shll $0x5, %eax
movl -0x18(%rbp), %ecx
shll $0x3, %ecx
addl %ecx, %eax
addl -0x1c(%rbp), %eax
popq %rbp
retq
jmp 0xf6c9b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xf6c6f
jmp 0xf6ca8
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xf6c5b
nop
| get_first_set:
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
lea rax, [rbp+var_4]
mov [rbp+var_10], rax
jmp short $+2
loc_F6C54:
mov [rbp+var_18], 0
loc_F6C5B:
mov rax, [rbp+var_10]
mov al, [rax]
mov [rbp+var_11], al
cmp al, 0
jz short loc_F6CA6
mov [rbp+var_1C], 0
loc_F6C6F:
movzx eax, [rbp+var_11]
mov ecx, [rbp+var_1C]
mov edx, 1
shl edx, cl
mov ecx, edx
and eax, ecx
cmp eax, 0
jz short loc_F6C99
mov eax, [rbp+var_8]
shl eax, 5
mov ecx, [rbp+var_18]
shl ecx, 3
add eax, ecx
add eax, [rbp+var_1C]
pop rbp
retn
loc_F6C99:
jmp short $+2
loc_F6C9B:
mov eax, [rbp+var_1C]
add eax, 1
mov [rbp+var_1C], eax
jmp short loc_F6C6F
loc_F6CA6:
jmp short $+2
loc_F6CA8:
mov eax, [rbp+var_18]
add eax, 1
mov [rbp+var_18], eax
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_F6C5B
| long long get_first_set(int a1, int a2)
{
int i; // [rsp+0h] [rbp-1Ch]
int v4; // [rsp+4h] [rbp-18h]
int *v5; // [rsp+Ch] [rbp-10h]
int v6; // [rsp+18h] [rbp-4h] BYREF
v6 = a1;
v5 = &v6;
v4 = 0;
while ( !*(_BYTE *)v5 )
{
++v4;
v5 = (int *)((char *)v5 + 1);
}
for ( i = 0; ((1 << i) & *(unsigned __int8 *)v5) == 0; ++i )
;
return (unsigned int)(i + 8 * v4 + 32 * a2);
}
| get_first_set:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
LEA RAX,[RBP + -0x4]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001f6c54
LAB_001f6c54:
MOV dword ptr [RBP + -0x18],0x0
LAB_001f6c5b:
MOV RAX,qword ptr [RBP + -0x10]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x11],AL
CMP AL,0x0
JZ 0x001f6ca6
MOV dword ptr [RBP + -0x1c],0x0
LAB_001f6c6f:
MOVZX EAX,byte ptr [RBP + -0x11]
MOV ECX,dword ptr [RBP + -0x1c]
MOV EDX,0x1
SHL EDX,CL
MOV ECX,EDX
AND EAX,ECX
CMP EAX,0x0
JZ 0x001f6c99
MOV EAX,dword ptr [RBP + -0x8]
SHL EAX,0x5
MOV ECX,dword ptr [RBP + -0x18]
SHL ECX,0x3
ADD EAX,ECX
ADD EAX,dword ptr [RBP + -0x1c]
POP RBP
RET
LAB_001f6c99:
JMP 0x001f6c9b
LAB_001f6c9b:
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x001f6c6f
LAB_001f6ca6:
JMP 0x001f6ca8
LAB_001f6ca8:
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,0x1
MOV dword ptr [RBP + -0x18],EAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001f6c5b
|
int get_first_set(int8 param_1,int param_2)
{
int local_24;
int local_20;
byte *local_18;
byte local_c [4];
local_20 = 0;
for (local_18 = local_c; *local_18 == 0; local_18 = local_18 + 1) {
local_20 = local_20 + 1;
}
local_24 = 0;
while (((uint)*local_18 & 1 << ((byte)local_24 & 0x1f)) == 0) {
local_24 = local_24 + 1;
}
return param_2 * 0x20 + local_20 * 8 + local_24;
}
| |
47,265 | compile_cmp_expr | fabiosvm[P]rak/src/compiler.c | static inline void compile_cmp_expr(RakCompiler *comp, RakError *err)
{
compile_range_expr(comp, err);
if (!rak_is_ok(err)) return;
for (;;)
{
if (match(comp, RAK_TOKEN_KIND_GTEQ))
{
next(comp, err);
compile_range_expr(comp, err);
if (!rak_is_ok(err)) return;
emit_instr(comp, rak_lt_instr(), err);
if (!rak_is_ok(err)) return;
emit_instr(comp, rak_not_instr(), err);
if (!rak_is_ok(err)) return;
continue;
}
if (match(comp, RAK_TOKEN_KIND_GT))
{
next(comp, err);
compile_range_expr(comp, err);
if (!rak_is_ok(err)) return;
emit_instr(comp, rak_gt_instr(), err);
if (!rak_is_ok(err)) return;
continue;
}
if (match(comp, RAK_TOKEN_KIND_LTEQ))
{
next(comp, err);
compile_range_expr(comp, err);
if (!rak_is_ok(err)) return;
emit_instr(comp, rak_gt_instr(), err);
if (!rak_is_ok(err)) return;
emit_instr(comp, rak_not_instr(), err);
if (!rak_is_ok(err)) return;
continue;
}
if (match(comp, RAK_TOKEN_KIND_LT))
{
next(comp, err);
compile_range_expr(comp, err);
if (!rak_is_ok(err)) return;
emit_instr(comp, rak_lt_instr(), err);
if (!rak_is_ok(err)) return;
continue;
}
break;
}
} | O3 | c | compile_cmp_expr:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5230
movb (%rbx), %al
cmpb $0x1, %al
jne 0x4ffb
cmpl $0x15, 0x2810(%r14)
jne 0x4ffb
leaq 0x27f8(%r14), %rdi
movq %rbx, %rsi
callq 0x679a
movb (%rbx), %al
cmpb $0x1, %al
jne 0x4ffb
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5230
movb (%rbx), %al
cmpb $0x1, %al
jne 0x4ffb
movq %r14, %rdi
movl $0xa, %esi
movq %rbx, %rdx
callq 0x392d
movb (%rbx), %al
testb $0x1, %al
je 0x5224
leaq 0x27f8(%r14), %r15
leaq 0x5423(%rip), %r12 # 0xa434
movl 0x2810(%r14), %eax
addl $-0x11, %eax
cmpl $0x3, %eax
ja 0x5224
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movq %r15, %rdi
movq %rbx, %rsi
callq 0x679a
cmpb $0x1, (%rbx)
jne 0x5224
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5230
movb (%rbx), %al
cmpb $0x1, %al
jne 0x5090
cmpl $0x15, 0x2810(%r14)
jne 0x5090
movq %r15, %rdi
movq %rbx, %rsi
callq 0x679a
movb (%rbx), %al
cmpb $0x1, %al
jne 0x5090
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5230
movb (%rbx), %al
cmpb $0x1, %al
jne 0x5090
movq %r14, %rdi
movl $0xa, %esi
movq %rbx, %rdx
callq 0x392d
movb (%rbx), %al
testb $0x1, %al
je 0x5224
movq %r14, %rdi
movl $0x12, %esi
jmp 0x5115
movq %r15, %rdi
movq %rbx, %rsi
callq 0x679a
cmpb $0x1, (%rbx)
jne 0x5224
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5230
movb (%rbx), %al
cmpb $0x1, %al
jne 0x5105
cmpl $0x15, 0x2810(%r14)
jne 0x5105
movq %r15, %rdi
movq %rbx, %rsi
callq 0x679a
movb (%rbx), %al
cmpb $0x1, %al
jne 0x5105
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5230
movb (%rbx), %al
cmpb $0x1, %al
jne 0x5105
movq %r14, %rdi
movl $0xa, %esi
movq %rbx, %rdx
callq 0x392d
movb (%rbx), %al
testb $0x1, %al
je 0x5224
movq %r14, %rdi
movl $0x11, %esi
movq %rbx, %rdx
callq 0x392d
cmpb $0x1, (%rbx)
jne 0x5224
movq %r14, %rdi
movl $0x18, %esi
jmp 0x5213
movq %r15, %rdi
movq %rbx, %rsi
callq 0x679a
cmpb $0x1, (%rbx)
jne 0x5224
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5230
movb (%rbx), %al
cmpb $0x1, %al
jne 0x5196
cmpl $0x15, 0x2810(%r14)
jne 0x5196
movq %r15, %rdi
movq %rbx, %rsi
callq 0x679a
movb (%rbx), %al
cmpb $0x1, %al
jne 0x5196
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5230
movb (%rbx), %al
cmpb $0x1, %al
jne 0x5196
movq %r14, %rdi
movl $0xa, %esi
movq %rbx, %rdx
callq 0x392d
movb (%rbx), %al
testb $0x1, %al
je 0x5224
movq %r14, %rdi
movl $0x12, %esi
jmp 0x5213
movq %r15, %rdi
movq %rbx, %rsi
callq 0x679a
cmpb $0x1, (%rbx)
jne 0x5224
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5230
movb (%rbx), %al
cmpb $0x1, %al
jne 0x5207
cmpl $0x15, 0x2810(%r14)
jne 0x5207
movq %r15, %rdi
movq %rbx, %rsi
callq 0x679a
movb (%rbx), %al
cmpb $0x1, %al
jne 0x5207
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5230
movb (%rbx), %al
cmpb $0x1, %al
jne 0x5207
movq %r14, %rdi
movl $0xa, %esi
movq %rbx, %rdx
callq 0x392d
movb (%rbx), %al
testb $0x1, %al
je 0x5224
movq %r14, %rdi
movl $0x11, %esi
movq %rbx, %rdx
callq 0x392d
cmpb $0x0, (%rbx)
jne 0x5011
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| compile_cmp_expr:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rsi
mov r14, rdi
call compile_add_expr
mov al, [rbx]
cmp al, 1
jnz short loc_4FFB
cmp dword ptr [r14+2810h], 15h
jnz short loc_4FFB
lea rdi, [r14+27F8h]
mov rsi, rbx
call rak_lexer_next
mov al, [rbx]
cmp al, 1
jnz short loc_4FFB
mov rdi, r14
mov rsi, rbx
call compile_add_expr
mov al, [rbx]
cmp al, 1
jnz short loc_4FFB
mov rdi, r14
mov esi, 0Ah
mov rdx, rbx
call rak_chunk_append_instr
mov al, [rbx]
loc_4FFB:
test al, 1
jz def_502B; jumptable 000000000000502B default case
lea r15, [r14+27F8h]
lea r12, jpt_502B
loc_5011:
mov eax, [r14+2810h]
add eax, 0FFFFFFEFh; switch 4 cases
cmp eax, 3
ja def_502B; jumptable 000000000000502B default case
movsxd rax, ds:(jpt_502B - 0A434h)[r12+rax*4]
add rax, r12
jmp rax; switch jump
loc_502D:
mov rdi, r15; jumptable 000000000000502B case 17
mov rsi, rbx
call rak_lexer_next
cmp byte ptr [rbx], 1
jnz def_502B; jumptable 000000000000502B default case
mov rdi, r14
mov rsi, rbx
call compile_add_expr
mov al, [rbx]
cmp al, 1
jnz short loc_5090
cmp dword ptr [r14+2810h], 15h
jnz short loc_5090
mov rdi, r15
mov rsi, rbx
call rak_lexer_next
mov al, [rbx]
cmp al, 1
jnz short loc_5090
mov rdi, r14
mov rsi, rbx
call compile_add_expr
mov al, [rbx]
cmp al, 1
jnz short loc_5090
mov rdi, r14
mov esi, 0Ah
mov rdx, rbx
call rak_chunk_append_instr
mov al, [rbx]
loc_5090:
test al, 1
jz def_502B; jumptable 000000000000502B default case
mov rdi, r14
mov esi, 12h
jmp short loc_5115
loc_50A2:
mov rdi, r15; jumptable 000000000000502B case 19
mov rsi, rbx
call rak_lexer_next
cmp byte ptr [rbx], 1
jnz def_502B; jumptable 000000000000502B default case
mov rdi, r14
mov rsi, rbx
call compile_add_expr
mov al, [rbx]
cmp al, 1
jnz short loc_5105
cmp dword ptr [r14+2810h], 15h
jnz short loc_5105
mov rdi, r15
mov rsi, rbx
call rak_lexer_next
mov al, [rbx]
cmp al, 1
jnz short loc_5105
mov rdi, r14
mov rsi, rbx
call compile_add_expr
mov al, [rbx]
cmp al, 1
jnz short loc_5105
mov rdi, r14
mov esi, 0Ah
mov rdx, rbx
call rak_chunk_append_instr
mov al, [rbx]
loc_5105:
test al, 1
jz def_502B; jumptable 000000000000502B default case
mov rdi, r14
mov esi, 11h
loc_5115:
mov rdx, rbx
call rak_chunk_append_instr
cmp byte ptr [rbx], 1
jnz def_502B; jumptable 000000000000502B default case
mov rdi, r14
mov esi, 18h
jmp loc_5213
loc_5133:
mov rdi, r15; jumptable 000000000000502B case 20
mov rsi, rbx
call rak_lexer_next
cmp byte ptr [rbx], 1
jnz def_502B; jumptable 000000000000502B default case
mov rdi, r14
mov rsi, rbx
call compile_add_expr
mov al, [rbx]
cmp al, 1
jnz short loc_5196
cmp dword ptr [r14+2810h], 15h
jnz short loc_5196
mov rdi, r15
mov rsi, rbx
call rak_lexer_next
mov al, [rbx]
cmp al, 1
jnz short loc_5196
mov rdi, r14
mov rsi, rbx
call compile_add_expr
mov al, [rbx]
cmp al, 1
jnz short loc_5196
mov rdi, r14
mov esi, 0Ah
mov rdx, rbx
call rak_chunk_append_instr
mov al, [rbx]
loc_5196:
test al, 1
jz def_502B; jumptable 000000000000502B default case
mov rdi, r14
mov esi, 12h
jmp short loc_5213
loc_51A8:
mov rdi, r15; jumptable 000000000000502B case 18
mov rsi, rbx
call rak_lexer_next
cmp byte ptr [rbx], 1
jnz short def_502B; jumptable 000000000000502B default case
mov rdi, r14
mov rsi, rbx
call compile_add_expr
mov al, [rbx]
cmp al, 1
jnz short loc_5207
cmp dword ptr [r14+2810h], 15h
jnz short loc_5207
mov rdi, r15
mov rsi, rbx
call rak_lexer_next
mov al, [rbx]
cmp al, 1
jnz short loc_5207
mov rdi, r14
mov rsi, rbx
call compile_add_expr
mov al, [rbx]
cmp al, 1
jnz short loc_5207
mov rdi, r14
mov esi, 0Ah
mov rdx, rbx
call rak_chunk_append_instr
mov al, [rbx]
loc_5207:
test al, 1
jz short def_502B; jumptable 000000000000502B default case
mov rdi, r14
mov esi, 11h
loc_5213:
mov rdx, rbx
call rak_chunk_append_instr
cmp byte ptr [rbx], 0
jnz loc_5011
def_502B:
add rsp, 8; jumptable 000000000000502B default case
pop rbx
pop r12
pop r14
pop r15
retn
| char compile_cmp_expr(long long a1, char *a2)
{
int v4; // eax
int v5; // ecx
int v6; // r8d
int v7; // r9d
int v8; // ecx
int v9; // r8d
int v10; // r9d
long long v11; // rdi
int v12; // esi
int v13; // ecx
int v14; // r8d
int v15; // r9d
long long v16; // rdi
int v17; // esi
compile_add_expr(a1);
LOBYTE(v4) = *a2;
if ( *a2 == 1 && *(_DWORD *)(a1 + 10256) == 21 )
{
rak_lexer_next(a1 + 10232, a2);
LOBYTE(v4) = *a2;
if ( *a2 == 1 )
{
compile_add_expr(a1);
LOBYTE(v4) = *a2;
if ( *a2 == 1 )
{
rak_chunk_append_instr(a1, 10, a2, v5, v6, v7);
LOBYTE(v4) = *a2;
}
}
}
if ( (v4 & 1) != 0 )
{
while ( 2 )
{
v4 = *(_DWORD *)(a1 + 10256) - 17;
switch ( *(_DWORD *)(a1 + 10256) )
{
case 0x11:
LOBYTE(v4) = rak_lexer_next(a1 + 10232, a2);
if ( *a2 == 1 )
{
compile_add_expr(a1);
LOBYTE(v4) = *a2;
if ( *a2 == 1 && *(_DWORD *)(a1 + 10256) == 21 )
{
rak_lexer_next(a1 + 10232, a2);
LOBYTE(v4) = *a2;
if ( *a2 == 1 )
{
compile_add_expr(a1);
LOBYTE(v4) = *a2;
if ( *a2 == 1 )
{
rak_chunk_append_instr(a1, 10, a2, v8, v9, v10);
LOBYTE(v4) = *a2;
}
}
}
if ( (v4 & 1) != 0 )
{
v11 = a1;
v12 = 18;
goto LABEL_24;
}
}
break;
case 0x12:
LOBYTE(v4) = rak_lexer_next(a1 + 10232, a2);
if ( *a2 == 1 )
{
compile_add_expr(a1);
LOBYTE(v4) = *a2;
if ( *a2 == 1 && *(_DWORD *)(a1 + 10256) == 21 )
{
rak_lexer_next(a1 + 10232, a2);
LOBYTE(v4) = *a2;
if ( *a2 == 1 )
{
compile_add_expr(a1);
LOBYTE(v4) = *a2;
if ( *a2 == 1 )
{
rak_chunk_append_instr(a1, 10, a2, v13, v14, v15);
LOBYTE(v4) = *a2;
}
}
}
if ( (v4 & 1) != 0 )
{
v16 = a1;
v17 = 17;
goto LABEL_42;
}
}
break;
case 0x13:
LOBYTE(v4) = rak_lexer_next(a1 + 10232, a2);
if ( *a2 == 1 )
{
compile_add_expr(a1);
LOBYTE(v4) = *a2;
if ( *a2 == 1 && *(_DWORD *)(a1 + 10256) == 21 )
{
rak_lexer_next(a1 + 10232, a2);
LOBYTE(v4) = *a2;
if ( *a2 == 1 )
{
compile_add_expr(a1);
LOBYTE(v4) = *a2;
if ( *a2 == 1 )
{
rak_chunk_append_instr(a1, 10, a2, v8, v9, v10);
LOBYTE(v4) = *a2;
}
}
}
if ( (v4 & 1) != 0 )
{
v11 = a1;
v12 = 17;
LABEL_24:
LOBYTE(v4) = rak_chunk_append_instr(v11, v12, a2, v8, v9, v10);
if ( *a2 == 1 )
{
v16 = a1;
v17 = 24;
goto LABEL_42;
}
}
}
break;
case 0x14:
LOBYTE(v4) = rak_lexer_next(a1 + 10232, a2);
if ( *a2 == 1 )
{
compile_add_expr(a1);
LOBYTE(v4) = *a2;
if ( *a2 == 1 && *(_DWORD *)(a1 + 10256) == 21 )
{
rak_lexer_next(a1 + 10232, a2);
LOBYTE(v4) = *a2;
if ( *a2 == 1 )
{
compile_add_expr(a1);
LOBYTE(v4) = *a2;
if ( *a2 == 1 )
{
rak_chunk_append_instr(a1, 10, a2, v13, v14, v15);
LOBYTE(v4) = *a2;
}
}
}
if ( (v4 & 1) != 0 )
{
v16 = a1;
v17 = 18;
LABEL_42:
LOBYTE(v4) = rak_chunk_append_instr(v16, v17, a2, v13, v14, v15);
if ( *a2 )
continue;
}
}
break;
default:
return v4;
}
break;
}
}
return v4;
}
| compile_cmp_expr:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
CALL 0x00105230
MOV AL,byte ptr [RBX]
CMP AL,0x1
JNZ 0x00104ffb
CMP dword ptr [R14 + 0x2810],0x15
JNZ 0x00104ffb
LEA RDI,[R14 + 0x27f8]
MOV RSI,RBX
CALL 0x0010679a
MOV AL,byte ptr [RBX]
CMP AL,0x1
JNZ 0x00104ffb
MOV RDI,R14
MOV RSI,RBX
CALL 0x00105230
MOV AL,byte ptr [RBX]
CMP AL,0x1
JNZ 0x00104ffb
MOV RDI,R14
MOV ESI,0xa
MOV RDX,RBX
CALL 0x0010392d
MOV AL,byte ptr [RBX]
LAB_00104ffb:
TEST AL,0x1
JZ 0x00105224
LEA R15,[R14 + 0x27f8]
LEA R12,[0x10a434]
LAB_00105011:
MOV EAX,dword ptr [R14 + 0x2810]
ADD EAX,-0x11
CMP EAX,0x3
JA 0x00105224
MOVSXD RAX,dword ptr [R12 + RAX*0x4]
ADD RAX,R12
switchD:
JMP RAX
caseD_11:
MOV RDI,R15
MOV RSI,RBX
CALL 0x0010679a
CMP byte ptr [RBX],0x1
JNZ 0x00105224
MOV RDI,R14
MOV RSI,RBX
CALL 0x00105230
MOV AL,byte ptr [RBX]
CMP AL,0x1
JNZ 0x00105090
CMP dword ptr [R14 + 0x2810],0x15
JNZ 0x00105090
MOV RDI,R15
MOV RSI,RBX
CALL 0x0010679a
MOV AL,byte ptr [RBX]
CMP AL,0x1
JNZ 0x00105090
MOV RDI,R14
MOV RSI,RBX
CALL 0x00105230
MOV AL,byte ptr [RBX]
CMP AL,0x1
JNZ 0x00105090
MOV RDI,R14
MOV ESI,0xa
MOV RDX,RBX
CALL 0x0010392d
MOV AL,byte ptr [RBX]
LAB_00105090:
TEST AL,0x1
JZ 0x00105224
MOV RDI,R14
MOV ESI,0x12
JMP 0x00105115
caseD_13:
MOV RDI,R15
MOV RSI,RBX
CALL 0x0010679a
CMP byte ptr [RBX],0x1
JNZ 0x00105224
MOV RDI,R14
MOV RSI,RBX
CALL 0x00105230
MOV AL,byte ptr [RBX]
CMP AL,0x1
JNZ 0x00105105
CMP dword ptr [R14 + 0x2810],0x15
JNZ 0x00105105
MOV RDI,R15
MOV RSI,RBX
CALL 0x0010679a
MOV AL,byte ptr [RBX]
CMP AL,0x1
JNZ 0x00105105
MOV RDI,R14
MOV RSI,RBX
CALL 0x00105230
MOV AL,byte ptr [RBX]
CMP AL,0x1
JNZ 0x00105105
MOV RDI,R14
MOV ESI,0xa
MOV RDX,RBX
CALL 0x0010392d
MOV AL,byte ptr [RBX]
LAB_00105105:
TEST AL,0x1
JZ 0x00105224
MOV RDI,R14
MOV ESI,0x11
LAB_00105115:
MOV RDX,RBX
CALL 0x0010392d
CMP byte ptr [RBX],0x1
JNZ 0x00105224
MOV RDI,R14
MOV ESI,0x18
JMP 0x00105213
caseD_14:
MOV RDI,R15
MOV RSI,RBX
CALL 0x0010679a
CMP byte ptr [RBX],0x1
JNZ 0x00105224
MOV RDI,R14
MOV RSI,RBX
CALL 0x00105230
MOV AL,byte ptr [RBX]
CMP AL,0x1
JNZ 0x00105196
CMP dword ptr [R14 + 0x2810],0x15
JNZ 0x00105196
MOV RDI,R15
MOV RSI,RBX
CALL 0x0010679a
MOV AL,byte ptr [RBX]
CMP AL,0x1
JNZ 0x00105196
MOV RDI,R14
MOV RSI,RBX
CALL 0x00105230
MOV AL,byte ptr [RBX]
CMP AL,0x1
JNZ 0x00105196
MOV RDI,R14
MOV ESI,0xa
MOV RDX,RBX
CALL 0x0010392d
MOV AL,byte ptr [RBX]
LAB_00105196:
TEST AL,0x1
JZ 0x00105224
MOV RDI,R14
MOV ESI,0x12
JMP 0x00105213
caseD_12:
MOV RDI,R15
MOV RSI,RBX
CALL 0x0010679a
CMP byte ptr [RBX],0x1
JNZ 0x00105224
MOV RDI,R14
MOV RSI,RBX
CALL 0x00105230
MOV AL,byte ptr [RBX]
CMP AL,0x1
JNZ 0x00105207
CMP dword ptr [R14 + 0x2810],0x15
JNZ 0x00105207
MOV RDI,R15
MOV RSI,RBX
CALL 0x0010679a
MOV AL,byte ptr [RBX]
CMP AL,0x1
JNZ 0x00105207
MOV RDI,R14
MOV RSI,RBX
CALL 0x00105230
MOV AL,byte ptr [RBX]
CMP AL,0x1
JNZ 0x00105207
MOV RDI,R14
MOV ESI,0xa
MOV RDX,RBX
CALL 0x0010392d
MOV AL,byte ptr [RBX]
LAB_00105207:
TEST AL,0x1
JZ 0x00105224
MOV RDI,R14
MOV ESI,0x11
LAB_00105213:
MOV RDX,RBX
CALL 0x0010392d
CMP byte ptr [RBX],0x0
JNZ 0x00105011
default:
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
void compile_cmp_expr(long param_1,byte *param_2)
{
long lVar1;
byte bVar2;
int8 uVar3;
compile_add_expr();
bVar2 = *param_2;
if ((bVar2 == 1) && (*(int *)(param_1 + 0x2810) == 0x15)) {
rak_lexer_next(param_1 + 0x27f8,param_2);
bVar2 = *param_2;
if (bVar2 == 1) {
compile_add_expr(param_1,param_2);
bVar2 = *param_2;
if (bVar2 == 1) {
rak_chunk_append_instr(param_1,10,param_2);
bVar2 = *param_2;
}
}
}
if ((bVar2 & 1) != 0) {
lVar1 = param_1 + 0x27f8;
do {
switch(*(int4 *)(param_1 + 0x2810)) {
case 0x11:
rak_lexer_next(lVar1,param_2);
if (*param_2 != 1) {
return;
}
compile_add_expr(param_1,param_2);
bVar2 = *param_2;
if ((bVar2 == 1) && (*(int *)(param_1 + 0x2810) == 0x15)) {
rak_lexer_next(lVar1,param_2);
bVar2 = *param_2;
if (bVar2 == 1) {
compile_add_expr(param_1,param_2);
bVar2 = *param_2;
if (bVar2 == 1) {
rak_chunk_append_instr(param_1,10,param_2);
bVar2 = *param_2;
}
}
}
if ((bVar2 & 1) == 0) {
return;
}
uVar3 = 0x12;
goto LAB_00105115;
case 0x12:
rak_lexer_next(lVar1,param_2);
if (*param_2 != 1) {
return;
}
compile_add_expr(param_1,param_2);
bVar2 = *param_2;
if ((bVar2 == 1) && (*(int *)(param_1 + 0x2810) == 0x15)) {
rak_lexer_next(lVar1,param_2);
bVar2 = *param_2;
if (bVar2 == 1) {
compile_add_expr(param_1,param_2);
bVar2 = *param_2;
if (bVar2 == 1) {
rak_chunk_append_instr(param_1,10,param_2);
bVar2 = *param_2;
}
}
}
if ((bVar2 & 1) == 0) {
return;
}
uVar3 = 0x11;
break;
case 0x13:
rak_lexer_next(lVar1,param_2);
if (*param_2 != 1) {
return;
}
compile_add_expr(param_1,param_2);
bVar2 = *param_2;
if ((bVar2 == 1) && (*(int *)(param_1 + 0x2810) == 0x15)) {
rak_lexer_next(lVar1,param_2);
bVar2 = *param_2;
if (bVar2 == 1) {
compile_add_expr(param_1,param_2);
bVar2 = *param_2;
if (bVar2 == 1) {
rak_chunk_append_instr(param_1,10,param_2);
bVar2 = *param_2;
}
}
}
if ((bVar2 & 1) == 0) {
return;
}
uVar3 = 0x11;
LAB_00105115:
rak_chunk_append_instr(param_1,uVar3,param_2);
if (*param_2 != 1) {
return;
}
uVar3 = 0x18;
break;
case 0x14:
rak_lexer_next(lVar1,param_2);
if (*param_2 != 1) {
return;
}
compile_add_expr(param_1,param_2);
bVar2 = *param_2;
if ((bVar2 == 1) && (*(int *)(param_1 + 0x2810) == 0x15)) {
rak_lexer_next(lVar1,param_2);
bVar2 = *param_2;
if (bVar2 == 1) {
compile_add_expr(param_1,param_2);
bVar2 = *param_2;
if (bVar2 == 1) {
rak_chunk_append_instr(param_1,10,param_2);
bVar2 = *param_2;
}
}
}
if ((bVar2 & 1) == 0) {
return;
}
uVar3 = 0x12;
break;
default:
goto switchD_0010502b_default;
}
rak_chunk_append_instr(param_1,uVar3,param_2);
} while (*param_2 != 0);
}
switchD_0010502b_default:
return;
}
| |
47,266 | my_copy_fix_mb2_or_mb4 | eloqsql/strings/ctype-ucs2.c | static size_t
my_copy_fix_mb2_or_mb4(CHARSET_INFO *cs,
char *dst, size_t dst_length,
const char *src, size_t src_length,
size_t nchars, MY_STRCOPY_STATUS *status)
{
size_t length2, src_offset= src_length % cs->mbminlen;
my_char_copy_status_t padstatus;
if (!src_offset)
return my_copy_fix_mb(cs, dst, dst_length,
src, src_length, nchars, status);
if ((padstatus= my_copy_incomplete_char(cs, dst, dst_length,
src, src_length, nchars, TRUE)) ==
MY_CHAR_COPY_ERROR)
{
status->m_source_end_pos= status->m_well_formed_error_pos= src;
return 0;
}
length2= my_copy_fix_mb(cs, dst + cs->mbminlen, dst_length - cs->mbminlen,
src + src_offset, src_length - src_offset,
nchars - 1, status);
if (padstatus == MY_CHAR_COPY_FIXED)
status->m_well_formed_error_pos= src;
return cs->mbminlen /* The left-padded character */ + length2;
} | O0 | c | my_copy_fix_mb2_or_mb4:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x98(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movq %rdx, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x6a1a0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0x4f950
movq %rax, -0x8(%rbp)
jmp 0x6a25c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movl $0x1, (%rsp)
callq 0x6ba50
movl %eax, -0x4c(%rbp)
cmpl $0x1, %eax
jne 0x6a1e9
movq -0x28(%rbp), %rcx
movq 0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rbp), %rax
movq %rcx, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x6a25c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x98(%rax), %eax
addq %rax, %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movl 0x98(%rax), %eax
subq %rax, %rdx
movq -0x28(%rbp), %rcx
addq -0x48(%rbp), %rcx
movq -0x30(%rbp), %r8
subq -0x48(%rbp), %r8
movq -0x38(%rbp), %r9
subq $0x1, %r9
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0x4f950
movq %rax, -0x40(%rbp)
cmpl $0x2, -0x4c(%rbp)
jne 0x6a24a
movq -0x28(%rbp), %rcx
movq 0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x98(%rax), %eax
addq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_copy_fix_mb2_or_mb4:
push rbp
mov rbp, rsp
sub rsp, 60h
mov rax, [rbp+arg_0]
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 rax, [rbp+var_30]
mov rcx, [rbp+var_10]
mov ecx, [rcx+98h]
xor edx, edx
div rcx
mov [rbp+var_48], rdx
cmp [rbp+var_48], 0
jnz short loc_6A1A0
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_28]
mov r8, [rbp+var_30]
mov r9, [rbp+var_38]
mov rax, [rbp+arg_0]
mov [rsp+60h+var_60], rax
call my_copy_fix_mb
mov [rbp+var_8], rax
jmp loc_6A25C
loc_6A1A0:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_28]
mov r8, [rbp+var_30]
mov r9, [rbp+var_38]
mov dword ptr [rsp+60h+var_60], 1
call my_copy_incomplete_char
mov [rbp+var_4C], eax
cmp eax, 1
jnz short loc_6A1E9
mov rcx, [rbp+var_28]
mov rax, [rbp+arg_0]
mov [rax+8], rcx
mov rax, [rbp+arg_0]
mov [rax], rcx
mov [rbp+var_8], 0
jmp short loc_6A25C
loc_6A1E9:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rax, [rbp+var_10]
mov eax, [rax+98h]
add rsi, rax
mov rdx, [rbp+var_20]
mov rax, [rbp+var_10]
mov eax, [rax+98h]
sub rdx, rax
mov rcx, [rbp+var_28]
add rcx, [rbp+var_48]
mov r8, [rbp+var_30]
sub r8, [rbp+var_48]
mov r9, [rbp+var_38]
sub r9, 1
mov rax, [rbp+arg_0]
mov [rsp+60h+var_60], rax
call my_copy_fix_mb
mov [rbp+var_40], rax
cmp [rbp+var_4C], 2
jnz short loc_6A24A
mov rcx, [rbp+var_28]
mov rax, [rbp+arg_0]
mov [rax+8], rcx
loc_6A24A:
mov rax, [rbp+var_10]
mov eax, [rax+98h]
add rax, [rbp+var_40]
mov [rbp+var_8], rax
loc_6A25C:
mov rax, [rbp+var_8]
add rsp, 60h
pop rbp
retn
| long long my_copy_fix_mb2_or_mb4(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
unsigned long long a5,
long long a6,
long long *a7)
{
int v8; // [rsp+14h] [rbp-4Ch]
unsigned long long v9; // [rsp+18h] [rbp-48h]
long long fixed; // [rsp+20h] [rbp-40h]
v9 = a5 % *(unsigned int *)(a1 + 152);
if ( !v9 )
return my_copy_fix_mb(a1, a2, a3, a4, a5, a6, a7);
v8 = my_copy_incomplete_char(a1, a2, a3, a4, a5, a6, 1);
if ( v8 == 1 )
{
a7[1] = a4;
*a7 = a4;
return 0LL;
}
else
{
fixed = my_copy_fix_mb(
a1,
*(unsigned int *)(a1 + 152) + a2,
a3 - *(unsigned int *)(a1 + 152),
v9 + a4,
a5 - v9,
a6 - 1,
a7);
if ( v8 == 2 )
a7[1] = a4;
return fixed + *(unsigned int *)(a1 + 152);
}
}
| my_copy_fix_mb2_or_mb4:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0x98]
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x48],RDX
CMP qword ptr [RBP + -0x48],0x0
JNZ 0x0016a1a0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8,qword ptr [RBP + -0x30]
MOV R9,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RSP],RAX
CALL 0x0014f950
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0016a25c
LAB_0016a1a0:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8,qword ptr [RBP + -0x30]
MOV R9,qword ptr [RBP + -0x38]
MOV dword ptr [RSP],0x1
CALL 0x0016ba50
MOV dword ptr [RBP + -0x4c],EAX
CMP EAX,0x1
JNZ 0x0016a1e9
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RAX],RCX
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0016a25c
LAB_0016a1e9:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x98]
ADD RSI,RAX
MOV RDX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x98]
SUB RDX,RAX
MOV RCX,qword ptr [RBP + -0x28]
ADD RCX,qword ptr [RBP + -0x48]
MOV R8,qword ptr [RBP + -0x30]
SUB R8,qword ptr [RBP + -0x48]
MOV R9,qword ptr [RBP + -0x38]
SUB R9,0x1
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RSP],RAX
CALL 0x0014f950
MOV qword ptr [RBP + -0x40],RAX
CMP dword ptr [RBP + -0x4c],0x2
JNZ 0x0016a24a
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
LAB_0016a24a:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x98]
ADD RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x8],RAX
LAB_0016a25c:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x60
POP RBP
RET
|
long my_copy_fix_mb2_or_mb4
(long param_1,long param_2,long param_3,long param_4,ulong param_5,long param_6,
long *param_7)
{
int iVar1;
ulong uVar2;
long local_10;
uVar2 = param_5 % (ulong)*(uint *)(param_1 + 0x98);
if (uVar2 == 0) {
local_10 = my_copy_fix_mb(param_1,param_2,param_3,param_4,param_5,param_6,param_7);
}
else {
iVar1 = my_copy_incomplete_char(param_1,param_2,param_3,param_4,param_5,param_6,1);
if (iVar1 == 1) {
param_7[1] = param_4;
*param_7 = param_4;
local_10 = 0;
}
else {
local_10 = my_copy_fix_mb(param_1,param_2 + (ulong)*(uint *)(param_1 + 0x98),
param_3 - (ulong)*(uint *)(param_1 + 0x98),param_4 + uVar2,
param_5 - uVar2,param_6 + -1,param_7);
if (iVar1 == 2) {
param_7[1] = param_4;
}
local_10 = (ulong)*(uint *)(param_1 + 0x98) + local_10;
}
}
return local_10;
}
| |
47,267 | evmone::Result evmone::instr::core::extcall_impl<(evmone::Opcode)251>(evmone::StackTop, long, evmone::ExecutionState&) | corpus-core[P]colibri-stateless/build_O2/_deps/evmone_external-src/lib/evmone/instructions_calls.cpp | Result extcall_impl(StackTop stack, int64_t gas_left, ExecutionState& state) noexcept
{
static_assert(Op == OP_EXTCALL || Op == OP_EXTDELEGATECALL || Op == OP_EXTSTATICCALL);
const auto dst_u256 = stack.pop();
const auto input_offset_u256 = stack.pop();
const auto input_size_u256 = stack.pop();
const auto value = (Op == OP_EXTSTATICCALL || Op == OP_EXTDELEGATECALL) ? 0 : stack.pop();
const auto has_value = value != 0;
stack.push(EXTCALL_ABORT); // Assume (hard) failure.
state.return_data.clear();
// Address space expansion ready check.
static constexpr auto ADDRESS_MAX = (uint256{1} << 160) - 1;
if (dst_u256 > ADDRESS_MAX)
return {EVMC_ARGUMENT_OUT_OF_RANGE, gas_left};
const auto dst = intx::be::trunc<evmc::address>(dst_u256);
if (state.host.access_account(dst) == EVMC_ACCESS_COLD)
{
if ((gas_left -= instr::additional_cold_account_access_cost) < 0)
return {EVMC_OUT_OF_GAS, gas_left};
}
const auto target_addr_or_result = get_target_address(dst, gas_left, state);
if (const auto* result = std::get_if<Result>(&target_addr_or_result))
return *result;
const auto* addr_ptr = std::get_if<evmc::address>(&target_addr_or_result);
const auto& code_addr = *addr_ptr;
if (!check_memory(gas_left, state.memory, input_offset_u256, input_size_u256))
return {EVMC_OUT_OF_GAS, gas_left};
const auto input_offset = static_cast<size_t>(input_offset_u256);
const auto input_size = static_cast<size_t>(input_size_u256);
evmc_message msg{.kind = to_call_kind(Op)};
msg.flags = (Op == OP_EXTSTATICCALL) ? uint32_t{EVMC_STATIC} : state.msg->flags;
if (dst != code_addr)
msg.flags |= EVMC_DELEGATED;
else
msg.flags &= ~std::underlying_type_t<evmc_flags>{EVMC_DELEGATED};
msg.depth = state.msg->depth + 1;
msg.recipient = (Op != OP_EXTDELEGATECALL) ? dst : state.msg->recipient;
msg.code_address = code_addr;
msg.sender = (Op == OP_EXTDELEGATECALL) ? state.msg->sender : state.msg->recipient;
msg.value =
(Op == OP_EXTDELEGATECALL) ? state.msg->value : intx::be::store<evmc::uint256be>(value);
if (input_size > 0)
{
// input_offset may be garbage if input_size == 0.
msg.input_data = &state.memory[input_offset];
msg.input_size = input_size;
}
auto cost = has_value ? CALL_VALUE_COST : 0;
if constexpr (Op == OP_EXTCALL)
{
if (has_value && state.in_static_mode())
return {EVMC_STATIC_MODE_VIOLATION, gas_left};
if (has_value && !state.host.account_exists(dst))
cost += ACCOUNT_CREATION_COST;
}
if ((gas_left -= cost) < 0)
return {EVMC_OUT_OF_GAS, gas_left};
msg.gas = gas_left - std::max(gas_left / 64, MIN_RETAINED_GAS);
if (msg.gas < MIN_CALLEE_GAS || state.msg->depth >= 1024 ||
(has_value &&
intx::be::load<uint256>(state.host.get_balance(state.msg->recipient)) < value))
{
stack.top() = EXTCALL_REVERT;
return {EVMC_SUCCESS, gas_left}; // "Light" failure.
}
if constexpr (Op == OP_EXTDELEGATECALL)
{
// The code targeted by EXTDELEGATECALL must also be an EOF.
// This restriction has been added to EIP-3540 in
// https://github.com/ethereum/EIPs/pull/7131
uint8_t target_code_prefix[2];
const auto s = state.host.copy_code(
msg.code_address, 0, target_code_prefix, std::size(target_code_prefix));
if (!is_eof_container({target_code_prefix, s}))
{
stack.top() = EXTCALL_REVERT;
return {EVMC_SUCCESS, gas_left}; // "Light" failure.
}
}
const auto result = state.host.call(msg);
state.return_data.assign(result.output_data, result.output_size);
if (result.status_code == EVMC_SUCCESS)
stack.top() = EXTCALL_SUCCESS;
else if (result.status_code == EVMC_REVERT)
stack.top() = EXTCALL_REVERT;
else
stack.top() = EXTCALL_ABORT;
const auto gas_used = msg.gas - result.gas_left;
gas_left -= gas_used;
state.gas_refund += result.gas_refund;
return {EVMC_SUCCESS, gas_left};
} | O2 | cpp | evmone::Result evmone::instr::core::extcall_impl<(evmone::Opcode)251>(evmone::StackTop, long, evmone::ExecutionState&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
movq %rsi, (%rsp)
movups (%rdi), %xmm0
movups 0x10(%rdi), %xmm1
leaq 0xa0(%rsp), %rsi
movaps %xmm1, 0x10(%rsi)
movaps %xmm0, (%rsi)
movups -0x20(%rdi), %xmm0
movups -0x10(%rdi), %xmm1
movaps %xmm1, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movups -0x40(%rdi), %xmm0
movups -0x30(%rdi), %xmm1
movaps %xmm1, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movq $0x2, -0x40(%rdi)
xorps %xmm0, %xmm0
andq $0x0, -0x28(%rdi)
movups %xmm0, -0x38(%rdi)
andq $0x0, 0x50(%rdx)
movq 0x48(%rdx), %rax
movb $0x0, (%rax)
leaq 0x38f00(%rip), %rdi # 0x7c410
callq 0x3ad6f
testb %al, %al
je 0x43522
pushq $0xe
popq %r12
jmp 0x43710
leaq 0x2c(%rsp), %r12
leaq 0xa0(%rsp), %rsi
movq %r12, %rdi
callq 0x3b4af
leaq 0x28(%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x2f5c0
testl %eax, %eax
jne 0x43562
leaq -0x9c4(%r13), %rbp
movq %rbp, (%rsp)
cmpq $0x9c4, %r13 # imm = 0x9C4
jl 0x436ff
leaq 0x80(%rsp), %r12
leaq 0x2c(%rsp), %rsi
movq %rsp, %rdx
movq %r12, %rdi
movq %rbx, %rcx
callq 0x41aa8
movb 0x18(%r12), %bpl
cmpb $0x1, %bpl
jne 0x4359d
movl 0x80(%rsp), %r12d
movq 0x88(%rsp), %rbp
jmp 0x4370d
leaq 0x8(%rbx), %r13
movq %rsp, %rdi
leaq 0x60(%rsp), %rdx
leaq 0x40(%rsp), %rcx
movq %r13, %rsi
callq 0x3b250
testb %al, %al
je 0x43705
movq %r13, 0x20(%rsp)
xorl %eax, %eax
testb %bpl, %bpl
cmovneq %rax, %r12
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x118(%rsp), %rbp
movl $0xb0, %edx
movq %rbp, %rdi
xorl %esi, %esi
callq 0x221a0
movl $0x1, -0x8(%rbp)
movq 0x20(%rbx), %rax
movl 0x4(%rax), %r13d
leaq 0x2c(%rsp), %rdi
movq %r12, %rsi
callq 0x4208a
andl $-0x3, %r13d
movzbl %al, %eax
leal (%r13,%rax,2), %eax
movl %eax, -0x4(%rbp)
movq 0x20(%rbx), %rcx
movl 0x8(%rcx), %eax
leal 0x1(%rax), %edx
movl %edx, (%rbp)
movl 0x28(%rcx), %edx
movl %edx, 0x20(%rbp)
movups 0x18(%rcx), %xmm0
movups %xmm0, 0x10(%rbp)
movl 0x10(%r12), %edx
movl %edx, 0x98(%rbp)
movups (%r12), %xmm0
movups %xmm0, 0x88(%rbp)
movl 0x3c(%rcx), %edx
movl %edx, 0x34(%rbp)
movq 0x8(%rsp), %rdx
movups 0x2c(%rcx), %xmm0
movups %xmm0, 0x24(%rbp)
movups 0x50(%rcx), %xmm0
movups 0x60(%rcx), %xmm1
movups %xmm0, 0x48(%rbp)
movups %xmm1, 0x58(%rbp)
testq %rdx, %rdx
je 0x43699
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rsi
addq (%rcx), %rsi
movq %rsi, 0x150(%rsp)
movq %rdx, 0x158(%rsp)
movq (%rsp), %rbp
testq %rbp, %rbp
js 0x436ff
leaq -0x40(%r14), %rsi
addq $-0x38, %r14
movq %rbp, %rcx
shrq $0x6, %rcx
cmpq $0x1389, %rcx # imm = 0x1389
movl $0x1388, %edx # imm = 0x1388
cmovaeq %rcx, %rdx
movq %rbp, %rcx
subq %rdx, %rcx
movq %rcx, 0x120(%rsp)
cmpq $0x8fc, %rcx # imm = 0x8FC
setl %cl
cmpl $0x400, %eax # imm = 0x400
setge %al
orb %cl, %al
cmpb $0x1, %al
jne 0x43728
movq $0x1, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
xorl %r12d, %r12d
jmp 0x4370d
pushq $0x3
popq %r12
jmp 0x4370d
pushq $0x3
popq %r12
movq (%rsp), %rbp
movq %rbp, %r13
movl %r12d, %eax
movq %r13, %rdx
addq $0x1c8, %rsp # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, 0x8(%rsp)
movl 0x10(%r12), %eax
leaq 0xc0(%rsp), %rsi
movl %eax, 0x10(%rsi)
movups (%r12), %xmm0
movaps %xmm0, (%rsi)
xorl %r12d, %r12d
leaq 0x16(%rsp), %r13
pushq $0x2
popq %r8
movq %r15, %rdi
xorl %edx, %edx
movq %r13, %rcx
callq 0x2f4f2
movq %rax, %rdi
movq %r13, %rsi
callq 0x3dbd3
testb %al, %al
je 0x437bd
leaq 0x48(%rbx), %r13
leaq 0xc0(%rsp), %rbp
leaq 0x110(%rsp), %rdx
movq %rbp, %rdi
movq %r15, %rsi
callq 0x2f51e
movq 0x18(%rbp), %rsi
movq 0x20(%rbp), %rdx
movq %r13, %rdi
callq 0x42094
movl 0xc0(%rsp), %eax
cmpl $0x2, %eax
movq 0x8(%rsp), %rcx
je 0x437da
testl %eax, %eax
jne 0x437e3
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rcx)
movups %xmm0, (%rcx)
jmp 0x437f6
movq 0x8(%rsp), %rax
movq $0x1, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
jmp 0x43709
movq $0x1, (%rcx)
jmp 0x437ea
movq $0x2, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
leaq 0xc0(%rsp), %rdi
movq 0x8(%rdi), %rbp
movq 0x10(%rdi), %rax
subq 0x120(%rsp), %rbp
addq (%rsp), %rbp
movq %rbp, (%rsp)
addq %rax, (%rbx)
callq 0x2e864
jmp 0x4370d
movq %rax, %rdi
callq 0x2e859
| _ZN6evmone5instr4core12extcall_implILNS_6OpcodeE249EEENS_6ResultENS_8StackTopElRNS_14ExecutionStateE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 1C8h
mov rbx, rdx
mov r13, rsi
mov r14, rdi
mov [rsp+1F8h+var_1F8], rsi
movups xmm0, xmmword ptr [rdi]
movups xmm1, xmmword ptr [rdi+10h]
lea rsi, [rsp+1F8h+var_158]
movaps xmmword ptr [rsi+10h], xmm1
movaps xmmword ptr [rsi], xmm0
movups xmm0, xmmword ptr [rdi-20h]
movups xmm1, xmmword ptr [rdi-10h]
movaps [rsp+1F8h+var_188], xmm1
movaps [rsp+1F8h+var_198], xmm0
movups xmm0, xmmword ptr [rdi-40h]
movups xmm1, xmmword ptr [rdi-30h]
movaps [rsp+1F8h+var_1A8], xmm1
movaps [rsp+1F8h+var_1B8], xmm0
mov qword ptr [rdi-40h], 2
xorps xmm0, xmm0
and qword ptr [rdi-28h], 0
movups xmmword ptr [rdi-38h], xmm0
and qword ptr [rdx+50h], 0
mov rax, [rdx+48h]
mov byte ptr [rax], 0
lea rdi, _ZZN6evmone5instr4core12extcall_implILNS_6OpcodeE249EEENS_6ResultENS_8StackTopElRNS_14ExecutionStateEE11ADDRESS_MAX; evmone::instr::core::extcall_impl<(evmone::Opcode)249>(evmone::StackTop,long,evmone::ExecutionState &)::ADDRESS_MAX
call _ZN4intxltERKNS_4uintILj256EEES3_; intx::operator<(intx::uint<256u> const&,intx::uint<256u> const&)
test al, al
jz short loc_43522
push 0Eh
pop r12
jmp loc_43710
loc_43522:
lea r12, [rsp+1F8h+var_1CC]
lea rsi, [rsp+1F8h+var_158]
mov rdi, r12
call _ZN4intx2be5truncIN4evmc7addressELj256EEET_RKNS_4uintIXT0_EEE; intx::be::trunc<evmc::address,256u>(intx::uint<256u> const&)
lea r15, [rbx+28h]
mov rdi, r15
mov rsi, r12
call _ZN4evmc11HostContext14access_accountERKNS_7addressE; evmc::HostContext::access_account(evmc::address const&)
test eax, eax
jnz short loc_43562
lea rbp, [r13-9C4h]
mov [rsp+1F8h+var_1F8], rbp
cmp r13, 9C4h
jl loc_436FF
loc_43562:
lea r12, [rsp+1F8h+var_178]
lea rsi, [rsp+1F8h+var_1CC]
mov rdx, rsp
mov rdi, r12
mov rcx, rbx
call _ZN6evmone5instr4core12_GLOBAL__N_118get_target_addressERKN4evmc7addressERlRNS_14ExecutionStateE; evmone::instr::core::`anonymous namespace'::get_target_address(evmc::address const&,long &,evmone::ExecutionState &)
mov bpl, [r12+18h]
cmp bpl, 1
jnz short loc_4359D
mov r12d, [rsp+1F8h+var_178]
mov rbp, [rsp+1F8h+var_170]
jmp loc_4370D
loc_4359D:
lea r13, [rbx+8]
mov rdi, rsp
lea rdx, [rsp+1F8h+var_198]
lea rcx, [rsp+1F8h+var_1B8]
mov rsi, r13
call _ZN6evmone12check_memoryERlRNS_6MemoryERKN4intx4uintILj256EEES7_; evmone::check_memory(long &,evmone::Memory &,intx::uint<256u> const&,intx::uint<256u> const&)
test al, al
jz loc_43705
mov [rsp+1F8h+var_1D8], r13
xor eax, eax
test bpl, bpl
cmovnz r12, rax
mov rax, qword ptr [rsp+1F8h+var_198]
mov [rsp+1F8h+var_1E0], rax
mov rax, qword ptr [rsp+1F8h+var_1B8]
mov [rsp+1F8h+var_1F0], rax
lea rbp, [rsp+1F8h+var_E0]
mov edx, 0B0h
mov rdi, rbp
xor esi, esi
call _memset
mov dword ptr [rbp-8], 1
mov rax, [rbx+20h]
mov r13d, [rax+4]
lea rdi, [rsp+1F8h+var_1CC]
mov rsi, r12
call _ZN4evmcneERKNS_7addressES2_; evmc::operator!=(evmc::address const&,evmc::address const&)
and r13d, 0FFFFFFFDh
movzx eax, al
lea eax, [r13+rax*2+0]
mov [rbp-4], eax
mov rcx, [rbx+20h]
mov eax, [rcx+8]
lea edx, [rax+1]
mov [rbp+0], edx
mov edx, [rcx+28h]
mov [rbp+20h], edx
movups xmm0, xmmword ptr [rcx+18h]
movups xmmword ptr [rbp+10h], xmm0
mov edx, [r12+10h]
mov [rbp+98h], edx
movups xmm0, xmmword ptr [r12]
movups xmmword ptr [rbp+88h], xmm0
mov edx, [rcx+3Ch]
mov [rbp+34h], edx
mov rdx, [rsp+1F8h+var_1F0]
movups xmm0, xmmword ptr [rcx+2Ch]
movups xmmword ptr [rbp+24h], xmm0
movups xmm0, xmmword ptr [rcx+50h]
movups xmm1, xmmword ptr [rcx+60h]
movups xmmword ptr [rbp+48h], xmm0
movups xmmword ptr [rbp+58h], xmm1
test rdx, rdx
jz short loc_43699
mov rcx, [rsp+1F8h+var_1D8]
mov rsi, [rsp+1F8h+var_1E0]
add rsi, [rcx]
mov [rsp+1F8h+var_A8], rsi
mov [rsp+1F8h+var_A0], rdx
loc_43699:
mov rbp, [rsp+1F8h+var_1F8]
test rbp, rbp
js short loc_436FF
lea rsi, [r14-40h]
add r14, 0FFFFFFFFFFFFFFC8h
mov rcx, rbp
shr rcx, 6
cmp rcx, 1389h
mov edx, 1388h
cmovnb rdx, rcx
mov rcx, rbp
sub rcx, rdx
mov [rsp+1F8h+var_D8], rcx
cmp rcx, 8FCh
setl cl
cmp eax, 400h
setnl al
or al, cl
cmp al, 1
jnz short loc_43728
mov qword ptr [rsi], 1
xorps xmm0, xmm0
movups xmmword ptr [r14], xmm0
and qword ptr [r14+10h], 0
xor r12d, r12d
jmp short loc_4370D
loc_436FF:
push 3
pop r12
jmp short loc_4370D
loc_43705:
push 3
pop r12
loc_43709:
mov rbp, [rsp+1F8h+var_1F8]
loc_4370D:
mov r13, rbp
loc_43710:
mov eax, r12d
mov rdx, r13
add rsp, 1C8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_43728:
mov [rsp+1F8h+var_1F0], rsi
mov eax, [r12+10h]
lea rsi, [rsp+1F8h+var_138]
mov [rsi+10h], eax
movups xmm0, xmmword ptr [r12]
movaps xmmword ptr [rsi], xmm0
xor r12d, r12d
lea r13, [rsp+1F8h+var_1E2]
push 2
pop r8
mov rdi, r15
xor edx, edx
mov rcx, r13
call _ZNK4evmc11HostContext9copy_codeERKNS_7addressEmPhm; evmc::HostContext::copy_code(evmc::address const&,ulong,uchar *,ulong)
mov rdi, rax
mov rsi, r13
call _ZN6evmone16is_eof_containerESt17basic_string_viewIhN4evmc11byte_traitsIhEEE; evmone::is_eof_container(std::basic_string_view<uchar,evmc::byte_traits<uchar>>)
test al, al
jz short loc_437BD
lea r13, [rbx+48h]
lea rbp, [rsp+1F8h+var_138]
lea rdx, [rsp+1F8h+var_E8]
mov rdi, rbp
mov rsi, r15
call _ZN4evmc11HostContext4callERK12evmc_message; evmc::HostContext::call(evmc_message const&)
mov rsi, [rbp+18h]
mov rdx, [rbp+20h]
mov rdi, r13
call _ZNSt7__cxx1112basic_stringIhN4evmc11byte_traitsIhEESaIhEE6assignEPKhm; std::basic_string<uchar,evmc::byte_traits<uchar>,std::allocator<uchar>>::assign(uchar const*,ulong)
mov eax, [rsp+1F8h+var_138]
cmp eax, 2
mov rcx, [rsp+1F8h+var_1F0]
jz short loc_437DA
test eax, eax
jnz short loc_437E3
xorps xmm0, xmm0
movups xmmword ptr [rcx+10h], xmm0
movups xmmword ptr [rcx], xmm0
jmp short loc_437F6
loc_437BD:
mov rax, [rsp+1F8h+var_1F0]
mov qword ptr [rax], 1
xorps xmm0, xmm0
movups xmmword ptr [r14], xmm0
and qword ptr [r14+10h], 0
jmp loc_43709
loc_437DA:
mov qword ptr [rcx], 1
jmp short loc_437EA
loc_437E3:
mov qword ptr [rcx], 2
loc_437EA:
xorps xmm0, xmm0
movups xmmword ptr [r14], xmm0
and qword ptr [r14+10h], 0
loc_437F6:
lea rdi, [rsp+1F8h+var_138]; this
mov rbp, [rdi+8]
mov rax, [rdi+10h]
sub rbp, [rsp+1F8h+var_D8]
add rbp, [rsp+1F8h+var_1F8]
mov [rsp+1F8h+var_1F8], rbp
add [rbx], rax
call _ZN4evmc6ResultD2Ev; evmc::Result::~Result()
jmp loc_4370D
mov rdi, rax
call __clang_call_terminate
| long long evmone::instr::core::extcall_impl<(evmone::Opcode)249>(_OWORD *a1, long long a2, long long a3)
{
__int128 v4; // xmm0
__int128 v5; // xmm0
__int128 v6; // xmm0
unsigned int v7; // r12d
unsigned int *v8; // r12
char v9; // bp
int v10; // r13d
long long v11; // rcx
int v12; // eax
__int128 v13; // xmm1
char *v14; // r14
long long v15; // rdx
long long v17; // rax
_OWORD *v18; // rcx
long long v19; // [rsp+0h] [rbp-1F8h] BYREF
_OWORD *v20; // [rsp+8h] [rbp-1F0h]
char v21[2]; // [rsp+16h] [rbp-1E2h] BYREF
long long v22; // [rsp+18h] [rbp-1E0h]
_QWORD *v23; // [rsp+20h] [rbp-1D8h]
__int128 v24; // [rsp+2Ch] [rbp-1CCh] BYREF
_OWORD v25[2]; // [rsp+40h] [rbp-1B8h] BYREF
_OWORD v26[2]; // [rsp+60h] [rbp-198h] BYREF
unsigned int v27; // [rsp+80h] [rbp-178h] BYREF
char v28; // [rsp+98h] [rbp-160h]
_OWORD v29[2]; // [rsp+A0h] [rbp-158h] BYREF
__int128 v30; // [rsp+C0h] [rbp-138h] BYREF
long long v31; // [rsp+D0h] [rbp-128h]
long long v32; // [rsp+D8h] [rbp-120h]
long long v33; // [rsp+E0h] [rbp-118h]
int v34; // [rsp+110h] [rbp-E8h]
unsigned int v35; // [rsp+114h] [rbp-E4h]
int v36; // [rsp+118h] [rbp-E0h] BYREF
long long v37; // [rsp+120h] [rbp-D8h]
__int128 v38; // [rsp+128h] [rbp-D0h]
int v39; // [rsp+138h] [rbp-C0h]
__int128 v40; // [rsp+13Ch] [rbp-BCh]
int v41; // [rsp+14Ch] [rbp-ACh]
long long v42; // [rsp+150h] [rbp-A8h]
_OWORD *v43; // [rsp+158h] [rbp-A0h]
__int128 v44; // [rsp+160h] [rbp-98h]
__int128 v45; // [rsp+170h] [rbp-88h]
__int128 v46; // [rsp+1A0h] [rbp-58h]
unsigned int v47; // [rsp+1B0h] [rbp-48h]
v19 = a2;
v4 = *a1;
v29[1] = a1[1];
v29[0] = v4;
v5 = *(a1 - 2);
v26[1] = *(a1 - 1);
v26[0] = v5;
v6 = *(a1 - 4);
v25[1] = *(a1 - 3);
v25[0] = v6;
*((_QWORD *)a1 - 8) = 2LL;
*((_QWORD *)a1 - 5) = 0LL;
*(_OWORD *)((char *)a1 - 56) = 0LL;
*(_QWORD *)(a3 + 80) = 0LL;
**(_BYTE **)(a3 + 72) = 0;
if ( !intx::operator<(
evmone::instr::core::extcall_impl<(evmone::Opcode)249>(evmone::StackTop,long,evmone::ExecutionState &)::ADDRESS_MAX,
(unsigned long long *)v29) )
{
intx::be::trunc<evmc::address,256u>((long long)&v24);
if ( !(unsigned int)evmc::HostContext::access_account(a3 + 40) )
{
v19 = a2 - 2500;
if ( a2 < 2500 )
return 3;
}
v8 = &v27;
evmone::instr::core::`anonymous namespace'::get_target_address((long long)&v27, &v24, &v19, a3);
v9 = v28;
if ( v28 == 1 )
return v27;
if ( !evmone::check_memory((long long)&v19, a3 + 8, (long long)v26, v25) )
return 3;
v23 = (_QWORD *)(a3 + 8);
if ( v9 )
v8 = 0LL;
v22 = *(_QWORD *)&v26[0];
v20 = *(_OWORD **)&v25[0];
memset(&v36, 0LL, 176LL);
v34 = 1;
v10 = *(_DWORD *)(*(_QWORD *)(a3 + 32) + 4LL);
v35 = (v10 & 0xFFFFFFFD) + 2 * (unsigned __int8)evmc::operator!=((long long)&v24);
v11 = *(_QWORD *)(a3 + 32);
v12 = *(_DWORD *)(v11 + 8);
v36 = v12 + 1;
v39 = *(_DWORD *)(v11 + 40);
v38 = *(_OWORD *)(v11 + 24);
v47 = v8[4];
v46 = *(_OWORD *)v8;
v41 = *(_DWORD *)(v11 + 60);
v40 = *(_OWORD *)(v11 + 44);
v13 = *(_OWORD *)(v11 + 96);
v44 = *(_OWORD *)(v11 + 80);
v45 = v13;
if ( v20 )
{
v42 = *v23 + v22;
v43 = v20;
}
if ( v19 < 0 )
return 3;
v14 = (char *)a1 - 56;
v15 = 5000LL;
if ( (unsigned long long)v19 >> 6 >= 0x1389 )
v15 = (unsigned long long)v19 >> 6;
v37 = v19 - v15;
if ( v19 - v15 < 2300 || v12 >= 1024 )
{
*((_QWORD *)a1 - 8) = 1LL;
*(_OWORD *)v14 = 0LL;
*((_QWORD *)v14 + 2) = 0LL;
return 0;
}
v20 = a1 - 4;
LODWORD(v31) = v8[4];
v30 = *(_OWORD *)v8;
v7 = 0;
v17 = evmc::HostContext::copy_code(a3 + 40);
if ( !(unsigned __int8)evmone::is_eof_container(v17, (long long)v21) )
{
*(_QWORD *)v20 = 1LL;
*(_OWORD *)v14 = 0LL;
*((_QWORD *)v14 + 2) = 0LL;
return v7;
}
evmc::HostContext::call(&v30, a3 + 40);
std::basic_string<unsigned char,evmc::byte_traits<unsigned char>,std::allocator<unsigned char>>::assign(
a3 + 72,
v32,
v33);
v18 = v20;
if ( (_DWORD)v30 == 2 )
{
*(_QWORD *)v20 = 1LL;
}
else
{
if ( !(_DWORD)v30 )
{
v20[1] = 0LL;
*v18 = 0LL;
LABEL_28:
v19 += *((_QWORD *)&v30 + 1) - v37;
*(_QWORD *)a3 += v31;
evmc::Result::~Result((evmc::Result *)&v30);
return v7;
}
*(_QWORD *)v20 = 2LL;
}
*(_OWORD *)v14 = 0LL;
*((_QWORD *)v14 + 2) = 0LL;
goto LABEL_28;
}
return 14;
}
| extcall_impl<(evmone::Opcode)249>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x1c8
MOV RBX,RDX
MOV R13,RSI
MOV R14,RDI
MOV qword ptr [RSP],RSI
MOVUPS XMM0,xmmword ptr [RDI]
MOVUPS XMM1,xmmword ptr [RDI + 0x10]
LEA RSI,[RSP + 0xa0]
MOVAPS xmmword ptr [RSI + 0x10],XMM1
MOVAPS xmmword ptr [RSI],XMM0
MOVUPS XMM0,xmmword ptr [RDI + -0x20]
MOVUPS XMM1,xmmword ptr [RDI + -0x10]
MOVAPS xmmword ptr [RSP + 0x70],XMM1
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOVUPS XMM0,xmmword ptr [RDI + -0x40]
MOVUPS XMM1,xmmword ptr [RDI + -0x30]
MOVAPS xmmword ptr [RSP + 0x50],XMM1
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOV qword ptr [RDI + -0x40],0x2
XORPS XMM0,XMM0
AND qword ptr [RDI + -0x28],0x0
MOVUPS xmmword ptr [RDI + -0x38],XMM0
AND qword ptr [RDX + 0x50],0x0
MOV RAX,qword ptr [RDX + 0x48]
MOV byte ptr [RAX],0x0
LEA RDI,[0x17c410]
CALL 0x0013ad6f
TEST AL,AL
JZ 0x00143522
PUSH 0xe
POP R12
JMP 0x00143710
LAB_00143522:
LEA R12,[RSP + 0x2c]
LEA RSI,[RSP + 0xa0]
MOV RDI,R12
CALL 0x0013b4af
LEA R15,[RBX + 0x28]
MOV RDI,R15
MOV RSI,R12
CALL 0x0012f5c0
TEST EAX,EAX
JNZ 0x00143562
LEA RBP,[R13 + -0x9c4]
MOV qword ptr [RSP],RBP
CMP R13,0x9c4
JL 0x001436ff
LAB_00143562:
LEA R12,[RSP + 0x80]
LEA RSI,[RSP + 0x2c]
MOV RDX,RSP
MOV RDI,R12
MOV RCX,RBX
CALL 0x00141aa8
MOV BPL,byte ptr [R12 + 0x18]
CMP BPL,0x1
JNZ 0x0014359d
MOV R12D,dword ptr [RSP + 0x80]
MOV RBP,qword ptr [RSP + 0x88]
JMP 0x0014370d
LAB_0014359d:
LEA R13,[RBX + 0x8]
MOV RDI,RSP
LEA RDX,[RSP + 0x60]
LEA RCX,[RSP + 0x40]
MOV RSI,R13
CALL 0x0013b250
TEST AL,AL
JZ 0x00143705
MOV qword ptr [RSP + 0x20],R13
XOR EAX,EAX
TEST BPL,BPL
CMOVNZ R12,RAX
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x8],RAX
LEA RBP,[RSP + 0x118]
MOV EDX,0xb0
MOV RDI,RBP
XOR ESI,ESI
CALL 0x001221a0
MOV dword ptr [RBP + -0x8],0x1
MOV RAX,qword ptr [RBX + 0x20]
MOV R13D,dword ptr [RAX + 0x4]
LEA RDI,[RSP + 0x2c]
MOV RSI,R12
CALL 0x0014208a
AND R13D,0xfffffffd
MOVZX EAX,AL
LEA EAX,[R13 + RAX*0x2]
MOV dword ptr [RBP + -0x4],EAX
MOV RCX,qword ptr [RBX + 0x20]
MOV EAX,dword ptr [RCX + 0x8]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP],EDX
MOV EDX,dword ptr [RCX + 0x28]
MOV dword ptr [RBP + 0x20],EDX
MOVUPS XMM0,xmmword ptr [RCX + 0x18]
MOVUPS xmmword ptr [RBP + 0x10],XMM0
MOV EDX,dword ptr [R12 + 0x10]
MOV dword ptr [RBP + 0x98],EDX
MOVUPS XMM0,xmmword ptr [R12]
MOVUPS xmmword ptr [RBP + 0x88],XMM0
MOV EDX,dword ptr [RCX + 0x3c]
MOV dword ptr [RBP + 0x34],EDX
MOV RDX,qword ptr [RSP + 0x8]
MOVUPS XMM0,xmmword ptr [RCX + 0x2c]
MOVUPS xmmword ptr [RBP + 0x24],XMM0
MOVUPS XMM0,xmmword ptr [RCX + 0x50]
MOVUPS XMM1,xmmword ptr [RCX + 0x60]
MOVUPS xmmword ptr [RBP + 0x48],XMM0
MOVUPS xmmword ptr [RBP + 0x58],XMM1
TEST RDX,RDX
JZ 0x00143699
MOV RCX,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x18]
ADD RSI,qword ptr [RCX]
MOV qword ptr [RSP + 0x150],RSI
MOV qword ptr [RSP + 0x158],RDX
LAB_00143699:
MOV RBP,qword ptr [RSP]
TEST RBP,RBP
JS 0x001436ff
LEA RSI,[R14 + -0x40]
ADD R14,-0x38
MOV RCX,RBP
SHR RCX,0x6
CMP RCX,0x1389
MOV EDX,0x1388
CMOVNC RDX,RCX
MOV RCX,RBP
SUB RCX,RDX
MOV qword ptr [RSP + 0x120],RCX
CMP RCX,0x8fc
SETL CL
CMP EAX,0x400
SETGE AL
OR AL,CL
CMP AL,0x1
JNZ 0x00143728
MOV qword ptr [RSI],0x1
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14],XMM0
AND qword ptr [R14 + 0x10],0x0
XOR R12D,R12D
JMP 0x0014370d
LAB_001436ff:
PUSH 0x3
POP R12
JMP 0x0014370d
LAB_00143705:
PUSH 0x3
POP R12
LAB_00143709:
MOV RBP,qword ptr [RSP]
LAB_0014370d:
MOV R13,RBP
LAB_00143710:
MOV EAX,R12D
MOV RDX,R13
ADD RSP,0x1c8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00143728:
MOV qword ptr [RSP + 0x8],RSI
MOV EAX,dword ptr [R12 + 0x10]
LEA RSI,[RSP + 0xc0]
MOV dword ptr [RSI + 0x10],EAX
MOVUPS XMM0,xmmword ptr [R12]
MOVAPS xmmword ptr [RSI],XMM0
XOR R12D,R12D
LEA R13,[RSP + 0x16]
PUSH 0x2
POP R8
MOV RDI,R15
XOR EDX,EDX
MOV RCX,R13
CALL 0x0012f4f2
MOV RDI,RAX
MOV RSI,R13
CALL 0x0013dbd3
TEST AL,AL
JZ 0x001437bd
LEA R13,[RBX + 0x48]
LEA RBP,[RSP + 0xc0]
LEA RDX,[RSP + 0x110]
MOV RDI,RBP
MOV RSI,R15
CALL 0x0012f51e
MOV RSI,qword ptr [RBP + 0x18]
MOV RDX,qword ptr [RBP + 0x20]
LAB_00143794:
MOV RDI,R13
CALL 0x00142094
MOV EAX,dword ptr [RSP + 0xc0]
CMP EAX,0x2
MOV RCX,qword ptr [RSP + 0x8]
JZ 0x001437da
TEST EAX,EAX
JNZ 0x001437e3
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RCX + 0x10],XMM0
MOVUPS xmmword ptr [RCX],XMM0
JMP 0x001437f6
LAB_001437bd:
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX],0x1
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14],XMM0
AND qword ptr [R14 + 0x10],0x0
JMP 0x00143709
LAB_001437da:
MOV qword ptr [RCX],0x1
JMP 0x001437ea
LAB_001437e3:
MOV qword ptr [RCX],0x2
LAB_001437ea:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14],XMM0
AND qword ptr [R14 + 0x10],0x0
LAB_001437f6:
LEA RDI,[RSP + 0xc0]
MOV RBP,qword ptr [RDI + 0x8]
MOV RAX,qword ptr [RDI + 0x10]
SUB RBP,qword ptr [RSP + 0x120]
ADD RBP,qword ptr [RSP]
MOV qword ptr [RSP],RBP
ADD qword ptr [RBX],RAX
CALL 0x0012e864
JMP 0x0014370d
|
/* evmone::Result evmone::instr::core::extcall_impl<(evmone::Opcode)249>(evmone::StackTop, long,
evmone::ExecutionState&) */
int1 [16]
evmone::instr::core::extcall_impl<(evmone::Opcode)249>
(int8 *param_1,ulong param_2,ExecutionState *param_3)
{
address *paVar1;
uint uVar2;
long lVar3;
char cVar4;
byte bVar5;
int iVar6;
evmone *peVar7;
ulong uVar8;
_anonymous_namespace_ *p_Var9;
int8 *puVar10;
int1 auVar11 [16];
ulong local_1f8;
int8 *local_1f0;
int1 local_1e2 [2];
long local_1e0;
Memory *local_1d8;
be local_1cc [20];
long local_1b8;
int8 uStack_1b0;
int8 local_1a8;
int8 uStack_1a0;
long local_198;
int8 uStack_190;
int8 local_188;
int8 uStack_180;
uint local_178 [2];
ulong local_170;
char local_160;
int8 local_158;
int8 uStack_150;
int8 local_148;
int8 uStack_140;
int8 local_138;
long lStack_130;
int4 local_128;
int4 uStack_124;
uchar *local_120;
ulong local_118;
int4 local_e8;
int local_e4;
int local_e0 [2];
long local_d8;
int8 local_d0;
int8 uStack_c8;
int4 local_c0;
int8 local_bc;
int8 uStack_b4;
int4 local_ac;
long local_a8;
long local_a0;
int8 local_98;
int8 uStack_90;
int8 local_88;
int8 uStack_80;
int8 local_58;
int8 uStack_50;
int4 local_48;
local_158 = *param_1;
uStack_150 = param_1[1];
local_148 = param_1[2];
uStack_140 = param_1[3];
local_198 = param_1[-4];
uStack_190 = param_1[-3];
local_188 = param_1[-2];
uStack_180 = param_1[-1];
local_1b8 = param_1[-8];
uStack_1b0 = param_1[-7];
local_1a8 = param_1[-6];
uStack_1a0 = param_1[-5];
param_1[-8] = 2;
param_1[-5] = 0;
param_1[-7] = 0;
param_1[-6] = 0;
*(int8 *)(param_3 + 0x50) = 0;
**(int1 **)(param_3 + 0x48) = 0;
local_1f8 = param_2;
cVar4 = intx::operator<((uint *)extcall_impl<(evmone::Opcode)249>(evmone::StackTop,long,evmone::ExecutionState&)
::ADDRESS_MAX,(uint *)&local_158);
if (cVar4 != '\0') {
uVar8 = 0xe;
goto LAB_00143710;
}
intx::be::trunc<evmc::address,256u>(local_1cc,(uint *)&local_158);
paVar1 = (address *)(param_3 + 0x28);
iVar6 = evmc::HostContext::access_account(paVar1);
if ((iVar6 == 0) && (local_1f8 = param_2 - 0x9c4, (long)param_2 < 0x9c4)) {
LAB_001436ff:
uVar8 = 3;
param_2 = local_1f8;
goto LAB_00143710;
}
(anonymous_namespace)::get_target_address
((_anonymous_namespace_ *)local_178,(address *)local_1cc,(long *)&local_1f8,param_3);
if (local_160 == '\x01') {
uVar8 = (ulong)local_178[0];
param_2 = local_170;
goto LAB_00143710;
}
cVar4 = check_memory((long *)&local_1f8,(Memory *)(param_3 + 8),(uint *)&local_198,
(uint *)&local_1b8);
if (cVar4 == '\0') {
uVar8 = 3;
param_2 = local_1f8;
goto LAB_00143710;
}
p_Var9 = (_anonymous_namespace_ *)local_178;
if (local_160 != '\0') {
p_Var9 = (_anonymous_namespace_ *)(address *)0x0;
}
local_1e0 = local_198;
local_1f0 = (int8 *)local_1b8;
local_1d8 = (Memory *)(param_3 + 8);
memset(local_e0,0,0xb0);
local_e8 = 1;
uVar2 = *(uint *)(*(long *)(param_3 + 0x20) + 4);
bVar5 = evmc::operator!=((address *)local_1cc,(address *)p_Var9);
local_e4 = (uVar2 & 0xfffffffd) + (uint)bVar5 * 2;
lVar3 = *(long *)(param_3 + 0x20);
local_e0[0] = *(int *)(lVar3 + 8) + 1;
local_c0 = *(int4 *)(lVar3 + 0x28);
local_d0 = *(int8 *)(lVar3 + 0x18);
uStack_c8 = *(int8 *)(lVar3 + 0x20);
local_48 = *(int4 *)((address *)p_Var9 + 0x10);
local_58 = *(int8 *)p_Var9;
uStack_50 = *(int8 *)((address *)p_Var9 + 8);
local_ac = *(int4 *)(lVar3 + 0x3c);
local_bc = *(int8 *)(lVar3 + 0x2c);
uStack_b4 = *(int8 *)(lVar3 + 0x34);
local_98 = *(int8 *)(lVar3 + 0x50);
uStack_90 = *(int8 *)(lVar3 + 0x58);
local_88 = *(int8 *)(lVar3 + 0x60);
uStack_80 = *(int8 *)(lVar3 + 0x68);
if (local_1f0 != (int8 *)0x0) {
local_a8 = local_1e0 + *(long *)local_1d8;
local_a0 = (long)local_1f0;
}
if ((long)local_1f8 < 0) goto LAB_001436ff;
local_1f0 = param_1 + -8;
puVar10 = param_1 + -7;
uVar8 = 5000;
if (5000 < local_1f8 >> 6) {
uVar8 = local_1f8 >> 6;
}
local_d8 = local_1f8 - uVar8;
if (0x3ff < *(int *)(lVar3 + 8) || (long)(local_1f8 - uVar8) < 0x8fc) {
*local_1f0 = 1;
*puVar10 = 0;
param_1[-6] = 0;
param_1[-5] = 0;
uVar8 = 0;
param_2 = local_1f8;
goto LAB_00143710;
}
local_128 = *(int4 *)((address *)p_Var9 + 0x10);
local_138 = *(int8 *)p_Var9;
lStack_130 = *(long *)((address *)p_Var9 + 8);
uVar8 = 0;
peVar7 = (evmone *)
evmc::HostContext::copy_code(paVar1,(ulong)&local_138,(uchar *)0x0,(ulong)local_1e2);
cVar4 = is_eof_container(peVar7,local_1e2);
if (cVar4 == '\0') {
*local_1f0 = 1;
*puVar10 = 0;
param_1[-6] = 0;
param_1[-5] = 0;
param_2 = local_1f8;
goto LAB_00143710;
}
evmc::HostContext::call((HostContext *)&local_138,(evmc_message *)paVar1);
/* try { // try from 00143794 to 0014379b has its CatchHandler @ 00143823 */
std::__cxx11::
basic_string<unsigned_char,evmc::byte_traits<unsigned_char>,std::allocator<unsigned_char>>::assign
((basic_string<unsigned_char,evmc::byte_traits<unsigned_char>,std::allocator<unsigned_char>>
*)(param_3 + 0x48),local_120,local_118);
if ((int)local_138 == 2) {
*local_1f0 = 1;
LAB_001437ea:
*puVar10 = 0;
param_1[-6] = 0;
param_1[-5] = 0;
}
else {
if ((int)local_138 != 0) {
*local_1f0 = 2;
goto LAB_001437ea;
}
local_1f0[2] = 0;
local_1f0[3] = 0;
*local_1f0 = 0;
local_1f0[1] = 0;
}
param_2 = (lStack_130 - local_d8) + local_1f8;
*(long *)param_3 = *(long *)param_3 + CONCAT44(uStack_124,local_128);
local_1f8 = param_2;
evmc::Result::~Result((Result *)&local_138);
LAB_00143710:
auVar11._8_8_ = param_2;
auVar11._0_8_ = uVar8;
return auVar11;
}
| |
47,268 | ma_init_alloc_root | eloqsql/libmariadb/libmariadb/ma_alloc.c | void ma_init_alloc_root(MA_MEM_ROOT *mem_root, size_t block_size, size_t pre_alloc_size)
{
mem_root->free= mem_root->used= mem_root->pre_alloc= 0;
mem_root->min_malloc=32;
mem_root->block_size= (block_size-MALLOC_OVERHEAD-sizeof(MA_USED_MEM)+8);
mem_root->error_handler=0;
mem_root->block_num= 4;
mem_root->first_block_usage= 0;
#if !(defined(HAVE_purify) && defined(EXTRA_DEBUG))
if (pre_alloc_size)
{
if ((mem_root->free = mem_root->pre_alloc=
(MA_USED_MEM*) malloc(pre_alloc_size+ ALIGN_SIZE(sizeof(MA_USED_MEM)))))
{
mem_root->free->size=pre_alloc_size+ALIGN_SIZE(sizeof(MA_USED_MEM));
mem_root->free->left=pre_alloc_size;
mem_root->free->next=0;
}
}
#endif
} | O0 | c | ma_init_alloc_root:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x20, 0x18(%rax)
movq -0x10(%rbp), %rcx
subq $0x8, %rcx
subq $0x18, %rcx
addq $0x8, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movl $0x4, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x2c(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x48898
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x368d0
movq -0x8(%rbp), %rcx
movq %rax, 0x10(%rcx)
movq -0x8(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0x48896
movq -0x18(%rbp), %rcx
addq $0x18, %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq $0x0, (%rax)
jmp 0x48898
addq $0x20, %rsp
popq %rbp
retq
nop
| ma_init_alloc_root:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov qword ptr [rax+10h], 0
mov rax, [rbp+var_8]
mov qword ptr [rax+8], 0
mov rax, [rbp+var_8]
mov qword ptr [rax], 0
mov rax, [rbp+var_8]
mov qword ptr [rax+18h], 20h ; ' '
mov rcx, [rbp+var_10]
sub rcx, 8
sub rcx, 18h
add rcx, 8
mov rax, [rbp+var_8]
mov [rax+20h], rcx
mov rax, [rbp+var_8]
mov qword ptr [rax+30h], 0
mov rax, [rbp+var_8]
mov dword ptr [rax+28h], 4
mov rax, [rbp+var_8]
mov dword ptr [rax+2Ch], 0
cmp [rbp+var_18], 0
jz short loc_48898
mov rdi, [rbp+var_18]
add rdi, 18h
call _malloc
mov rcx, [rbp+var_8]
mov [rcx+10h], rax
mov rcx, [rbp+var_8]
mov [rcx], rax
cmp rax, 0
jz short loc_48896
mov rcx, [rbp+var_18]
add rcx, 18h
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rax+10h], rcx
mov rcx, [rbp+var_18]
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rax+8], rcx
mov rax, [rbp+var_8]
mov rax, [rax]
mov qword ptr [rax], 0
loc_48896:
jmp short $+2
loc_48898:
add rsp, 20h
pop rbp
retn
| long long ma_init_alloc_root(long long *a1, long long a2, long long a3)
{
long long result; // rax
a1[2] = 0LL;
a1[1] = 0LL;
*a1 = 0LL;
a1[3] = 32LL;
a1[4] = a2 - 32 + 8;
a1[6] = 0LL;
*((_DWORD *)a1 + 10) = 4;
result = (long long)a1;
*((_DWORD *)a1 + 11) = 0;
if ( a3 )
{
result = malloc(a3 + 24);
a1[2] = result;
*a1 = result;
if ( result )
{
*(_QWORD *)(*a1 + 16) = a3 + 24;
*(_QWORD *)(*a1 + 8) = a3;
result = *a1;
*(_QWORD *)*a1 = 0LL;
}
}
return result;
}
| ma_init_alloc_root:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x10],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x8],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x18],0x20
MOV RCX,qword ptr [RBP + -0x10]
SUB RCX,0x8
SUB RCX,0x18
ADD RCX,0x8
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x20],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x30],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x28],0x4
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x2c],0x0
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00148898
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x18
CALL 0x001368d0
MOV RCX,qword ptr [RBP + -0x8]
MOV qword ptr [RCX + 0x10],RAX
MOV RCX,qword ptr [RBP + -0x8]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JZ 0x00148896
MOV RCX,qword ptr [RBP + -0x18]
ADD RCX,0x18
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX],0x0
LAB_00148896:
JMP 0x00148898
LAB_00148898:
ADD RSP,0x20
POP RBP
RET
|
void ma_init_alloc_root(long *param_1,long param_2,long param_3)
{
void *pvVar1;
param_1[2] = 0;
param_1[1] = 0;
*param_1 = 0;
param_1[3] = 0x20;
param_1[4] = param_2 + -0x18;
param_1[6] = 0;
*(int4 *)(param_1 + 5) = 4;
*(int4 *)((long)param_1 + 0x2c) = 0;
if (param_3 != 0) {
pvVar1 = malloc(param_3 + 0x18);
param_1[2] = (long)pvVar1;
*param_1 = (long)pvVar1;
if (pvVar1 != (void *)0x0) {
*(long *)(*param_1 + 0x10) = param_3 + 0x18;
*(long *)(*param_1 + 8) = param_3;
*(int8 *)*param_1 = 0;
}
}
return;
}
| |
47,269 | PFS_account::aggregate_statements(PFS_user*, PFS_host*) | eloqsql/storage/perfschema/pfs_account.cc | void PFS_account::aggregate_statements(PFS_user *safe_user, PFS_host *safe_host)
{
if (read_instr_class_statements_stats() == NULL)
return;
if (likely(safe_user != NULL && safe_host != NULL))
{
/*
Aggregate EVENTS_STATEMENTS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
- EVENTS_STATEMENTS_SUMMARY_BY_USER_BY_EVENT_NAME
- EVENTS_STATEMENTS_SUMMARY_BY_HOST_BY_EVENT_NAME
in parallel.
*/
aggregate_all_statements(write_instr_class_statements_stats(),
safe_user->write_instr_class_statements_stats(),
safe_host->write_instr_class_statements_stats());
return;
}
if (safe_user != NULL)
{
/*
Aggregate EVENTS_STATEMENTS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
- EVENTS_STATEMENTS_SUMMARY_BY_USER_BY_EVENT_NAME
- EVENTS_STATEMENTS_SUMMARY_GLOBAL_BY_EVENT_NAME
in parallel.
*/
aggregate_all_statements(write_instr_class_statements_stats(),
safe_user->write_instr_class_statements_stats(),
global_instr_class_statements_array);
return;
}
if (safe_host != NULL)
{
/*
Aggregate EVENTS_STATEMENTS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
- EVENTS_STATEMENTS_SUMMARY_BY_HOST_BY_EVENT_NAME
*/
aggregate_all_statements(write_instr_class_statements_stats(),
safe_host->write_instr_class_statements_stats());
return;
}
/*
Aggregate EVENTS_STATEMENTS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
- EVENTS_STATEMENTS_SUMMARY_GLOBAL_BY_EVENT_NAME
*/
aggregate_all_statements(write_instr_class_statements_stats(),
global_instr_class_statements_array);
return;
} | O0 | cpp | PFS_account::aggregate_statements(PFS_user*, PFS_host*):
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x418b0
cmpq $0x0, %rax
jne 0x52e6c
jmp 0x52f40
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x21(%rbp)
je 0x52e83
cmpq $0x0, -0x18(%rbp)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x52ec5
movq -0x20(%rbp), %rdi
callq 0x418f0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x418f0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x418f0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
callq 0x3c440
jmp 0x52f40
cmpq $0x0, -0x10(%rbp)
je 0x52efa
movq -0x20(%rbp), %rdi
callq 0x418f0
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x418f0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
leaq 0x3bac10(%rip), %rax # 0x40db00
movq (%rax), %rdx
callq 0x3c440
jmp 0x52f40
cmpq $0x0, -0x18(%rbp)
je 0x52f25
movq -0x20(%rbp), %rdi
callq 0x418f0
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x418f0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x3c3b0
jmp 0x52f40
movq -0x20(%rbp), %rdi
callq 0x418f0
movq %rax, %rdi
leaq 0x3babc8(%rip), %rax # 0x40db00
movq (%rax), %rsi
callq 0x3c3b0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZN11PFS_account20aggregate_statementsEP8PFS_userP8PFS_host:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rdi, [rbp+var_8]; this
mov [rbp+var_20], rdi
call _ZNK20PFS_connection_slice33read_instr_class_statements_statsEv; PFS_connection_slice::read_instr_class_statements_stats(void)
cmp rax, 0
jnz short loc_52E6C
jmp loc_52F40
loc_52E6C:
xor eax, eax
cmp [rbp+var_10], 0
mov [rbp+var_21], al
jz short loc_52E83
cmp [rbp+var_18], 0
setnz al
mov [rbp+var_21], al
loc_52E83:
mov al, [rbp+var_21]
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_52EC5
mov rdi, [rbp+var_20]; this
call _ZN20PFS_connection_slice34write_instr_class_statements_statsEv; PFS_connection_slice::write_instr_class_statements_stats(void)
mov [rbp+var_38], rax
mov rdi, [rbp+var_10]; this
call _ZN20PFS_connection_slice34write_instr_class_statements_statsEv; PFS_connection_slice::write_instr_class_statements_stats(void)
mov [rbp+var_30], rax
mov rdi, [rbp+var_18]; this
call _ZN20PFS_connection_slice34write_instr_class_statements_statsEv; PFS_connection_slice::write_instr_class_statements_stats(void)
mov rdi, [rbp+var_38]; PFS_statement_stat *
mov rsi, [rbp+var_30]; PFS_statement_stat *
mov rdx, rax; PFS_statement_stat *
call _Z24aggregate_all_statementsP18PFS_statement_statS0_S0_; aggregate_all_statements(PFS_statement_stat *,PFS_statement_stat *,PFS_statement_stat *)
jmp short loc_52F40
loc_52EC5:
cmp [rbp+var_10], 0
jz short loc_52EFA
mov rdi, [rbp+var_20]; this
call _ZN20PFS_connection_slice34write_instr_class_statements_statsEv; PFS_connection_slice::write_instr_class_statements_stats(void)
mov [rbp+var_40], rax
mov rdi, [rbp+var_10]; this
call _ZN20PFS_connection_slice34write_instr_class_statements_statsEv; PFS_connection_slice::write_instr_class_statements_stats(void)
mov rdi, [rbp+var_40]; PFS_statement_stat *
mov rsi, rax; PFS_statement_stat *
lea rax, global_instr_class_statements_array
mov rdx, [rax]; PFS_statement_stat *
call _Z24aggregate_all_statementsP18PFS_statement_statS0_S0_; aggregate_all_statements(PFS_statement_stat *,PFS_statement_stat *,PFS_statement_stat *)
jmp short loc_52F40
loc_52EFA:
cmp [rbp+var_18], 0
jz short loc_52F25
mov rdi, [rbp+var_20]; this
call _ZN20PFS_connection_slice34write_instr_class_statements_statsEv; PFS_connection_slice::write_instr_class_statements_stats(void)
mov [rbp+var_48], rax
mov rdi, [rbp+var_18]; this
call _ZN20PFS_connection_slice34write_instr_class_statements_statsEv; PFS_connection_slice::write_instr_class_statements_stats(void)
mov rdi, [rbp+var_48]; PFS_statement_stat *
mov rsi, rax; PFS_statement_stat *
call _Z24aggregate_all_statementsP18PFS_statement_statS0_; aggregate_all_statements(PFS_statement_stat *,PFS_statement_stat *)
jmp short loc_52F40
loc_52F25:
mov rdi, [rbp+var_20]; this
call _ZN20PFS_connection_slice34write_instr_class_statements_statsEv; PFS_connection_slice::write_instr_class_statements_stats(void)
mov rdi, rax; PFS_statement_stat *
lea rax, global_instr_class_statements_array
mov rsi, [rax]; PFS_statement_stat *
call _Z24aggregate_all_statementsP18PFS_statement_statS0_; aggregate_all_statements(PFS_statement_stat *,PFS_statement_stat *)
loc_52F40:
add rsp, 50h
pop rbp
retn
| PFS_statement_stat * PFS_account::aggregate_statements(PFS_account *this, PFS_user *a2, PFS_host *a3)
{
PFS_statement_stat *result; // rax
PFS_statement_stat *v4; // rax
PFS_statement_stat *v5; // rax
PFS_statement_stat *v6; // rax
PFS_statement_stat *v7; // rax
PFS_statement_stat *v8; // [rsp+8h] [rbp-48h]
PFS_statement_stat *v9; // [rsp+10h] [rbp-40h]
PFS_statement_stat *v10; // [rsp+18h] [rbp-38h]
PFS_statement_stat *v11; // [rsp+20h] [rbp-30h]
bool v12; // [rsp+2Fh] [rbp-21h]
result = (PFS_statement_stat *)PFS_connection_slice::read_instr_class_statements_stats(this);
if ( result )
{
v12 = 0;
if ( a2 )
v12 = a3 != 0LL;
if ( v12 )
{
v10 = (PFS_statement_stat *)PFS_connection_slice::write_instr_class_statements_stats(this);
v11 = (PFS_statement_stat *)PFS_connection_slice::write_instr_class_statements_stats(a2);
v4 = (PFS_statement_stat *)PFS_connection_slice::write_instr_class_statements_stats(a3);
return aggregate_all_statements(v10, v11, v4);
}
else if ( a2 )
{
v9 = (PFS_statement_stat *)PFS_connection_slice::write_instr_class_statements_stats(this);
v5 = (PFS_statement_stat *)PFS_connection_slice::write_instr_class_statements_stats(a2);
return aggregate_all_statements(v9, v5, global_instr_class_statements_array);
}
else if ( a3 )
{
v8 = (PFS_statement_stat *)PFS_connection_slice::write_instr_class_statements_stats(this);
v6 = (PFS_statement_stat *)PFS_connection_slice::write_instr_class_statements_stats(a3);
return aggregate_all_statements(v8, v6);
}
else
{
v7 = (PFS_statement_stat *)PFS_connection_slice::write_instr_class_statements_stats(this);
return aggregate_all_statements(v7, global_instr_class_statements_array);
}
}
return result;
}
| aggregate_statements:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RDI
CALL 0x001418b0
CMP RAX,0x0
JNZ 0x00152e6c
JMP 0x00152f40
LAB_00152e6c:
XOR EAX,EAX
CMP qword ptr [RBP + -0x10],0x0
MOV byte ptr [RBP + -0x21],AL
JZ 0x00152e83
CMP qword ptr [RBP + -0x18],0x0
SETNZ AL
MOV byte ptr [RBP + -0x21],AL
LAB_00152e83:
MOV AL,byte ptr [RBP + -0x21]
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x00152ec5
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001418f0
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001418f0
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001418f0
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,RAX
CALL 0x0013c440
JMP 0x00152f40
LAB_00152ec5:
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00152efa
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001418f0
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001418f0
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,RAX
LEA RAX,[0x50db00]
MOV RDX,qword ptr [RAX]
CALL 0x0013c440
JMP 0x00152f40
LAB_00152efa:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00152f25
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001418f0
MOV qword ptr [RBP + -0x48],RAX
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001418f0
MOV RDI,qword ptr [RBP + -0x48]
MOV RSI,RAX
CALL 0x0013c3b0
JMP 0x00152f40
LAB_00152f25:
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001418f0
MOV RDI,RAX
LEA RAX,[0x50db00]
MOV RSI,qword ptr [RAX]
CALL 0x0013c3b0
LAB_00152f40:
ADD RSP,0x50
POP RBP
RET
|
/* PFS_account::aggregate_statements(PFS_user*, PFS_host*) */
void __thiscall
PFS_account::aggregate_statements(PFS_account *this,PFS_user *param_1,PFS_host *param_2)
{
long lVar1;
PFS_statement_stat *pPVar2;
PFS_statement_stat *pPVar3;
PFS_statement_stat *pPVar4;
lVar1 = PFS_connection_slice::read_instr_class_statements_stats((PFS_connection_slice *)this);
if (lVar1 != 0) {
if (param_1 == (PFS_user *)0x0 || param_2 == (PFS_host *)0x0) {
if (param_1 == (PFS_user *)0x0) {
if (param_2 == (PFS_host *)0x0) {
pPVar2 = (PFS_statement_stat *)
PFS_connection_slice::write_instr_class_statements_stats
((PFS_connection_slice *)this);
aggregate_all_statements(pPVar2,global_instr_class_statements_array);
}
else {
pPVar2 = (PFS_statement_stat *)
PFS_connection_slice::write_instr_class_statements_stats
((PFS_connection_slice *)this);
pPVar3 = (PFS_statement_stat *)
PFS_connection_slice::write_instr_class_statements_stats
((PFS_connection_slice *)param_2);
aggregate_all_statements(pPVar2,pPVar3);
}
}
else {
pPVar2 = (PFS_statement_stat *)
PFS_connection_slice::write_instr_class_statements_stats
((PFS_connection_slice *)this);
pPVar3 = (PFS_statement_stat *)
PFS_connection_slice::write_instr_class_statements_stats
((PFS_connection_slice *)param_1);
aggregate_all_statements(pPVar2,pPVar3,global_instr_class_statements_array);
}
}
else {
pPVar2 = (PFS_statement_stat *)
PFS_connection_slice::write_instr_class_statements_stats
((PFS_connection_slice *)this);
pPVar3 = (PFS_statement_stat *)
PFS_connection_slice::write_instr_class_statements_stats
((PFS_connection_slice *)param_1);
pPVar4 = (PFS_statement_stat *)
PFS_connection_slice::write_instr_class_statements_stats
((PFS_connection_slice *)param_2);
aggregate_all_statements(pPVar2,pPVar3,pPVar4);
}
}
return;
}
| |
47,270 | js_parse_check_duplicate_parameter | bluesky950520[P]quickjs/quickjs.c | static int js_parse_check_duplicate_parameter(JSParseState *s, JSAtom name)
{
/* Check for duplicate parameter names */
JSFunctionDef *fd = s->cur_func;
int i;
for (i = 0; i < fd->arg_count; i++) {
if (fd->args[i].var_name == name)
goto duplicate;
}
for (i = 0; i < fd->var_count; i++) {
if (fd->vars[i].var_name == name)
goto duplicate;
}
return 0;
duplicate:
return js_parse_error(s, "Duplicate parameter name not allowed in this context");
} | O0 | c | js_parse_check_duplicate_parameter:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq 0x90(%rax), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0xb4(%rcx), %eax
jge 0xa5a78
movq 0x8(%rsp), %rax
movq 0xa8(%rax), %rax
movslq 0x4(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl 0x14(%rsp), %eax
jne 0xa5a69
jmp 0xa5acc
jmp 0xa5a6b
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xa5a36
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0xa4(%rcx), %eax
jge 0xa5ac2
movq 0x8(%rsp), %rax
movq 0x90(%rax), %rax
movslq 0x4(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl 0x14(%rsp), %eax
jne 0xa5ab3
jmp 0xa5acc
jmp 0xa5ab5
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xa5a80
movl $0x0, 0x24(%rsp)
jmp 0xa5ae3
movq 0x18(%rsp), %rdi
leaq 0x69004(%rip), %rsi # 0x10eadc
movb $0x0, %al
callq 0x473d0
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
| js_parse_check_duplicate_parameter:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov [rsp+28h+var_14], esi
mov rax, [rsp+28h+var_10]
mov rax, [rax+90h]
mov [rsp+28h+var_20], rax
mov [rsp+28h+var_24], 0
loc_A5A36:
mov eax, [rsp+28h+var_24]
mov rcx, [rsp+28h+var_20]
cmp eax, [rcx+0B4h]
jge short loc_A5A78
mov rax, [rsp+28h+var_20]
mov rax, [rax+0A8h]
movsxd rcx, [rsp+28h+var_24]
shl rcx, 4
add rax, rcx
mov eax, [rax]
cmp eax, [rsp+28h+var_14]
jnz short loc_A5A69
jmp short loc_A5ACC
loc_A5A69:
jmp short $+2
loc_A5A6B:
mov eax, [rsp+28h+var_24]
add eax, 1
mov [rsp+28h+var_24], eax
jmp short loc_A5A36
loc_A5A78:
mov [rsp+28h+var_24], 0
loc_A5A80:
mov eax, [rsp+28h+var_24]
mov rcx, [rsp+28h+var_20]
cmp eax, [rcx+0A4h]
jge short loc_A5AC2
mov rax, [rsp+28h+var_20]
mov rax, [rax+90h]
movsxd rcx, [rsp+28h+var_24]
shl rcx, 4
add rax, rcx
mov eax, [rax]
cmp eax, [rsp+28h+var_14]
jnz short loc_A5AB3
jmp short loc_A5ACC
loc_A5AB3:
jmp short $+2
loc_A5AB5:
mov eax, [rsp+28h+var_24]
add eax, 1
mov [rsp+28h+var_24], eax
jmp short loc_A5A80
loc_A5AC2:
mov [rsp+28h+var_4], 0
jmp short loc_A5AE3
loc_A5ACC:
mov rdi, [rsp+28h+var_10]
lea rsi, aDuplicateParam; "Duplicate parameter name not allowed in"...
mov al, 0
call js_parse_error
mov [rsp+28h+var_4], eax
loc_A5AE3:
mov eax, [rsp+28h+var_4]
add rsp, 28h
retn
| long long js_parse_check_duplicate_parameter(
_QWORD *a1,
int a2,
long long a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
long long a12,
long long a13,
long long a14)
{
long long v14; // rcx
char v16; // [rsp+0h] [rbp-28h]
int i; // [rsp+4h] [rbp-24h]
int j; // [rsp+4h] [rbp-24h]
long long v19; // [rsp+8h] [rbp-20h]
v19 = a1[18];
for ( i = 0; i < *(_DWORD *)(v19 + 180); ++i )
{
v14 = 16LL * i;
if ( *(_DWORD *)(v14 + *(_QWORD *)(v19 + 168)) == a2 )
return (unsigned int)js_parse_error(
a1,
(long long)"Duplicate parameter name not allowed in this context",
a3,
v14,
a13,
a14,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
v16);
}
for ( j = 0; j < *(_DWORD *)(v19 + 164); ++j )
{
v14 = 16LL * j;
if ( *(_DWORD *)(v14 + *(_QWORD *)(v19 + 144)) == a2 )
return (unsigned int)js_parse_error(
a1,
(long long)"Duplicate parameter name not allowed in this context",
a3,
v14,
a13,
a14,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
v16);
}
return 0;
}
| js_parse_check_duplicate_parameter:
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
MOV dword ptr [RSP + 0x14],ESI
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x90]
MOV qword ptr [RSP + 0x8],RAX
MOV dword ptr [RSP + 0x4],0x0
LAB_001a5a36:
MOV EAX,dword ptr [RSP + 0x4]
MOV RCX,qword ptr [RSP + 0x8]
CMP EAX,dword ptr [RCX + 0xb4]
JGE 0x001a5a78
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0xa8]
MOVSXD RCX,dword ptr [RSP + 0x4]
SHL RCX,0x4
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EAX,dword ptr [RSP + 0x14]
JNZ 0x001a5a69
JMP 0x001a5acc
LAB_001a5a69:
JMP 0x001a5a6b
LAB_001a5a6b:
MOV EAX,dword ptr [RSP + 0x4]
ADD EAX,0x1
MOV dword ptr [RSP + 0x4],EAX
JMP 0x001a5a36
LAB_001a5a78:
MOV dword ptr [RSP + 0x4],0x0
LAB_001a5a80:
MOV EAX,dword ptr [RSP + 0x4]
MOV RCX,qword ptr [RSP + 0x8]
CMP EAX,dword ptr [RCX + 0xa4]
JGE 0x001a5ac2
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x90]
MOVSXD RCX,dword ptr [RSP + 0x4]
SHL RCX,0x4
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EAX,dword ptr [RSP + 0x14]
JNZ 0x001a5ab3
JMP 0x001a5acc
LAB_001a5ab3:
JMP 0x001a5ab5
LAB_001a5ab5:
MOV EAX,dword ptr [RSP + 0x4]
ADD EAX,0x1
MOV dword ptr [RSP + 0x4],EAX
JMP 0x001a5a80
LAB_001a5ac2:
MOV dword ptr [RSP + 0x24],0x0
JMP 0x001a5ae3
LAB_001a5acc:
MOV RDI,qword ptr [RSP + 0x18]
LEA RSI,[0x20eadc]
MOV AL,0x0
CALL 0x001473d0
MOV dword ptr [RSP + 0x24],EAX
LAB_001a5ae3:
MOV EAX,dword ptr [RSP + 0x24]
ADD RSP,0x28
RET
|
int4 js_parse_check_duplicate_parameter(long param_1,int param_2)
{
long lVar1;
int4 uVar2;
int local_24;
lVar1 = *(long *)(param_1 + 0x90);
for (local_24 = 0; local_24 < *(int *)(lVar1 + 0xb4); local_24 = local_24 + 1) {
if (*(int *)(*(long *)(lVar1 + 0xa8) + (long)local_24 * 0x10) == param_2) goto LAB_001a5acc;
}
local_24 = 0;
while( true ) {
if (*(int *)(lVar1 + 0xa4) <= local_24) {
return 0;
}
if (*(int *)(*(long *)(lVar1 + 0x90) + (long)local_24 * 0x10) == param_2) break;
local_24 = local_24 + 1;
}
LAB_001a5acc:
uVar2 = js_parse_error(param_1,"Duplicate parameter name not allowed in this context");
return uVar2;
}
| |
47,271 | js_parse_check_duplicate_parameter | bluesky950520[P]quickjs/quickjs.c | static int js_parse_check_duplicate_parameter(JSParseState *s, JSAtom name)
{
/* Check for duplicate parameter names */
JSFunctionDef *fd = s->cur_func;
int i;
for (i = 0; i < fd->arg_count; i++) {
if (fd->args[i].var_name == name)
goto duplicate;
}
for (i = 0; i < fd->var_count; i++) {
if (fd->vars[i].var_name == name)
goto duplicate;
}
return 0;
duplicate:
return js_parse_error(s, "Duplicate parameter name not allowed in this context");
} | O1 | c | js_parse_check_duplicate_parameter:
pushq %rax
movq 0x90(%rdi), %rax
movslq 0xb4(%rax), %rcx
testq %rcx, %rcx
jle 0x6412f
movq 0xa8(%rax), %rdx
shlq $0x4, %rcx
xorl %r8d, %r8d
cmpl %esi, (%rdx,%r8)
je 0x6415a
addq $0x10, %r8
cmpq %r8, %rcx
jne 0x64120
movslq 0xa4(%rax), %rcx
testq %rcx, %rcx
jle 0x64156
movq 0x90(%rax), %rax
shlq $0x4, %rcx
xorl %edx, %edx
cmpl %esi, (%rax,%rdx)
je 0x6415a
addq $0x10, %rdx
cmpq %rdx, %rcx
jne 0x64148
xorl %eax, %eax
jmp 0x6416d
leaq 0x3b97f(%rip), %rsi # 0x9fae0
xorl %eax, %eax
callq 0x2f0d5
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
popq %rcx
retq
| js_parse_check_duplicate_parameter:
push rax
mov rax, [rdi+90h]
movsxd rcx, dword ptr [rax+0B4h]
test rcx, rcx
jle short loc_6412F
mov rdx, [rax+0A8h]
shl rcx, 4
xor r8d, r8d
loc_64120:
cmp [rdx+r8], esi
jz short loc_6415A
add r8, 10h
cmp rcx, r8
jnz short loc_64120
loc_6412F:
movsxd rcx, dword ptr [rax+0A4h]
test rcx, rcx
jle short loc_64156
mov rax, [rax+90h]
shl rcx, 4
xor edx, edx
loc_64148:
cmp [rax+rdx], esi
jz short loc_6415A
add rdx, 10h
cmp rcx, rdx
jnz short loc_64148
loc_64156:
xor eax, eax
jmp short loc_6416D
loc_6415A:
lea rsi, aDuplicateParam; "Duplicate parameter name not allowed in"...
xor eax, eax
call js_parse_error
mov eax, 0FFFFFFFFh
loc_6416D:
pop rcx
retn
| long long js_parse_check_duplicate_parameter(
long long *a1,
int a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
long long a11,
long long a12,
long long a13,
long long a14)
{
char v14; // al
long long v15; // rax
long long v16; // rcx
long long v17; // rdx
long long v18; // rcx
long long v19; // rcx
long long v20; // rax
char v22; // [rsp-8h] [rbp-8h]
v22 = v14;
v15 = a1[18];
v16 = *(int *)(v15 + 180);
if ( v16 <= 0 )
{
LABEL_5:
v19 = *(int *)(v15 + 164);
if ( v19 <= 0 )
return 0LL;
v20 = *(_QWORD *)(v15 + 144);
v18 = 16 * v19;
v17 = 0LL;
while ( *(_DWORD *)(v20 + v17) != a2 )
{
v17 += 16LL;
if ( v18 == v17 )
return 0LL;
}
}
else
{
v17 = *(_QWORD *)(v15 + 168);
v18 = 16 * v16;
a13 = 0LL;
while ( *(_DWORD *)(v17 + a13) != a2 )
{
a13 += 16LL;
if ( v18 == a13 )
goto LABEL_5;
}
}
js_parse_error(
a1,
(long long)"Duplicate parameter name not allowed in this context",
v17,
v18,
a13,
a14,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
v22);
return 0xFFFFFFFFLL;
}
| js_parse_check_duplicate_parameter:
PUSH RAX
MOV RAX,qword ptr [RDI + 0x90]
MOVSXD RCX,dword ptr [RAX + 0xb4]
TEST RCX,RCX
JLE 0x0016412f
MOV RDX,qword ptr [RAX + 0xa8]
SHL RCX,0x4
XOR R8D,R8D
LAB_00164120:
CMP dword ptr [RDX + R8*0x1],ESI
JZ 0x0016415a
ADD R8,0x10
CMP RCX,R8
JNZ 0x00164120
LAB_0016412f:
MOVSXD RCX,dword ptr [RAX + 0xa4]
TEST RCX,RCX
JLE 0x00164156
MOV RAX,qword ptr [RAX + 0x90]
SHL RCX,0x4
XOR EDX,EDX
LAB_00164148:
CMP dword ptr [RAX + RDX*0x1],ESI
JZ 0x0016415a
ADD RDX,0x10
CMP RCX,RDX
JNZ 0x00164148
LAB_00164156:
XOR EAX,EAX
JMP 0x0016416d
LAB_0016415a:
LEA RSI,[0x19fae0]
XOR EAX,EAX
CALL 0x0012f0d5
MOV EAX,0xffffffff
LAB_0016416d:
POP RCX
RET
|
int8 js_parse_check_duplicate_parameter(long param_1,int param_2)
{
long lVar1;
long lVar2;
lVar1 = *(long *)(param_1 + 0x90);
if (0 < (long)*(int *)(lVar1 + 0xb4)) {
lVar2 = 0;
do {
if (*(int *)(*(long *)(lVar1 + 0xa8) + lVar2) == param_2) goto LAB_0016415a;
lVar2 = lVar2 + 0x10;
} while ((long)*(int *)(lVar1 + 0xb4) * 0x10 != lVar2);
}
if (0 < (long)*(int *)(lVar1 + 0xa4)) {
lVar2 = 0;
do {
if (*(int *)(*(long *)(lVar1 + 0x90) + lVar2) == param_2) {
LAB_0016415a:
js_parse_error(param_1,"Duplicate parameter name not allowed in this context");
return 0xffffffff;
}
lVar2 = lVar2 + 0x10;
} while ((long)*(int *)(lVar1 + 0xa4) * 0x10 != lVar2);
}
return 0;
}
| |
47,272 | ma_decrypt | eloqsql/storage/maria/ma_crypt.c | static int ma_decrypt(MARIA_SHARE *share, MARIA_CRYPT_DATA *crypt_data,
const uchar *src, uchar *dst, uint size,
uint pageno, LSN lsn,
uint key_version)
{
int rc;
uint32 dstlen= 0; /* Must be set because of error message */
rc= encryption_scheme_decrypt(src, size, dst, &dstlen,
&crypt_data->scheme, key_version,
crypt_data->space, pageno, lsn);
DBUG_ASSERT(!my_assert_on_error || rc == MY_AES_OK);
DBUG_ASSERT(!my_assert_on_error || dstlen == size);
if (! (rc == MY_AES_OK && dstlen == size))
{
my_errno= HA_ERR_DECRYPTION_FAILED;
if (!share->silence_encryption_errors)
my_printf_error(HA_ERR_DECRYPTION_FAILED,
"failed to decrypt '%s' rc: %d dstlen: %u size: %u\n",
MYF(ME_FATAL|ME_ERROR_LOG),
share->open_file_name.str, rc, dstlen, size);
return 1;
}
return 0;
} | O0 | c | ma_decrypt:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl %r9d, -0x30(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %r8
movl 0x18(%rbp), %r9d
movq -0x18(%rbp), %rax
movl 0x60(%rax), %r11d
movl -0x30(%rbp), %r10d
movq 0x10(%rbp), %rax
leaq -0x38(%rbp), %rcx
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x2b760
movl %eax, -0x34(%rbp)
jmp 0x9e9bd
jmp 0x9e9bf
jmp 0x9e9c1
cmpl $0x0, -0x34(%rbp)
jne 0x9e9cf
movl -0x38(%rbp), %eax
cmpl -0x2c(%rbp), %eax
je 0x9ea21
callq 0xfc990
movl $0xc0, (%rax)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x7ec(%rax)
jne 0x9ea18
movq -0x10(%rbp), %rax
movq 0x5e0(%rax), %rcx
movl -0x34(%rbp), %r8d
movl -0x38(%rbp), %r9d
movl -0x2c(%rbp), %eax
movl $0xc0, %edi
leaq 0xbd344(%rip), %rsi # 0x15bd4d
movl $0x1040, %edx # imm = 0x1040
movl %eax, (%rsp)
movb $0x0, %al
callq 0xf2c30
movl $0x1, -0x4(%rbp)
jmp 0x9ea28
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ma_decrypt:
push rbp
mov rbp, rsp
sub rsp, 50h
mov eax, [rbp+arg_8]
mov rax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_2C], r8d
mov [rbp+var_30], r9d
mov [rbp+var_38], 0
mov rdi, [rbp+var_20]
mov esi, [rbp+var_2C]
mov rdx, [rbp+var_28]
mov r8, [rbp+var_18]
mov r9d, [rbp+arg_8]
mov rax, [rbp+var_18]
mov r11d, [rax+60h]
mov r10d, [rbp+var_30]
mov rax, [rbp+arg_0]
lea rcx, [rbp+var_38]
mov [rsp+50h+var_50], r11d
mov [rsp+50h+var_48], r10d
mov [rsp+50h+var_40], rax
call encryption_scheme_decrypt
mov [rbp+var_34], eax
jmp short $+2
loc_9E9BD:
jmp short $+2
loc_9E9BF:
jmp short $+2
loc_9E9C1:
cmp [rbp+var_34], 0
jnz short loc_9E9CF
mov eax, [rbp+var_38]
cmp eax, [rbp+var_2C]
jz short loc_9EA21
loc_9E9CF:
call _my_thread_var
mov dword ptr [rax], 0C0h
mov rax, [rbp+var_10]
cmp byte ptr [rax+7ECh], 0
jnz short loc_9EA18
mov rax, [rbp+var_10]
mov rcx, [rax+5E0h]
mov r8d, [rbp+var_34]
mov r9d, [rbp+var_38]
mov eax, [rbp+var_2C]
mov edi, 0C0h
lea rsi, aFailedToDecryp; "failed to decrypt '%s' rc: %d dstlen:"...
mov edx, 1040h
mov [rsp+50h+var_50], eax
mov al, 0
call my_printf_error
loc_9EA18:
mov [rbp+var_4], 1
jmp short loc_9EA28
loc_9EA21:
mov [rbp+var_4], 0
loc_9EA28:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
| long long ma_decrypt(long long a1, long long a2, long long a3, long long a4, unsigned int a5, int a6, long long a7)
{
const char *v8; // rsi
long long v9; // rdx
long long v10; // rcx
long long v11; // r8
long long v12; // r9
int v14; // [rsp+0h] [rbp-50h]
int v16; // [rsp+1Ch] [rbp-34h]
v8 = (const char *)a5;
v14 = *(_DWORD *)(a2 + 96);
v16 = encryption_scheme_decrypt();
if ( v16 || a5 )
{
*(_DWORD *)my_thread_var(a3, v8, v9, v10, v11, v12, v14, a6, a7) = 192;
if ( !*(_BYTE *)(a1 + 2028) )
my_printf_error(
192,
(unsigned int)"failed to decrypt '%s' rc: %d dstlen: %u size: %u\n",
4160,
*(_QWORD *)(a1 + 1504),
v16,
0);
return 1;
}
else
{
return 0;
}
}
| ma_decrypt:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV EAX,dword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV dword ptr [RBP + -0x2c],R8D
MOV dword ptr [RBP + -0x30],R9D
MOV dword ptr [RBP + -0x38],0x0
MOV RDI,qword ptr [RBP + -0x20]
MOV ESI,dword ptr [RBP + -0x2c]
MOV RDX,qword ptr [RBP + -0x28]
MOV R8,qword ptr [RBP + -0x18]
MOV R9D,dword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + -0x18]
MOV R11D,dword ptr [RAX + 0x60]
MOV R10D,dword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + 0x10]
LEA RCX,[RBP + -0x38]
MOV dword ptr [RSP],R11D
MOV dword ptr [RSP + 0x8],R10D
MOV qword ptr [RSP + 0x10],RAX
CALL 0x0012b760
MOV dword ptr [RBP + -0x34],EAX
JMP 0x0019e9bd
LAB_0019e9bd:
JMP 0x0019e9bf
LAB_0019e9bf:
JMP 0x0019e9c1
LAB_0019e9c1:
CMP dword ptr [RBP + -0x34],0x0
JNZ 0x0019e9cf
MOV EAX,dword ptr [RBP + -0x38]
CMP EAX,dword ptr [RBP + -0x2c]
JZ 0x0019ea21
LAB_0019e9cf:
CALL 0x001fc990
MOV dword ptr [RAX],0xc0
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX + 0x7ec],0x0
JNZ 0x0019ea18
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x5e0]
MOV R8D,dword ptr [RBP + -0x34]
MOV R9D,dword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x2c]
MOV EDI,0xc0
LEA RSI,[0x25bd4d]
MOV EDX,0x1040
MOV dword ptr [RSP],EAX
MOV AL,0x0
CALL 0x001f2c30
LAB_0019ea18:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0019ea28
LAB_0019ea21:
MOV dword ptr [RBP + -0x4],0x0
LAB_0019ea28:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
int4
ma_decrypt(long param_1,long param_2,int8 param_3,int8 param_4,int param_5,
int4 param_6,int8 param_7,int4 param_8)
{
int4 *puVar1;
int local_40;
int local_3c;
int4 local_38;
int local_34;
int8 local_30;
int8 local_28;
long local_20;
long local_18;
int4 local_c;
local_40 = 0;
local_38 = param_6;
local_34 = param_5;
local_30 = param_4;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
local_3c = encryption_scheme_decrypt
(param_3,param_5,param_4,&local_40,param_2,param_8,
*(int4 *)(param_2 + 0x60),param_6,param_7);
if ((local_3c == 0) && (local_40 == local_34)) {
local_c = 0;
}
else {
puVar1 = (int4 *)_my_thread_var();
*puVar1 = 0xc0;
if (*(char *)(local_18 + 0x7ec) == '\0') {
my_printf_error(0xc0,"failed to decrypt \'%s\' rc: %d dstlen: %u size: %u\n",0x1040,
*(int8 *)(local_18 + 0x5e0),local_3c,local_40,local_34);
}
local_c = 1;
}
return local_c;
}
| |
47,273 | w_search | eloqsql/storage/maria/ma_write.c | static int w_search(register MARIA_HA *info, uint32 comp_flag, MARIA_KEY *key,
my_off_t page_pos,
MARIA_PAGE *father_page, uchar *father_keypos,
my_bool insert_last)
{
int error,flag;
uchar *temp_buff,*keypos,*keybuff;
my_bool was_last_key, buff_alloced;
my_off_t next_page, dup_key_pos;
MARIA_SHARE *share= info->s;
MARIA_KEYDEF *keyinfo= key->keyinfo;
MARIA_PAGE page;
DBUG_ENTER("w_search");
DBUG_PRINT("enter", ("page: %lu", (ulong) (page_pos/keyinfo->block_length)));
alloc_on_stack(*info->stack_end_ptr, temp_buff, buff_alloced,
(keyinfo->block_length + keyinfo->max_store_length*3));
if (!temp_buff)
DBUG_RETURN(1);
keybuff= temp_buff + (keyinfo->block_length + keyinfo->max_store_length*2);
if (_ma_fetch_keypage(&page, info, keyinfo, page_pos, PAGECACHE_LOCK_WRITE,
DFLT_INIT_HITS, temp_buff, 0))
goto err;
flag= (*keyinfo->bin_search)(key, &page, comp_flag, &keypos,
keybuff, &was_last_key);
if (flag == 0)
{
MARIA_KEY tmp_key;
/* get position to record with duplicated key */
tmp_key.keyinfo= keyinfo;
tmp_key.data= keybuff;
if ((*keyinfo->get_key)(&tmp_key, page.flag, page.node, &keypos))
dup_key_pos= _ma_row_pos_from_key(&tmp_key);
else
dup_key_pos= HA_OFFSET_ERROR;
if (keyinfo->flag & HA_FULLTEXT)
{
uint off;
int subkeys;
get_key_full_length_rdonly(off, keybuff);
subkeys=ft_sintXkorr(keybuff+off);
comp_flag=SEARCH_SAME;
if (subkeys >= 0)
{
/* normal word, one-level tree structure */
flag=(*keyinfo->bin_search)(key, &page, comp_flag,
&keypos, keybuff, &was_last_key);
}
else
{
/* popular word. two-level tree. going down */
my_off_t root= dup_key_pos;
MARIA_KEY subkey;
get_key_full_length_rdonly(off, key->data);
subkey.keyinfo= keyinfo= &share->ft2_keyinfo;
subkey.data= key->data + off;
subkey.data_length= key->data_length - off;
subkey.ref_length= key->ref_length;
subkey.flag= key->flag;
/* we'll modify key entry 'in vivo' */
keypos-= keyinfo->keylength + page.node;
error= _ma_ck_real_write_btree(info, &subkey, &root, comp_flag);
_ma_dpointer(share, keypos+HA_FT_WLEN, root);
subkeys--; /* should there be underflow protection ? */
DBUG_ASSERT(subkeys < 0);
ft_intXstore(keypos, subkeys);
if (!error)
{
page_mark_changed(info, &page);
if (_ma_write_keypage(&page, PAGECACHE_LOCK_LEFT_WRITELOCKED,
DFLT_INIT_HITS))
goto err;
}
stack_alloc_free(temp_buff, buff_alloced);
DBUG_RETURN(error);
}
}
else /* not HA_FULLTEXT, normal HA_NOSAME key */
{
/*
TODO
When the index will support true versioning - with multiple
identical values in the UNIQUE index, invisible to each other -
the following should be changed to "continue inserting keys, at the
end (of the row or statement) wait". We need to wait on *all*
unique conflicts at once, not one-at-a-time, because we need to
know all blockers in advance, otherwise we'll have incomplete wait-for
graph.
*/
/*
transaction that has inserted the conflicting key may be in progress.
the caller will wait for it to be committed or aborted.
*/
info->dup_key_trid= _ma_trid_from_key(&tmp_key);
info->dup_key_pos= dup_key_pos;
my_errno= HA_ERR_FOUND_DUPP_KEY;
DBUG_PRINT("warning",
("Duplicate key. dup_key_trid: %lu pos %lu visible: %d",
(ulong) info->dup_key_trid,
(ulong) info->dup_key_pos,
info->trn ? trnman_can_read_from(info->trn,
info->dup_key_trid) : 2));
goto err;
}
}
if (flag == MARIA_FOUND_WRONG_KEY)
{
my_errno= HA_ERR_CRASHED;
goto err;
}
if (!was_last_key)
insert_last=0;
next_page= _ma_kpos(page.node, keypos);
if (next_page == HA_OFFSET_ERROR ||
(error= w_search(info, comp_flag, key, next_page,
&page, keypos, insert_last)) > 0)
{
error= _ma_insert(info, key, &page, keypos, keybuff,
father_page, father_keypos, insert_last);
if (error < 0)
goto err;
page_mark_changed(info, &page);
if (_ma_write_keypage(&page, PAGECACHE_LOCK_LEFT_WRITELOCKED,
DFLT_INIT_HITS))
goto err;
}
stack_alloc_free(temp_buff, buff_alloced);
DBUG_RETURN(error);
err:
stack_alloc_free(temp_buff, buff_alloced);
DBUG_PRINT("exit",("Error: %d",my_errno));
DBUG_RETURN(-1);
} | O3 | c | w_search:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r9, -0x68(%rbp)
movq %r8, -0x60(%rbp)
movq %rcx, %r12
movl %esi, -0x48(%rbp)
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq (%rdi), %rax
movq %rax, -0x58(%rbp)
movq %rdx, -0x70(%rbp)
movq 0x8(%rdx), %r13
movzwl 0xa6(%r13), %r15d
movzwl 0xb0(%r13), %ebx
leaq (%rbx,%rbx,2), %rsi
addq %r15, %rsi
leaq -0xb0(%rbp), %rcx
movq %rsi, (%rcx)
movq 0x78(%rdi), %rax
movq (%rax), %rax
subq %rcx, %rax
subq %rsi, %rax
jbe 0x56139
cmpq $0x10000, %rax # imm = 0x10000
ja 0x56123
cmpl $0x1000, %esi # imm = 0x1000
jb 0x56139
cmpq $0x8001, %rax # imm = 0x8001
jb 0x56139
movq %rsp, %rax
addl $0xf, %esi
andl $-0x10, %esi
subq %rsi, %rax
movq %rax, %rsp
movb $0x1, %cl
movl %ecx, -0x44(%rbp)
jmp 0x56165
movl $0x10010, %edx # imm = 0x10010
xorl %edi, %edi
callq 0x9fec1
testq %rax, %rax
je 0x561ef
movzwl 0xa6(%r13), %r15d
movzwl 0xb0(%r13), %ebx
movl $0x0, -0x44(%rbp)
leaq -0xb0(%rbp), %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
movl $0x4, %r8d
movl $0x3, %r9d
pushq $0x0
movq %rax, -0x50(%rbp)
pushq %rax
callq 0x6f2ce
addq $0x10, %rsp
testb %al, %al
je 0x561ac
movl $0xffffffff, %r13d # imm = 0xFFFFFFFF
cmpb $0x0, -0x44(%rbp)
jne 0x561f5
movq -0x50(%rbp), %rdi
callq 0xa00ee
jmp 0x561f5
leaq (%r15,%rbx,2), %r12
addq -0x50(%rbp), %r12
leaq -0xb0(%rbp), %rsi
leaq -0x40(%rbp), %rcx
leaq -0x31(%rbp), %r9
movq -0x70(%rbp), %r15
movq %r15, %rdi
movl -0x48(%rbp), %edx
movq %r12, %r8
callq *0xd8(%r13)
testl %eax, %eax
je 0x5621a
cmpl $0x7fffffff, %eax # imm = 0x7FFFFFFF
jne 0x5625b
callq 0xa1c32
movl $0x7e, (%rax)
jmp 0x56195
movl $0x1, %r13d
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x564df
movl %r13d, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0xd0(%rbp), %rdi
movq %r13, 0x8(%rdi)
movq %r12, (%rdi)
movl -0x88(%rbp), %edx
movl -0x84(%rbp), %esi
leaq -0x40(%rbp), %rcx
callq *0xe0(%r13)
testl %eax, %eax
je 0x56310
leaq -0xd0(%rbp), %rdi
callq 0x6d444
movq %rax, %rbx
jmp 0x56317
xorl %eax, %eax
cmpb $0x0, -0x31(%rbp)
movzbl 0x10(%rbp), %ebx
cmovel %eax, %ebx
movl -0x88(%rbp), %edi
movq -0x40(%rbp), %rsi
callq 0x6d2df
movsbl %bl, %ebx
cmpq $-0x1, %rax
je 0x562ad
movq -0x40(%rbp), %r9
subq $0x8, %rsp
leaq -0xb0(%rbp), %r8
movq %r14, %rdi
movl -0x48(%rbp), %esi
movq %r15, %rdx
movq %rax, %rcx
pushq %rbx
callq 0x5609a
addq $0x10, %rsp
testl %eax, %eax
jle 0x5635d
movq -0x40(%rbp), %rcx
leaq -0xb0(%rbp), %rdx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %r8
movq -0x60(%rbp), %r9
pushq %rbx
pushq -0x68(%rbp)
callq 0x567cb
addq $0x10, %rsp
testl %eax, %eax
js 0x56195
movl %eax, %r13d
movq 0x2e8(%r14), %rax
leaq -0xb0(%rbp), %rdi
movl 0x30(%rdi), %ecx
leaq (%rcx,%rcx,2), %rcx
movb $0x1, 0x10(%rax,%rcx,8)
movl $0x2, %esi
movl $0x3, %edx
callq 0x6f40d
testb %al, %al
jne 0x56195
jmp 0x56360
movq $-0x1, %rbx
testb $-0x80, 0xa2(%r13)
jne 0x5634b
leaq -0xd0(%rbp), %rdi
callq 0x6d4fc
movq %rax, 0x430(%r14)
movq %rbx, 0x428(%r14)
callq 0xa1c32
movl $0x79, (%rax)
jmp 0x56195
movzbl (%r12), %eax
cmpq $0xff, %rax
je 0x56373
incq %rax
jmp 0x56384
movl %eax, %r13d
cmpb $0x0, -0x44(%rbp)
movq -0x50(%rbp), %rdi
je 0x561a5
jmp 0x561f5
movzwl 0x1(%r12), %eax
rolw $0x8, %ax
movzwl %ax, %eax
addq $0x3, %rax
movzbl (%r12,%rax), %ecx
shll $0x18, %ecx
js 0x563bb
leaq -0xb0(%rbp), %rsi
movl $0x4, -0x48(%rbp)
leaq -0x40(%rbp), %rcx
leaq -0x31(%rbp), %r9
movq %r15, %rdi
movl $0x4, %edx
movq %r12, %r8
callq *0xd8(%r13)
jmp 0x561db
movzwl 0x2(%r12,%rax), %edx
rolw $0x8, %dx
movzwl %dx, %edx
movzbl 0x1(%r12,%rax), %r13d
shll $0x10, %r13d
orl %edx, %r13d
orl %ecx, %r13d
movq %rbx, -0x78(%rbp)
movq (%r15), %rax
movzbl (%rax), %ecx
cmpl $0xff, %ecx
je 0x563ee
incl %ecx
jmp 0x563fc
movzwl 0x1(%rax), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
addl $0x3, %ecx
movq -0x58(%rbp), %rbx
leaq 0x458(%rbx), %rdx
leaq -0xf0(%rbp), %rsi
movq %rdx, 0x8(%rsi)
movl %ecx, %edx
addq %rdx, %rax
movq %rax, (%rsi)
movl 0x10(%r15), %eax
subl %ecx, %eax
movl %eax, 0x10(%rsi)
movq 0x14(%r15), %rax
movq %rax, 0x14(%rsi)
movzwl 0x502(%rbx), %eax
addl -0x88(%rbp), %eax
subq %rax, -0x40(%rbp)
leaq -0x78(%rbp), %r12
movq %r14, %rdi
movq %r12, %rdx
movl $0x4, %ecx
callq 0x5603c
movl %eax, %r15d
movq -0x40(%rbp), %rsi
addq $0x4, %rsi
movq (%r12), %rdx
movq %rbx, %rdi
callq 0x6d628
movl %r13d, %edx
decl %edx
movq -0x40(%rbp), %rax
movb %dl, 0x3(%rax)
movq -0x40(%rbp), %rax
movb %dh, 0x2(%rax)
movl %edx, %eax
shrl $0x10, %eax
movq -0x40(%rbp), %rcx
movb %al, 0x1(%rcx)
shrl $0x18, %edx
movq -0x40(%rbp), %rax
movb %dl, (%rax)
testb %r15b, %r15b
je 0x564ac
cmpb $0x0, -0x44(%rbp)
jne 0x564a3
movq -0x50(%rbp), %rdi
callq 0xa00ee
movzbl %r15b, %r13d
jmp 0x561f5
movq 0x2e8(%r14), %rax
leaq -0xb0(%rbp), %rdi
movl 0x30(%rdi), %ecx
leaq (%rcx,%rcx,2), %rcx
movb $0x1, 0x10(%rax,%rcx,8)
movl $0x2, %esi
movl $0x3, %edx
callq 0x6f40d
testb %al, %al
jne 0x56195
jmp 0x56494
callq 0x29250
| w_search:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0C8h
mov [rbp+var_68], r9
mov [rbp+var_60], r8
mov r12, rcx
mov [rbp+var_48], esi
mov r14, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov rax, [rdi]
mov [rbp+var_58], rax
mov [rbp+var_70], rdx
mov r13, [rdx+8]
movzx r15d, word ptr [r13+0A6h]
movzx ebx, word ptr [r13+0B0h]
lea rsi, [rbx+rbx*2]
add rsi, r15
lea rcx, [rbp+var_B0]
mov [rcx], rsi
mov rax, [rdi+78h]
mov rax, [rax]
sub rax, rcx
sub rax, rsi
jbe short loc_56139
cmp rax, offset stru_10000
ja short loc_56123
cmp esi, 1000h
jb short loc_56139
cmp rax, 8001h
jb short loc_56139
loc_56123:
mov rax, rsp
add esi, 0Fh
and esi, 0FFFFFFF0h
sub rax, rsi
mov rsp, rax
mov cl, 1
mov [rbp+var_44], ecx
jmp short loc_56165
loc_56139:
mov edx, 10010h
xor edi, edi
call my_malloc
test rax, rax
jz loc_561EF
movzx r15d, word ptr [r13+0A6h]
movzx ebx, word ptr [r13+0B0h]
mov [rbp+var_44], 0
loc_56165:
lea rdi, [rbp+var_B0]
mov rsi, r14
mov rdx, r13
mov rcx, r12
mov r8d, 4
mov r9d, 3
push 0
mov [rbp+var_50], rax
push rax
call _ma_fetch_keypage
add rsp, 10h
test al, al
jz short loc_561AC
loc_56195:
mov r13d, 0FFFFFFFFh
cmp byte ptr [rbp+var_44], 0
jnz short loc_561F5
mov rdi, [rbp+var_50]
loc_561A5:
call my_free
jmp short loc_561F5
loc_561AC:
lea r12, [r15+rbx*2]
add r12, [rbp+var_50]
lea rsi, [rbp+var_B0]
lea rcx, [rbp+var_40]
lea r9, [rbp+var_31]
mov r15, [rbp+var_70]
mov rdi, r15
mov edx, [rbp+var_48]
mov r8, r12
call qword ptr [r13+0D8h]
test eax, eax
jz short loc_5621A
loc_561DB:
cmp eax, 7FFFFFFFh
jnz short loc_5625B
call _my_thread_var
mov dword ptr [rax], 7Eh ; '~'
jmp short loc_56195
loc_561EF:
mov r13d, 1
loc_561F5:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz loc_564DF
mov eax, r13d
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_5621A:
lea rdi, [rbp+var_D0]
mov [rdi+8], r13
mov [rdi], r12
mov edx, [rbp+var_88]
mov esi, [rbp+var_84]
lea rcx, [rbp+var_40]
call qword ptr [r13+0E0h]
test eax, eax
jz loc_56310
lea rdi, [rbp+var_D0]
call _ma_row_pos_from_key
mov rbx, rax
jmp loc_56317
loc_5625B:
xor eax, eax
cmp [rbp+var_31], 0
movzx ebx, [rbp+arg_0]
cmovz ebx, eax
mov edi, [rbp+var_88]
mov rsi, [rbp+var_40]
call _ma_kpos
movsx ebx, bl
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_562AD
mov r9, [rbp+var_40]
sub rsp, 8
lea r8, [rbp+var_B0]
mov rdi, r14
mov esi, [rbp+var_48]
mov rdx, r15
mov rcx, rax
push rbx
call w_search
add rsp, 10h
test eax, eax
jle loc_5635D
loc_562AD:
mov rcx, [rbp+var_40]
lea rdx, [rbp+var_B0]
mov rdi, r14
mov rsi, r15
mov r8, r12
mov r9, [rbp+var_60]
push rbx
push [rbp+var_68]
call _ma_insert
add rsp, 10h
test eax, eax
js loc_56195
mov r13d, eax
mov rax, [r14+2E8h]
lea rdi, [rbp+var_B0]
mov ecx, [rdi+30h]
lea rcx, [rcx+rcx*2]
mov byte ptr [rax+rcx*8+10h], 1
mov esi, 2
mov edx, 3
call _ma_write_keypage
test al, al
jnz loc_56195
jmp short loc_56360
loc_56310:
mov rbx, 0FFFFFFFFFFFFFFFFh
loc_56317:
test byte ptr [r13+0A2h], 80h
jnz short loc_5634B
lea rdi, [rbp+var_D0]
call _ma_trid_from_key
mov [r14+430h], rax
mov [r14+428h], rbx
call _my_thread_var
mov dword ptr [rax], 79h ; 'y'
jmp loc_56195
loc_5634B:
movzx eax, byte ptr [r12]
cmp rax, 0FFh
jz short loc_56373
inc rax
jmp short loc_56384
loc_5635D:
mov r13d, eax
loc_56360:
cmp byte ptr [rbp+var_44], 0
mov rdi, [rbp+var_50]
jz loc_561A5
jmp loc_561F5
loc_56373:
movzx eax, word ptr [r12+1]
rol ax, 8
movzx eax, ax
add rax, 3
loc_56384:
movzx ecx, byte ptr [r12+rax]
shl ecx, 18h
js short loc_563BB
lea rsi, [rbp+var_B0]
mov [rbp+var_48], 4
lea rcx, [rbp+var_40]
lea r9, [rbp+var_31]
mov rdi, r15
mov edx, 4
mov r8, r12
call qword ptr [r13+0D8h]
jmp loc_561DB
loc_563BB:
movzx edx, word ptr [r12+rax+2]
rol dx, 8
movzx edx, dx
movzx r13d, byte ptr [r12+rax+1]
shl r13d, 10h
or r13d, edx
or r13d, ecx
mov [rbp+var_78], rbx
mov rax, [r15]
movzx ecx, byte ptr [rax]
cmp ecx, 0FFh
jz short loc_563EE
inc ecx
jmp short loc_563FC
loc_563EE:
movzx ecx, word ptr [rax+1]
rol cx, 8
movzx ecx, cx
add ecx, 3
loc_563FC:
mov rbx, [rbp+var_58]
lea rdx, [rbx+458h]
lea rsi, [rbp+var_F0]
mov [rsi+8], rdx
mov edx, ecx
add rax, rdx
mov [rsi], rax
mov eax, [r15+10h]
sub eax, ecx
mov [rsi+10h], eax
mov rax, [r15+14h]
mov [rsi+14h], rax
movzx eax, word ptr [rbx+502h]
add eax, [rbp+var_88]
sub [rbp+var_40], rax
lea r12, [rbp+var_78]
mov rdi, r14
mov rdx, r12
mov ecx, 4
call _ma_ck_real_write_btree
mov r15d, eax
mov rsi, [rbp+var_40]
add rsi, 4
mov rdx, [r12]
mov rdi, rbx
call _ma_dpointer
mov edx, r13d
dec edx
mov rax, [rbp+var_40]
mov [rax+3], dl
mov rax, [rbp+var_40]
mov [rax+2], dh
mov eax, edx
shr eax, 10h
mov rcx, [rbp+var_40]
mov [rcx+1], al
shr edx, 18h
mov rax, [rbp+var_40]
mov [rax], dl
test r15b, r15b
jz short loc_564AC
loc_56494:
cmp byte ptr [rbp+var_44], 0
jnz short loc_564A3
mov rdi, [rbp+var_50]
call my_free
loc_564A3:
movzx r13d, r15b
jmp loc_561F5
loc_564AC:
mov rax, [r14+2E8h]
lea rdi, [rbp+var_B0]
mov ecx, [rdi+30h]
lea rcx, [rcx+rcx*2]
mov byte ptr [rax+rcx*8+10h], 1
mov esi, 2
mov edx, 3
call _ma_write_keypage
test al, al
jnz loc_56195
jmp short loc_56494
loc_564DF:
call ___stack_chk_fail
| long long w_search(long long a1, unsigned int a2, unsigned __int8 **a3, int a4, long long a5, long long a6, char a7)
{
unsigned __int8 *v9; // r13
long long v10; // r15
long long v11; // rbx
unsigned long long v12; // rsi
_QWORD *v13; // rcx
unsigned long long v14; // rax
bool v15; // cc
unsigned long long v16; // rax
char *v17; // rax
unsigned int v18; // r13d
char *v19; // rdi
unsigned __int8 *v20; // r12
unsigned __int8 **v21; // r15
unsigned __int8 **v22; // rdi
int v23; // eax
long long v25; // rbx
long long v27; // rax
int v28; // eax
int v29; // eax
long long v30; // rax
long long v31; // rax
int v32; // r13d
unsigned __int8 *v33; // rax
int v34; // ecx
unsigned int v35; // ecx
long long v36; // rbx
bool v37; // r15
long long v38; // rcx
_QWORD v39[2]; // [rsp+0h] [rbp-F0h] BYREF
unsigned int v40; // [rsp+10h] [rbp-E0h]
long long v41; // [rsp+14h] [rbp-DCh]
_QWORD v42[4]; // [rsp+20h] [rbp-D0h] BYREF
_QWORD v43[5]; // [rsp+40h] [rbp-B0h] BYREF
unsigned int v44; // [rsp+68h] [rbp-88h]
unsigned int v45; // [rsp+6Ch] [rbp-84h]
unsigned int v46; // [rsp+70h] [rbp-80h]
long long v47; // [rsp+78h] [rbp-78h] BYREF
unsigned __int8 **v48; // [rsp+80h] [rbp-70h]
long long v49; // [rsp+88h] [rbp-68h]
long long v50; // [rsp+90h] [rbp-60h]
long long v51; // [rsp+98h] [rbp-58h]
char *v52; // [rsp+A0h] [rbp-50h]
unsigned int v53; // [rsp+A8h] [rbp-48h]
int v54; // [rsp+ACh] [rbp-44h]
_BYTE *v55; // [rsp+B0h] [rbp-40h] BYREF
char v56; // [rsp+BFh] [rbp-31h] BYREF
unsigned long long v57; // [rsp+C0h] [rbp-30h]
v49 = a6;
v50 = a5;
v53 = a2;
v57 = __readfsqword(0x28u);
v51 = *(_QWORD *)a1;
v48 = a3;
v9 = a3[1];
v10 = *((unsigned __int16 *)v9 + 83);
v11 = *((unsigned __int16 *)v9 + 88);
v12 = v10 + 3 * v11;
v13 = v43;
v43[0] = v12;
v14 = **(_QWORD **)(a1 + 120) - (_QWORD)v43;
v15 = v14 <= v12;
v16 = v14 - v12;
if ( v15 || v16 <= (unsigned long long)&stru_10000 && ((unsigned int)v12 < 0x1000 || v16 < 0x8001) )
{
v17 = (char *)my_malloc(0LL, v12, 65552LL);
if ( !v17 )
return 1;
v10 = *((unsigned __int16 *)v9 + 83);
v11 = *((unsigned __int16 *)v9 + 88);
v54 = 0;
}
else
{
v17 = (char *)v39 - (((_DWORD)v12 + 15) & 0xFFFFFFF0);
LOBYTE(v13) = 1;
v54 = (int)v13;
}
v52 = v17;
if ( (unsigned __int8)ma_fetch_keypage((unsigned int)v43, a1, (_DWORD)v9, a4, 4, 3, (long long)v17) )
goto LABEL_9;
v20 = (unsigned __int8 *)&v52[2 * v11 + v10];
v21 = v48;
v22 = v48;
v23 = (*((long long ( **)(unsigned __int8 **, _QWORD *, _QWORD, _BYTE **, unsigned __int8 *, char *))v9 + 27))(
v48,
v43,
v53,
&v55,
v20,
&v56);
if ( v23 )
{
LABEL_13:
if ( v23 == 0x7FFFFFFF )
{
*(_DWORD *)my_thread_var(v22) = 126;
goto LABEL_9;
}
if ( !v56 )
a7 = 0;
v27 = ma_kpos(v44, v55);
if ( v27 == -1 || (v28 = w_search(a1, v53, (_DWORD)v21, v27, (unsigned int)v43, (_DWORD)v55, a7), v28 > 0) )
{
v29 = ma_insert(a1, (_DWORD)v21, (unsigned int)v43, (_DWORD)v55, (_DWORD)v20, v50, v49, a7);
if ( v29 < 0 )
goto LABEL_9;
v18 = v29;
*(_BYTE *)(*(_QWORD *)(a1 + 744) + 24LL * v46 + 16) = 1;
if ( (unsigned __int8)ma_write_keypage(v43, 2LL, 3LL) )
goto LABEL_9;
}
else
{
v18 = v28;
}
v19 = v52;
if ( (_BYTE)v54 )
return v18;
goto LABEL_11;
}
v42[1] = v9;
v42[0] = v20;
if ( (*((unsigned int ( **)(_QWORD *, _QWORD, _QWORD, _BYTE **))v9 + 28))(v42, v45, v44, &v55) )
v25 = ma_row_pos_from_key(v42);
else
v25 = -1LL;
if ( (v9[162] & 0x80u) == 0 )
{
*(_QWORD *)(a1 + 1072) = ma_trid_from_key(v42);
*(_QWORD *)(a1 + 1064) = v25;
*(_DWORD *)my_thread_var(v42) = 121;
goto LABEL_9;
}
v30 = *v20;
if ( v30 == 255 )
v31 = (unsigned __int16)__ROL2__(*(_WORD *)(v20 + 1), 8) + 3LL;
else
v31 = v30 + 1;
if ( (v20[v31] & 0x80) == 0 )
{
v53 = 4;
v22 = v21;
v23 = (*((long long ( **)(unsigned __int8 **, _QWORD *, long long, _BYTE **, unsigned __int8 *, char *))v9 + 27))(
v21,
v43,
4LL,
&v55,
v20,
&v56);
goto LABEL_13;
}
v32 = (v20[v31] << 24) | (unsigned __int16)__ROL2__(*(_WORD *)&v20[v31 + 2], 8) | (v20[v31 + 1] << 16);
v47 = v25;
v33 = *v21;
v34 = **v21;
if ( v34 == 255 )
v35 = (unsigned __int16)__ROL2__(*(_WORD *)(v33 + 1), 8) + 3;
else
v35 = v34 + 1;
v36 = v51;
v39[1] = v51 + 1112;
v39[0] = &v33[v35];
v40 = *((_DWORD *)v21 + 4) - v35;
v41 = *(long long *)((char *)v21 + 20);
v55 += -v44 - *(unsigned __int16 *)(v51 + 1282);
v37 = ma_ck_real_write_btree(a1, (long long)v39, &v47, 4);
ma_dpointer(v36, v55 + 4, v47, v38);
v55[3] = v32 - 1;
v55[2] = (unsigned __int16)(v32 - 1) >> 8;
v55[1] = (unsigned int)(v32 - 1) >> 16;
*v55 = (unsigned int)(v32 - 1) >> 24;
if ( v37
|| (*(_BYTE *)(*(_QWORD *)(a1 + 744) + 24LL * v46 + 16) = 1, !(unsigned __int8)ma_write_keypage(v43, 2LL, 3LL)) )
{
if ( !(_BYTE)v54 )
my_free(v52);
return v37;
}
LABEL_9:
v18 = -1;
if ( !(_BYTE)v54 )
{
v19 = v52;
LABEL_11:
my_free(v19);
}
return v18;
}
| w_search:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xc8
MOV qword ptr [RBP + -0x68],R9
MOV qword ptr [RBP + -0x60],R8
MOV R12,RCX
MOV dword ptr [RBP + -0x48],ESI
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RDI]
MOV qword ptr [RBP + -0x58],RAX
MOV qword ptr [RBP + -0x70],RDX
MOV R13,qword ptr [RDX + 0x8]
MOVZX R15D,word ptr [R13 + 0xa6]
MOVZX EBX,word ptr [R13 + 0xb0]
LEA RSI,[RBX + RBX*0x2]
ADD RSI,R15
LEA RCX,[RBP + -0xb0]
MOV qword ptr [RCX],RSI
MOV RAX,qword ptr [RDI + 0x78]
MOV RAX,qword ptr [RAX]
SUB RAX,RCX
SUB RAX,RSI
JBE 0x00156139
CMP RAX,0x10000
JA 0x00156123
CMP ESI,0x1000
JC 0x00156139
CMP RAX,0x8001
JC 0x00156139
LAB_00156123:
MOV RAX,RSP
ADD ESI,0xf
AND ESI,0xfffffff0
SUB RAX,RSI
MOV RSP,RAX
MOV CL,0x1
MOV dword ptr [RBP + -0x44],ECX
JMP 0x00156165
LAB_00156139:
MOV EDX,0x10010
XOR EDI,EDI
CALL 0x0019fec1
TEST RAX,RAX
JZ 0x001561ef
MOVZX R15D,word ptr [R13 + 0xa6]
MOVZX EBX,word ptr [R13 + 0xb0]
MOV dword ptr [RBP + -0x44],0x0
LAB_00156165:
LEA RDI,[RBP + -0xb0]
MOV RSI,R14
MOV RDX,R13
MOV RCX,R12
MOV R8D,0x4
MOV R9D,0x3
PUSH 0x0
MOV qword ptr [RBP + -0x50],RAX
PUSH RAX
CALL 0x0016f2ce
ADD RSP,0x10
TEST AL,AL
JZ 0x001561ac
LAB_00156195:
MOV R13D,0xffffffff
CMP byte ptr [RBP + -0x44],0x0
JNZ 0x001561f5
MOV RDI,qword ptr [RBP + -0x50]
LAB_001561a5:
CALL 0x001a00ee
JMP 0x001561f5
LAB_001561ac:
LEA R12,[R15 + RBX*0x2]
ADD R12,qword ptr [RBP + -0x50]
LEA RSI,[RBP + -0xb0]
LEA RCX,[RBP + -0x40]
LEA R9,[RBP + -0x31]
MOV R15,qword ptr [RBP + -0x70]
MOV RDI,R15
MOV EDX,dword ptr [RBP + -0x48]
MOV R8,R12
CALL qword ptr [R13 + 0xd8]
TEST EAX,EAX
JZ 0x0015621a
LAB_001561db:
CMP EAX,0x7fffffff
JNZ 0x0015625b
CALL 0x001a1c32
MOV dword ptr [RAX],0x7e
JMP 0x00156195
LAB_001561ef:
MOV R13D,0x1
LAB_001561f5:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001564df
MOV EAX,R13D
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0015621a:
LEA RDI,[RBP + -0xd0]
MOV qword ptr [RDI + 0x8],R13
MOV qword ptr [RDI],R12
MOV EDX,dword ptr [RBP + -0x88]
MOV ESI,dword ptr [RBP + -0x84]
LEA RCX,[RBP + -0x40]
CALL qword ptr [R13 + 0xe0]
TEST EAX,EAX
JZ 0x00156310
LEA RDI,[RBP + -0xd0]
CALL 0x0016d444
MOV RBX,RAX
JMP 0x00156317
LAB_0015625b:
XOR EAX,EAX
CMP byte ptr [RBP + -0x31],0x0
MOVZX EBX,byte ptr [RBP + 0x10]
CMOVZ EBX,EAX
MOV EDI,dword ptr [RBP + -0x88]
MOV RSI,qword ptr [RBP + -0x40]
CALL 0x0016d2df
MOVSX EBX,BL
CMP RAX,-0x1
JZ 0x001562ad
MOV R9,qword ptr [RBP + -0x40]
SUB RSP,0x8
LEA R8,[RBP + -0xb0]
MOV RDI,R14
MOV ESI,dword ptr [RBP + -0x48]
MOV RDX,R15
MOV RCX,RAX
PUSH RBX
CALL 0x0015609a
ADD RSP,0x10
TEST EAX,EAX
JLE 0x0015635d
LAB_001562ad:
MOV RCX,qword ptr [RBP + -0x40]
LEA RDX,[RBP + -0xb0]
MOV RDI,R14
MOV RSI,R15
MOV R8,R12
MOV R9,qword ptr [RBP + -0x60]
PUSH RBX
PUSH qword ptr [RBP + -0x68]
CALL 0x001567cb
ADD RSP,0x10
TEST EAX,EAX
JS 0x00156195
MOV R13D,EAX
MOV RAX,qword ptr [R14 + 0x2e8]
LEA RDI,[RBP + -0xb0]
MOV ECX,dword ptr [RDI + 0x30]
LEA RCX,[RCX + RCX*0x2]
MOV byte ptr [RAX + RCX*0x8 + 0x10],0x1
MOV ESI,0x2
MOV EDX,0x3
CALL 0x0016f40d
TEST AL,AL
JNZ 0x00156195
JMP 0x00156360
LAB_00156310:
MOV RBX,-0x1
LAB_00156317:
TEST byte ptr [R13 + 0xa2],0x80
JNZ 0x0015634b
LEA RDI,[RBP + -0xd0]
CALL 0x0016d4fc
MOV qword ptr [R14 + 0x430],RAX
MOV qword ptr [R14 + 0x428],RBX
CALL 0x001a1c32
MOV dword ptr [RAX],0x79
JMP 0x00156195
LAB_0015634b:
MOVZX EAX,byte ptr [R12]
CMP RAX,0xff
JZ 0x00156373
INC RAX
JMP 0x00156384
LAB_0015635d:
MOV R13D,EAX
LAB_00156360:
CMP byte ptr [RBP + -0x44],0x0
MOV RDI,qword ptr [RBP + -0x50]
JZ 0x001561a5
JMP 0x001561f5
LAB_00156373:
MOVZX EAX,word ptr [R12 + 0x1]
ROL AX,0x8
MOVZX EAX,AX
ADD RAX,0x3
LAB_00156384:
MOVZX ECX,byte ptr [R12 + RAX*0x1]
SHL ECX,0x18
JS 0x001563bb
LEA RSI,[RBP + -0xb0]
MOV dword ptr [RBP + -0x48],0x4
LEA RCX,[RBP + -0x40]
LEA R9,[RBP + -0x31]
MOV RDI,R15
MOV EDX,0x4
MOV R8,R12
CALL qword ptr [R13 + 0xd8]
JMP 0x001561db
LAB_001563bb:
MOVZX EDX,word ptr [R12 + RAX*0x1 + 0x2]
ROL DX,0x8
MOVZX EDX,DX
MOVZX R13D,byte ptr [R12 + RAX*0x1 + 0x1]
SHL R13D,0x10
OR R13D,EDX
OR R13D,ECX
MOV qword ptr [RBP + -0x78],RBX
MOV RAX,qword ptr [R15]
MOVZX ECX,byte ptr [RAX]
CMP ECX,0xff
JZ 0x001563ee
INC ECX
JMP 0x001563fc
LAB_001563ee:
MOVZX ECX,word ptr [RAX + 0x1]
ROL CX,0x8
MOVZX ECX,CX
ADD ECX,0x3
LAB_001563fc:
MOV RBX,qword ptr [RBP + -0x58]
LEA RDX,[RBX + 0x458]
LEA RSI,[RBP + -0xf0]
MOV qword ptr [RSI + 0x8],RDX
MOV EDX,ECX
ADD RAX,RDX
MOV qword ptr [RSI],RAX
MOV EAX,dword ptr [R15 + 0x10]
SUB EAX,ECX
MOV dword ptr [RSI + 0x10],EAX
MOV RAX,qword ptr [R15 + 0x14]
MOV qword ptr [RSI + 0x14],RAX
MOVZX EAX,word ptr [RBX + 0x502]
ADD EAX,dword ptr [RBP + -0x88]
SUB qword ptr [RBP + -0x40],RAX
LEA R12,[RBP + -0x78]
MOV RDI,R14
MOV RDX,R12
MOV ECX,0x4
CALL 0x0015603c
MOV R15D,EAX
MOV RSI,qword ptr [RBP + -0x40]
ADD RSI,0x4
MOV RDX,qword ptr [R12]
MOV RDI,RBX
CALL 0x0016d628
MOV EDX,R13D
DEC EDX
MOV RAX,qword ptr [RBP + -0x40]
MOV byte ptr [RAX + 0x3],DL
MOV RAX,qword ptr [RBP + -0x40]
MOV byte ptr [RAX + 0x2],DH
MOV EAX,EDX
SHR EAX,0x10
MOV RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RCX + 0x1],AL
SHR EDX,0x18
MOV RAX,qword ptr [RBP + -0x40]
MOV byte ptr [RAX],DL
TEST R15B,R15B
JZ 0x001564ac
LAB_00156494:
CMP byte ptr [RBP + -0x44],0x0
JNZ 0x001564a3
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x001a00ee
LAB_001564a3:
MOVZX R13D,R15B
JMP 0x001561f5
LAB_001564ac:
MOV RAX,qword ptr [R14 + 0x2e8]
LEA RDI,[RBP + -0xb0]
MOV ECX,dword ptr [RDI + 0x30]
LEA RCX,[RCX + RCX*0x2]
MOV byte ptr [RAX + RCX*0x8 + 0x10],0x1
MOV ESI,0x2
MOV EDX,0x3
CALL 0x0016f40d
TEST AL,AL
JNZ 0x00156195
JMP 0x00156494
LAB_001564df:
CALL 0x00129250
|
uint w_search(long *param_1,int4 param_2,int8 *param_3,int8 param_4,
int8 param_5,int8 param_6,char param_7)
{
byte bVar1;
byte bVar2;
ushort uVar3;
code *pcVar4;
int8 *puVar5;
int8 uVar6;
long lVar7;
int4 uVar8;
char cVar9;
byte bVar10;
int iVar11;
int iVar12;
uint uVar13;
ulong uVar14;
ulong uVar15;
int4 *puVar16;
long lVar17;
long lVar18;
long lVar19;
ulong uVar20;
byte **ppbVar21;
int1 *puVar22;
byte *pbVar23;
ulong uVar24;
long in_FS_OFFSET;
byte *local_f8;
long local_f0;
int local_e8;
int8 local_e4;
byte *local_d8;
long local_d0;
ulong local_b8 [5];
int local_90;
int4 local_8c;
uint local_88;
long local_80;
int8 *local_78;
int8 local_70;
int8 local_68;
long local_60;
int1 *local_58;
int4 local_50;
int4 local_4c;
int1 *local_48;
char local_39;
long local_38;
ppbVar21 = &local_f8;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
local_60 = *param_1;
lVar18 = param_3[1];
uVar24 = (ulong)*(ushort *)(lVar18 + 0xa6);
uVar20 = (ulong)*(ushort *)(lVar18 + 0xb0);
local_b8[0] = uVar20 * 3 + uVar24;
uVar14 = *(long *)param_1[0xf] - (long)local_b8;
uVar15 = uVar14 - local_b8[0];
local_78 = param_3;
local_70 = param_6;
local_68 = param_5;
local_50 = param_2;
if ((local_b8[0] < uVar14) &&
((0x10000 < uVar15 || ((0xfff < (uint)local_b8[0] && (0x8000 < uVar15)))))) {
puVar22 = (int1 *)((long)&local_f8 - (ulong)((uint)local_b8[0] + 0xf & 0xfffffff0));
local_4c = (int4)CONCAT71((int7)((ulong)local_b8 >> 8),1);
ppbVar21 = (byte **)puVar22;
}
else {
puVar22 = (int1 *)my_malloc(0,local_b8[0],0x10010);
if (puVar22 == (int1 *)0x0) {
uVar13 = 1;
goto LAB_001561f5;
}
uVar24 = (ulong)*(ushort *)(lVar18 + 0xa6);
uVar20 = (ulong)*(ushort *)(lVar18 + 0xb0);
local_4c = 0;
ppbVar21 = &local_f8;
}
*(int8 *)((long)ppbVar21 + -8) = 0;
local_58 = puVar22;
*(int1 **)((long)ppbVar21 + -0x10) = puVar22;
*(int8 *)((long)ppbVar21 + -0x18) = 0x15618d;
cVar9 = _ma_fetch_keypage(local_b8,param_1,lVar18,param_4,4,3);
uVar8 = local_50;
puVar5 = local_78;
if (cVar9 == '\0') {
pbVar23 = local_58 + uVar24 + uVar20 * 2;
pcVar4 = *(code **)(lVar18 + 0xd8);
*(int8 *)((long)ppbVar21 + -8) = 0x1561d7;
iVar11 = (*pcVar4)(puVar5,local_b8,uVar8,&local_48,pbVar23,&local_39);
iVar12 = local_90;
if (iVar11 == 0) {
pcVar4 = *(code **)(lVar18 + 0xe0);
local_d8 = pbVar23;
local_d0 = lVar18;
*(int8 *)((long)ppbVar21 + -8) = 0x15623f;
iVar12 = (*pcVar4)(&local_d8,local_8c,iVar12,&local_48);
if (iVar12 == 0) {
lVar17 = -1;
}
else {
*(int8 *)((long)ppbVar21 + -8) = 0x156253;
lVar17 = _ma_row_pos_from_key(&local_d8);
}
lVar7 = local_60;
if ((*(byte *)(lVar18 + 0xa2) & 0x80) == 0) {
*(int8 *)((long)ppbVar21 + -8) = 0x15632d;
lVar18 = _ma_trid_from_key(&local_d8);
param_1[0x86] = lVar18;
param_1[0x85] = lVar17;
*(int8 *)((long)ppbVar21 + -8) = 0x156340;
puVar16 = (int4 *)_my_thread_var();
*puVar16 = 0x79;
goto LAB_00156195;
}
if ((ulong)*pbVar23 == 0xff) {
lVar19 = (ulong)(ushort)(*(ushort *)(pbVar23 + 1) << 8 | *(ushort *)(pbVar23 + 1) >> 8) + 3;
}
else {
lVar19 = (ulong)*pbVar23 + 1;
}
bVar1 = pbVar23[lVar19];
if ((int)((uint)bVar1 << 0x18) < 0) {
uVar3 = *(ushort *)(pbVar23 + lVar19 + 2);
bVar2 = pbVar23[lVar19 + 1];
local_f8 = (byte *)*puVar5;
if (*local_f8 == 0xff) {
uVar13 = (ushort)(*(ushort *)(local_f8 + 1) << 8 | *(ushort *)(local_f8 + 1) >> 8) + 3;
}
else {
uVar13 = *local_f8 + 1;
}
local_f0 = local_60 + 0x458;
local_f8 = local_f8 + uVar13;
local_e8 = *(int *)(puVar5 + 2) - uVar13;
local_e4 = *(int8 *)((long)puVar5 + 0x14);
local_48 = local_48 + -(ulong)((uint)*(ushort *)(local_60 + 0x502) + local_90);
local_80 = lVar17;
*(int8 *)((long)ppbVar21 + -8) = 0x156450;
bVar10 = _ma_ck_real_write_btree(param_1,&local_f8,&local_80,4);
lVar18 = local_80;
puVar22 = local_48 + 4;
*(int8 *)((long)ppbVar21 + -8) = 0x156467;
_ma_dpointer(lVar7,puVar22,lVar18);
iVar12 = CONCAT13(bVar1,CONCAT12(bVar2,uVar3 << 8 | uVar3 >> 8)) + -1;
local_48[3] = (char)iVar12;
local_48[2] = (char)((uint)iVar12 >> 8);
local_48[1] = (char)((uint)iVar12 >> 0x10);
*local_48 = (char)((uint)iVar12 >> 0x18);
if (bVar10 == 0) {
*(int1 *)(param_1[0x5d] + 0x10 + (ulong)local_88 * 0x18) = 1;
*(int8 *)((long)ppbVar21 + -8) = 0x1564d5;
cVar9 = _ma_write_keypage(local_b8,2,3);
if (cVar9 != '\0') goto LAB_00156195;
}
puVar22 = local_58;
if ((char)local_4c == '\0') {
*(int8 *)((long)ppbVar21 + -8) = 0x1564a3;
my_free(puVar22);
}
uVar13 = (uint)bVar10;
goto LAB_001561f5;
}
local_50 = 4;
pcVar4 = *(code **)(lVar18 + 0xd8);
*(int8 *)((long)ppbVar21 + -8) = 0x1563b6;
iVar11 = (*pcVar4)(puVar5,local_b8,4,&local_48,pbVar23,&local_39);
}
puVar22 = local_48;
if (iVar11 == 0x7fffffff) {
*(int8 *)((long)ppbVar21 + -8) = 0x1561e7;
puVar16 = (int4 *)_my_thread_var();
*puVar16 = 0x7e;
goto LAB_00156195;
}
if (local_39 == '\0') {
param_7 = '\0';
}
*(int8 *)((long)ppbVar21 + -8) = 0x156277;
lVar18 = _ma_kpos(local_90,puVar22);
puVar22 = local_48;
uVar8 = local_50;
if (lVar18 == -1) {
LAB_001562ad:
puVar22 = local_48;
uVar6 = local_68;
*(ulong *)((long)ppbVar21 + -8) = (ulong)(uint)(int)param_7;
*(int8 *)((long)ppbVar21 + -0x10) = local_70;
*(int8 *)((long)ppbVar21 + -0x18) = 0x1562ce;
uVar13 = _ma_insert(param_1,puVar5,local_b8,puVar22,pbVar23,uVar6);
if (-1 < (int)uVar13) {
*(int1 *)(param_1[0x5d] + 0x10 + (ulong)local_88 * 0x18) = 1;
*(int8 *)((long)ppbVar21 + -8) = 0x156306;
cVar9 = _ma_write_keypage(local_b8,2,3);
if (cVar9 == '\0') goto LAB_00156360;
}
goto LAB_00156195;
}
*(ulong *)((long)ppbVar21 + -0x10) = (ulong)(uint)(int)param_7;
*(int8 *)((long)ppbVar21 + -0x18) = 0x1562a1;
uVar13 = w_search(param_1,uVar8,puVar5,lVar18,local_b8,puVar22);
if (0 < (int)uVar13) goto LAB_001562ad;
LAB_00156360:
puVar22 = local_58;
}
else {
LAB_00156195:
uVar13 = 0xffffffff;
puVar22 = local_58;
}
local_58 = puVar22;
if ((char)local_4c == '\0') {
*(int8 *)((long)ppbVar21 + -8) = 0x1561aa;
my_free(puVar22);
}
LAB_001561f5:
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return uVar13;
}
/* WARNING: Subroutine does not return */
*(code **)((long)ppbVar21 + -8) = _ma_enlarge_root;
__stack_chk_fail();
}
| |
47,274 | ggml_win_unpart | monkey531[P]llama/ggml/src/ggml.c | struct ggml_tensor * ggml_win_unpart(
struct ggml_context * ctx,
struct ggml_tensor * a,
int w0,
int h0,
int w) {
GGML_ASSERT(a->type == GGML_TYPE_F32);
const int64_t ne[4] = { a->ne[0], w0, h0, 1, };
struct ggml_tensor * result = ggml_new_tensor(ctx, GGML_TYPE_F32, 3, ne);
int32_t params[] = { w };
ggml_set_op_params(result, params, sizeof(params));
result->op = GGML_OP_WIN_UNPART;
result->src[0] = a;
return result;
} | O1 | c | ggml_win_unpart:
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpl $0x0, (%rsi)
jne 0x1e8eb
movl %r8d, %ebx
movq %rsi, %r14
movq 0x10(%rsi), %rsi
movq %rsp, %rax
movq %rsi, (%rax)
movslq %edx, %rdx
movq %rdx, 0x8(%rax)
movslq %ecx, %rcx
movq %rcx, 0x10(%rax)
movq $0x1, 0x18(%rax)
xorl %esi, %esi
movl $0x3, %edx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x19c80
testq %rax, %rax
je 0x1e907
movl %ebx, 0x54(%rax)
movl $0x42, 0x50(%rax)
movq %r14, 0x98(%rax)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x2bd1d(%rip), %rdi # 0x4a60f
leaq 0x2bd60(%rip), %rdx # 0x4a659
leaq 0x2c44a(%rip), %rcx # 0x4ad4a
movl $0x11ca, %esi # imm = 0x11CA
jmp 0x1e921
leaq 0x2dd99(%rip), %rdi # 0x4c6a7
leaq 0x2bd44(%rip), %rdx # 0x4a659
leaq 0x2ddda(%rip), %rcx # 0x4c6f6
movl $0x70, %esi
xorl %eax, %eax
callq 0x17c70
| ggml_win_unpart:
push r14
push rbx
sub rsp, 28h
cmp dword ptr [rsi], 0
jnz short loc_1E8EB
mov ebx, r8d
mov r14, rsi
mov rsi, [rsi+10h]
mov rax, rsp
mov [rax], rsi
movsxd rdx, edx
mov [rax+8], rdx
movsxd rcx, ecx
mov [rax+10h], rcx
mov qword ptr [rax+18h], 1
xor esi, esi
mov edx, 3
mov rcx, rax
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
test rax, rax
jz short loc_1E907
mov [rax+54h], ebx
mov dword ptr [rax+50h], 42h ; 'B'
mov [rax+98h], r14
add rsp, 28h
pop rbx
pop r14
retn
loc_1E8EB:
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, 11CAh
jmp short loc_1E921
loc_1E907:
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_1E921:
xor eax, eax
call _ggml_abort
| long long ggml_win_unpart(long long a1, long long a2, int a3, int a4, int a5, int a6)
{
long long result; // rax
const char *v8; // rdi
const char *v9; // rcx
int v10; // esi
_QWORD v11[7]; // [rsp+0h] [rbp-38h] BYREF
if ( *(_DWORD *)a2 )
{
v8 = "/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml.c";
v9 = "a->type == GGML_TYPE_F32";
v10 = 4554;
goto LABEL_6;
}
v11[0] = *(_QWORD *)(a2 + 16);
v11[1] = a3;
v11[2] = a4;
v11[3] = 1LL;
result = ggml_new_tensor_impl(a1, 0, 3, v11, 0LL, 0LL);
if ( !result )
{
v8 = "/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml-impl.h";
v9 = "tensor != NULL";
v10 = 112;
LABEL_6:
ggml_abort((_DWORD)v8, v10, (unsigned int)"GGML_ASSERT(%s) failed", (_DWORD)v9, a5, a6);
}
*(_DWORD *)(result + 84) = a5;
*(_DWORD *)(result + 80) = 66;
*(_QWORD *)(result + 152) = a2;
return result;
}
| ggml_win_unpart:
PUSH R14
PUSH RBX
SUB RSP,0x28
CMP dword ptr [RSI],0x0
JNZ 0x0011e8eb
MOV EBX,R8D
MOV R14,RSI
MOV RSI,qword ptr [RSI + 0x10]
MOV RAX,RSP
MOV qword ptr [RAX],RSI
MOVSXD RDX,EDX
MOV qword ptr [RAX + 0x8],RDX
MOVSXD RCX,ECX
MOV qword ptr [RAX + 0x10],RCX
MOV qword ptr [RAX + 0x18],0x1
XOR ESI,ESI
MOV EDX,0x3
MOV RCX,RAX
XOR R8D,R8D
XOR R9D,R9D
CALL 0x00119c80
TEST RAX,RAX
JZ 0x0011e907
MOV dword ptr [RAX + 0x54],EBX
MOV dword ptr [RAX + 0x50],0x42
MOV qword ptr [RAX + 0x98],R14
ADD RSP,0x28
POP RBX
POP R14
RET
LAB_0011e8eb:
LEA RDI,[0x14a60f]
LEA RDX,[0x14a659]
LEA RCX,[0x14ad4a]
MOV ESI,0x11ca
JMP 0x0011e921
LAB_0011e907:
LEA RDI,[0x14c6a7]
LEA RDX,[0x14a659]
LEA RCX,[0x14c6f6]
MOV ESI,0x70
LAB_0011e921:
XOR EAX,EAX
CALL 0x00117c70
|
void ggml_win_unpart(int8 param_1,int *param_2,int param_3,int param_4,int4 param_5)
{
long lVar1;
char *pcVar2;
int8 uVar3;
char *pcVar4;
int8 local_38;
long local_30;
long local_28;
int8 local_20;
if (*param_2 == 0) {
local_38 = *(int8 *)(param_2 + 4);
local_30 = (long)param_3;
local_28 = (long)param_4;
local_20 = 1;
lVar1 = ggml_new_tensor_impl(param_1,0,3,&local_38,0,0);
if (lVar1 != 0) {
*(int4 *)(lVar1 + 0x54) = param_5;
*(int4 *)(lVar1 + 0x50) = 0x42;
*(int **)(lVar1 + 0x98) = param_2;
return;
}
pcVar4 = "/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml-impl.h";
pcVar2 = "tensor != NULL";
uVar3 = 0x70;
}
else {
pcVar4 = "/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml.c";
pcVar2 = "a->type == GGML_TYPE_F32";
uVar3 = 0x11ca;
}
/* WARNING: Subroutine does not return */
ggml_abort(pcVar4,uVar3,"GGML_ASSERT(%s) failed",pcVar2);
}
| |
47,275 | mysql_stmt_attr_get@libmariadbclient_18 | eloqsql/libmariadb/libmariadb/mariadb_stmt.c | my_bool STDCALL mysql_stmt_attr_get(MYSQL_STMT *stmt, enum enum_stmt_attr_type attr_type, void *value)
{
switch (attr_type) {
case STMT_ATTR_STATE:
*(enum mysql_stmt_state *)value= stmt->state;
break;
case STMT_ATTR_UPDATE_MAX_LENGTH:
*(my_bool *)value= stmt->update_max_length;
break;
case STMT_ATTR_CURSOR_TYPE:
*(unsigned long *)value= stmt->flags;
break;
case STMT_ATTR_PREFETCH_ROWS:
*(unsigned long *)value= stmt->prefetch_rows;
break;
case STMT_ATTR_PREBIND_PARAMS:
*(unsigned int *)value= stmt->prebind_params;
break;
case STMT_ATTR_ARRAY_SIZE:
*(unsigned int *)value= stmt->array_size;
break;
case STMT_ATTR_ROW_SIZE:
*(size_t *)value= stmt->row_size;
break;
case STMT_ATTR_CB_USER_DATA:
*((void **)value) = stmt->user_data;
break;
default:
return(1);
}
return(0);
} | O3 | c | mysql_stmt_attr_get@libmariadbclient_18:
pushq %rbp
movq %rsp, %rbp
movb $0x1, %al
cmpl $0xc7, %esi
jle 0x28761
addl $0xffffff38, %esi # imm = 0xFFFFFF38
cmpl $0x4, %esi
ja 0x287ac
leaq 0x131c4(%rip), %rax # 0x3b914
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl 0x378(%rdi), %eax
jmp 0x287a8
testl %esi, %esi
je 0x28778
cmpl $0x1, %esi
je 0x28794
cmpl $0x2, %esi
jne 0x287ac
movq 0x318(%rdi), %rax
jmp 0x28798
movb 0x313(%rdi), %al
movb %al, (%rdx)
jmp 0x287aa
movq 0x380(%rdi), %rax
jmp 0x28798
movq 0x370(%rdi), %rax
jmp 0x28798
movq 0x48(%rdi), %rax
movq %rax, (%rdx)
jmp 0x287aa
movl 0x50(%rdi), %eax
jmp 0x287a8
movl 0x368(%rdi), %eax
movl %eax, (%rdx)
xorl %eax, %eax
popq %rbp
retq
| mysql_stmt_attr_get@libmariadbclient_18:
push rbp; Alternative name is 'mysql_stmt_attr_get'
mov rbp, rsp
mov al, 1
cmp esi, 0C7h
jle short loc_28761
add esi, 0FFFFFF38h; switch 5 cases
cmp esi, 4
ja short def_28757; jumptable 0000000000028757 default case
lea rax, jpt_28757
movsxd rcx, ds:(jpt_28757 - 3B914h)[rax+rsi*4]
add rcx, rax
jmp rcx; switch jump
loc_28759:
mov eax, [rdi+378h]; jumptable 0000000000028757 case 200
jmp short loc_287A8
loc_28761:
test esi, esi
jz short loc_28778
cmp esi, 1
jz short loc_28794
cmp esi, 2
jnz short def_28757; jumptable 0000000000028757 default case
mov rax, [rdi+318h]
jmp short loc_28798
loc_28778:
mov al, [rdi+313h]
mov [rdx], al
jmp short loc_287AA
loc_28782:
mov rax, [rdi+380h]; jumptable 0000000000028757 case 204
jmp short loc_28798
loc_2878B:
mov rax, [rdi+370h]; jumptable 0000000000028757 case 202
jmp short loc_28798
loc_28794:
mov rax, [rdi+48h]
loc_28798:
mov [rdx], rax
jmp short loc_287AA
loc_2879D:
mov eax, [rdi+50h]; jumptable 0000000000028757 case 203
jmp short loc_287A8
loc_287A2:
mov eax, [rdi+368h]; jumptable 0000000000028757 case 201
loc_287A8:
mov [rdx], eax
loc_287AA:
xor eax, eax
def_28757:
pop rbp; jumptable 0000000000028757 default case
retn
| char mysql_stmt_attr_get_libmariadbclient_18(long long a1, int a2, _DWORD *a3)
{
char result; // al
int v4; // eax
long long v5; // rax
result = 1;
if ( a2 > 199 )
{
switch ( a2 )
{
case 200:
v4 = *(_DWORD *)(a1 + 888);
goto LABEL_15;
case 201:
v4 = *(_DWORD *)(a1 + 872);
goto LABEL_15;
case 202:
v5 = *(_QWORD *)(a1 + 880);
goto LABEL_12;
case 203:
v4 = *(_DWORD *)(a1 + 80);
LABEL_15:
*a3 = v4;
return 0;
case 204:
v5 = *(_QWORD *)(a1 + 896);
goto LABEL_12;
default:
return result;
}
}
if ( a2 )
{
if ( a2 == 1 )
{
v5 = *(_QWORD *)(a1 + 72);
}
else
{
if ( a2 != 2 )
return result;
v5 = *(_QWORD *)(a1 + 792);
}
LABEL_12:
*(_QWORD *)a3 = v5;
}
else
{
*(_BYTE *)a3 = *(_BYTE *)(a1 + 787);
}
return 0;
}
| mysql_stmt_attr_get:
PUSH RBP
MOV RBP,RSP
MOV AL,0x1
CMP ESI,0xc7
JLE 0x00128761
ADD ESI,0xffffff38
CMP ESI,0x4
JA 0x001287ac
LEA RAX,[0x13b914]
MOVSXD RCX,dword ptr [RAX + RSI*0x4]
ADD RCX,RAX
switchD:
JMP RCX
caseD_c8:
MOV EAX,dword ptr [RDI + 0x378]
JMP 0x001287a8
LAB_00128761:
TEST ESI,ESI
JZ 0x00128778
CMP ESI,0x1
JZ 0x00128794
CMP ESI,0x2
JNZ 0x001287ac
MOV RAX,qword ptr [RDI + 0x318]
JMP 0x00128798
LAB_00128778:
MOV AL,byte ptr [RDI + 0x313]
MOV byte ptr [RDX],AL
JMP 0x001287aa
caseD_cc:
MOV RAX,qword ptr [RDI + 0x380]
JMP 0x00128798
caseD_ca:
MOV RAX,qword ptr [RDI + 0x370]
JMP 0x00128798
LAB_00128794:
MOV RAX,qword ptr [RDI + 0x48]
LAB_00128798:
MOV qword ptr [RDX],RAX
JMP 0x001287aa
caseD_cb:
MOV EAX,dword ptr [RDI + 0x50]
JMP 0x001287a8
caseD_c9:
MOV EAX,dword ptr [RDI + 0x368]
LAB_001287a8:
MOV dword ptr [RDX],EAX
LAB_001287aa:
XOR EAX,EAX
default:
POP RBP
RET
|
int8 mysql_stmt_attr_get(long param_1,int param_2,int8 *param_3)
{
int4 uVar1;
int8 uVar2;
uVar2 = 1;
if (param_2 < 200) {
if (param_2 != 0) {
if (param_2 == 1) {
uVar2 = *(int8 *)(param_1 + 0x48);
}
else {
if (param_2 != 2) {
return 1;
}
uVar2 = *(int8 *)(param_1 + 0x318);
}
goto LAB_00128798;
}
*(int1 *)param_3 = *(int1 *)(param_1 + 0x313);
goto LAB_001287aa;
}
switch(param_2) {
case 200:
uVar1 = *(int4 *)(param_1 + 0x378);
break;
case 0xc9:
uVar1 = *(int4 *)(param_1 + 0x368);
break;
case 0xca:
uVar2 = *(int8 *)(param_1 + 0x370);
goto LAB_00128798;
case 0xcb:
uVar1 = *(int4 *)(param_1 + 0x50);
break;
case 0xcc:
uVar2 = *(int8 *)(param_1 + 0x380);
LAB_00128798:
*param_3 = uVar2;
goto LAB_001287aa;
default:
goto switchD_00128757_default;
}
*(int4 *)param_3 = uVar1;
LAB_001287aa:
uVar2 = 0;
switchD_00128757_default:
return uVar2;
}
| |
47,276 | my_strcasecmp_utf8mb4 | eloqsql/strings/ctype-utf8.c | static int
my_strcasecmp_utf8mb4(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= my_mb_wc_utf8mb4_no_range(cs, &s_wc, (const uchar*) s);
/*
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;
my_tolower_utf8mb4(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_mb_wc_utf8mb4_no_range(cs, &t_wc, (const uchar*) t);
if (res <= 0)
return strcmp(s, t);
t+= res;
my_tolower_utf8mb4(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]);
} | O3 | c | my_strcasecmp_utf8mb4:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movb (%rsi), %al
testb %al, %al
je 0xd47d9
movq %rsi, %r14
movq 0x78(%rdi), %r15
leaq 0x30a51c(%rip), %r12 # 0x3dec20
cmpb $0x0, (%rbx)
je 0xd47d3
testb %al, %al
js 0xd4726
movzbl %al, %eax
leaq (%rax,%rax,2), %rax
movl 0x4(%r12,%rax,4), %r13d
movq %r13, -0x30(%rbp)
incq %r14
jmp 0xd476d
leaq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0xd4293
testl %eax, %eax
je 0xd47f9
movl %eax, %eax
addq %rax, %r14
movq -0x30(%rbp), %r13
cmpq (%r15), %r13
ja 0xd476d
movq 0x8(%r15), %rax
movq %r13, %rcx
shrq $0x8, %rcx
movq (%rax,%rcx,8), %rax
testq %rax, %rax
je 0xd476d
movzbl %r13b, %ecx
leaq (%rcx,%rcx,2), %rcx
movl 0x4(%rax,%rcx,4), %r13d
movq %r13, -0x30(%rbp)
movsbq (%rbx), %rax
testq %rax, %rax
js 0xd4784
leaq (%rax,%rax,2), %rax
movl 0x4(%r12,%rax,4), %eax
incq %rbx
jmp 0xd47c1
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0xd4293
testl %eax, %eax
je 0xd47f9
movl %eax, %eax
addq %rax, %rbx
movq -0x38(%rbp), %rax
cmpq (%r15), %rax
ja 0xd47c1
movq 0x8(%r15), %rcx
movq %rax, %rdx
shrq $0x8, %rdx
movq (%rcx,%rdx,8), %rcx
testq %rcx, %rcx
je 0xd47c1
movzbl %al, %eax
leaq (%rax,%rax,2), %rax
movl 0x4(%rcx,%rax,4), %eax
cmpq %rax, %r13
jne 0xd47f4
movb (%r14), %al
testb %al, %al
jne 0xd4704
xorl %eax, %eax
movzbl %al, %r13d
jmp 0xd47dc
xorl %r13d, %r13d
movzbl (%rbx), %eax
subl %eax, %r13d
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
subl %eax, %r13d
jmp 0xd47e2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2a690
movl %eax, %r13d
jmp 0xd47e2
| my_strcasecmp_utf8mb4:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdx
mov al, [rsi]
test al, al
jz loc_D47D9
mov r14, rsi
mov r15, [rdi+78h]
lea r12, my_unicase_default_page00
loc_D4704:
cmp byte ptr [rbx], 0
jz loc_D47D3
test al, al
js short loc_D4726
movzx eax, al
lea rax, [rax+rax*2]
mov r13d, [r12+rax*4+4]
mov [rbp+var_30], r13
inc r14
jmp short loc_D476D
loc_D4726:
lea rdi, [rbp+var_30]
mov rsi, r14
call my_mb_wc_utf8mb4_no_range
test eax, eax
jz loc_D47F9
mov eax, eax
add r14, rax
mov r13, [rbp+var_30]
cmp r13, [r15]
ja short loc_D476D
mov rax, [r15+8]
mov rcx, r13
shr rcx, 8
mov rax, [rax+rcx*8]
test rax, rax
jz short loc_D476D
movzx ecx, r13b
lea rcx, [rcx+rcx*2]
mov r13d, [rax+rcx*4+4]
mov [rbp+var_30], r13
loc_D476D:
movsx rax, byte ptr [rbx]
test rax, rax
js short loc_D4784
lea rax, [rax+rax*2]
mov eax, [r12+rax*4+4]
inc rbx
jmp short loc_D47C1
loc_D4784:
lea rdi, [rbp+var_38]
mov rsi, rbx
call my_mb_wc_utf8mb4_no_range
test eax, eax
jz short loc_D47F9
mov eax, eax
add rbx, rax
mov rax, [rbp+var_38]
cmp rax, [r15]
ja short loc_D47C1
mov rcx, [r15+8]
mov rdx, rax
shr rdx, 8
mov rcx, [rcx+rdx*8]
test rcx, rcx
jz short loc_D47C1
movzx eax, al
lea rax, [rax+rax*2]
mov eax, [rcx+rax*4+4]
loc_D47C1:
cmp r13, rax
jnz short loc_D47F4
mov al, [r14]
test al, al
jnz loc_D4704
xor eax, eax
loc_D47D3:
movzx r13d, al
jmp short loc_D47DC
loc_D47D9:
xor r13d, r13d
loc_D47DC:
movzx eax, byte ptr [rbx]
sub r13d, eax
loc_D47E2:
mov eax, r13d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_D47F4:
sub r13d, eax
jmp short loc_D47E2
loc_D47F9:
mov rdi, r14
mov rsi, rbx
call _strcmp
mov r13d, eax
jmp short loc_D47E2
| long long my_strcasecmp_utf8mb4(long long a1, unsigned __int8 *a2, unsigned __int8 *a3)
{
unsigned __int8 v4; // al
unsigned __int8 *v5; // r14
_QWORD *v6; // r15
unsigned long long v7; // r13
unsigned int v8; // eax
long long v9; // rax
long long v10; // rax
unsigned long long v11; // rax
unsigned int v12; // eax
long long v13; // rcx
int v14; // r13d
unsigned long long v17; // [rsp+8h] [rbp-38h] BYREF
unsigned long long v18[6]; // [rsp+10h] [rbp-30h] BYREF
v4 = *a2;
if ( *a2 )
{
v5 = a2;
v6 = *(_QWORD **)(a1 + 120);
while ( 1 )
{
if ( !*a3 )
goto LABEL_19;
if ( (v4 & 0x80u) != 0 )
{
v8 = my_mb_wc_utf8mb4_no_range(v18, v5);
if ( !v8 )
return (unsigned int)strcmp(v5, a3);
v5 += v8;
v7 = v18[0];
if ( v18[0] <= *v6 )
{
v9 = *(_QWORD *)(v6[1] + 8 * (v18[0] >> 8));
if ( v9 )
{
v7 = *(unsigned int *)(v9 + 12LL * LOBYTE(v18[0]) + 4);
v18[0] = v7;
}
}
}
else
{
v7 = (unsigned int)my_unicase_default_page00[3 * v4 + 1];
v18[0] = v7;
++v5;
}
v10 = (char)*a3;
if ( v10 < 0 )
{
v12 = my_mb_wc_utf8mb4_no_range(&v17, a3);
if ( !v12 )
return (unsigned int)strcmp(v5, a3);
a3 += v12;
v11 = v17;
if ( v17 <= *v6 )
{
v13 = *(_QWORD *)(v6[1] + 8 * (v17 >> 8));
if ( v13 )
v11 = *(unsigned int *)(v13 + 12LL * (unsigned __int8)v17 + 4);
}
}
else
{
v11 = (unsigned int)my_unicase_default_page00[3 * v10 + 1];
++a3;
}
if ( v7 != v11 )
return (unsigned int)(v7 - v11);
v4 = *v5;
if ( !*v5 )
{
v4 = 0;
LABEL_19:
v14 = v4;
return (unsigned int)(v14 - *a3);
}
}
}
v14 = 0;
return (unsigned int)(v14 - *a3);
}
| my_strcasecmp_utf8mb4:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDX
MOV AL,byte ptr [RSI]
TEST AL,AL
JZ 0x001d47d9
MOV R14,RSI
MOV R15,qword ptr [RDI + 0x78]
LEA R12,[0x4dec20]
LAB_001d4704:
CMP byte ptr [RBX],0x0
JZ 0x001d47d3
TEST AL,AL
JS 0x001d4726
MOVZX EAX,AL
LEA RAX,[RAX + RAX*0x2]
MOV R13D,dword ptr [R12 + RAX*0x4 + 0x4]
MOV qword ptr [RBP + -0x30],R13
INC R14
JMP 0x001d476d
LAB_001d4726:
LEA RDI,[RBP + -0x30]
MOV RSI,R14
CALL 0x001d4293
TEST EAX,EAX
JZ 0x001d47f9
MOV EAX,EAX
ADD R14,RAX
MOV R13,qword ptr [RBP + -0x30]
CMP R13,qword ptr [R15]
JA 0x001d476d
MOV RAX,qword ptr [R15 + 0x8]
MOV RCX,R13
SHR RCX,0x8
MOV RAX,qword ptr [RAX + RCX*0x8]
TEST RAX,RAX
JZ 0x001d476d
MOVZX ECX,R13B
LEA RCX,[RCX + RCX*0x2]
MOV R13D,dword ptr [RAX + RCX*0x4 + 0x4]
MOV qword ptr [RBP + -0x30],R13
LAB_001d476d:
MOVSX RAX,byte ptr [RBX]
TEST RAX,RAX
JS 0x001d4784
LEA RAX,[RAX + RAX*0x2]
MOV EAX,dword ptr [R12 + RAX*0x4 + 0x4]
INC RBX
JMP 0x001d47c1
LAB_001d4784:
LEA RDI,[RBP + -0x38]
MOV RSI,RBX
CALL 0x001d4293
TEST EAX,EAX
JZ 0x001d47f9
MOV EAX,EAX
ADD RBX,RAX
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [R15]
JA 0x001d47c1
MOV RCX,qword ptr [R15 + 0x8]
MOV RDX,RAX
SHR RDX,0x8
MOV RCX,qword ptr [RCX + RDX*0x8]
TEST RCX,RCX
JZ 0x001d47c1
MOVZX EAX,AL
LEA RAX,[RAX + RAX*0x2]
MOV EAX,dword ptr [RCX + RAX*0x4 + 0x4]
LAB_001d47c1:
CMP R13,RAX
JNZ 0x001d47f4
MOV AL,byte ptr [R14]
TEST AL,AL
JNZ 0x001d4704
XOR EAX,EAX
LAB_001d47d3:
MOVZX R13D,AL
JMP 0x001d47dc
LAB_001d47d9:
XOR R13D,R13D
LAB_001d47dc:
MOVZX EAX,byte ptr [RBX]
SUB R13D,EAX
LAB_001d47e2:
MOV EAX,R13D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001d47f4:
SUB R13D,EAX
JMP 0x001d47e2
LAB_001d47f9:
MOV RDI,R14
MOV RSI,RBX
CALL 0x0012a690
MOV R13D,EAX
JMP 0x001d47e2
|
int my_strcasecmp_utf8mb4(long param_1,byte *param_2,byte *param_3)
{
ulong *puVar1;
long lVar2;
ulong uVar3;
byte bVar4;
uint uVar5;
int iVar6;
ulong uVar7;
ulong local_40;
ulong local_38;
bVar4 = *param_2;
if (bVar4 == 0) {
uVar5 = 0;
}
else {
puVar1 = *(ulong **)(param_1 + 0x78);
do {
if (*param_3 == 0) goto LAB_001d47d3;
if ((char)bVar4 < '\0') {
uVar5 = my_mb_wc_utf8mb4_no_range(&local_38,param_2);
if (uVar5 == 0) goto LAB_001d47f9;
param_2 = param_2 + uVar5;
if ((local_38 <= *puVar1) &&
(lVar2 = *(long *)(puVar1[1] + (local_38 >> 8) * 8), lVar2 != 0)) {
local_38 = (ulong)*(uint *)(lVar2 + 4 + (local_38 & 0xff) * 0xc);
}
}
else {
local_38 = (ulong)*(uint *)(my_unicase_default_page00 + (ulong)bVar4 * 0xc + 4);
param_2 = param_2 + 1;
}
uVar3 = local_38;
bVar4 = *param_3;
if ((long)(char)bVar4 < 0) {
uVar5 = my_mb_wc_utf8mb4_no_range(&local_40,param_3);
if (uVar5 == 0) {
LAB_001d47f9:
iVar6 = strcmp((char *)param_2,(char *)param_3);
return iVar6;
}
param_3 = param_3 + uVar5;
uVar7 = local_40;
if ((local_40 <= *puVar1) &&
(lVar2 = *(long *)(puVar1[1] + (local_40 >> 8) * 8), lVar2 != 0)) {
uVar7 = (ulong)*(uint *)(lVar2 + 4 + (local_40 & 0xff) * 0xc);
}
}
else {
param_3 = param_3 + 1;
uVar7 = (ulong)*(uint *)(my_unicase_default_page00 + (long)(char)bVar4 * 0xc + 4);
}
if (uVar3 != uVar7) {
return (int)uVar3 - (int)uVar7;
}
bVar4 = *param_2;
} while (bVar4 != 0);
bVar4 = 0;
LAB_001d47d3:
uVar5 = (uint)bVar4;
}
return uVar5 - *param_3;
}
| |
47,277 | 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>::get_ref_impl<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> 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> const&) | monkey531[P]llama/common/json.hpp | static ReferenceType get_ref_impl(ThisType& obj)
{
// delegate the call to get_ptr<>()
auto* ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
if (JSON_HEDLEY_LIKELY(ptr != nullptr))
{
return *ptr;
}
JSON_THROW(type_error::create(303, detail::concat("incompatible ReferenceType for get_ref, actual type is ", obj.type_name()), &obj));
} | O1 | cpp | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> 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>::get_ref_impl<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> 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> const&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
cmpb $0x3, (%rdi)
jne 0xb4140
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xb4140
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x1b430
movq %rax, %rbx
movq %r14, %rdi
callq 0x60036
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x3ff00(%rip), %rsi # 0xf4064
leaq 0x10(%rsp), %rdi
callq 0xb41d9
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x12f, %esi # imm = 0x12F
movq %r14, %rcx
callq 0x883c0
xorl %ebp, %ebp
leaq 0x78d89(%rip), %rsi # 0x12cf18
leaq -0x5801e(%rip), %rdx # 0x5c178
movq %rbx, %rdi
callq 0x1bf20
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb41c4
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1b8e0
jmp 0xb41c4
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xb41d1
movq %rbx, %rdi
callq 0x1b670
movq %r14, %rdi
callq 0x1bfb0
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE12get_ref_implIRKS9_KSD_EET_RT0_:
push rbp; char
push r14; int
push rbx; __int64
sub rsp, 30h
mov r14, rdi
cmp byte ptr [rdi], 3
jnz short loc_B4140
mov rax, [r14+8]
test rax, rax
jz short loc_B4140
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_B4140:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aIncompatibleRe; "incompatible ReferenceType for get_ref,"...
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA56_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[56],char const*>(char const(&)[56],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 12Fh; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_B41C4
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_B41C4
mov r14, rax
mov bpl, 1
loc_B41C4:
test bpl, bpl
jz short loc_B41D1
mov rdi, rbx; void *
call ___cxa_free_exception
loc_B41D1:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::get_ref_impl<std::string 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> const>(
long long a1)
{
long long result; // rax
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
_QWORD v3[2]; // [rsp+10h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 != 3 || (result = *(_QWORD *)(a1 + 8)) == 0 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[56],char const*>(
v3,
"incompatible ReferenceType for get_ref, actual type is ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
exception,
303,
v3);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return result;
}
| get_ref_impl<std::__cxx11::string_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>const>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RDI
CMP byte ptr [RDI],0x3
JNZ 0x001b4140
MOV RAX,qword ptr [R14 + 0x8]
TEST RAX,RAX
JZ 0x001b4140
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_001b4140:
MOV EDI,0x20
CALL 0x0011b430
MOV RBX,RAX
MOV RDI,R14
CALL 0x00160036
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_001b415d:
LEA RSI,[0x1f4064]
LEA RDI,[RSP + 0x10]
CALL 0x001b41d9
MOV BPL,0x1
LAB_001b4171:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x12f
MOV RCX,R14
CALL 0x001883c0
XOR EBP,EBP
LEA RSI,[0x22cf18]
LEA RDX,[0x15c178]
MOV RDI,RBX
CALL 0x0011bf20
|
/* 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>::get_ref_impl<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>
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> const&) */
string * nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::
get_ref_impl<std::__cxx11::string_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>const>
(basic_json *param_1)
{
int8 uVar1;
char *local_40;
detail local_38 [32];
if ((*param_1 == (basic_json)0x3) && (*(string **)(param_1 + 8) != (string *)0x0)) {
return *(string **)(param_1 + 8);
}
uVar1 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)param_1);
/* try { // try from 001b415d to 001b416d has its CatchHandler @ 001b41be */
detail::concat<std::__cxx11::string,char_const(&)[56],char_const*>
(local_38,"incompatible ReferenceType for get_ref, actual type is ",&local_40);
/* try { // try from 001b4171 to 001b419d has its CatchHandler @ 001b419e */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar1,0x12f,local_38,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::type_error::typeinfo,detail::exception::~exception);
}
| |
47,278 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [29], char const*>(char const (&) [29], char const*&&) | monkey531[P]llama/common/json.hpp | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | O1 | cpp | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [29], char const*>(char const (&) [29], char const*&&):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x1a3d0
movq %rax, %r12
movq (%r14), %rdi
callq 0x1a3d0
addq %rax, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1ad50
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1b0c0
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x1b0c0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x86999
movq (%r13), %rsi
incq %rsi
callq 0x1a8b0
movq %r14, %rdi
callq 0x1af70
nop
| _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA29_KcPS9_EEET_DpOT0_:
push r15
push r14
push r13
push r12
push rbx
mov r14, rdx
mov r15, rsi
mov rbx, rdi
lea r13, [rdi+10h]
mov [rdi], r13
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rdi, rsi
call _strlen
mov r12, rax
mov rdi, [r14]
call _strlen
add r12, rax
mov rdi, rbx
mov rsi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
mov rdi, rbx
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rsi, [r14]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rax, rbx
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov r14, rax
mov rdi, [rbx]; void *
cmp rdi, r13
jz short loc_86999
mov rsi, [r13+0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_86999:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(
long long a1,
long long a2,
_QWORD *a3)
{
long long v4; // r12
long long v5; // rax
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v4 = strlen(a2);
v5 = strlen(*a3);
std::string::reserve(a1, v5 + v4);
std::string::append(a1, a2);
std::string::append(a1, *a3);
return a1;
}
| concat<std::__cxx11::string,char_const(&)[29],char_const*>:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
LEA R13,[RDI + 0x10]
MOV qword ptr [RDI],R13
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
MOV RDI,RSI
CALL 0x0011a3d0
MOV R12,RAX
MOV RDI,qword ptr [R14]
CALL 0x0011a3d0
ADD R12,RAX
LAB_00186954:
MOV RDI,RBX
MOV RSI,R12
CALL 0x0011ad50
MOV RDI,RBX
MOV RSI,R15
CALL 0x0011b0c0
MOV RSI,qword ptr [R14]
MOV RDI,RBX
CALL 0x0011b0c0
LAB_00186975:
MOV RAX,RBX
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* std::__cxx11::string nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string, char const
(&) [29], char const*>(char const (&) [29], char const*&&) */
detail * __thiscall
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[29],char_const*>
(detail *this,char *param_1,char **param_2)
{
*(detail **)this = this + 0x10;
*(int8 *)(this + 8) = 0;
this[0x10] = (detail)0x0;
strlen(param_1);
strlen(*param_2);
/* try { // try from 00186954 to 00186974 has its CatchHandler @ 00186982 */
std::__cxx11::string::reserve((ulong)this);
std::__cxx11::string::append((char *)this);
std::__cxx11::string::append((char *)this);
return this;
}
| |
47,279 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [29], char const*>(char const (&) [29], char const*&&) | monkey531[P]llama/common/json.hpp | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | O2 | cpp | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [29], char const*>(char const (&) [29], char const*&&):
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x41a97
movq %rbx, %rdi
movq %rax, %rsi
callq 0x23d60
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x873fa
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x241a8
movq %r14, %rdi
callq 0x23f70
| _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA39_KcS8_EEET_DpOT0_:
push r15
push r14
push rbx
mov r14, rdx
mov r15, rsi
mov rbx, rdi
lea rax, [rdi+10h]
mov [rdi], rax
and qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rdi, rsi
mov rsi, rdx
call _ZN8nlohmann16json_abi_v3_11_36detail13concat_lengthIJNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEEmPKcDpRKT_; nlohmann::json_abi_v3_11_3::detail::concat_length<std::string>(char const*,std::string const&)
mov rdi, rbx
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail11concat_intoINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA39_KcJS8_ETnNSt9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSD_OSE_DpOT1_
mov rax, rbx
pop rbx
pop r14
pop r15
retn
mov r14, rax
mov rdi, rbx; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[39],std::string>(
long long a1,
long long a2,
long long a3)
{
long long v4; // rax
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v4 = nlohmann::json_abi_v3_11_3::detail::concat_length<std::string>(a2, a3);
std::string::reserve(a1, v4);
ZN8nlohmann16json_abi_v3_11_36detail11concat_intoINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA39_KcJS8_ETnNSt9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSD_OSE_DpOT1_(
a1,
a2,
a3);
return a1;
}
| concat<std::__cxx11::string,char_const(&)[39],std::__cxx11::string>:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
AND qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
LAB_001872f3:
MOV RDI,RSI
MOV RSI,RDX
CALL 0x00141a97
MOV RDI,RBX
MOV RSI,RAX
CALL 0x00123d60
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x001873fa
LAB_00187317:
MOV RAX,RBX
POP RBX
POP R14
POP R15
RET
|
/* std::__cxx11::string nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string, char const
(&) [39], std::__cxx11::string >(char const (&) [39], std::__cxx11::string&&) */
detail * __thiscall
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,char_const(&)[39],std::__cxx11::string>
(detail *this,char *param_1,string *param_2)
{
*(detail **)this = this + 0x10;
*(int8 *)(this + 8) = 0;
this[0x10] = (detail)0x0;
/* try { // try from 001872f3 to 00187316 has its CatchHandler @ 00187320 */
concat_length<std::__cxx11::string>(param_1,param_2);
std::__cxx11::string::reserve((ulong)this);
_ZN8nlohmann16json_abi_v3_11_36detail11concat_intoINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA39_KcJS8_ETnNSt9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSD_OSE_DpOT1_
(this,param_1,param_2);
return this;
}
| |
47,280 | ma_get_last_key | eloqsql/storage/maria/ma_search.c | uchar *_ma_get_last_key(MARIA_KEY *key, MARIA_PAGE *ma_page, uchar *endpos)
{
uint page_flag,nod_flag;
uchar *lastpos, *page;
MARIA_KEYDEF *keyinfo= key->keyinfo;
DBUG_ENTER("_ma_get_last_key");
DBUG_PRINT("enter",("page: %p endpos: %p", ma_page->buff,
endpos));
page_flag= ma_page->flag;
nod_flag= ma_page->node;
page= ma_page->buff + keyinfo->share->keypage_header + nod_flag;
if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)) &&
! (page_flag & KEYPAGE_FLAG_HAS_TRANSID))
{
lastpos= endpos-keyinfo->keylength-nod_flag;
key->ref_length= keyinfo->share->rec_reflength;
key->data_length= keyinfo->keylength - key->ref_length;
key->flag= 0;
if (lastpos >= page)
bmove(key->data, lastpos, keyinfo->keylength + nod_flag);
}
else
{
lastpos= page;
key->data[0]=0; /* safety */
while (page < endpos)
{
lastpos= page;
if (!(*keyinfo->get_key)(key, page_flag, nod_flag, &page))
{
DBUG_PRINT("error",("Couldn't find last key: page: %p",
page));
_ma_set_fatal_error_with_share(keyinfo->share, HA_ERR_CRASHED);
DBUG_RETURN(0);
}
}
}
DBUG_PRINT("exit",("lastpos: %p length: %u", lastpos,
key->data_length + key->ref_length));
DBUG_RETURN(lastpos);
} | O3 | c | ma_get_last_key:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rbx
movl 0x28(%rsi), %r8d
movl 0x2c(%rsi), %edi
movq (%rbx), %rcx
movl 0x744(%rcx), %eax
addq 0x10(%rsi), %rax
addq %r8, %rax
movq %rax, -0x38(%rbp)
testb $0x28, 0xa2(%rbx)
sete %dl
movl %edi, -0x2c(%rbp)
testb $0x2, %dil
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x6df57
movzwl 0xaa(%rbx), %edx
subq %rdx, %r15
movq %r15, %r12
subq %r8, %r12
movl 0x740(%rcx), %ecx
movl %ecx, 0x14(%r14)
movzwl 0xaa(%rbx), %edx
subl %ecx, %edx
movl %edx, 0x10(%r14)
movl $0x0, 0x18(%r14)
cmpq %rax, %r12
jb 0x6dfa2
movq (%r14), %rdi
movzwl 0xaa(%rbx), %edx
addl %r8d, %edx
movq %r12, %rsi
callq 0x29110
jmp 0x6dfa2
movq (%r14), %rcx
movb $0x0, (%rcx)
cmpq %r15, %rax
jae 0x6df8d
movq %rax, %r12
movq %r14, %rdi
movl -0x2c(%rbp), %esi
movq %r8, %r13
movl %r8d, %edx
leaq -0x38(%rbp), %rcx
callq *0xe0(%rbx)
testl %eax, %eax
je 0x6df92
movq -0x38(%rbp), %rax
cmpq %r15, %rax
movq %r13, %r8
jb 0x6df62
jmp 0x6dfa2
movq %rax, %r12
jmp 0x6dfa2
movq (%rbx), %rdi
movl $0x7e, %esi
callq 0x3fc8a
xorl %r12d, %r12d
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ma_get_last_key:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r15, rdx
mov r14, rdi
mov rbx, [rdi+8]
mov r8d, [rsi+28h]
mov edi, [rsi+2Ch]
mov rcx, [rbx]
mov eax, [rcx+744h]
add rax, [rsi+10h]
add rax, r8
mov [rbp+var_38], rax
test byte ptr [rbx+0A2h], 28h
setz dl
mov [rbp+var_2C], edi
test dil, 2
setz sil
and sil, dl
cmp sil, 1
jnz short loc_6DF57
movzx edx, word ptr [rbx+0AAh]
sub r15, rdx
mov r12, r15
sub r12, r8
mov ecx, [rcx+740h]
mov [r14+14h], ecx
movzx edx, word ptr [rbx+0AAh]
sub edx, ecx
mov [r14+10h], edx
mov dword ptr [r14+18h], 0
cmp r12, rax
jb short loc_6DFA2
mov rdi, [r14]
movzx edx, word ptr [rbx+0AAh]
add edx, r8d
mov rsi, r12
call _memmove
jmp short loc_6DFA2
loc_6DF57:
mov rcx, [r14]
mov byte ptr [rcx], 0
cmp rax, r15
jnb short loc_6DF8D
loc_6DF62:
mov r12, rax
mov rdi, r14
mov esi, [rbp+var_2C]
mov r13, r8
mov edx, r8d
lea rcx, [rbp+var_38]
call qword ptr [rbx+0E0h]
test eax, eax
jz short loc_6DF92
mov rax, [rbp+var_38]
cmp rax, r15
mov r8, r13
jb short loc_6DF62
jmp short loc_6DFA2
loc_6DF8D:
mov r12, rax
jmp short loc_6DFA2
loc_6DF92:
mov rdi, [rbx]
mov esi, 7Eh ; '~'
call _ma_set_fatal_error_with_share
xor r12d, r12d
loc_6DFA2:
mov rax, r12
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| unsigned long long ma_get_last_key(long long a1, long long a2, unsigned long long a3)
{
long long *v5; // rbx
long long v6; // r8
unsigned int v7; // edi
long long v8; // rcx
unsigned long long v9; // rax
bool v10; // dl
unsigned long long v11; // r15
unsigned long long v12; // r12
int v13; // ecx
long long v14; // r13
long long v15; // rdx
long long v16; // rcx
long long v17; // r8
int v18; // r9d
unsigned long long v20; // [rsp+8h] [rbp-38h] BYREF
unsigned int v21; // [rsp+14h] [rbp-2Ch]
v5 = *(long long **)(a1 + 8);
v6 = *(unsigned int *)(a2 + 40);
v7 = *(_DWORD *)(a2 + 44);
v8 = *v5;
v9 = v6 + *(_QWORD *)(a2 + 16) + *(unsigned int *)(*v5 + 1860);
v20 = v9;
v10 = (*((_BYTE *)v5 + 162) & 0x28) == 0;
v21 = v7;
if ( v10 && (v7 & 2) == 0 )
{
v11 = a3 - *((unsigned __int16 *)v5 + 85);
v12 = v11 - v6;
v13 = *(_DWORD *)(v8 + 1856);
*(_DWORD *)(a1 + 20) = v13;
*(_DWORD *)(a1 + 16) = *((unsigned __int16 *)v5 + 85) - v13;
*(_DWORD *)(a1 + 24) = 0;
if ( v11 - v6 >= v9 )
memmove(*(_QWORD *)a1, v11 - v6, (unsigned int)v6 + *((unsigned __int16 *)v5 + 85));
}
else
{
**(_BYTE **)a1 = 0;
if ( v9 >= a3 )
{
return v9;
}
else
{
while ( 1 )
{
v12 = v9;
v14 = v6;
if ( !((unsigned int ( *)(long long, _QWORD, _QWORD, unsigned long long *))v5[28])(
a1,
v21,
(unsigned int)v6,
&v20) )
break;
v9 = v20;
v6 = v14;
if ( v20 >= a3 )
return v12;
}
ma_set_fatal_error_with_share(*v5, 126, v15, v16, v17, v18);
return 0LL;
}
}
return v12;
}
| _ma_get_last_key:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R15,RDX
MOV R14,RDI
MOV RBX,qword ptr [RDI + 0x8]
MOV R8D,dword ptr [RSI + 0x28]
MOV EDI,dword ptr [RSI + 0x2c]
MOV RCX,qword ptr [RBX]
MOV EAX,dword ptr [RCX + 0x744]
ADD RAX,qword ptr [RSI + 0x10]
ADD RAX,R8
MOV qword ptr [RBP + -0x38],RAX
TEST byte ptr [RBX + 0xa2],0x28
SETZ DL
MOV dword ptr [RBP + -0x2c],EDI
TEST DIL,0x2
SETZ SIL
AND SIL,DL
CMP SIL,0x1
JNZ 0x0016df57
MOVZX EDX,word ptr [RBX + 0xaa]
SUB R15,RDX
MOV R12,R15
SUB R12,R8
MOV ECX,dword ptr [RCX + 0x740]
MOV dword ptr [R14 + 0x14],ECX
MOVZX EDX,word ptr [RBX + 0xaa]
SUB EDX,ECX
MOV dword ptr [R14 + 0x10],EDX
MOV dword ptr [R14 + 0x18],0x0
CMP R12,RAX
JC 0x0016dfa2
MOV RDI,qword ptr [R14]
MOVZX EDX,word ptr [RBX + 0xaa]
ADD EDX,R8D
MOV RSI,R12
CALL 0x00129110
JMP 0x0016dfa2
LAB_0016df57:
MOV RCX,qword ptr [R14]
MOV byte ptr [RCX],0x0
CMP RAX,R15
JNC 0x0016df8d
LAB_0016df62:
MOV R12,RAX
MOV RDI,R14
MOV ESI,dword ptr [RBP + -0x2c]
MOV R13,R8
MOV EDX,R8D
LEA RCX,[RBP + -0x38]
CALL qword ptr [RBX + 0xe0]
TEST EAX,EAX
JZ 0x0016df92
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,R15
MOV R8,R13
JC 0x0016df62
JMP 0x0016dfa2
LAB_0016df8d:
MOV R12,RAX
JMP 0x0016dfa2
LAB_0016df92:
MOV RDI,qword ptr [RBX]
MOV ESI,0x7e
CALL 0x0013fc8a
XOR R12D,R12D
LAB_0016dfa2:
MOV RAX,R12
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void * _ma_get_last_key(int8 *param_1,long param_2,void *param_3)
{
uint uVar1;
long *plVar2;
void *pvVar3;
void *pvVar4;
int iVar5;
ulong uVar6;
void *local_40;
uint local_34;
plVar2 = (long *)param_1[1];
uVar1 = *(uint *)(param_2 + 0x28);
uVar6 = (ulong)uVar1;
local_34 = *(uint *)(param_2 + 0x2c);
local_40 = (void *)((ulong)*(uint *)(*plVar2 + 0x744) + *(long *)(param_2 + 0x10) + uVar6);
if ((local_34 & 2) == 0 && (*(byte *)((long)plVar2 + 0xa2) & 0x28) == 0) {
param_3 = (void *)((long)param_3 + (-uVar6 - (ulong)*(ushort *)((long)plVar2 + 0xaa)));
iVar5 = *(int *)(*plVar2 + 0x740);
*(int *)((long)param_1 + 0x14) = iVar5;
*(uint *)(param_1 + 2) = (uint)*(ushort *)((long)plVar2 + 0xaa) - iVar5;
*(int4 *)(param_1 + 3) = 0;
if (local_40 <= param_3) {
memmove((void *)*param_1,param_3,(ulong)(*(ushort *)((long)plVar2 + 0xaa) + uVar1));
}
}
else {
*(int1 *)*param_1 = 0;
pvVar4 = local_40;
do {
pvVar3 = local_40;
if (param_3 <= pvVar3) {
return pvVar4;
}
local_40 = pvVar3;
iVar5 = (*(code *)plVar2[0x1c])(param_1,local_34,uVar6,&local_40);
pvVar4 = pvVar3;
} while (iVar5 != 0);
_ma_set_fatal_error_with_share(*plVar2,0x7e);
param_3 = (void *)0x0;
}
return param_3;
}
| |
47,281 | string_view::operator[](unsigned long) const | llama.cpp/common/json-schema-to-grammar.cpp | char operator[](size_t pos) const {
auto index = _start + pos;
if (index >= _end) {
throw std::out_of_range("string_view index out of range");
}
return _str[_start + pos];
} | O3 | cpp | string_view::operator[](unsigned long) const:
pushq %r14
pushq %rbx
pushq %rax
addq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
jae 0xc2485
movq (%rdi), %rax
movq (%rax), %rax
movb (%rax,%rsi), %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x1c460
movq %rax, %rbx
leaq 0xfdd0(%rip), %rsi # 0xd2269
movq %rax, %rdi
callq 0x1c290
movq 0x3da78(%rip), %rsi # 0xfff20
movq 0x3dad1(%rip), %rdx # 0xfff80
movq %rbx, %rdi
callq 0x1c7b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x1caa0
movq %r14, %rdi
callq 0x1c7d0
| _ZNK11string_viewixEm:
push r14
push rbx
push rax
add rsi, [rdi+8]
cmp rsi, [rdi+10h]
jnb short loc_C2485
mov rax, [rdi]
mov rax, [rax]
mov al, [rax+rsi]
add rsp, 8
pop rbx
pop r14
retn
loc_C2485:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aStringViewInde; "string_view index out of range"
mov rdi, rax; this
call __ZNSt12out_of_rangeC1EPKc; std::out_of_range::out_of_range(char const*)
mov rsi, cs:_ZTISt12out_of_range_ptr; lptinfo
mov rdx, cs:_ZNSt12out_of_rangeD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
mov rdi, rbx; void *
call ___cxa_free_exception
mov rdi, r14
call __Unwind_Resume
| char string_view::operator[](long long a1, long long a2)
{
unsigned long long v2; // rsi
std::out_of_range *exception; // rbx
v2 = *(_QWORD *)(a1 + 8) + a2;
if ( v2 >= *(_QWORD *)(a1 + 16) )
{
exception = (std::out_of_range *)__cxa_allocate_exception(0x10uLL);
std::out_of_range::out_of_range(exception, "string_view index out of range");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::out_of_range,
(void (*)(void *))&std::out_of_range::~out_of_range);
}
return *(_BYTE *)(**(_QWORD **)a1 + v2);
}
| operator[]:
PUSH R14
PUSH RBX
PUSH RAX
ADD RSI,qword ptr [RDI + 0x8]
CMP RSI,qword ptr [RDI + 0x10]
JNC 0x001c2485
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX]
MOV AL,byte ptr [RAX + RSI*0x1]
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_001c2485:
MOV EDI,0x10
CALL 0x0011c460
MOV RBX,RAX
LAB_001c2492:
LEA RSI,[0x1d2269]
MOV RDI,RAX
CALL 0x0011c290
LAB_001c24a1:
MOV RSI,qword ptr [0x001fff20]
MOV RDX,qword ptr [0x001fff80]
MOV RDI,RBX
CALL 0x0011c7b0
|
/* string_view::operator[](unsigned long) const */
int8 __thiscall string_view::operator[](string_view *this,ulong param_1)
{
out_of_range *this_00;
if (param_1 + *(long *)(this + 8) < *(ulong *)(this + 0x10)) {
return CONCAT71((int7)((ulong)**(long **)this >> 8),
*(int1 *)(**(long **)this + param_1 + *(long *)(this + 8)));
}
this_00 = (out_of_range *)__cxa_allocate_exception(0x10);
/* try { // try from 001c2492 to 001c24a0 has its CatchHandler @ 001c24b7 */
std::out_of_range::out_of_range(this_00,"string_view index out of range");
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_001fff20,PTR__out_of_range_001fff80);
}
| |
47,282 | PVG_FT_Stroker_BeginSubPath | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-ft-stroker.c | PVG_FT_Error PVG_FT_Stroker_BeginSubPath(PVG_FT_Stroker stroker, PVG_FT_Vector* to,
PVG_FT_Bool open)
{
/* We cannot process the first point, because there is not enough */
/* information regarding its corner/cap. The latter will be processed */
/* in the `PVG_FT_Stroker_EndSubPath' routine. */
/* */
stroker->first_point = TRUE;
stroker->center = *to;
stroker->subpath_open = open;
/* Determine if we need to check whether the border radius is greater */
/* than the radius of curvature of a curve, to handle this case */
/* specially. This is only required if bevel joins or butt caps may */
/* be created, because round & miter joins and round & square caps */
/* cover the negative sector created with wide strokes. */
stroker->handle_wide_strokes =
PVG_FT_BOOL(stroker->line_join != PVG_FT_STROKER_LINEJOIN_ROUND ||
(stroker->subpath_open &&
stroker->line_cap == PVG_FT_STROKER_LINECAP_BUTT));
/* record the subpath start point for each border */
stroker->subpath_start = *to;
stroker->angle_in = 0;
return 0;
} | O0 | c | PVG_FT_Stroker_BeginSubPath:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, 0x28(%rax)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x18(%rax)
movb -0x11(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x29(%rax)
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x0, 0x58(%rcx)
movb %al, -0x12(%rbp)
jne 0x8534f
movq -0x8(%rbp), %rax
movzbl 0x29(%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x13(%rbp)
je 0x85349
movq -0x8(%rbp), %rax
cmpl $0x0, 0x54(%rax)
sete %al
movb %al, -0x13(%rbp)
movb -0x13(%rbp), %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x50(%rax)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x38(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| PVG_FT_Stroker_BeginSubPath:
push rbp
mov rbp, rsp
mov al, dl
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_11], al
mov rax, [rbp+var_8]
mov byte ptr [rax+28h], 1
mov rax, [rbp+var_8]
mov rcx, [rbp+var_10]
mov rdx, [rcx]
mov [rax+10h], rdx
mov rcx, [rcx+8]
mov [rax+18h], rcx
mov cl, [rbp+var_11]
mov rax, [rbp+var_8]
mov [rax+29h], cl
mov rcx, [rbp+var_8]
mov al, 1
cmp dword ptr [rcx+58h], 0
mov [rbp+var_12], al
jnz short loc_8534F
mov rax, [rbp+var_8]
movzx ecx, byte ptr [rax+29h]
xor eax, eax
cmp ecx, 0
mov [rbp+var_13], al
jz short loc_85349
mov rax, [rbp+var_8]
cmp dword ptr [rax+54h], 0
setz al
mov [rbp+var_13], al
loc_85349:
mov al, [rbp+var_13]
mov [rbp+var_12], al
loc_8534F:
mov al, [rbp+var_12]
and al, 1
movzx eax, al
mov cl, al
mov rax, [rbp+var_8]
mov [rax+50h], cl
mov rax, [rbp+var_8]
mov rcx, [rbp+var_10]
mov rdx, [rcx]
mov [rax+38h], rdx
mov rcx, [rcx+8]
mov [rax+40h], rcx
mov rax, [rbp+var_8]
mov qword ptr [rax], 0
xor eax, eax
pop rbp
retn
| long long PVG_FT_Stroker_BeginSubPath(long long a1, _QWORD *a2, char a3)
{
bool v4; // [rsp+1h] [rbp-13h]
char v5; // [rsp+2h] [rbp-12h]
*(_BYTE *)(a1 + 40) = 1;
*(_QWORD *)(a1 + 16) = *a2;
*(_QWORD *)(a1 + 24) = a2[1];
*(_BYTE *)(a1 + 41) = a3;
v5 = 1;
if ( !*(_DWORD *)(a1 + 88) )
{
v4 = 0;
if ( *(_BYTE *)(a1 + 41) )
v4 = *(_DWORD *)(a1 + 84) == 0;
v5 = v4;
}
*(_BYTE *)(a1 + 80) = v5 & 1;
*(_QWORD *)(a1 + 56) = *a2;
*(_QWORD *)(a1 + 64) = a2[1];
*(_QWORD *)a1 = 0LL;
return 0LL;
}
| PVG_FT_Stroker_BeginSubPath:
PUSH RBP
MOV RBP,RSP
MOV AL,DL
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV byte ptr [RBP + -0x11],AL
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x28],0x1
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX + 0x10],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x18],RCX
MOV CL,byte ptr [RBP + -0x11]
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x29],CL
MOV RCX,qword ptr [RBP + -0x8]
MOV AL,0x1
CMP dword ptr [RCX + 0x58],0x0
MOV byte ptr [RBP + -0x12],AL
JNZ 0x0018534f
MOV RAX,qword ptr [RBP + -0x8]
MOVZX ECX,byte ptr [RAX + 0x29]
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0x13],AL
JZ 0x00185349
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x54],0x0
SETZ AL
MOV byte ptr [RBP + -0x13],AL
LAB_00185349:
MOV AL,byte ptr [RBP + -0x13]
MOV byte ptr [RBP + -0x12],AL
LAB_0018534f:
MOV AL,byte ptr [RBP + -0x12]
AND AL,0x1
MOVZX EAX,AL
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x50],CL
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX + 0x38],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x40],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],0x0
XOR EAX,EAX
POP RBP
RET
|
int8 PVG_FT_Stroker_BeginSubPath(int8 *param_1,int8 *param_2,int1 param_3)
{
bool local_1b;
bool local_1a;
*(int1 *)(param_1 + 5) = 1;
param_1[2] = *param_2;
param_1[3] = param_2[1];
*(int1 *)((long)param_1 + 0x29) = param_3;
local_1a = true;
if (*(int *)(param_1 + 0xb) == 0) {
local_1b = false;
if (*(char *)((long)param_1 + 0x29) != '\0') {
local_1b = *(int *)((long)param_1 + 0x54) == 0;
}
local_1a = local_1b;
}
*(bool *)(param_1 + 10) = local_1a;
param_1[7] = *param_2;
param_1[8] = param_2[1];
*param_1 = 0;
return 0;
}
| |
47,283 | PVG_FT_Stroker_BeginSubPath | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-ft-stroker.c | PVG_FT_Error PVG_FT_Stroker_BeginSubPath(PVG_FT_Stroker stroker, PVG_FT_Vector* to,
PVG_FT_Bool open)
{
/* We cannot process the first point, because there is not enough */
/* information regarding its corner/cap. The latter will be processed */
/* in the `PVG_FT_Stroker_EndSubPath' routine. */
/* */
stroker->first_point = TRUE;
stroker->center = *to;
stroker->subpath_open = open;
/* Determine if we need to check whether the border radius is greater */
/* than the radius of curvature of a curve, to handle this case */
/* specially. This is only required if bevel joins or butt caps may */
/* be created, because round & miter joins and round & square caps */
/* cover the negative sector created with wide strokes. */
stroker->handle_wide_strokes =
PVG_FT_BOOL(stroker->line_join != PVG_FT_STROKER_LINEJOIN_ROUND ||
(stroker->subpath_open &&
stroker->line_cap == PVG_FT_STROKER_LINECAP_BUTT));
/* record the subpath start point for each border */
stroker->subpath_start = *to;
stroker->angle_in = 0;
return 0;
} | O3 | c | PVG_FT_Stroker_BeginSubPath:
movb $0x1, 0x28(%rdi)
movups (%rsi), %xmm0
movups %xmm0, 0x10(%rdi)
movb %dl, 0x29(%rdi)
movb $0x1, %al
cmpl $0x0, 0x58(%rdi)
jne 0x3df10
testb %dl, %dl
je 0x3df0e
cmpl $0x0, 0x54(%rdi)
sete %al
jmp 0x3df10
xorl %eax, %eax
movb %al, 0x50(%rdi)
movups (%rsi), %xmm0
movups %xmm0, 0x38(%rdi)
movq $0x0, (%rdi)
xorl %eax, %eax
retq
| PVG_FT_Stroker_BeginSubPath:
mov byte ptr [rdi+28h], 1
movups xmm0, xmmword ptr [rsi]
movups xmmword ptr [rdi+10h], xmm0
mov [rdi+29h], dl
mov al, 1
cmp dword ptr [rdi+58h], 0
jnz short loc_3DF10
test dl, dl
jz short loc_3DF0E
cmp dword ptr [rdi+54h], 0
setz al
jmp short loc_3DF10
loc_3DF0E:
xor eax, eax
loc_3DF10:
mov [rdi+50h], al
movups xmm0, xmmword ptr [rsi]
movups xmmword ptr [rdi+38h], xmm0
mov qword ptr [rdi], 0
xor eax, eax
retn
| long long PVG_FT_Stroker_BeginSubPath(long long a1, _OWORD *a2, char a3)
{
bool v3; // al
*(_BYTE *)(a1 + 40) = 1;
*(_OWORD *)(a1 + 16) = *a2;
*(_BYTE *)(a1 + 41) = a3;
v3 = 1;
if ( !*(_DWORD *)(a1 + 88) )
{
if ( a3 )
v3 = *(_DWORD *)(a1 + 84) == 0;
else
v3 = 0;
}
*(_BYTE *)(a1 + 80) = v3;
*(_OWORD *)(a1 + 56) = *a2;
*(_QWORD *)a1 = 0LL;
return 0LL;
}
| PVG_FT_Stroker_BeginSubPath:
MOV byte ptr [RDI + 0x28],0x1
MOVUPS XMM0,xmmword ptr [RSI]
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOV byte ptr [RDI + 0x29],DL
MOV AL,0x1
CMP dword ptr [RDI + 0x58],0x0
JNZ 0x0013df10
TEST DL,DL
JZ 0x0013df0e
CMP dword ptr [RDI + 0x54],0x0
SETZ AL
JMP 0x0013df10
LAB_0013df0e:
XOR EAX,EAX
LAB_0013df10:
MOV byte ptr [RDI + 0x50],AL
MOVUPS XMM0,xmmword ptr [RSI]
MOVUPS xmmword ptr [RDI + 0x38],XMM0
MOV qword ptr [RDI],0x0
XOR EAX,EAX
RET
|
int8 PVG_FT_Stroker_BeginSubPath(int8 *param_1,int8 *param_2,char param_3)
{
int8 uVar1;
bool bVar2;
*(int1 *)(param_1 + 5) = 1;
uVar1 = param_2[1];
param_1[2] = *param_2;
param_1[3] = uVar1;
*(char *)((long)param_1 + 0x29) = param_3;
bVar2 = true;
if (*(int *)(param_1 + 0xb) == 0) {
if (param_3 == '\0') {
bVar2 = false;
}
else {
bVar2 = *(int *)((long)param_1 + 0x54) == 0;
}
}
*(bool *)(param_1 + 10) = bVar2;
uVar1 = param_2[1];
param_1[7] = *param_2;
param_1[8] = uVar1;
*param_1 = 0;
return 0;
}
| |
47,284 | Json::appendHex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned int) | aimrt_mujoco_sim/_deps/jsoncpp-src/src/lib_json/json_writer.cpp | static void appendHex(String& result, unsigned ch) {
result.append("\\u").append(toHex16Bit(ch));
} | O3 | cpp | Json::appendHex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned int):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %r14d
leaq 0xa1e2(%rip), %rsi # 0x89a64
callq 0x20280
movq %rax, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x8(%rsp), %r15
movl $0x4, %esi
movq %r15, %rdi
movl $0x20, %edx
callq 0x1e240
movl %r14d, %eax
shrl $0x8, %eax
movl $0xff, %ecx
andl %ecx, %eax
leaq 0xa1b1(%rip), %rdx # 0x89a70
movq (%r15), %rsi
movb (%rdx,%rax,2), %dil
movb 0x1(%rdx,%rax,2), %al
movb %dil, (%rsi)
movq (%r15), %rsi
movb %al, 0x1(%rsi)
andl %ecx, %r14d
movq (%r15), %rax
movb (%rdx,%r14,2), %cl
movb 0x1(%rdx,%r14,2), %dl
movb %cl, 0x2(%rax)
movq (%r15), %rax
movb %dl, 0x3(%rax)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x201d0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7f909
callq 0x1f0e0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7f927
callq 0x1f0e0
movq %rbx, %rdi
callq 0x1ffd0
nop
| _ZN4JsonL9appendHexERNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEj:
push r15
push r14
push r12
push rbx
sub rsp, 28h
mov r14d, esi
lea rsi, aU_0; "\\u"
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rbx, rax
lea r12, [rsp+48h+var_30]
mov [r12-10h], r12
lea r15, [rsp+48h+var_40]
mov esi, 4
mov rdi, r15
mov edx, 20h ; ' '
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
mov eax, r14d
shr eax, 8
mov ecx, 0FFh
and eax, ecx
lea rdx, _ZN4JsonL4hex2E; "000102030405060708090a0b0c0d0e0f1011121"...
mov rsi, [r15]
mov dil, [rdx+rax*2]
mov al, [rdx+rax*2+1]
mov [rsi], dil
mov rsi, [r15]
mov [rsi+1], al
and r14d, ecx
mov rax, [r15]
mov cl, [rdx+r14*2]
mov dl, [rdx+r14*2+1]
mov [rax+2], cl
mov rax, [r15]
mov [rax+3], dl
mov rsi, [r15]
mov rdx, [r15+8]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
mov rdi, [rsp+48h+var_40]; void *
cmp rdi, r12
jz short loc_7F909
call __ZdlPv; operator delete(void *)
loc_7F909:
add rsp, 28h
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, r12
jz short loc_7F927
call __ZdlPv; operator delete(void *)
loc_7F927:
mov rdi, rbx
call __Unwind_Resume
| void Json::appendHex(long long a1, __int16 a2)
{
long long v2; // rbx
char v3; // al
char v4; // dl
void *v5[2]; // [rsp+8h] [rbp-40h] BYREF
_BYTE v6[48]; // [rsp+18h] [rbp-30h] BYREF
v2 = std::string::append(a1, "\\u");
v5[0] = v6;
std::string::_M_construct(v5, 4LL, 32LL);
v3 = Json::hex2[2 * HIBYTE(a2) + 1];
*(_BYTE *)v5[0] = Json::hex2[2 * HIBYTE(a2)];
*((_BYTE *)v5[0] + 1) = v3;
v4 = Json::hex2[2 * (unsigned __int8)a2 + 1];
*((_BYTE *)v5[0] + 2) = Json::hex2[2 * (unsigned __int8)a2];
*((_BYTE *)v5[0] + 3) = v4;
std::string::_M_append(v2, v5[0], v5[1]);
if ( v5[0] != v6 )
operator delete(v5[0]);
}
| appendHex:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14D,ESI
LEA RSI,[0x189a64]
CALL 0x00120280
MOV RBX,RAX
LEA R12,[RSP + 0x18]
MOV qword ptr [R12 + -0x10],R12
LEA R15,[RSP + 0x8]
MOV ESI,0x4
MOV RDI,R15
MOV EDX,0x20
CALL 0x0011e240
MOV EAX,R14D
SHR EAX,0x8
MOV ECX,0xff
AND EAX,ECX
LEA RDX,[0x189a70]
MOV RSI,qword ptr [R15]
MOV DIL,byte ptr [RDX + RAX*0x2]
MOV AL,byte ptr [RDX + RAX*0x2 + 0x1]
MOV byte ptr [RSI],DIL
MOV RSI,qword ptr [R15]
MOV byte ptr [RSI + 0x1],AL
AND R14D,ECX
MOV RAX,qword ptr [R15]
MOV CL,byte ptr [RDX + R14*0x2]
MOV DL,byte ptr [RDX + R14*0x2 + 0x1]
MOV byte ptr [RAX + 0x2],CL
MOV RAX,qword ptr [R15]
MOV byte ptr [RAX + 0x3],DL
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
LAB_0017f8f2:
MOV RDI,RBX
CALL 0x001201d0
LAB_0017f8fa:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R12
JZ 0x0017f909
CALL 0x0011f0e0
LAB_0017f909:
ADD RSP,0x28
POP RBX
POP R12
POP R14
POP R15
RET
|
/* Json::appendHex(std::__cxx11::string&, unsigned int) */
void Json::appendHex(string *param_1,uint param_2)
{
char cVar1;
string *this;
ulong uVar2;
char *local_40;
ulong local_38;
char local_30 [16];
this = (string *)std::__cxx11::string::append(param_1,"\\u");
local_40 = local_30;
std::__cxx11::string::_M_construct((string *)&local_40,4,' ');
uVar2 = (ulong)(param_2 >> 8 & 0xff);
cVar1 = hex2[uVar2 * 2 + 1];
*local_40 = hex2[uVar2 * 2];
local_40[1] = cVar1;
cVar1 = hex2[(ulong)(param_2 & 0xff) * 2 + 1];
local_40[2] = hex2[(ulong)(param_2 & 0xff) * 2];
local_40[3] = cVar1;
/* try { // try from 0017f8f2 to 0017f8f9 has its CatchHandler @ 0017f915 */
std::__cxx11::string::_M_append(this,local_40,local_38);
if (local_40 != local_30) {
operator_delete(local_40);
}
return;
}
| |
47,285 | string_from[abi:cxx11](std::vector<int, std::allocator<int>> const&) | llama.cpp/common/common.cpp | std::string string_from(const std::vector<int> & values) {
std::stringstream buf;
buf << "[ ";
bool first = true;
for (auto e : values) {
if (first) {
first = false;
} else {
buf << ", ";
}
buf << std::to_string(e);
}
buf << " ]";
return buf.str();
} | O3 | cpp | string_from[abi:cxx11](std::vector<int, std::allocator<int>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rsi, %rbx
movq %rdi, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x204d0
leaq 0x40(%rsp), %rdi
leaq 0x2d16a(%rip), %rsi # 0x1244bc
movl $0x2, %edx
callq 0x21060
movq (%rbx), %r12
movq 0x8(%rbx), %r15
cmpq %r15, %r12
je 0xf7452
movb $0x1, %al
movl $0xd1b71759, %r14d # imm = 0xD1B71759
movl (%r12), %r13d
testb $0x1, %al
jne 0xf7392
movl $0x2, %edx
leaq 0x40(%rsp), %rdi
leaq 0x2d821(%rip), %rsi # 0x124bae
callq 0x21060
movl %r13d, %ebp
negl %ebp
cmovsl %r13d, %ebp
movl $0x1, %ebx
cmpl $0xa, %ebp
jb 0xf73e1
movl $0x4, %ebx
movl %ebp, %eax
cmpl $0x63, %eax
jbe 0xf73da
cmpl $0x3e7, %eax # imm = 0x3E7
jbe 0xf73df
cmpl $0x2710, %eax # imm = 0x2710
jb 0xf73e1
movl %eax, %ecx
imulq %r14, %rcx
shrq $0x2d, %rcx
addl $0x4, %ebx
cmpl $0x1869f, %eax # imm = 0x1869F
movl %ecx, %eax
ja 0xf73ac
addl $-0x3, %ebx
jmp 0xf73e1
addl $-0x2, %ebx
jmp 0xf73e1
decl %ebx
shrl $0x1f, %r13d
leal (%rbx,%r13), %esi
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
movl $0x2d, %edx
callq 0x209c0
addq 0x8(%rsp), %r13
movq %r13, %rdi
movl %ebx, %esi
movl %ebp, %edx
callq 0x73bee
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x21060
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xf7443
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20180
addq $0x4, %r12
xorl %eax, %eax
cmpq %r15, %r12
jne 0xf7374
leaq 0x1b006(%rip), %rsi # 0x11245f
movl $0x2, %edx
leaq 0x40(%rsp), %rdi
callq 0x21060
movq 0x28(%rsp), %rbx
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x20650
movq 0x6ab2f(%rip), %rsi # 0x161fb0
leaq 0x30(%rsp), %rdi
callq 0x20cf0
leaq 0xb0(%rsp), %rdi
callq 0x20c40
movq %rbx, %rax
addq $0x1b8, %rsp # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xf74b1
jmp 0xf74b1
movq %rax, %rbx
jmp 0xf74dd
movq %rax, %rdi
callq 0x2868d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xf74dd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20180
movq 0x6aacc(%rip), %rsi # 0x161fb0
leaq 0x30(%rsp), %rdi
callq 0x20cf0
leaq 0xb0(%rsp), %rdi
callq 0x20c40
movq %rbx, %rdi
callq 0x20ae0
| _Z11string_fromB5cxx11RKSt6vectorIiSaIiEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 1B8h
mov rbx, rsi
mov [rsp+1E8h+var_1C0], rdi
lea rdi, [rsp+1E8h+var_1B8]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(void)
lea rdi, [rsp+1E8h+var_1A8]
lea rsi, asc_1244BC; "[ "
mov edx, 2
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov r12, [rbx]
mov r15, [rbx+8]
cmp r12, r15
jz loc_F7452
mov al, 1
mov r14d, 0D1B71759h
loc_F7374:
mov r13d, [r12]
test al, 1
jnz short loc_F7392
mov edx, 2
lea rdi, [rsp+1E8h+var_1A8]
lea rsi, aZuD+6; ", "
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
loc_F7392:
mov ebp, r13d
neg ebp
cmovs ebp, r13d
mov ebx, 1
cmp ebp, 0Ah
jb short loc_F73E1
mov ebx, 4
mov eax, ebp
loc_F73AC:
cmp eax, 63h ; 'c'
jbe short loc_F73DA
cmp eax, 3E7h
jbe short loc_F73DF
cmp eax, 2710h
jb short loc_F73E1
mov ecx, eax
imul rcx, r14
shr rcx, 2Dh
add ebx, 4
cmp eax, 1869Fh
mov eax, ecx
ja short loc_F73AC
add ebx, 0FFFFFFFDh
jmp short loc_F73E1
loc_F73DA:
add ebx, 0FFFFFFFEh
jmp short loc_F73E1
loc_F73DF:
dec ebx
loc_F73E1:
shr r13d, 1Fh
lea esi, [rbx+r13]
lea rax, [rsp+1E8h+var_1D0]
mov [rsp+1E8h+var_1E0], rax
lea rdi, [rsp+1E8h+var_1E0]
mov edx, 2Dh ; '-'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
add r13, [rsp+1E8h+var_1E0]
mov rdi, r13
mov esi, ebx
mov edx, ebp
call _ZNSt8__detail18__to_chars_10_implIjEEvPcjT_; std::__detail::__to_chars_10_impl<uint>(char *,uint,uint)
mov rsi, [rsp+1E8h+var_1E0]
mov rdx, [rsp+1E8h+var_1D8]
lea rdi, [rsp+1E8h+var_1A8]
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, [rsp+1E8h+var_1E0]; void *
lea rax, [rsp+1E8h+var_1D0]
cmp rdi, rax
jz short loc_F7443
mov rsi, [rsp+1E8h+var_1D0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_F7443:
add r12, 4
xor eax, eax
cmp r12, r15
jnz loc_F7374
loc_F7452:
lea rsi, asc_11245D+2; " ]"
mov edx, 2
lea rdi, [rsp+1E8h+var_1A8]
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rbx, [rsp+1E8h+var_1C0]
lea rsi, [rsp+1E8h+var_1A0]
mov rdi, rbx
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
mov rsi, cs:_ZTTNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+1E8h+var_1B8]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED2Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
lea rdi, [rsp+1E8h+var_138]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rax, rbx
add rsp, 1B8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_F74B1
jmp short $+2
loc_F74B1:
mov rbx, rax
jmp short loc_F74DD
mov rdi, rax
call __clang_call_terminate
mov rbx, rax
mov rdi, [rsp+1E8h+var_1E0]; void *
lea rax, [rsp+1E8h+var_1D0]
cmp rdi, rax
jz short loc_F74DD
mov rsi, [rsp+1E8h+var_1D0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_F74DD:
mov rsi, cs:_ZTTNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+1E8h+var_1B8]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED2Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
lea rdi, [rsp+1E8h+var_138]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rdi, rbx
call __Unwind_Resume
| long long string_from[abi:cxx11](long long a1, int **a2)
{
int *v2; // r12
int *v3; // r15
char v4; // al
int v5; // r13d
unsigned int v6; // ebp
int v7; // ebx
unsigned int v8; // eax
bool v9; // cc
unsigned int v10; // r13d
long long v11; // rbx
void *v13[2]; // [rsp+8h] [rbp-1E0h] BYREF
_QWORD v14[2]; // [rsp+18h] [rbp-1D0h] BYREF
long long v15; // [rsp+28h] [rbp-1C0h]
_BYTE v16[16]; // [rsp+30h] [rbp-1B8h] BYREF
char v17[8]; // [rsp+40h] [rbp-1A8h] BYREF
char v18[104]; // [rsp+48h] [rbp-1A0h] BYREF
char v19[312]; // [rsp+B0h] [rbp-138h] BYREF
v15 = a1;
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(v16);
std::__ostream_insert<char,std::char_traits<char>>(v17, "[ ", 2LL);
v2 = *a2;
v3 = a2[1];
if ( *a2 != v3 )
{
v4 = 1;
do
{
v5 = *v2;
if ( (v4 & 1) == 0 )
std::__ostream_insert<char,std::char_traits<char>>(v17, ", ", 2LL);
v6 = -v5;
if ( v5 > 0 )
v6 = v5;
v7 = 1;
if ( v6 >= 0xA )
{
v7 = 4;
v8 = v6;
while ( 1 )
{
if ( v8 <= 0x63 )
{
v7 -= 2;
goto LABEL_16;
}
if ( v8 <= 0x3E7 )
break;
if ( v8 < 0x2710 )
goto LABEL_16;
v7 += 4;
v9 = v8 <= 0x1869F;
v8 /= 0x2710u;
if ( v9 )
{
v7 -= 3;
goto LABEL_16;
}
}
--v7;
}
LABEL_16:
v10 = (unsigned int)v5 >> 31;
v13[0] = v14;
std::string::_M_construct(v13, v7 + v10, 45LL);
std::__detail::__to_chars_10_impl<unsigned int>((char *)v13[0] + v10, v7, v6);
std::__ostream_insert<char,std::char_traits<char>>(v17, v13[0], v13[1]);
if ( v13[0] != v14 )
operator delete(v13[0], v14[0] + 1LL);
++v2;
v4 = 0;
}
while ( v2 != v3 );
}
std::__ostream_insert<char,std::char_traits<char>>(v17, " ]", 2LL);
v11 = v15;
std::stringbuf::str(v15, v18);
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream(
v16,
&`VTT for'std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>);
std::ios_base::~ios_base((std::ios_base *)v19);
return v11;
}
| string_from[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x1b8
MOV RBX,RSI
MOV qword ptr [RSP + 0x28],RDI
LEA RDI,[RSP + 0x30]
CALL 0x001204d0
LEA RDI,[RSP + 0x40]
LAB_001f734b:
LEA RSI,[0x2244bc]
MOV EDX,0x2
CALL 0x00121060
MOV R12,qword ptr [RBX]
MOV R15,qword ptr [RBX + 0x8]
CMP R12,R15
JZ 0x001f7452
MOV AL,0x1
MOV R14D,0xd1b71759
LAB_001f7374:
MOV R13D,dword ptr [R12]
TEST AL,0x1
JNZ 0x001f7392
LAB_001f737c:
MOV EDX,0x2
LEA RDI,[RSP + 0x40]
LEA RSI,[0x224bae]
CALL 0x00121060
LAB_001f7392:
MOV EBP,R13D
NEG EBP
CMOVS EBP,R13D
MOV EBX,0x1
CMP EBP,0xa
JC 0x001f73e1
MOV EBX,0x4
MOV EAX,EBP
LAB_001f73ac:
CMP EAX,0x63
JBE 0x001f73da
CMP EAX,0x3e7
JBE 0x001f73df
CMP EAX,0x2710
JC 0x001f73e1
MOV ECX,EAX
IMUL RCX,R14
SHR RCX,0x2d
ADD EBX,0x4
CMP EAX,0x1869f
MOV EAX,ECX
JA 0x001f73ac
ADD EBX,-0x3
JMP 0x001f73e1
LAB_001f73da:
ADD EBX,-0x2
JMP 0x001f73e1
LAB_001f73df:
DEC EBX
LAB_001f73e1:
SHR R13D,0x1f
LEA ESI,[RBX + R13*0x1]
LEA RAX,[RSP + 0x18]
MOV qword ptr [RSP + 0x8],RAX
LAB_001f73f3:
LEA RDI,[RSP + 0x8]
MOV EDX,0x2d
CALL 0x001209c0
ADD R13,qword ptr [RSP + 0x8]
MOV RDI,R13
MOV ESI,EBX
MOV EDX,EBP
CALL 0x00173bee
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
LAB_001f741d:
LEA RDI,[RSP + 0x40]
CALL 0x00121060
MOV RDI,qword ptr [RSP + 0x8]
LEA RAX,[RSP + 0x18]
CMP RDI,RAX
JZ 0x001f7443
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00120180
LAB_001f7443:
ADD R12,0x4
XOR EAX,EAX
CMP R12,R15
JNZ 0x001f7374
LAB_001f7452:
LEA RSI,[0x21245f]
MOV EDX,0x2
LEA RDI,[RSP + 0x40]
CALL 0x00121060
MOV RBX,qword ptr [RSP + 0x28]
LEA RSI,[RSP + 0x48]
MOV RDI,RBX
CALL 0x00120650
LAB_001f747a:
MOV RSI,qword ptr [0x00261fb0]
LEA RDI,[RSP + 0x30]
CALL 0x00120cf0
LEA RDI,[RSP + 0xb0]
CALL 0x00120c40
MOV RAX,RBX
ADD RSP,0x1b8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* string_from[abi:cxx11](std::vector<int, std::allocator<int> > const&) */
vector * string_from_abi_cxx11_(vector *param_1)
{
uint uVar1;
uint *puVar2;
uint uVar3;
vector *pvVar4;
uint uVar5;
bool bVar6;
uint uVar7;
ulong uVar8;
uint uVar9;
int8 *in_RSI;
uint *puVar10;
long *local_1e0;
long local_1d8;
long local_1d0 [2];
vector *local_1c0;
stringstream local_1b8 [16];
ostream local_1a8 [112];
ios_base local_138 [264];
local_1c0 = param_1;
std::__cxx11::stringstream::stringstream(local_1b8);
/* try { // try from 001f734b to 001f735b has its CatchHandler @ 001f74ad */
std::__ostream_insert<char,std::char_traits<char>>(local_1a8,"[ ",2);
puVar10 = (uint *)*in_RSI;
puVar2 = (uint *)in_RSI[1];
if (puVar10 != puVar2) {
bVar6 = true;
do {
uVar1 = *puVar10;
if (!bVar6) {
/* try { // try from 001f737c to 001f7391 has its CatchHandler @ 001f74b1 */
std::__ostream_insert<char,std::char_traits<char>>(local_1a8,", ",2);
}
uVar3 = -uVar1;
if (0 < (int)uVar1) {
uVar3 = uVar1;
}
uVar9 = 1;
if (9 < uVar3) {
uVar8 = (ulong)uVar3;
uVar5 = 4;
do {
uVar9 = uVar5;
uVar7 = (uint)uVar8;
if (uVar7 < 100) {
uVar9 = uVar9 - 2;
goto LAB_001f73e1;
}
if (uVar7 < 1000) {
uVar9 = uVar9 - 1;
goto LAB_001f73e1;
}
if (uVar7 < 10000) goto LAB_001f73e1;
uVar8 = uVar8 / 10000;
uVar5 = uVar9 + 4;
} while (99999 < uVar7);
uVar9 = uVar9 + 1;
}
LAB_001f73e1:
local_1e0 = local_1d0;
/* try { // try from 001f73f3 to 001f7401 has its CatchHandler @ 001f74b6 */
std::__cxx11::string::_M_construct((ulong)&local_1e0,(char)uVar9 - (char)((int)uVar1 >> 0x1f))
;
std::__detail::__to_chars_10_impl<unsigned_int>
((char *)((long)local_1e0 + (ulong)(uVar1 >> 0x1f)),uVar9,uVar3);
/* try { // try from 001f741d to 001f7426 has its CatchHandler @ 001f74be */
std::__ostream_insert<char,std::char_traits<char>>(local_1a8,(char *)local_1e0,local_1d8);
if (local_1e0 != local_1d0) {
operator_delete(local_1e0,local_1d0[0] + 1);
}
puVar10 = puVar10 + 1;
bVar6 = false;
} while (puVar10 != puVar2);
}
/* try { // try from 001f7452 to 001f7479 has its CatchHandler @ 001f74af */
std::__ostream_insert<char,std::char_traits<char>>(local_1a8," ]",2);
pvVar4 = local_1c0;
std::__cxx11::stringbuf::str();
std::__cxx11::stringstream::~stringstream(local_1b8);
std::ios_base::~ios_base(local_138);
return pvVar4;
}
| |
47,286 | void nlohmann::json_abi_v3_11_3::detail::from_json<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>, int, 0>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, int&) | monkey531[P]llama/common/json.hpp | inline void from_json(const BasicJsonType& j, ArithmeticType& val)
{
switch (static_cast<value_t>(j))
{
case value_t::number_unsigned:
{
val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
break;
}
case value_t::number_integer:
{
val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
break;
}
case value_t::number_float:
{
val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
break;
}
case value_t::boolean:
{
val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
break;
}
case value_t::null:
case value_t::object:
case value_t::array:
case value_t::string:
case value_t::binary:
case value_t::discarded:
default:
JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j));
}
} | O1 | cpp | void nlohmann::json_abi_v3_11_3::detail::from_json<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>, int, 0>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, int&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
movzbl (%rdi), %eax
addl $-0x4, %eax
cmpl $0x3, %eax
ja 0x5238e
leaq 0x576f1(%rip), %rcx # 0xa9a58
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x8(%r14), %eax
jmp 0x52383
movzbl 0x8(%r14), %eax
jmp 0x52383
cvttsd2si 0x8(%r14), %eax
movl %eax, (%rsi)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x18350
movq %rax, %rbx
movq %r14, %rdi
callq 0x3e11c
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x5942a(%rip), %rsi # 0xab7dc
leaq 0x10(%rsp), %rdi
callq 0x3e093
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x12e, %esi # imm = 0x12E
movq %r14, %rcx
callq 0x3dec4
xorl %ebp, %ebp
leaq 0x89eeb(%rip), %rsi # 0xdc2c8
leaq -0x5c60(%rip), %rdx # 0x4c784
movq %rbx, %rdi
callq 0x18b30
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52412
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x186a0
jmp 0x52412
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x5241f
movq %rbx, %rdi
callq 0x184f0
movq %r14, %rdi
callq 0x18ba0
nop
| _ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEiTnNSt9enable_ifIXaaaaaaaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_17number_unsigned_tEEE5valuentsr3std7is_sameISH_NSI_16number_integer_tEEE5valuentsr3std7is_sameISH_NSI_14number_float_tEEE5valuentsr3std7is_sameISH_NSI_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_:
push rbp; char
push r14; int
push rbx; __int64
sub rsp, 30h
mov r14, rdi
movzx eax, byte ptr [rdi]
add eax, 0FFFFFFFCh; switch 4 cases
cmp eax, 3
ja short def_5236E; jumptable 000000000005236E default case
lea rcx, jpt_5236E
movsxd rax, ds:(jpt_5236E - 0A9A58h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_52370:
mov eax, [r14+8]; jumptable 000000000005236E cases 5,6
jmp short loc_52383
loc_52376:
movzx eax, byte ptr [r14+8]; jumptable 000000000005236E case 4
jmp short loc_52383
loc_5237D:
cvttsd2si eax, qword ptr [r14+8]; jumptable 000000000005236E case 7
loc_52383:
mov [rsi], eax
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
def_5236E:
mov edi, 20h ; ' '; jumptable 000000000005236E default case
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aTypeMustBeNumb; "type must be number, but is "
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA29_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(char const(&)[29],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 12Eh; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_52412
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_52412
mov r14, rax
mov bpl, 1
loc_52412:
test bpl, bpl
jz short loc_5241F
mov rdi, rbx; void *
call ___cxa_free_exception
loc_5241F:
mov rdi, r14
call __Unwind_Resume
| long long ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEiTnNSt9enable_ifIXaaaaaaaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_17number_unsigned_tEEE5valuentsr3std7is_sameISH_NSI_16number_integer_tEEE5valuentsr3std7is_sameISH_NSI_14number_float_tEEE5valuentsr3std7is_sameISH_NSI_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_(
unsigned __int8 *a1,
_DWORD *a2)
{
long long result; // rax
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
const char *v4; // [rsp+8h] [rbp-40h] BYREF
_QWORD v5[2]; // [rsp+10h] [rbp-38h] BYREF
switch ( *a1 )
{
case 4u:
result = a1[8];
break;
case 5u:
case 6u:
result = *((unsigned int *)a1 + 2);
break;
case 7u:
result = (unsigned int)(int)*((double *)a1 + 1);
break;
default:
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
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>::type_name(a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(
(long long)v5,
(long long)"type must be number, but is ",
&v4);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
exception,
302,
v5);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
*a2 = result;
return result;
}
| _ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEiTnNSt9enable_ifIXaaaaaaaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_17number_unsigned_tEEE5valuentsr3std7is_sameISH_NSI_16number_integer_tEEE5valuentsr3std7is_sameISH_NSI_14number_float_tEEE5valuentsr3std7is_sameISH_NSI_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RDI
MOVZX EAX,byte ptr [RDI]
ADD EAX,-0x4
CMP EAX,0x3
JA 0x0015238e
LEA RCX,[0x1a9a58]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_5:
MOV EAX,dword ptr [R14 + 0x8]
JMP 0x00152383
caseD_4:
MOVZX EAX,byte ptr [R14 + 0x8]
JMP 0x00152383
caseD_7:
CVTTSD2SI EAX,qword ptr [R14 + 0x8]
LAB_00152383:
MOV dword ptr [RSI],EAX
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
default:
MOV EDI,0x20
CALL 0x00118350
MOV RBX,RAX
MOV RDI,R14
CALL 0x0013e11c
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_001523ab:
LEA RSI,[0x1ab7dc]
LEA RDI,[RSP + 0x10]
CALL 0x0013e093
MOV BPL,0x1
LAB_001523bf:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x12e
MOV RCX,R14
CALL 0x0013dec4
XOR EBP,EBP
LEA RSI,[0x1dc2c8]
LEA RDX,[0x14c784]
MOV RDI,RBX
CALL 0x00118b30
|
void _ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEiTnNSt9enable_ifIXaaaaaaaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_17number_unsigned_tEEE5valuentsr3std7is_sameISH_NSI_16number_integer_tEEE5valuentsr3std7is_sameISH_NSI_14number_float_tEEE5valuentsr3std7is_sameISH_NSI_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_
(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,uint *param_2)
{
uint uVar1;
int8 uVar2;
char *local_40;
detail local_38 [32];
switch(*param_1) {
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x4:
uVar1 = (uint)(byte)param_1[8];
break;
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x5:
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x6:
uVar1 = *(uint *)(param_1 + 8);
break;
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x7:
uVar1 = (uint)*(double *)(param_1 + 8);
break;
default:
uVar2 = __cxa_allocate_exception(0x20);
local_40 = (char *)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>
::type_name(param_1);
/* try { // try from 001523ab to 001523bb has its CatchHandler @ 0015240c */
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[29],char_const*>
(local_38,"type must be number, but is ",&local_40);
/* try { // try from 001523bf to 001523eb has its CatchHandler @ 001523ec */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar2,0x12e,local_38,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar2,&nlohmann::json_abi_v3_11_3::detail::type_error::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
*param_2 = uVar1;
return;
}
| |
47,287 | unicode_case1 | bluesky950520[P]quickjs/libunicode.c | static int unicode_case1(CharRange *cr, int case_mask)
{
#define MR(x) (1 << RUN_TYPE_ ## x)
const uint32_t tab_run_mask[3] = {
MR(U) | MR(UF) | MR(UL) | MR(LSU) | MR(U2L_399_EXT2) | MR(UF_D20) |
MR(UF_D1_EXT) | MR(U_EXT) | MR(UF_EXT2) | MR(UF_EXT3),
MR(L) | MR(LF) | MR(UL) | MR(LSU) | MR(U2L_399_EXT2) | MR(LF_EXT) | MR(LF_EXT2),
MR(UF) | MR(LF) | MR(UL) | MR(LSU) | MR(U2L_399_EXT2) | MR(LF_EXT) | MR(LF_EXT2) | MR(UF_D20) | MR(UF_D1_EXT) | MR(LF_EXT) | MR(UF_EXT2) | MR(UF_EXT3),
};
#undef MR
uint32_t mask, v, code, type, len, i, idx;
if (case_mask == 0)
return 0;
mask = 0;
for(i = 0; i < 3; i++) {
if ((case_mask >> i) & 1)
mask |= tab_run_mask[i];
}
for(idx = 0; idx < countof(case_conv_table1); idx++) {
v = case_conv_table1[idx];
type = (v >> (32 - 17 - 7 - 4)) & 0xf;
code = v >> (32 - 17);
len = (v >> (32 - 17 - 7)) & 0x7f;
if ((mask >> type) & 1) {
// printf("%d: type=%d %04x %04x\n", idx, type, code, code + len - 1);
switch(type) {
case RUN_TYPE_UL:
if ((case_mask & CASE_U) && (case_mask & (CASE_L | CASE_F)))
goto def_case;
code += ((case_mask & CASE_U) != 0);
for(i = 0; i < len; i += 2) {
if (cr_add_interval(cr, code + i, code + i + 1))
return -1;
}
break;
case RUN_TYPE_LSU:
if ((case_mask & CASE_U) && (case_mask & (CASE_L | CASE_F)))
goto def_case;
if (!(case_mask & CASE_U)) {
if (cr_add_interval(cr, code, code + 1))
return -1;
}
if (cr_add_interval(cr, code + 1, code + 2))
return -1;
if (case_mask & CASE_U) {
if (cr_add_interval(cr, code + 2, code + 3))
return -1;
}
break;
default:
def_case:
if (cr_add_interval(cr, code, code + len))
return -1;
break;
}
}
}
return 0;
} | O2 | c | unicode_case1:
testl %esi, %esi
je 0x84127
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x10fbc(%rip), %rcx # 0x94fcc
xorl %r13d, %r13d
cmpq $0x3, %rax
je 0x8402a
btl %eax, %esi
jae 0x84021
orl (%rcx), %r13d
incq %rax
addq $0x4, %rcx
jmp 0x84013
movl %esi, %eax
andl $0x1, %eax
movl %eax, 0x4(%rsp)
sete %al
testb $0x6, %sil
sete %cl
orb %al, %cl
movb %cl, 0x3(%rsp)
xorl %r14d, %r14d
cmpq $0x17a, %r14 # imm = 0x17A
je 0x8412a
leaq 0x9946(%rip), %rax # 0x8d9a0
movl (%rax,%r14,4), %ebp
movl %ebp, %eax
shrl $0x4, %eax
andl $0xf, %eax
btl %eax, %r13d
jae 0x8411a
movl %ebp, %r15d
shrl $0xf, %r15d
shrl $0x8, %ebp
andl $0x7f, %ebp
cmpl $0x5, %eax
je 0x840b8
cmpl $0x4, %eax
jne 0x84106
cmpb $0x0, 0x3(%rsp)
je 0x84106
addl 0x4(%rsp), %r15d
xorl %r12d, %r12d
cmpl %ebp, %r12d
jae 0x8411a
leal 0x1(%r15), %edx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x83c49
addl $0x2, %r12d
addl $0x2, %r15d
testl %eax, %eax
je 0x84096
jmp 0x84122
cmpb $0x0, 0x3(%rsp)
je 0x84106
leal 0x1(%r15), %ebp
cmpl $0x0, 0x4(%rsp)
jne 0x840db
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x83c49
testl %eax, %eax
jne 0x84122
leal 0x2(%r15), %r12d
movq %rbx, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x83c49
testl %eax, %eax
jne 0x84122
cmpl $0x0, 0x4(%rsp)
je 0x8411a
addl $0x3, %r15d
movq %rbx, %rdi
movl %r12d, %esi
movl %r15d, %edx
jmp 0x84111
addl %r15d, %ebp
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x83c49
testl %eax, %eax
jne 0x84122
incq %r14
jmp 0x84046
pushq $-0x1
popq %rax
jmp 0x8412c
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| unicode_case1:
test esi, esi
jz loc_84127
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
xor eax, eax
lea rcx, unk_94FCC
xor r13d, r13d
loc_84013:
cmp rax, 3
jz short loc_8402A
bt esi, eax
jnb short loc_84021
or r13d, [rcx]
loc_84021:
inc rax
add rcx, 4
jmp short loc_84013
loc_8402A:
mov eax, esi
and eax, 1
mov [rsp+38h+var_34], eax
setz al
test sil, 6
setz cl
or cl, al
mov [rsp+38h+var_35], cl
xor r14d, r14d
loc_84046:
cmp r14, 17Ah
jz loc_8412A
lea rax, case_conv_table1
mov ebp, [rax+r14*4]
mov eax, ebp
shr eax, 4
and eax, 0Fh
bt r13d, eax
jnb loc_8411A
mov r15d, ebp
shr r15d, 0Fh
shr ebp, 8
and ebp, 7Fh
cmp eax, 5
jz short loc_840B8
cmp eax, 4
jnz short loc_84106
cmp [rsp+38h+var_35], 0
jz short loc_84106
add r15d, [rsp+38h+var_34]
xor r12d, r12d
loc_84096:
cmp r12d, ebp
jnb short loc_8411A
lea edx, [r15+1]
mov rdi, rbx
mov esi, r15d
call cr_add_interval
add r12d, 2
add r15d, 2
test eax, eax
jz short loc_84096
jmp short loc_84122
loc_840B8:
cmp [rsp+38h+var_35], 0
jz short loc_84106
lea ebp, [r15+1]
cmp [rsp+38h+var_34], 0
jnz short loc_840DB
mov rdi, rbx
mov esi, r15d
mov edx, ebp
call cr_add_interval
test eax, eax
jnz short loc_84122
loc_840DB:
lea r12d, [r15+2]
mov rdi, rbx
mov esi, ebp
mov edx, r12d
call cr_add_interval
test eax, eax
jnz short loc_84122
cmp [rsp+38h+var_34], 0
jz short loc_8411A
add r15d, 3
mov rdi, rbx
mov esi, r12d
mov edx, r15d
jmp short loc_84111
loc_84106:
add ebp, r15d
mov rdi, rbx
mov esi, r15d
mov edx, ebp
loc_84111:
call cr_add_interval
test eax, eax
jnz short loc_84122
loc_8411A:
inc r14
jmp loc_84046
loc_84122:
push 0FFFFFFFFFFFFFFFFh
pop rax
jmp short loc_8412C
loc_84127:
xor eax, eax
retn
loc_8412A:
xor eax, eax
loc_8412C:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long unicode_case1(int *a1, int a2)
{
long long v3; // rax
_DWORD *v4; // rcx
int v5; // r13d
long long i; // r14
unsigned int v7; // ebp
unsigned int v8; // eax
int v9; // r15d
unsigned int v10; // ebp
int v11; // r15d
unsigned int j; // r12d
int v13; // eax
int v14; // ebp
int *v15; // rdi
int v16; // esi
int v17; // edx
bool v19; // [rsp+1h] [rbp-35h]
int v20; // [rsp+2h] [rbp-34h]
if ( !a2 )
return 0LL;
v3 = 0LL;
v4 = &unk_94FCC;
v5 = 0;
while ( v3 != 3 )
{
if ( _bittest(&a2, v3) )
v5 |= *v4;
++v3;
++v4;
}
v20 = a2 & 1;
v19 = v20 == 0 || (a2 & 6) == 0;
for ( i = 0LL; i != 378; ++i )
{
v7 = case_conv_table1[i];
v8 = (unsigned __int8)v7 >> 4;
if ( !_bittest(&v5, v8) )
continue;
v9 = v7 >> 15;
v10 = (v7 >> 8) & 0x7F;
if ( v8 != 5 )
{
if ( v8 == 4 && v19 )
{
v11 = v20 + v9;
for ( j = 0; j < v10; j += 2 )
{
v13 = cr_add_interval(a1, v11, v11 + 1);
v11 += 2;
if ( v13 )
return -1LL;
}
continue;
}
LABEL_23:
v15 = a1;
v16 = v9;
v17 = v9 + v10;
LABEL_24:
if ( (unsigned int)cr_add_interval(v15, v16, v17) )
return -1LL;
continue;
}
if ( !v19 )
goto LABEL_23;
v14 = v9 + 1;
if ( !v20 && (unsigned int)cr_add_interval(a1, v9, v14) || (unsigned int)cr_add_interval(a1, v14, v9 + 2) )
return -1LL;
if ( v20 )
{
v15 = a1;
v16 = v9 + 2;
v17 = v9 + 3;
goto LABEL_24;
}
}
return 0LL;
}
| unicode_case1:
TEST ESI,ESI
JZ 0x00184127
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
XOR EAX,EAX
LEA RCX,[0x194fcc]
XOR R13D,R13D
LAB_00184013:
CMP RAX,0x3
JZ 0x0018402a
BT ESI,EAX
JNC 0x00184021
OR R13D,dword ptr [RCX]
LAB_00184021:
INC RAX
ADD RCX,0x4
JMP 0x00184013
LAB_0018402a:
MOV EAX,ESI
AND EAX,0x1
MOV dword ptr [RSP + 0x4],EAX
SETZ AL
TEST SIL,0x6
SETZ CL
OR CL,AL
MOV byte ptr [RSP + 0x3],CL
XOR R14D,R14D
LAB_00184046:
CMP R14,0x17a
JZ 0x0018412a
LEA RAX,[0x18d9a0]
MOV EBP,dword ptr [RAX + R14*0x4]
MOV EAX,EBP
SHR EAX,0x4
AND EAX,0xf
BT R13D,EAX
JNC 0x0018411a
MOV R15D,EBP
SHR R15D,0xf
SHR EBP,0x8
AND EBP,0x7f
CMP EAX,0x5
JZ 0x001840b8
CMP EAX,0x4
JNZ 0x00184106
CMP byte ptr [RSP + 0x3],0x0
JZ 0x00184106
ADD R15D,dword ptr [RSP + 0x4]
XOR R12D,R12D
LAB_00184096:
CMP R12D,EBP
JNC 0x0018411a
LEA EDX,[R15 + 0x1]
MOV RDI,RBX
MOV ESI,R15D
CALL 0x00183c49
ADD R12D,0x2
ADD R15D,0x2
TEST EAX,EAX
JZ 0x00184096
JMP 0x00184122
LAB_001840b8:
CMP byte ptr [RSP + 0x3],0x0
JZ 0x00184106
LEA EBP,[R15 + 0x1]
CMP dword ptr [RSP + 0x4],0x0
JNZ 0x001840db
MOV RDI,RBX
MOV ESI,R15D
MOV EDX,EBP
CALL 0x00183c49
TEST EAX,EAX
JNZ 0x00184122
LAB_001840db:
LEA R12D,[R15 + 0x2]
MOV RDI,RBX
MOV ESI,EBP
MOV EDX,R12D
CALL 0x00183c49
TEST EAX,EAX
JNZ 0x00184122
CMP dword ptr [RSP + 0x4],0x0
JZ 0x0018411a
ADD R15D,0x3
MOV RDI,RBX
MOV ESI,R12D
MOV EDX,R15D
JMP 0x00184111
LAB_00184106:
ADD EBP,R15D
MOV RDI,RBX
MOV ESI,R15D
MOV EDX,EBP
LAB_00184111:
CALL 0x00183c49
TEST EAX,EAX
JNZ 0x00184122
LAB_0018411a:
INC R14
JMP 0x00184046
LAB_00184122:
PUSH -0x1
POP RAX
JMP 0x0018412c
LAB_00184127:
XOR EAX,EAX
RET
LAB_0018412a:
XOR EAX,EAX
LAB_0018412c:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 unicode_case1(int8 param_1,uint param_2)
{
uint uVar1;
int iVar2;
long lVar3;
uint *puVar4;
uint uVar5;
uint uVar6;
uint uVar7;
int iVar8;
bool bVar9;
bool bVar10;
uint local_34;
if (param_2 == 0) {
return 0;
}
puVar4 = &DAT_00194fcc;
uVar6 = 0;
for (lVar3 = 0; lVar3 != 3; lVar3 = lVar3 + 1) {
if ((param_2 >> ((uint)lVar3 & 0x1f) & 1) != 0) {
uVar6 = uVar6 | *puVar4;
}
puVar4 = puVar4 + 1;
}
bVar9 = (param_2 & 1) != 0;
local_34 = param_2 & 1;
bVar10 = (param_2 & 6) != 0;
lVar3 = 0;
do {
if (lVar3 == 0x17a) {
return 0;
}
uVar5 = (&case_conv_table1)[lVar3];
uVar1 = uVar5 >> 4 & 0xf;
if ((uVar6 >> uVar1 & 1) != 0) {
uVar7 = uVar5 >> 0xf;
uVar5 = uVar5 >> 8 & 0x7f;
if (uVar1 == 5) {
if (bVar10 && bVar9) goto LAB_00184106;
if ((local_34 == 0) && (iVar8 = cr_add_interval(param_1,uVar7,uVar7 + 1), iVar8 != 0)) {
return 0xffffffffffffffff;
}
uVar5 = uVar7 + 2;
iVar8 = cr_add_interval(param_1,uVar7 + 1,uVar5);
if (iVar8 != 0) {
return 0xffffffffffffffff;
}
if (local_34 == 0) goto LAB_0018411a;
iVar8 = uVar7 + 3;
}
else {
if ((uVar1 == 4) && (!bVar10 || !bVar9)) {
iVar8 = uVar7 + local_34;
uVar1 = 0;
while (uVar1 < uVar5) {
iVar2 = cr_add_interval(param_1,iVar8,iVar8 + 1);
uVar1 = uVar1 + 2;
iVar8 = iVar8 + 2;
if (iVar2 != 0) {
return 0xffffffffffffffff;
}
}
goto LAB_0018411a;
}
LAB_00184106:
iVar8 = uVar5 + uVar7;
uVar5 = uVar7;
}
iVar8 = cr_add_interval(param_1,uVar5,iVar8);
if (iVar8 != 0) {
return 0xffffffffffffffff;
}
}
LAB_0018411a:
lVar3 = lVar3 + 1;
} while( true );
}
| |
47,288 | my_charlen_utf8mb3 | eloqsql/strings/ctype-utf8.c | static
int my_charlen_utf8mb3(CHARSET_INFO *cs __attribute__((unused)),
const uchar *s, const uchar *e)
{
uchar c;
if (s >= e)
return MY_CS_TOOSMALL;
c= s[0];
if (c < 0xf0)
return my_valid_mbcharlen_utf8mb3(s, e);
return MY_CS_ILSEQ;
} | O3 | c | my_charlen_utf8mb3:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rdx, %rsi
jae 0x4faa7
movb (%rsi), %cl
cmpb $-0x11, %cl
ja 0x4faa5
movl $0x1, %eax
testb %cl, %cl
jns 0x4faa7
cmpb $-0x3e, %cl
jae 0x4faa9
xorl %eax, %eax
popq %rbp
retq
cmpb $-0x21, %cl
ja 0x4fac9
leaq 0x2(%rsi), %rcx
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rdx, %rcx
ja 0x4faa7
xorl %eax, %eax
cmpb $-0x40, 0x1(%rsi)
setl %al
addl %eax, %eax
jmp 0x4faa7
leaq 0x3(%rsi), %rdi
movl $0xffffff99, %eax # imm = 0xFFFFFF99
cmpq %rdx, %rdi
ja 0x4faa7
movb 0x1(%rsi), %dl
cmpb $-0x41, %dl
jg 0x4faa5
cmpb $-0x41, 0x2(%rsi)
movl $0x0, %eax
jg 0x4faa7
xorl %eax, %eax
cmpb $-0x60, %dl
setae %al
cmpb $-0x20, %cl
leal (%rax,%rax,2), %ecx
movl $0x3, %eax
cmovel %ecx, %eax
jmp 0x4faa7
| my_charlen_utf8mb3:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rsi, rdx
jnb short loc_4FAA7
mov cl, [rsi]
cmp cl, 0EFh
ja short loc_4FAA5
mov eax, 1
test cl, cl
jns short loc_4FAA7
cmp cl, 0C2h
jnb short loc_4FAA9
loc_4FAA5:
xor eax, eax
loc_4FAA7:
pop rbp
retn
loc_4FAA9:
cmp cl, 0DFh
ja short loc_4FAC9
lea rcx, [rsi+2]
mov eax, 0FFFFFF9Ah
cmp rcx, rdx
ja short loc_4FAA7
xor eax, eax
cmp byte ptr [rsi+1], 0C0h
setl al
add eax, eax
jmp short loc_4FAA7
loc_4FAC9:
lea rdi, [rsi+3]
mov eax, 0FFFFFF99h
cmp rdi, rdx
ja short loc_4FAA7
mov dl, [rsi+1]
cmp dl, 0BFh
jg short loc_4FAA5
cmp byte ptr [rsi+2], 0BFh
mov eax, 0
jg short loc_4FAA7
xor eax, eax
cmp dl, 0A0h
setnb al
cmp cl, 0E0h
lea ecx, [rax+rax*2]
mov eax, 3
cmovz eax, ecx
jmp short loc_4FAA7
| long long my_charlen_utf8mb3(long long a1, char *a2, unsigned long long a3)
{
long long result; // rax
char v4; // cl
char v5; // dl
result = 4294967195LL;
if ( (unsigned long long)a2 < a3 )
{
v4 = *a2;
if ( (unsigned __int8)*a2 > 0xEFu )
return 0LL;
result = 1LL;
if ( v4 >= 0 )
return result;
if ( (unsigned __int8)v4 < 0xC2u )
return 0LL;
if ( (unsigned __int8)v4 > 0xDFu )
{
result = 4294967193LL;
if ( (unsigned long long)(a2 + 3) <= a3 )
{
v5 = a2[1];
if ( v5 > -65 )
return 0LL;
result = 0LL;
if ( a2[2] <= -65 )
{
result = 3LL;
if ( v4 == -32 )
return 3 * (unsigned int)((unsigned __int8)v5 >= 0xA0u);
}
}
}
else
{
result = 4294967194LL;
if ( (unsigned long long)(a2 + 2) <= a3 )
return 2 * (unsigned int)(a2[1] < -64);
}
}
return result;
}
| my_charlen_utf8mb3:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RSI,RDX
JNC 0x0014faa7
MOV CL,byte ptr [RSI]
CMP CL,0xef
JA 0x0014faa5
MOV EAX,0x1
TEST CL,CL
JNS 0x0014faa7
CMP CL,0xc2
JNC 0x0014faa9
LAB_0014faa5:
XOR EAX,EAX
LAB_0014faa7:
POP RBP
RET
LAB_0014faa9:
CMP CL,0xdf
JA 0x0014fac9
LEA RCX,[RSI + 0x2]
MOV EAX,0xffffff9a
CMP RCX,RDX
JA 0x0014faa7
XOR EAX,EAX
CMP byte ptr [RSI + 0x1],0xc0
SETL AL
ADD EAX,EAX
JMP 0x0014faa7
LAB_0014fac9:
LEA RDI,[RSI + 0x3]
MOV EAX,0xffffff99
CMP RDI,RDX
JA 0x0014faa7
MOV DL,byte ptr [RSI + 0x1]
CMP DL,0xbf
JG 0x0014faa5
CMP byte ptr [RSI + 0x2],0xbf
MOV EAX,0x0
JG 0x0014faa7
XOR EAX,EAX
CMP DL,0xa0
SETNC AL
CMP CL,0xe0
LEA ECX,[RAX + RAX*0x2]
MOV EAX,0x3
CMOVZ EAX,ECX
JMP 0x0014faa7
|
int my_charlen_utf8mb3(int8 param_1,byte *param_2,byte *param_3)
{
byte bVar1;
if (param_3 <= param_2) {
return -0x65;
}
bVar1 = *param_2;
if (bVar1 < 0xf0) {
if (-1 < (char)bVar1) {
return 1;
}
if (0xc1 < bVar1) {
if (bVar1 < 0xe0) {
if (param_3 < param_2 + 2) {
return -0x66;
}
return (uint)((char)param_2[1] < -0x40) * 2;
}
if (param_3 < param_2 + 3) {
return -0x67;
}
if ((char)param_2[1] < -0x40) {
if (-0x41 < (char)param_2[2]) {
return 0;
}
if (bVar1 != 0xe0) {
return 3;
}
return (uint)(0x9f < param_2[1]) * 3;
}
}
}
return 0;
}
| |
47,289 | exchange_int32s | bluesky950520[P]quickjs/cutils.c | static void exchange_int32s(void *a, void *b, size_t size) {
uint32_t *ap = (uint32_t *)a;
uint32_t *bp = (uint32_t *)b;
for (size /= sizeof(uint32_t); size-- != 0;) {
uint32_t t = *ap;
*ap++ = *bp;
*bp++ = t;
}
} | O1 | c | exchange_int32s:
cmpq $0x4, %rdx
jb 0x1c936
shrq $0x2, %rdx
xorl %eax, %eax
movl (%rdi,%rax,4), %ecx
movl (%rsi,%rax,4), %r8d
movl %r8d, (%rdi,%rax,4)
movl %ecx, (%rsi,%rax,4)
incq %rax
cmpq %rax, %rdx
jne 0x1c920
retq
| exchange_int32s:
cmp rdx, 4
jb short locret_1C936
shr rdx, 2
xor eax, eax
loc_1C920:
mov ecx, [rdi+rax*4]
mov r8d, [rsi+rax*4]
mov [rdi+rax*4], r8d
mov [rsi+rax*4], ecx
inc rax
cmp rdx, rax
jnz short loc_1C920
locret_1C936:
retn
| void exchange_int32s(long long a1, long long a2, unsigned long long a3)
{
unsigned long long v3; // rdx
long long v4; // rax
int v5; // ecx
if ( a3 >= 4 )
{
v3 = a3 >> 2;
v4 = 0LL;
do
{
v5 = *(_DWORD *)(a1 + 4 * v4);
*(_DWORD *)(a1 + 4 * v4) = *(_DWORD *)(a2 + 4 * v4);
*(_DWORD *)(a2 + 4 * v4++) = v5;
}
while ( v3 != v4 );
}
}
| |||
47,290 | exchange_int32s | bluesky950520[P]quickjs/cutils.c | static void exchange_int32s(void *a, void *b, size_t size) {
uint32_t *ap = (uint32_t *)a;
uint32_t *bp = (uint32_t *)b;
for (size /= sizeof(uint32_t); size-- != 0;) {
uint32_t t = *ap;
*ap++ = *bp;
*bp++ = t;
}
} | O2 | c | exchange_int32s:
shrq $0x2, %rdx
xorl %eax, %eax
cmpq %rax, %rdx
je 0x16f3e
movl (%rdi,%rax,4), %ecx
movl (%rsi,%rax,4), %r8d
movl %r8d, (%rdi,%rax,4)
movl %ecx, (%rsi,%rax,4)
incq %rax
jmp 0x16f26
retq
| exchange_int32s:
shr rdx, 2
xor eax, eax
loc_16F26:
cmp rdx, rax
jz short locret_16F3E
mov ecx, [rdi+rax*4]
mov r8d, [rsi+rax*4]
mov [rdi+rax*4], r8d
mov [rsi+rax*4], ecx
inc rax
jmp short loc_16F26
locret_16F3E:
retn
| long long exchange_int32s(long long a1, long long a2, unsigned long long a3)
{
unsigned long long v3; // rdx
long long result; // rax
int v5; // ecx
v3 = a3 >> 2;
for ( result = 0LL; v3 != result; ++result )
{
v5 = *(_DWORD *)(a1 + 4 * result);
*(_DWORD *)(a1 + 4 * result) = *(_DWORD *)(a2 + 4 * result);
*(_DWORD *)(a2 + 4 * result) = v5;
}
return result;
}
| exchange_int32s:
SHR RDX,0x2
XOR EAX,EAX
LAB_00116f26:
CMP RDX,RAX
JZ 0x00116f3e
MOV ECX,dword ptr [RDI + RAX*0x4]
MOV R8D,dword ptr [RSI + RAX*0x4]
MOV dword ptr [RDI + RAX*0x4],R8D
MOV dword ptr [RSI + RAX*0x4],ECX
INC RAX
JMP 0x00116f26
LAB_00116f3e:
RET
|
void exchange_int32s(long param_1,long param_2,ulong param_3)
{
int4 uVar1;
ulong uVar2;
for (uVar2 = 0; param_3 >> 2 != uVar2; uVar2 = uVar2 + 1) {
uVar1 = *(int4 *)(param_1 + uVar2 * 4);
*(int4 *)(param_1 + uVar2 * 4) = *(int4 *)(param_2 + uVar2 * 4);
*(int4 *)(param_2 + uVar2 * 4) = uVar1;
}
return;
}
| |
47,291 | exchange_int32s | bluesky950520[P]quickjs/cutils.c | static void exchange_int32s(void *a, void *b, size_t size) {
uint32_t *ap = (uint32_t *)a;
uint32_t *bp = (uint32_t *)b;
for (size /= sizeof(uint32_t); size-- != 0;) {
uint32_t t = *ap;
*ap++ = *bp;
*bp++ = t;
}
} | O3 | c | exchange_int32s:
cmpq $0x4, %rdx
jb 0x1d234
shrq $0x2, %rdx
xorl %eax, %eax
movl (%rdi,%rax,4), %ecx
movl (%rsi,%rax,4), %r8d
movl %r8d, (%rdi,%rax,4)
movl %ecx, (%rsi,%rax,4)
incq %rax
cmpq %rax, %rdx
jne 0x1d21e
retq
| exchange_int32s:
cmp rdx, 4
jb short locret_1D234
shr rdx, 2
xor eax, eax
loc_1D21E:
mov ecx, [rdi+rax*4]
mov r8d, [rsi+rax*4]
mov [rdi+rax*4], r8d
mov [rsi+rax*4], ecx
inc rax
cmp rdx, rax
jnz short loc_1D21E
locret_1D234:
retn
| void exchange_int32s(long long a1, long long a2, unsigned long long a3)
{
unsigned long long v3; // rdx
long long v4; // rax
int v5; // ecx
if ( a3 >= 4 )
{
v3 = a3 >> 2;
v4 = 0LL;
do
{
v5 = *(_DWORD *)(a1 + 4 * v4);
*(_DWORD *)(a1 + 4 * v4) = *(_DWORD *)(a2 + 4 * v4);
*(_DWORD *)(a2 + 4 * v4++) = v5;
}
while ( v3 != v4 );
}
}
| exchange_int32s:
CMP RDX,0x4
JC 0x0011d234
SHR RDX,0x2
XOR EAX,EAX
LAB_0011d21e:
MOV ECX,dword ptr [RDI + RAX*0x4]
MOV R8D,dword ptr [RSI + RAX*0x4]
MOV dword ptr [RDI + RAX*0x4],R8D
MOV dword ptr [RSI + RAX*0x4],ECX
INC RAX
CMP RDX,RAX
JNZ 0x0011d21e
LAB_0011d234:
RET
|
void exchange_int32s(long param_1,long param_2,ulong param_3)
{
int4 uVar1;
ulong uVar2;
if (3 < param_3) {
uVar2 = 0;
do {
uVar1 = *(int4 *)(param_1 + uVar2 * 4);
*(int4 *)(param_1 + uVar2 * 4) = *(int4 *)(param_2 + uVar2 * 4);
*(int4 *)(param_2 + uVar2 * 4) = uVar1;
uVar2 = uVar2 + 1;
} while (param_3 >> 2 != uVar2);
}
return;
}
| |
47,292 | wait_for_readers | eloqsql/storage/maria/ma_pagecache.c | static inline void wait_for_readers(PAGECACHE *pagecache
__attribute__((unused)),
PAGECACHE_BLOCK_LINK *block
__attribute__((unused)))
{
struct st_my_thread_var *thread= my_thread_var;
DBUG_ASSERT(block->condvar == NULL);
while (block->hash_link->requests)
{
DBUG_ENTER("wait_for_readers");
DBUG_PRINT("wait",
("suspend thread: %s %ld block: %u",
thread->name, (ulong) thread->id,
PCBLOCK_NUMBER(pagecache, block)));
block->condvar= &thread->suspend;
pagecache_pthread_cond_wait(&thread->suspend, &pagecache->cache_lock);
block->condvar= NULL;
DBUG_VOID_RETURN;
}
} | O0 | c | wait_for_readers:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0xfea30
movq %rax, -0x18(%rbp)
jmp 0x9c83b
jmp 0x9c83d
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x0, 0x68(%rax)
je 0x9c891
jmp 0x9c84d
jmp 0x9c84f
movq -0x18(%rbp), %rcx
addq $0x8, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
addq $0xc8, %rsi
leaq 0xc16ff(%rip), %rdx # 0x15df78
movl $0x64d, %ecx # imm = 0x64D
callq 0x9bf10
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
jmp 0x9c891
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| wait_for_readers:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
call _my_thread_var
mov [rbp+var_18], rax
jmp short $+2
loc_9C83B:
jmp short $+2
loc_9C83D:
mov rax, [rbp+var_10]
mov rax, [rax+20h]
cmp dword ptr [rax+68h], 0
jz short loc_9C891
jmp short $+2
loc_9C84D:
jmp short $+2
loc_9C84F:
mov rcx, [rbp+var_18]
add rcx, 8
mov rax, [rbp+var_10]
mov [rax+28h], rcx
mov rdi, [rbp+var_18]
add rdi, 8
mov rsi, [rbp+var_8]
add rsi, 0C8h
lea rdx, aWorkspaceLlm4b_20; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 64Dh
call inline_mysql_cond_wait_2
mov rax, [rbp+var_10]
mov qword ptr [rax+28h], 0
jmp short $+2
loc_9C891:
add rsp, 20h
pop rbp
retn
| long long wait_for_readers(long long a1, long long a2)
{
long long result; // rax
long long v3; // [rsp+8h] [rbp-18h]
v3 = my_thread_var(a1, (const char *)a2);
result = *(_QWORD *)(a2 + 32);
if ( *(_DWORD *)(result + 104) )
{
*(_QWORD *)(a2 + 40) = v3 + 8;
inline_mysql_cond_wait_2(
v3 + 8,
a1 + 200,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0x64Du);
result = a2;
*(_QWORD *)(a2 + 40) = 0LL;
}
return result;
}
| wait_for_readers:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
CALL 0x001fea30
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0019c83b
LAB_0019c83b:
JMP 0x0019c83d
LAB_0019c83d:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
CMP dword ptr [RAX + 0x68],0x0
JZ 0x0019c891
JMP 0x0019c84d
LAB_0019c84d:
JMP 0x0019c84f
LAB_0019c84f:
MOV RCX,qword ptr [RBP + -0x18]
ADD RCX,0x8
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x28],RCX
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x8
MOV RSI,qword ptr [RBP + -0x8]
ADD RSI,0xc8
LEA RDX,[0x25df78]
MOV ECX,0x64d
CALL 0x0019bf10
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x28],0x0
JMP 0x0019c891
LAB_0019c891:
ADD RSP,0x20
POP RBP
RET
|
void wait_for_readers(long param_1,long param_2)
{
long lVar1;
lVar1 = _my_thread_var();
if (*(int *)(*(long *)(param_2 + 0x20) + 0x68) != 0) {
*(long *)(param_2 + 0x28) = lVar1 + 8;
inline_mysql_cond_wait
(lVar1 + 8,param_1 + 200,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",0x64d);
*(int8 *)(param_2 + 0x28) = 0;
}
return;
}
| |
47,293 | wait_for_readers | eloqsql/storage/maria/ma_pagecache.c | static inline void wait_for_readers(PAGECACHE *pagecache
__attribute__((unused)),
PAGECACHE_BLOCK_LINK *block
__attribute__((unused)))
{
struct st_my_thread_var *thread= my_thread_var;
DBUG_ASSERT(block->condvar == NULL);
while (block->hash_link->requests)
{
DBUG_ENTER("wait_for_readers");
DBUG_PRINT("wait",
("suspend thread: %s %ld block: %u",
thread->name, (ulong) thread->id,
PCBLOCK_NUMBER(pagecache, block)));
block->condvar= &thread->suspend;
pagecache_pthread_cond_wait(&thread->suspend, &pagecache->cache_lock);
block->condvar= NULL;
DBUG_VOID_RETURN;
}
} | O3 | c | wait_for_readers:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa8dda
movq 0x20(%rbx), %rcx
cmpl $0x0, 0x68(%rcx)
je 0x7333f
movq %rax, %rcx
addq $0x8, %rax
movq %rax, 0x28(%rbx)
addq $0xc8, %r14
cmpq $0x0, 0x38(%rcx)
jne 0x73344
movq %rax, %rdi
movq %r14, %rsi
callq 0x2a410
movq $0x0, 0x28(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6fce8(%rip), %rdx # 0xe3033
movq %rax, %rdi
movq %r14, %rsi
movl $0x64d, %ecx # imm = 0x64D
callq 0x30240
jmp 0x73337
| wait_for_readers:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rsi
mov r14, rdi
call _my_thread_var
mov rcx, [rbx+20h]
cmp dword ptr [rcx+68h], 0
jz short loc_7333F
mov rcx, rax
add rax, 8
mov [rbx+28h], rax
add r14, 0C8h
cmp qword ptr [rcx+38h], 0
jnz short loc_73344
mov rdi, rax
mov rsi, r14
call _pthread_cond_wait
loc_73337:
mov qword ptr [rbx+28h], 0
loc_7333F:
pop rbx
pop r14
pop rbp
retn
loc_73344:
lea rdx, aWorkspaceLlm4b_36; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, rax
mov rsi, r14
mov ecx, 64Dh
call psi_cond_wait
jmp short loc_73337
| long long wait_for_readers(long long a1, long long a2)
{
long long result; // rax
long long v3; // rcx
long long v4; // rax
long long v5; // r14
result = my_thread_var(a1, (const char *)a2);
if ( *(_DWORD *)(*(_QWORD *)(a2 + 32) + 104LL) )
{
v3 = result;
v4 = result + 8;
*(_QWORD *)(a2 + 40) = v4;
v5 = a1 + 200;
if ( *(_QWORD *)(v3 + 56) )
result = psi_cond_wait(
v4,
v5,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0x64Du);
else
result = pthread_cond_wait(v4, v5);
*(_QWORD *)(a2 + 40) = 0LL;
}
return result;
}
| wait_for_readers:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
CALL 0x001a8dda
MOV RCX,qword ptr [RBX + 0x20]
CMP dword ptr [RCX + 0x68],0x0
JZ 0x0017333f
MOV RCX,RAX
ADD RAX,0x8
MOV qword ptr [RBX + 0x28],RAX
ADD R14,0xc8
CMP qword ptr [RCX + 0x38],0x0
JNZ 0x00173344
MOV RDI,RAX
MOV RSI,R14
CALL 0x0012a410
LAB_00173337:
MOV qword ptr [RBX + 0x28],0x0
LAB_0017333f:
POP RBX
POP R14
POP RBP
RET
LAB_00173344:
LEA RDX,[0x1e3033]
MOV RDI,RAX
MOV RSI,R14
MOV ECX,0x64d
CALL 0x00130240
JMP 0x00173337
|
void wait_for_readers(long param_1,long param_2)
{
long lVar1;
pthread_cond_t *__cond;
lVar1 = _my_thread_var();
if (*(int *)(*(long *)(param_2 + 0x20) + 0x68) != 0) {
__cond = (pthread_cond_t *)(lVar1 + 8);
*(pthread_cond_t **)(param_2 + 0x28) = __cond;
if (*(long *)(lVar1 + 0x38) == 0) {
pthread_cond_wait(__cond,(pthread_mutex_t *)(param_1 + 200));
}
else {
psi_cond_wait(__cond,(pthread_mutex_t *)(param_1 + 200),
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",0x64d);
}
*(int8 *)(param_2 + 0x28) = 0;
}
return;
}
| |
47,294 | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::operator->() const | monkey531[P]llama/common/json.hpp | pointer operator->() const
{
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_data.m_type)
{
case value_t::object:
{
JSON_ASSERT(m_it.object_iterator != m_object->m_data.m_value.object->end());
return &(m_it.object_iterator->second);
}
case value_t::array:
{
JSON_ASSERT(m_it.array_iterator != m_object->m_data.m_value.array->end());
return &*m_it.array_iterator;
}
case value_t::null:
case value_t::string:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::binary:
case value_t::discarded:
default:
{
if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
{
return m_object;
}
JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
}
}
} | O1 | cpp | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::operator->() const:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0x4b79f
movq %rdi, %r14
movzbl (%rax), %ecx
cmpl $0x2, %ecx
je 0x4b702
cmpl $0x1, %ecx
jne 0x4b72f
movq 0x8(%rax), %rcx
movq 0x8(%r14), %rax
cmpq 0x8(%rcx), %rax
je 0x4b7bb
addq $0x20, %rax
jmp 0x4b736
movq 0x8(%rax), %rcx
movq 0x10(%r14), %rax
cmpq 0x8(%rcx), %rax
jne 0x4b736
leaq 0x62096(%rip), %rdi # 0xad7ad
leaq 0x60863(%rip), %rdx # 0xabf81
leaq 0x6362e(%rip), %rcx # 0xaed53
movl $0x3397, %esi # imm = 0x3397
jmp 0x4b7d5
cmpq $0x0, 0x18(%r14)
jne 0x4b741
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x18350
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x63632(%rip), %rsi # 0xaed90
leaq 0x6363b(%rip), %rdx # 0xaeda0
leaq 0x8(%rsp), %rdi
callq 0x1de7e
movq (%r14), %rcx
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0xd6, %esi
callq 0x4bc4a
xorl %ebp, %ebp
leaq 0x93c60(%rip), %rsi # 0xdf3f0
leaq 0x2d9d(%rip), %rdx # 0x4e534
movq %rbx, %rdi
callq 0x18b50
leaq 0x62007(%rip), %rdi # 0xad7ad
leaq 0x607d4(%rip), %rdx # 0xabf81
leaq 0x64777(%rip), %rcx # 0xaff2b
movl $0x338b, %esi # imm = 0x338B
jmp 0x4b7d5
leaq 0x61feb(%rip), %rdi # 0xad7ad
leaq 0x607b8(%rip), %rdx # 0xabf81
leaq 0x63544(%rip), %rcx # 0xaed14
movl $0x3391, %esi # imm = 0x3391
xorl %eax, %eax
callq 0x18af0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4b7fe
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x186a0
jmp 0x4b7fe
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x4b80b
movq %rbx, %rdi
callq 0x184f0
movq %r14, %rdi
callq 0x18bc0
nop
| _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEptEv:
push rbp; char
push r15; int
push r14; __int64
push rbx; int
sub rsp, 28h
mov rax, [rdi]
test rax, rax
jz loc_4B79F
mov r14, rdi
movzx ecx, byte ptr [rax]
cmp ecx, 2
jz short loc_4B702
cmp ecx, 1
jnz short loc_4B72F
mov rcx, [rax+8]
mov rax, [r14+8]
cmp rax, [rcx+8]
jz loc_4B7BB
add rax, 20h ; ' '
jmp short loc_4B736
loc_4B702:
mov rcx, [rax+8]
mov rax, [r14+10h]
cmp rax, [rcx+8]
jnz short loc_4B736
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aMItArrayIterat; "m_it.array_iterator != m_object->m_data"...
mov esi, 3397h
jmp loc_4B7D5
loc_4B72F:
cmp qword ptr [r14+18h], 0
jnz short loc_4B741
loc_4B736:
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_4B741:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r15, [rsp+48h+var_30]
mov [r15-10h], r15
lea rsi, aCannotGetValue; "cannot get value"
lea rdx, aCannotGetValue+10h; ""
lea rdi, [rsp+48h+var_40]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rcx, [r14]
mov bpl, 1
lea rdx, [rsp+48h+var_40]
mov rdi, rbx; this
mov esi, 0D6h; int
call _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_4B79F:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aAnchorMObjectN+7; "m_object != nullptr"
mov esi, 338Bh
jmp short loc_4B7D5
loc_4B7BB:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aMItObjectItera; "m_it.object_iterator != m_object->m_dat"...
mov esi, 3391h
loc_4B7D5:
xor eax, eax
call _ggml_abort
mov r14, rax
mov rdi, [rsp+48h+var_40]; void *
cmp rdi, r15
jz short loc_4B7FE
mov rsi, [rsp+48h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_4B7FE
mov r14, rax
mov bpl, 1
loc_4B7FE:
test bpl, bpl
jz short loc_4B80B
mov rdi, rbx; void *
call ___cxa_free_exception
loc_4B80B:
mov rdi, r14
call __Unwind_Resume
| operator->:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x0014b79f
MOV R14,RDI
MOVZX ECX,byte ptr [RAX]
CMP ECX,0x2
JZ 0x0014b702
CMP ECX,0x1
JNZ 0x0014b72f
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [R14 + 0x8]
CMP RAX,qword ptr [RCX + 0x8]
JZ 0x0014b7bb
ADD RAX,0x20
JMP 0x0014b736
LAB_0014b702:
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [R14 + 0x10]
CMP RAX,qword ptr [RCX + 0x8]
JNZ 0x0014b736
LEA RDI,[0x1ad7ad]
LEA RDX,[0x1abf81]
LEA RCX,[0x1aed53]
MOV ESI,0x3397
JMP 0x0014b7d5
LAB_0014b72f:
CMP qword ptr [R14 + 0x18],0x0
JNZ 0x0014b741
LAB_0014b736:
ADD RSP,0x28
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0014b741:
MOV EDI,0x20
CALL 0x00118350
MOV RBX,RAX
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
LAB_0014b757:
LEA RSI,[0x1aed90]
LEA RDX,[0x1aeda0]
LEA RDI,[RSP + 0x8]
CALL 0x0011de7e
MOV RCX,qword ptr [R14]
MOV BPL,0x1
LAB_0014b775:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0xd6
CALL 0x0014bc4a
XOR EBP,EBP
LEA RSI,[0x1df3f0]
LEA RDX,[0x14e534]
MOV RDI,RBX
CALL 0x00118b50
LAB_0014b79f:
LEA RDI,[0x1ad7ad]
LEA RDX,[0x1abf81]
LEA RCX,[0x1aff2b]
MOV ESI,0x338b
JMP 0x0014b7d5
LAB_0014b7bb:
LEA RDI,[0x1ad7ad]
LEA RDX,[0x1abf81]
LEA RCX,[0x1aed14]
MOV ESI,0x3391
LAB_0014b7d5:
XOR EAX,EAX
CALL 0x00118af0
|
/* nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::TEMPNAMEPLACEHOLDERVALUE() const */
char * __thiscall
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::operator->(iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this)
{
long *plVar1;
char *pcVar2;
int8 uVar3;
int1 *local_40 [2];
int1 local_30 [16];
pcVar2 = *(char **)this;
if (pcVar2 == (char *)0x0) {
pcVar2 = "m_object != nullptr";
uVar3 = 0x338b;
LAB_0014b7d5:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",uVar3,
"GGML_ASSERT(%s) failed",pcVar2);
}
if (*pcVar2 == '\x02') {
plVar1 = (long *)(pcVar2 + 8);
pcVar2 = *(char **)(this + 0x10);
if (pcVar2 == *(char **)(*plVar1 + 8)) {
pcVar2 = "m_it.array_iterator != m_object->m_data.m_value.array->end()";
uVar3 = 0x3397;
goto LAB_0014b7d5;
}
}
else if (*pcVar2 == '\x01') {
if (*(long *)(this + 8) == *(long *)(*(long *)(pcVar2 + 8) + 8)) {
pcVar2 = "m_it.object_iterator != m_object->m_data.m_value.object->end()";
uVar3 = 0x3391;
goto LAB_0014b7d5;
}
pcVar2 = (char *)(*(long *)(this + 8) + 0x20);
}
else if (*(long *)(this + 0x18) != 0) {
uVar3 = __cxa_allocate_exception(0x20);
local_40[0] = local_30;
/* try { // try from 0014b757 to 0014b76e has its CatchHandler @ 0014b7f8 */
std::__cxx11::string::_M_construct<char_const*>(local_40,"cannot get value","");
/* try { // try from 0014b775 to 0014b79e has its CatchHandler @ 0014b7dc */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar3,0xd6,local_40,*(int8 *)this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar3,&invalid_iterator::typeinfo,exception::~exception);
}
return pcVar2;
}
| ||
47,295 | ma_keylength_part | eloqsql/storage/maria/ma_search.c | uint _ma_keylength_part(MARIA_KEYDEF *keyinfo, register const uchar *key,
HA_KEYSEG *end)
{
reg1 HA_KEYSEG *keyseg;
const uchar *start= key;
for (keyseg=keyinfo->seg ; keyseg != end ; keyseg++)
{
if (keyseg->flag & HA_NULL_PART)
if (!*key++)
continue;
if (keyseg->flag & (HA_SPACE_PACK | HA_BLOB_PART | HA_VAR_LENGTH_PART))
{
uint length;
get_key_length(length,key);
key+=length;
}
else
key+= keyseg->length;
}
return (uint) (key-start);
} | O0 | c | ma_keylength_part:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0xc0(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x6cd4d
movq -0x20(%rbp), %rax
movzwl 0x12(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x6ccb0
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
cmpb $0x0, (%rax)
jne 0x6ccae
jmp 0x6cd3c
jmp 0x6ccb0
movq -0x20(%rbp), %rax
movzwl 0x12(%rax), %eax
andl $0x29, %eax
cmpl $0x0, %eax
je 0x6cd24
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xff, %eax
je 0x6cce5
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movzbl (%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0x6cd12
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
movzwl %ax, %eax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzwl %ax, %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x10(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x6cd3a
movq -0x20(%rbp), %rax
movzwl 0x14(%rax), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x6cd3c
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
jmp 0x6cc77
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
popq %rbp
retq
nopw (%rax,%rax)
| _ma_keylength_part:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
mov rax, [rbp+var_8]
mov rax, [rax+0C0h]
mov [rbp+var_20], rax
loc_6CC77:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_18]
jz loc_6CD4D
mov rax, [rbp+var_20]
movzx eax, word ptr [rax+12h]
and eax, 10h
cmp eax, 0
jz short loc_6CCB0
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 1
mov [rbp+var_10], rcx
cmp byte ptr [rax], 0
jnz short loc_6CCAE
jmp loc_6CD3C
loc_6CCAE:
jmp short $+2
loc_6CCB0:
mov rax, [rbp+var_20]
movzx eax, word ptr [rax+12h]
and eax, 29h
cmp eax, 0
jz short loc_6CD24
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax]
cmp eax, 0FFh
jz short loc_6CCE5
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 1
mov [rbp+var_10], rcx
movzx eax, byte ptr [rax]
mov [rbp+var_2C], eax
jmp short loc_6CD12
loc_6CCE5:
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+2]
movzx eax, ax
mov rcx, [rbp+var_10]
movzx ecx, byte ptr [rcx+1]
movzx ecx, cx
shl ecx, 8
or eax, ecx
movzx eax, ax
mov [rbp+var_2C], eax
mov rax, [rbp+var_10]
add rax, 3
mov [rbp+var_10], rax
loc_6CD12:
mov ecx, [rbp+var_2C]
mov rax, [rbp+var_10]
mov ecx, ecx
add rax, rcx
mov [rbp+var_10], rax
jmp short loc_6CD3A
loc_6CD24:
mov rax, [rbp+var_20]
movzx ecx, word ptr [rax+14h]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
loc_6CD3A:
jmp short $+2
loc_6CD3C:
mov rax, [rbp+var_20]
add rax, 20h ; ' '
mov [rbp+var_20], rax
jmp loc_6CC77
loc_6CD4D:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_28]
sub rax, rcx
pop rbp
retn
| unsigned __int8 * ma_keylength_part(long long a1, unsigned __int8 *a2, long long a3)
{
unsigned __int8 *v3; // rax
unsigned __int8 *v4; // rax
int v6; // [rsp+0h] [rbp-2Ch]
long long i; // [rsp+Ch] [rbp-20h]
unsigned __int8 *v8; // [rsp+1Ch] [rbp-10h]
unsigned __int8 *v9; // [rsp+1Ch] [rbp-10h]
v8 = a2;
for ( i = *(_QWORD *)(a1 + 192); i != a3; i += 32LL )
{
if ( (*(_WORD *)(i + 18) & 0x10) != 0 )
{
v3 = v8++;
if ( !*v3 )
continue;
}
if ( (*(_WORD *)(i + 18) & 0x29) != 0 )
{
if ( *v8 == 255 )
{
v6 = _byteswap_ushort(*(_WORD *)(v8 + 1));
v9 = v8 + 3;
}
else
{
v4 = v8;
v9 = v8 + 1;
v6 = *v4;
}
v8 = &v9[v6];
}
else
{
v8 += *(unsigned __int16 *)(i + 20);
}
}
return (unsigned __int8 *)(v8 - a2);
}
| _ma_keylength_part:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xc0]
MOV qword ptr [RBP + -0x20],RAX
LAB_0016cc77:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x18]
JZ 0x0016cd4d
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,word ptr [RAX + 0x12]
AND EAX,0x10
CMP EAX,0x0
JZ 0x0016ccb0
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x10],RCX
CMP byte ptr [RAX],0x0
JNZ 0x0016ccae
JMP 0x0016cd3c
LAB_0016ccae:
JMP 0x0016ccb0
LAB_0016ccb0:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,word ptr [RAX + 0x12]
AND EAX,0x29
CMP EAX,0x0
JZ 0x0016cd24
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0xff
JZ 0x0016cce5
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x10],RCX
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x0016cd12
LAB_0016cce5:
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x2]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RCX + 0x1]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOVZX EAX,AX
MOV dword ptr [RBP + -0x2c],EAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x3
MOV qword ptr [RBP + -0x10],RAX
LAB_0016cd12:
MOV ECX,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
JMP 0x0016cd3a
LAB_0016cd24:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX ECX,word ptr [RAX + 0x14]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
LAB_0016cd3a:
JMP 0x0016cd3c
LAB_0016cd3c:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x20
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0016cc77
LAB_0016cd4d:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x28]
SUB RAX,RCX
POP RBP
RET
|
long _ma_keylength_part(long param_1,byte *param_2,long param_3)
{
byte bVar1;
byte *pbVar2;
uint local_34;
long local_28;
byte *local_18;
local_18 = param_2;
for (local_28 = *(long *)(param_1 + 0xc0); local_28 != param_3; local_28 = local_28 + 0x20) {
if (((*(ushort *)(local_28 + 0x12) & 0x10) == 0) ||
(pbVar2 = local_18 + 1, bVar1 = *local_18, local_18 = pbVar2, bVar1 != 0)) {
if ((*(ushort *)(local_28 + 0x12) & 0x29) == 0) {
local_18 = local_18 + (int)(uint)*(ushort *)(local_28 + 0x14);
}
else {
if (*local_18 == 0xff) {
local_34 = (uint)CONCAT11(local_18[1],local_18[2]);
local_18 = local_18 + 3;
}
else {
local_34 = (uint)*local_18;
local_18 = local_18 + 1;
}
local_18 = local_18 + local_34;
}
}
}
return (long)local_18 - (long)param_2;
}
| |
47,296 | stbi__shiftsigned(unsigned int, int, int) | monkey531[P]llama/examples/llava/../../common/stb_image.h | static int stbi__shiftsigned(unsigned int v, int shift, int bits)
{
static unsigned int mul_table[9] = {
0,
0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/,
0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/,
};
static unsigned int shift_table[9] = {
0, 0,0,1,0,2,4,6,0,
};
if (shift < 0)
v <<= -shift;
else
v >>= shift;
STBI_ASSERT(v < 256);
v >>= (8-bits);
STBI_ASSERT(bits >= 0 && bits <= 8);
return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits];
} | O2 | c | stbi__shiftsigned(unsigned int, int, int):
movl %esi, %ecx
negb %cl
movl %edi, %eax
shll %cl, %eax
movl %esi, %ecx
shrl %cl, %edi
testl %esi, %esi
cmovnsl %edi, %eax
movb $0x8, %cl
subb %dl, %cl
shrl %cl, %eax
movslq %edx, %rcx
leaq 0x8717d(%rip), %rdx # 0xc5fe0
imull (%rdx,%rcx,4), %eax
leaq 0x871a2(%rip), %rdx # 0xc6010
movb (%rdx,%rcx,4), %cl
sarl %cl, %eax
retq
| _ZL17stbi__shiftsignedjii:
mov ecx, esi
neg cl
mov eax, edi
shl eax, cl
mov ecx, esi
shr edi, cl
test esi, esi
cmovns eax, edi
mov cl, 8
sub cl, dl
shr eax, cl
movsxd rcx, edx
lea rdx, _ZZL17stbi__shiftsignedjiiE9mul_table; stbi__shiftsigned(uint,int,int)::mul_table
imul eax, [rdx+rcx*4]
lea rdx, _ZZL17stbi__shiftsignedjiiE11shift_table; stbi__shiftsigned(uint,int,int)::shift_table
mov cl, [rdx+rcx*4]
sar eax, cl
retn
| long long stbi__shiftsigned(unsigned int a1, int a2, int a3)
{
unsigned int v3; // eax
unsigned int v4; // edi
v3 = a1 << -(char)a2;
v4 = a1 >> a2;
if ( a2 >= 0 )
v3 = v4;
return (unsigned int)((int)(stbi__shiftsigned(unsigned int,int,int)::mul_table[a3] * (v3 >> (8 - a3))) >> stbi__shiftsigned(unsigned int,int,int)::shift_table[4 * a3]);
}
| stbi__shiftsigned:
MOV ECX,ESI
NEG CL
MOV EAX,EDI
SHL EAX,CL
MOV ECX,ESI
SHR EDI,CL
TEST ESI,ESI
CMOVNS EAX,EDI
MOV CL,0x8
SUB CL,DL
SHR EAX,CL
MOVSXD RCX,EDX
LEA RDX,[0x1c5fe0]
IMUL EAX,dword ptr [RDX + RCX*0x4]
LEA RDX,[0x1c6010]
MOV CL,byte ptr [RDX + RCX*0x4]
SAR EAX,CL
RET
|
/* stbi__shiftsigned(unsigned int, int, int) */
int stbi__shiftsigned(uint param_1,int param_2,int param_3)
{
uint uVar1;
uVar1 = param_1 << (-(byte)param_2 & 0x1f);
if (-1 < param_2) {
uVar1 = param_1 >> ((byte)param_2 & 0x1f);
}
return (int)((uVar1 >> (8U - (char)param_3 & 0x1f)) *
*(int *)(stbi__shiftsigned(unsigned_int,int,int)::mul_table + (long)param_3 * 4)) >>
(stbi__shiftsigned(unsigned_int,int,int)::shift_table[(long)param_3 * 4] & 0x1f);
}
| |
47,297 | my_strnxfrm_tis620_nopad | eloqsql/strings/ctype-tis620.c | static size_t
my_strnxfrm_tis620_nopad(CHARSET_INFO *cs,
uchar *dst, size_t dstlen, uint nweights,
const uchar *src, size_t srclen, uint flags)
{
size_t len, dstlen0= dstlen;
len= MY_MIN(dstlen, srclen);
memcpy(dst, src, len);
len= thai2sortable(dst, len);
set_if_smaller(dstlen, nweights);
set_if_smaller(len, dstlen);
len= my_strxfrm_pad_desc_and_reverse_nopad(cs, dst, dst + len, dst + dstlen,
(uint)(dstlen - len), flags, 0);
if ((flags & MY_STRXFRM_PAD_TO_MAXLEN) && len < dstlen0)
{
size_t fill_length= dstlen0 - len;
memset(dst + len, 0x00, fill_length);
len= dstlen0;
}
return len;
} | O0 | c | my_strnxfrm_tis620_nopad:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x5834e
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x58356
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x25260
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x580f0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
cmpq %rcx, %rax
jbe 0x58393
movl -0x1c(%rbp), %eax
movq %rax, -0x18(%rbp)
jmp 0x58395
jmp 0x58397
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x583a9
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x583ab
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rcx
addq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
subq -0x38(%rbp), %rax
movl %eax, %r8d
movl 0x10(%rbp), %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x52870
movq %rax, -0x38(%rbp)
movl 0x10(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x58422
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x58422
movq -0x40(%rbp), %rax
subq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rdx
xorl %esi, %esi
callq 0x251d0
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| my_strnxfrm_tis620_nopad:
push rbp
mov rbp, rsp
sub rsp, 60h
mov eax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rax, [rbp+var_18]
cmp rax, [rbp+var_30]
jnb short loc_5834E
mov rax, [rbp+var_18]
mov [rbp+var_50], rax
jmp short loc_58356
loc_5834E:
mov rax, [rbp+var_30]
mov [rbp+var_50], rax
loc_58356:
mov rax, [rbp+var_50]
mov [rbp+var_38], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_38]
call _memcpy
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_38]
call thai2sortable
mov [rbp+var_38], rax
mov rax, [rbp+var_18]
mov ecx, [rbp+var_1C]
cmp rax, rcx
jbe short loc_58393
mov eax, [rbp+var_1C]
mov [rbp+var_18], rax
loc_58393:
jmp short $+2
loc_58395:
jmp short $+2
loc_58397:
mov rax, [rbp+var_38]
cmp rax, [rbp+var_18]
jbe short loc_583A9
mov rax, [rbp+var_18]
mov [rbp+var_38], rax
loc_583A9:
jmp short $+2
loc_583AB:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_10]
add rdx, [rbp+var_38]
mov rcx, [rbp+var_10]
add rcx, [rbp+var_18]
mov rax, [rbp+var_18]
sub rax, [rbp+var_38]
mov r8d, eax
mov r9d, [rbp+arg_0]
xor eax, eax
mov [rsp+60h+var_60], 0
call my_strxfrm_pad_desc_and_reverse_nopad
mov [rbp+var_38], rax
mov eax, [rbp+arg_0]
and eax, 80h
cmp eax, 0
jz short loc_58422
mov rax, [rbp+var_38]
cmp rax, [rbp+var_40]
jnb short loc_58422
mov rax, [rbp+var_40]
sub rax, [rbp+var_38]
mov [rbp+var_48], rax
mov rdi, [rbp+var_10]
add rdi, [rbp+var_38]
mov rdx, [rbp+var_48]
xor esi, esi
call _memset
mov rax, [rbp+var_40]
mov [rbp+var_38], rax
loc_58422:
mov rax, [rbp+var_38]
add rsp, 60h
pop rbp
retn
| unsigned long long my_strnxfrm_tis620_nopad(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
unsigned int a4,
long long a5,
unsigned long long a6,
unsigned int a7)
{
long long v8; // [rsp+10h] [rbp-50h]
unsigned long long v10; // [rsp+28h] [rbp-38h]
unsigned long long v11; // [rsp+28h] [rbp-38h]
unsigned long long v13; // [rsp+48h] [rbp-18h]
v13 = a3;
if ( a3 >= a6 )
v8 = a6;
else
v8 = a3;
memcpy(a2, a5, v8);
v10 = thai2sortable(a2, v8);
if ( v13 > a4 )
v13 = a4;
if ( v10 > v13 )
v10 = v13;
v11 = my_strxfrm_pad_desc_and_reverse_nopad(
a1,
(long long)a2,
(unsigned long long)&a2[v10],
(unsigned long long)&a2[v13],
(int)v13 - (int)v10,
a7,
0);
if ( (a7 & 0x80) != 0 && v11 < a3 )
{
memset(&a2[v11], 0LL, a3 - v11);
return a3;
}
return v11;
}
| my_strnxfrm_tis620_nopad:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x0015834e
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00158356
LAB_0015834e:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x50],RAX
LAB_00158356:
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x38]
CALL 0x00125260
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x001580f0
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x1c]
CMP RAX,RCX
JBE 0x00158393
MOV EAX,dword ptr [RBP + -0x1c]
MOV qword ptr [RBP + -0x18],RAX
LAB_00158393:
JMP 0x00158395
LAB_00158395:
JMP 0x00158397
LAB_00158397:
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x18]
JBE 0x001583a9
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x38],RAX
LAB_001583a9:
JMP 0x001583ab
LAB_001583ab:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x10]
ADD RDX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr [RBP + -0x38]
MOV R8D,EAX
MOV R9D,dword ptr [RBP + 0x10]
XOR EAX,EAX
MOV dword ptr [RSP],0x0
CALL 0x00152870
MOV qword ptr [RBP + -0x38],RAX
MOV EAX,dword ptr [RBP + 0x10]
AND EAX,0x80
CMP EAX,0x0
JZ 0x00158422
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x00158422
MOV RAX,qword ptr [RBP + -0x40]
SUB RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x48],RAX
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x48]
XOR ESI,ESI
CALL 0x001251d0
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x38],RAX
LAB_00158422:
MOV RAX,qword ptr [RBP + -0x38]
ADD RSP,0x60
POP RBP
RET
|
ulong my_strnxfrm_tis620_nopad
(int8 param_1,void *param_2,ulong param_3,uint param_4,void *param_5,
ulong param_6,uint param_7)
{
size_t local_58;
ulong local_40;
ulong local_20;
local_58 = param_6;
if (param_3 < param_6) {
local_58 = param_3;
}
memcpy(param_2,param_5,local_58);
local_40 = thai2sortable(param_2,local_58);
local_20 = param_3;
if (param_4 < param_3) {
local_20 = (ulong)param_4;
}
if (local_20 < local_40) {
local_40 = local_20;
}
local_40 = my_strxfrm_pad_desc_and_reverse_nopad
(param_1,param_2,(long)param_2 + local_40,(long)param_2 + local_20,
(int)local_20 - (int)local_40,param_7,0);
if (((param_7 & 0x80) != 0) && (local_40 < param_3)) {
memset((void *)((long)param_2 + local_40),0,param_3 - local_40);
local_40 = param_3;
}
return local_40;
}
| |
47,298 | pvio_socket_set_timeout | eloqsql/libmariadb/plugins/pvio/pvio_socket.c | my_bool pvio_socket_set_timeout(MARIADB_PVIO *pvio, enum enum_pvio_timeout type, int timeout)
{
struct st_pvio_socket *csock= NULL;
if (!pvio)
return 1;
csock= (struct st_pvio_socket *)pvio->data;
pvio->timeout[type]= (timeout > 0) ? timeout * 1000 : -1;
if (csock)
return pvio_socket_change_timeout(pvio, type, timeout * 1000);
return 0;
} | O3 | c | pvio_socket_set_timeout:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x33219
movl %edx, %eax
imull $0x3e8, %edx, %edx # imm = 0x3E8
testl %eax, %eax
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmovgl %edx, %eax
movl %esi, %ecx
cmpq $0x0, (%rdi)
movl %eax, 0x24(%rdi,%rcx,4)
je 0x3321d
popq %rbp
jmp 0x33e70
movb $0x1, %al
jmp 0x3321f
xorl %eax, %eax
popq %rbp
retq
| pvio_socket_set_timeout:
push rbp
mov rbp, rsp
test rdi, rdi
jz short loc_33219
mov eax, edx
imul edx, 3E8h
test eax, eax
mov eax, 0FFFFFFFFh
cmovg eax, edx
mov ecx, esi
cmp qword ptr [rdi], 0
mov [rdi+rcx*4+24h], eax
jz short loc_3321D
pop rbp
jmp pvio_socket_change_timeout
loc_33219:
mov al, 1
jmp short loc_3321F
loc_3321D:
xor eax, eax
loc_3321F:
pop rbp
retn
| char pvio_socket_set_timeout(_QWORD *a1, unsigned int a2, int a3)
{
int v4; // edx
bool v5; // cc
int v6; // eax
bool v7; // zf
if ( !a1 )
return 1;
v4 = 1000 * a3;
v5 = a3 <= 0;
v6 = -1;
if ( !v5 )
v6 = v4;
v7 = *a1 == 0LL;
*((_DWORD *)a1 + a2 + 9) = v6;
if ( v7 )
return 0;
else
return pvio_socket_change_timeout();
}
| pvio_socket_set_timeout:
PUSH RBP
MOV RBP,RSP
TEST RDI,RDI
JZ 0x00133219
MOV EAX,EDX
IMUL EDX,EDX,0x3e8
TEST EAX,EAX
MOV EAX,0xffffffff
CMOVG EAX,EDX
MOV ECX,ESI
CMP qword ptr [RDI],0x0
MOV dword ptr [RDI + RCX*0x4 + 0x24],EAX
JZ 0x0013321d
POP RBP
JMP 0x00133e70
LAB_00133219:
MOV AL,0x1
JMP 0x0013321f
LAB_0013321d:
XOR EAX,EAX
LAB_0013321f:
POP RBP
RET
|
int8 pvio_socket_set_timeout(long *param_1,uint param_2,int param_3)
{
long lVar1;
int iVar2;
int8 uVar3;
if (param_1 == (long *)0x0) {
uVar3 = 1;
}
else {
iVar2 = -1;
if (0 < param_3) {
iVar2 = param_3 * 1000;
}
lVar1 = *param_1;
*(int *)((long)param_1 + (ulong)param_2 * 4 + 0x24) = iVar2;
if (lVar1 != 0) {
uVar3 = pvio_socket_change_timeout();
return uVar3;
}
uVar3 = 0;
}
return uVar3;
}
| |
47,299 | pfs_drop_sp_v1 | eloqsql/storage/perfschema/pfs.cc | void pfs_drop_sp_v1(uint sp_type,
const char* schema_name,
uint schema_name_length,
const char* object_name,
uint object_name_length)
{
PFS_thread *pfs_thread= my_thread_get_THR_PFS();
if (unlikely(pfs_thread == NULL))
return;
if (object_name_length > COL_OBJECT_NAME_SIZE)
object_name_length= COL_OBJECT_NAME_SIZE;
if (schema_name_length > COL_OBJECT_SCHEMA_SIZE)
schema_name_length= COL_OBJECT_SCHEMA_SIZE;
drop_program(pfs_thread,
sp_type_to_object_type(sp_type),
object_name, object_name_length,
schema_name, schema_name_length);
} | O3 | cpp | pfs_drop_sp_v1:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, %r15
movl %edx, %r13d
movq %rsi, %r14
movl %edi, %r12d
movl 0x3a5e43(%rip), %edi # 0x3d026c
callq 0x26540
testq %rax, %rax
je 0x2a47b
pushq $0x40
popq %r9
cmpl %r9d, %ebx
cmovael %r9d, %ebx
cmpl %r9d, %r13d
cmovbl %r13d, %r9d
decl %r12d
xorl %esi, %esi
cmpl $0x5, %r12d
ja 0x2a45d
movl %r12d, %ecx
leaq 0x56c2e(%rip), %rdx # 0x81088
movl (%rdx,%rcx,4), %esi
movq %rax, %rdi
movq %r15, %rdx
movl %ebx, %ecx
movq %r14, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x412c0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| pfs_drop_sp_v1:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ebx, r8d
mov r15, rcx
mov r13d, edx
mov r14, rsi
mov r12d, edi
mov edi, cs:THR_PFS
call _pthread_getspecific
test rax, rax
jz short loc_2A47B
push 40h ; '@'
pop r9
cmp ebx, r9d
cmovnb ebx, r9d
cmp r13d, r9d
cmovb r9d, r13d
dec r12d
xor esi, esi
cmp r12d, 5
ja short loc_2A45D
mov ecx, r12d
lea rdx, dword_81088
mov esi, [rdx+rcx*4]
loc_2A45D:
mov rdi, rax
mov rdx, r15
mov ecx, ebx
mov r8, r14
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _Z12drop_programP10PFS_thread16enum_object_typePKcjS3_j; drop_program(PFS_thread *,enum_object_type,char const*,uint,char const*,uint)
loc_2A47B:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long pfs_drop_sp_v1(int a1, long long a2, long long a3, long long a4, unsigned int a5)
{
long long result; // rax
long long v9; // rsi
result = pthread_getspecific((unsigned int)THR_PFS);
if ( result )
{
if ( a5 >= 0x40 )
a5 = 64;
v9 = 0LL;
if ( (unsigned int)(a1 - 1) <= 5 )
v9 = dword_81088[a1 - 1];
return drop_program(result, v9, a4, a5, a2);
}
return result;
}
| pfs_drop_sp_v1:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV EBX,R8D
MOV R15,RCX
MOV R13D,EDX
MOV R14,RSI
MOV R12D,EDI
MOV EDI,dword ptr [0x004d026c]
CALL 0x00126540
TEST RAX,RAX
JZ 0x0012a47b
PUSH 0x40
POP R9
CMP EBX,R9D
CMOVNC EBX,R9D
CMP R13D,R9D
CMOVC R9D,R13D
DEC R12D
XOR ESI,ESI
CMP R12D,0x5
JA 0x0012a45d
MOV ECX,R12D
LEA RDX,[0x181088]
MOV ESI,dword ptr [RDX + RCX*0x4]
LAB_0012a45d:
MOV RDI,RAX
MOV RDX,R15
MOV ECX,EBX
MOV R8,R14
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001412c0
LAB_0012a47b:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void pfs_drop_sp_v1(int param_1,int8 param_2,uint param_3,int8 param_4,uint param_5)
{
void *pvVar1;
int4 uVar2;
uint uVar3;
pvVar1 = pthread_getspecific(THR_PFS);
if (pvVar1 != (void *)0x0) {
if (0x3f < param_5) {
param_5 = 0x40;
}
uVar3 = 0x40;
if (param_3 < 0x40) {
uVar3 = param_3;
}
uVar2 = 0;
if (param_1 - 1U < 6) {
uVar2 = *(int4 *)(&DAT_00181088 + (ulong)(param_1 - 1U) * 4);
}
drop_program(pvVar1,uVar2,param_4,param_5,param_2,uVar3);
return;
}
return;
}
|
Subsets and Splits
C++ Functions With Standard Library Dependencies
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ Standard Library Function Analysis
Filters C++ code examples that use standard library containers and types, providing useful insights into common programming patterns and data structures in the dataset.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.