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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
63,600
|
my_readlink
|
eloqsql/mysys/my_symlink.c
|
int my_readlink(char *to, const char *filename, myf MyFlags)
{
#ifndef HAVE_READLINK
strmov(to,filename);
return 1;
#else
int result=0;
int length;
DBUG_ENTER("my_readlink");
if ((length=readlink(filename, to, FN_REFLEN-1)) < 0)
{
/* Don't give an error if this wasn't a symlink */
if ((my_errno=errno) == EINVAL)
{
result= 1;
strmov(to,filename);
}
else
{
if (MyFlags & MY_WME)
my_error(EE_CANT_READLINK, MYF(0), filename, errno);
result= -1;
}
}
else
to[length]=0;
DBUG_PRINT("exit" ,("result: %d", result));
DBUG_RETURN(result);
#endif /* HAVE_READLINK */
}
|
O3
|
c
|
my_readlink:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1ff, %edx # imm = 0x1FF
movq %rsi, %rdi
movq %r14, %rsi
callq 0x243c0
testl %eax, %eax
js 0x2b60e
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
movb $0x0, (%r14,%rax)
xorl %r14d, %r14d
jmp 0x2b65b
callq 0x24050
movq %rax, %r12
movl (%rax), %r13d
callq 0x2bff6
movl %r13d, (%rax)
cmpl $0x16, %r13d
jne 0x2b63a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x24310
movl $0x1, %r14d
jmp 0x2b65b
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
testb $0x10, %r15b
je 0x2b65b
movl (%r12), %ecx
movl $0x18, %edi
xorl %esi, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x27c17
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_readlink:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rdx
mov rbx, rsi
mov r14, rdi
mov edx, 1FFh
mov rdi, rsi
mov rsi, r14
call _readlink
test eax, eax
js short loc_2B60E
and eax, 7FFFFFFFh
mov byte ptr [r14+rax], 0
xor r14d, r14d
jmp short loc_2B65B
loc_2B60E:
call ___errno_location
mov r12, rax
mov r13d, [rax]
call _my_thread_var
mov [rax], r13d
cmp r13d, 16h
jnz short loc_2B63A
mov rdi, r14
mov rsi, rbx
call _strcpy
mov r14d, 1
jmp short loc_2B65B
loc_2B63A:
mov r14d, 0FFFFFFFFh
test r15b, 10h
jz short loc_2B65B
mov ecx, [r12]
mov edi, 18h
xor esi, esi
mov rdx, rbx
xor eax, eax
call my_error
loc_2B65B:
mov eax, r14d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long my_readlink(long long a1, long long a2, char a3)
{
int v4; // eax
unsigned int v5; // r14d
unsigned int *v6; // r12
unsigned int v7; // r13d
v4 = readlink(a2, a1, 511LL);
if ( v4 < 0 )
{
v6 = (unsigned int *)__errno_location(a2);
v7 = *v6;
*(_DWORD *)my_thread_var(a2) = v7;
if ( v7 == 22 )
{
strcpy(a1, a2);
return 1;
}
else
{
v5 = -1;
if ( (a3 & 0x10) != 0 )
my_error(0x18u, 0LL, a2, *v6);
}
}
else
{
*(_BYTE *)(a1 + (v4 & 0x7FFFFFFF)) = 0;
return 0;
}
return v5;
}
|
my_readlink:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RDX
MOV RBX,RSI
MOV R14,RDI
MOV EDX,0x1ff
MOV RDI,RSI
MOV RSI,R14
CALL 0x001243c0
TEST EAX,EAX
JS 0x0012b60e
AND EAX,0x7fffffff
MOV byte ptr [R14 + RAX*0x1],0x0
XOR R14D,R14D
JMP 0x0012b65b
LAB_0012b60e:
CALL 0x00124050
MOV R12,RAX
MOV R13D,dword ptr [RAX]
CALL 0x0012bff6
MOV dword ptr [RAX],R13D
CMP R13D,0x16
JNZ 0x0012b63a
MOV RDI,R14
MOV RSI,RBX
CALL 0x00124310
MOV R14D,0x1
JMP 0x0012b65b
LAB_0012b63a:
MOV R14D,0xffffffff
TEST R15B,0x10
JZ 0x0012b65b
MOV ECX,dword ptr [R12]
MOV EDI,0x18
XOR ESI,ESI
MOV RDX,RBX
XOR EAX,EAX
CALL 0x00127c17
LAB_0012b65b:
MOV EAX,R14D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 my_readlink(char *param_1,char *param_2,ulong param_3)
{
int iVar1;
ssize_t sVar2;
int *piVar3;
int *piVar4;
int8 uVar5;
sVar2 = readlink(param_2,param_1,0x1ff);
if ((int)(uint)sVar2 < 0) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar4 = (int *)_my_thread_var();
*piVar4 = iVar1;
if (iVar1 == 0x16) {
strcpy(param_1,param_2);
uVar5 = 1;
}
else {
uVar5 = 0xffffffff;
if ((param_3 & 0x10) != 0) {
my_error(0x18,0,param_2,*piVar3);
}
}
}
else {
param_1[(uint)sVar2 & 0x7fffffff] = '\0';
uVar5 = 0;
}
return uVar5;
}
|
|
63,601
|
my_xml_leave
|
eloqsql/strings/xml.c
|
static int my_xml_leave(MY_XML_PARSER *p, const char *str, size_t slen)
{
char *e, *tag;
size_t glen;
char s[32];
char g[32];
int rc;
/* Find previous '/' or beginning */
for (e= p->attr.end; (e > p->attr.start) && (e[0] != '/') ; e--);
glen= (size_t) ((e[0] == '/') ? (p->attr.end - e - 1) : p->attr.end - e);
tag= e[0] == '/' ? e + 1 : e;
if (str && (slen != glen || memcmp(str, tag, slen)))
{
mstr(s,str,sizeof(s)-1,slen);
if (glen)
{
mstr(g, tag, sizeof(g)-1, glen);
sprintf(p->errstr,"'</%s>' unexpected ('</%s>' wanted)",s,g);
}
else
sprintf(p->errstr,"'</%s>' unexpected (END-OF-INPUT wanted)", s);
return MY_XML_ERROR;
}
if (p->flags & MY_XML_FLAG_RELATIVE_NAMES)
rc= p->leave_xml ? p->leave_xml(p, str, slen) : MY_XML_OK;
else
rc= (p->leave_xml ?
p->leave_xml(p, p->attr.start, p->attr.end - p->attr.start) :
MY_XML_OK);
*e='\0';
p->attr.end= e;
return rc;
}
|
O0
|
c
|
my_xml_leave:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x60(%rbp)
movq %rsi, -0x68(%rbp)
movq %rdx, -0x70(%rbp)
movq -0x60(%rbp), %rax
movq 0x120(%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rcx
movq -0x60(%rbp), %rdx
xorl %eax, %eax
cmpq 0x118(%rdx), %rcx
movb %al, -0x8d(%rbp)
jbe 0x7eb9f
movq -0x78(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
setne %al
movb %al, -0x8d(%rbp)
movb -0x8d(%rbp), %al
testb $0x1, %al
jne 0x7ebab
jmp 0x7ebbb
jmp 0x7ebad
movq -0x78(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x78(%rbp)
jmp 0x7eb73
movq -0x78(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x7ebe6
movq -0x60(%rbp), %rax
movq 0x120(%rax), %rax
movq -0x78(%rbp), %rcx
subq %rcx, %rax
subq $0x1, %rax
movq %rax, -0x98(%rbp)
jmp 0x7ebff
movq -0x60(%rbp), %rax
movq 0x120(%rax), %rax
movq -0x78(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x78(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x7ec2a
movq -0x78(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xa0(%rbp)
jmp 0x7ec35
movq -0x78(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, -0x68(%rbp)
je 0x7eced
movq -0x70(%rbp), %rax
cmpq -0x88(%rbp), %rax
jne 0x7ec6e
movq -0x68(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0x24130
cmpl $0x0, %eax
je 0x7eced
leaq -0x30(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rcx
movl $0x1f, %edx
callq 0x7f2a0
cmpq $0x0, -0x88(%rbp)
je 0x7ecc7
leaq -0x50(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rcx
movl $0x1f, %edx
callq 0x7f2a0
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
leaq -0x30(%rbp), %rdx
leaq -0x50(%rbp), %rcx
leaq 0x6cc0(%rip), %rsi # 0x8597e
movb $0x0, %al
callq 0x240a0
jmp 0x7ece1
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
leaq -0x30(%rbp), %rdx
leaq 0x6cc8(%rip), %rsi # 0x859a2
movb $0x0, %al
callq 0x240a0
movl $0x1, -0x54(%rbp)
jmp 0x7edc2
movq -0x60(%rbp), %rax
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x7ed42
movq -0x60(%rbp), %rax
cmpq $0x0, 0x158(%rax)
je 0x7ed2a
movq -0x60(%rbp), %rax
movq 0x158(%rax), %rax
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq *%rax
movl %eax, -0xa4(%rbp)
jmp 0x7ed34
xorl %eax, %eax
movl %eax, -0xa4(%rbp)
jmp 0x7ed34
movl -0xa4(%rbp), %eax
movl %eax, -0x8c(%rbp)
jmp 0x7eda3
movq -0x60(%rbp), %rax
cmpq $0x0, 0x158(%rax)
je 0x7ed8d
movq -0x60(%rbp), %rax
movq 0x158(%rax), %rax
movq -0x60(%rbp), %rdi
movq -0x60(%rbp), %rcx
movq 0x118(%rcx), %rsi
movq -0x60(%rbp), %rcx
movq 0x120(%rcx), %rdx
movq -0x60(%rbp), %rcx
movq 0x118(%rcx), %rcx
subq %rcx, %rdx
callq *%rax
movl %eax, -0xa8(%rbp)
jmp 0x7ed97
xorl %eax, %eax
movl %eax, -0xa8(%rbp)
jmp 0x7ed97
movl -0xa8(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x78(%rbp), %rax
movb $0x0, (%rax)
movq -0x78(%rbp), %rcx
movq -0x60(%rbp), %rax
movq %rcx, 0x120(%rax)
movl -0x8c(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %eax
movl %eax, -0xac(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x7edec
movl -0xac(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
callq 0x24300
nopw %cs:(%rax,%rax)
|
my_xml_leave:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_60], rdi
mov [rbp+var_68], rsi
mov [rbp+var_70], rdx
mov rax, [rbp+var_60]
mov rax, [rax+120h]
mov [rbp+var_78], rax
loc_7EB73:
mov rcx, [rbp+var_78]
mov rdx, [rbp+var_60]
xor eax, eax
cmp rcx, [rdx+118h]
mov [rbp+var_8D], al
jbe short loc_7EB9F
mov rax, [rbp+var_78]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
setnz al
mov [rbp+var_8D], al
loc_7EB9F:
mov al, [rbp+var_8D]
test al, 1
jnz short loc_7EBAB
jmp short loc_7EBBB
loc_7EBAB:
jmp short $+2
loc_7EBAD:
mov rax, [rbp+var_78]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_78], rax
jmp short loc_7EB73
loc_7EBBB:
mov rax, [rbp+var_78]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
jnz short loc_7EBE6
mov rax, [rbp+var_60]
mov rax, [rax+120h]
mov rcx, [rbp+var_78]
sub rax, rcx
sub rax, 1
mov [rbp+var_98], rax
jmp short loc_7EBFF
loc_7EBE6:
mov rax, [rbp+var_60]
mov rax, [rax+120h]
mov rcx, [rbp+var_78]
sub rax, rcx
mov [rbp+var_98], rax
loc_7EBFF:
mov rax, [rbp+var_98]
mov [rbp+var_88], rax
mov rax, [rbp+var_78]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
jnz short loc_7EC2A
mov rax, [rbp+var_78]
add rax, 1
mov [rbp+var_A0], rax
jmp short loc_7EC35
loc_7EC2A:
mov rax, [rbp+var_78]
mov [rbp+var_A0], rax
loc_7EC35:
mov rax, [rbp+var_A0]
mov [rbp+var_80], rax
cmp [rbp+var_68], 0
jz loc_7ECED
mov rax, [rbp+var_70]
cmp rax, [rbp+var_88]
jnz short loc_7EC6E
mov rdi, [rbp+var_68]
mov rsi, [rbp+var_80]
mov rdx, [rbp+var_70]
call _memcmp
cmp eax, 0
jz short loc_7ECED
loc_7EC6E:
lea rdi, [rbp+var_30]
mov rsi, [rbp+var_68]
mov rcx, [rbp+var_70]
mov edx, 1Fh
call mstr_0
cmp [rbp+var_88], 0
jz short loc_7ECC7
lea rdi, [rbp+var_50]
mov rsi, [rbp+var_80]
mov rcx, [rbp+var_88]
mov edx, 1Fh
call mstr_0
mov rdi, [rbp+var_60]
add rdi, 8
lea rdx, [rbp+var_30]
lea rcx, [rbp+var_50]
lea rsi, aSUnexpectedSWa; "'</%s>' unexpected ('</%s>' wanted)"
mov al, 0
call _sprintf
jmp short loc_7ECE1
loc_7ECC7:
mov rdi, [rbp+var_60]
add rdi, 8
lea rdx, [rbp+var_30]
lea rsi, aSUnexpectedEnd; "'</%s>' unexpected (END-OF-INPUT wanted"...
mov al, 0
call _sprintf
loc_7ECE1:
mov [rbp+var_54], 1
jmp loc_7EDC2
loc_7ECED:
mov rax, [rbp+var_60]
mov eax, [rax]
and eax, 1
cmp eax, 0
jz short loc_7ED42
mov rax, [rbp+var_60]
cmp qword ptr [rax+158h], 0
jz short loc_7ED2A
mov rax, [rbp+var_60]
mov rax, [rax+158h]
mov rdi, [rbp+var_60]
mov rsi, [rbp+var_68]
mov rdx, [rbp+var_70]
call rax
mov [rbp+var_A4], eax
jmp short loc_7ED34
loc_7ED2A:
xor eax, eax
mov [rbp+var_A4], eax
jmp short $+2
loc_7ED34:
mov eax, [rbp+var_A4]
mov [rbp+var_8C], eax
jmp short loc_7EDA3
loc_7ED42:
mov rax, [rbp+var_60]
cmp qword ptr [rax+158h], 0
jz short loc_7ED8D
mov rax, [rbp+var_60]
mov rax, [rax+158h]
mov rdi, [rbp+var_60]
mov rcx, [rbp+var_60]
mov rsi, [rcx+118h]
mov rcx, [rbp+var_60]
mov rdx, [rcx+120h]
mov rcx, [rbp+var_60]
mov rcx, [rcx+118h]
sub rdx, rcx
call rax
mov [rbp+var_A8], eax
jmp short loc_7ED97
loc_7ED8D:
xor eax, eax
mov [rbp+var_A8], eax
jmp short $+2
loc_7ED97:
mov eax, [rbp+var_A8]
mov [rbp+var_8C], eax
loc_7EDA3:
mov rax, [rbp+var_78]
mov byte ptr [rax], 0
mov rcx, [rbp+var_78]
mov rax, [rbp+var_60]
mov [rax+120h], rcx
mov eax, [rbp+var_8C]
mov [rbp+var_54], eax
loc_7EDC2:
mov eax, [rbp+var_54]
mov [rbp+var_AC], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_7EDEC
mov eax, [rbp+var_AC]
add rsp, 0B0h
pop rbp
retn
loc_7EDEC:
call ___stack_chk_fail
|
long long my_xml_leave(long long a1, long long a2, long long a3)
{
unsigned int v4; // [rsp+8h] [rbp-A8h]
unsigned int v5; // [rsp+Ch] [rbp-A4h]
_BYTE *v6; // [rsp+10h] [rbp-A0h]
long long v7; // [rsp+18h] [rbp-98h]
bool v8; // [rsp+23h] [rbp-8Dh]
unsigned int v9; // [rsp+24h] [rbp-8Ch]
_BYTE *i; // [rsp+38h] [rbp-78h]
char v13[32]; // [rsp+60h] [rbp-50h] BYREF
char v14[40]; // [rsp+80h] [rbp-30h] BYREF
unsigned long long v15; // [rsp+A8h] [rbp-8h]
v15 = __readfsqword(0x28u);
for ( i = *(_BYTE **)(a1 + 288); ; --i )
{
v8 = 0;
if ( (unsigned long long)i > *(_QWORD *)(a1 + 280) )
v8 = *i != 47;
if ( !v8 )
break;
}
if ( *i == 47 )
v7 = *(_QWORD *)(a1 + 288) - (_QWORD)i - 1LL;
else
v7 = *(_QWORD *)(a1 + 288) - (_QWORD)i;
if ( *i == 47 )
v6 = i + 1;
else
v6 = i;
if ( !a2 || a3 == v7 && !(unsigned int)memcmp(a2, v6, a3) )
{
if ( (*(_DWORD *)a1 & 1) != 0 )
{
if ( *(_QWORD *)(a1 + 344) )
v5 = (*(long long ( **)(long long, long long, long long))(a1 + 344))(a1, a2, a3);
else
v5 = 0;
v9 = v5;
}
else
{
if ( *(_QWORD *)(a1 + 344) )
v4 = (*(long long ( **)(long long, _QWORD, _QWORD))(a1 + 344))(
a1,
*(_QWORD *)(a1 + 280),
*(_QWORD *)(a1 + 288) - *(_QWORD *)(a1 + 280));
else
v4 = 0;
v9 = v4;
}
*i = 0;
*(_QWORD *)(a1 + 288) = i;
return v9;
}
else
{
mstr_0(v14, a2, 31LL, a3);
if ( v7 )
{
mstr_0(v13, v6, 31LL, v7);
sprintf(a1 + 8, "'</%s>' unexpected ('</%s>' wanted)", v14, v13);
}
else
{
sprintf(a1 + 8, "'</%s>' unexpected (END-OF-INPUT wanted)", v14);
}
return 1;
}
}
|
my_xml_leave:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x60],RDI
MOV qword ptr [RBP + -0x68],RSI
MOV qword ptr [RBP + -0x70],RDX
MOV RAX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RAX + 0x120]
MOV qword ptr [RBP + -0x78],RAX
LAB_0017eb73:
MOV RCX,qword ptr [RBP + -0x78]
MOV RDX,qword ptr [RBP + -0x60]
XOR EAX,EAX
CMP RCX,qword ptr [RDX + 0x118]
MOV byte ptr [RBP + -0x8d],AL
JBE 0x0017eb9f
MOV RAX,qword ptr [RBP + -0x78]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
SETNZ AL
MOV byte ptr [RBP + -0x8d],AL
LAB_0017eb9f:
MOV AL,byte ptr [RBP + -0x8d]
TEST AL,0x1
JNZ 0x0017ebab
JMP 0x0017ebbb
LAB_0017ebab:
JMP 0x0017ebad
LAB_0017ebad:
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x78],RAX
JMP 0x0017eb73
LAB_0017ebbb:
MOV RAX,qword ptr [RBP + -0x78]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
JNZ 0x0017ebe6
MOV RAX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RAX + 0x120]
MOV RCX,qword ptr [RBP + -0x78]
SUB RAX,RCX
SUB RAX,0x1
MOV qword ptr [RBP + -0x98],RAX
JMP 0x0017ebff
LAB_0017ebe6:
MOV RAX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RAX + 0x120]
MOV RCX,qword ptr [RBP + -0x78]
SUB RAX,RCX
MOV qword ptr [RBP + -0x98],RAX
LAB_0017ebff:
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr [RBP + -0x78]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
JNZ 0x0017ec2a
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,0x1
MOV qword ptr [RBP + -0xa0],RAX
JMP 0x0017ec35
LAB_0017ec2a:
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0xa0],RAX
LAB_0017ec35:
MOV RAX,qword ptr [RBP + -0xa0]
MOV qword ptr [RBP + -0x80],RAX
CMP qword ptr [RBP + -0x68],0x0
JZ 0x0017eced
MOV RAX,qword ptr [RBP + -0x70]
CMP RAX,qword ptr [RBP + -0x88]
JNZ 0x0017ec6e
MOV RDI,qword ptr [RBP + -0x68]
MOV RSI,qword ptr [RBP + -0x80]
MOV RDX,qword ptr [RBP + -0x70]
CALL 0x00124130
CMP EAX,0x0
JZ 0x0017eced
LAB_0017ec6e:
LEA RDI,[RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x68]
MOV RCX,qword ptr [RBP + -0x70]
MOV EDX,0x1f
CALL 0x0017f2a0
CMP qword ptr [RBP + -0x88],0x0
JZ 0x0017ecc7
LEA RDI,[RBP + -0x50]
MOV RSI,qword ptr [RBP + -0x80]
MOV RCX,qword ptr [RBP + -0x88]
MOV EDX,0x1f
CALL 0x0017f2a0
MOV RDI,qword ptr [RBP + -0x60]
ADD RDI,0x8
LEA RDX,[RBP + -0x30]
LEA RCX,[RBP + -0x50]
LEA RSI,[0x18597e]
MOV AL,0x0
CALL 0x001240a0
JMP 0x0017ece1
LAB_0017ecc7:
MOV RDI,qword ptr [RBP + -0x60]
ADD RDI,0x8
LEA RDX,[RBP + -0x30]
LEA RSI,[0x1859a2]
MOV AL,0x0
CALL 0x001240a0
LAB_0017ece1:
MOV dword ptr [RBP + -0x54],0x1
JMP 0x0017edc2
LAB_0017eced:
MOV RAX,qword ptr [RBP + -0x60]
MOV EAX,dword ptr [RAX]
AND EAX,0x1
CMP EAX,0x0
JZ 0x0017ed42
MOV RAX,qword ptr [RBP + -0x60]
CMP qword ptr [RAX + 0x158],0x0
JZ 0x0017ed2a
MOV RAX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RAX + 0x158]
MOV RDI,qword ptr [RBP + -0x60]
MOV RSI,qword ptr [RBP + -0x68]
MOV RDX,qword ptr [RBP + -0x70]
CALL RAX
MOV dword ptr [RBP + -0xa4],EAX
JMP 0x0017ed34
LAB_0017ed2a:
XOR EAX,EAX
MOV dword ptr [RBP + -0xa4],EAX
JMP 0x0017ed34
LAB_0017ed34:
MOV EAX,dword ptr [RBP + -0xa4]
MOV dword ptr [RBP + -0x8c],EAX
JMP 0x0017eda3
LAB_0017ed42:
MOV RAX,qword ptr [RBP + -0x60]
CMP qword ptr [RAX + 0x158],0x0
JZ 0x0017ed8d
MOV RAX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RAX + 0x158]
MOV RDI,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x60]
MOV RSI,qword ptr [RCX + 0x118]
MOV RCX,qword ptr [RBP + -0x60]
MOV RDX,qword ptr [RCX + 0x120]
MOV RCX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RCX + 0x118]
SUB RDX,RCX
CALL RAX
MOV dword ptr [RBP + -0xa8],EAX
JMP 0x0017ed97
LAB_0017ed8d:
XOR EAX,EAX
MOV dword ptr [RBP + -0xa8],EAX
JMP 0x0017ed97
LAB_0017ed97:
MOV EAX,dword ptr [RBP + -0xa8]
MOV dword ptr [RBP + -0x8c],EAX
LAB_0017eda3:
MOV RAX,qword ptr [RBP + -0x78]
MOV byte ptr [RAX],0x0
MOV RCX,qword ptr [RBP + -0x78]
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RAX + 0x120],RCX
MOV EAX,dword ptr [RBP + -0x8c]
MOV dword ptr [RBP + -0x54],EAX
LAB_0017edc2:
MOV EAX,dword ptr [RBP + -0x54]
MOV dword ptr [RBP + -0xac],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0017edec
MOV EAX,dword ptr [RBP + -0xac]
ADD RSP,0xb0
POP RBP
RET
LAB_0017edec:
CALL 0x00124300
|
int4 my_xml_leave(uint *param_1,void *param_2,size_t param_3)
{
int iVar1;
long in_FS_OFFSET;
bool bVar2;
int4 local_b0;
int4 local_ac;
char *local_a8;
size_t local_a0;
int4 local_94;
char *local_80;
int4 local_5c;
int1 local_58 [32];
int1 local_38 [40];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_80 = *(char **)(param_1 + 0x48);
while( true ) {
bVar2 = false;
if (*(char **)(param_1 + 0x46) < local_80) {
bVar2 = *local_80 != '/';
}
if (!bVar2) break;
local_80 = local_80 + -1;
}
if (*local_80 == '/') {
local_a0 = (*(long *)(param_1 + 0x48) - (long)local_80) - 1;
}
else {
local_a0 = *(long *)(param_1 + 0x48) - (long)local_80;
}
if (*local_80 == '/') {
local_a8 = local_80 + 1;
}
else {
local_a8 = local_80;
}
if (param_2 == (void *)0x0) {
LAB_0017eced:
if ((*param_1 & 1) == 0) {
if (*(long *)(param_1 + 0x56) == 0) {
local_b0 = 0;
}
else {
local_b0 = (**(code **)(param_1 + 0x56))
(param_1,*(int8 *)(param_1 + 0x46),
*(long *)(param_1 + 0x48) - *(long *)(param_1 + 0x46));
}
local_94 = local_b0;
}
else {
if (*(long *)(param_1 + 0x56) == 0) {
local_ac = 0;
}
else {
local_ac = (**(code **)(param_1 + 0x56))(param_1,param_2,param_3);
}
local_94 = local_ac;
}
*local_80 = '\0';
*(char **)(param_1 + 0x48) = local_80;
local_5c = local_94;
}
else {
if (param_3 == local_a0) {
iVar1 = memcmp(param_2,local_a8,param_3);
if (iVar1 == 0) goto LAB_0017eced;
}
mstr(local_38,param_2,0x1f,param_3);
if (local_a0 == 0) {
sprintf((char *)(param_1 + 2),"\'</%s>\' unexpected (END-OF-INPUT wanted)",local_38);
}
else {
mstr(local_58,local_a8,0x1f,local_a0);
sprintf((char *)(param_1 + 2),"\'</%s>\' unexpected (\'</%s>\' wanted)",local_38,local_58);
}
local_5c = 1;
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_5c;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
63,602
|
r3d_texture_load_ibl_brdf_lut
|
r3d/src/r3d_state.c
|
void r3d_texture_load_ibl_brdf_lut(void)
{
// TODO: Review in case 'R3D.support.TEX_R16G16F' is false
Image img = { 0 };
uint32_t width = 0, height = 0;
uint32_t special_format_size = 0; // should be 4 or 8 (RG16F or RG32F)
img.data = r3d_load_dds_from_memory_ext(TEX_IBL_BRDF_LUT, TEX_IBL_BRDF_LUT_SIZE, &width, &height, &special_format_size);
img.width = (int)width;
img.height = (int)height;
if (img.data && (special_format_size == 4 || special_format_size == 8)) {
GLuint texId;
glGenTextures(1, &texId);
glBindTexture(GL_TEXTURE_2D, texId);
GLenum internal_format = (special_format_size == 4) ? GL_RG16F : GL_RG32F;
GLenum data_type = (special_format_size == 4) ? GL_HALF_FLOAT : GL_FLOAT;
glTexImage2D(GL_TEXTURE_2D, 0, internal_format, img.width, img.height, 0, GL_RG, data_type, img.data);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_2D, 0);
R3D.texture.iblBrdfLut = texId;
RL_FREE(img.data);
}
else {
img = LoadImageFromMemory(".dds", TEX_IBL_BRDF_LUT, TEX_IBL_BRDF_LUT_SIZE);
R3D.texture.iblBrdfLut = rlLoadTexture(img.data, img.width, img.height, img.format, img.mipmaps);
UnloadImage(img);
}
}
|
O0
|
c
|
r3d_texture_load_ibl_brdf_lut:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x8210
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
leaq 0x9c3cc(%rip), %rax # 0x1fc200
movq (%rax), %rsi
leaq 0x5c342(%rip), %rdi # 0x1bc180
leaq -0x1c(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x24(%rbp), %r8
callq 0x1642c0
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x15ff8a
cmpl $0x4, -0x24(%rbp)
je 0x15fe7a
cmpl $0x8, -0x24(%rbp)
jne 0x15ff8a
movl $0x1, %edi
leaq -0x28(%rbp), %rsi
leaq 0xbb666(%rip), %rax # 0x21b4f0
callq *(%rax)
leaq 0xbaf0d(%rip), %rax # 0x21ada0
movq (%rax), %rax
movl -0x28(%rbp), %esi
movl $0xde1, %edi # imm = 0xDE1
callq *%rax
movl -0x24(%rbp), %edx
movl $0x8230, %eax # imm = 0x8230
movl $0x822f, %ecx # imm = 0x822F
cmpl $0x4, %edx
cmovel %ecx, %eax
movl %eax, -0x2c(%rbp)
movl -0x24(%rbp), %edx
movl $0x1406, %eax # imm = 0x1406
movl $0x140b, %ecx # imm = 0x140B
cmpl $0x4, %edx
cmovel %ecx, %eax
movl %eax, -0x30(%rbp)
leaq 0xbc4ad(%rip), %rax # 0x21c380
movq (%rax), %rax
movl -0x2c(%rbp), %edx
movl -0x10(%rbp), %ecx
movl -0xc(%rbp), %r8d
movl -0x30(%rbp), %r11d
movq -0x18(%rbp), %r10
movl $0xde1, %edi # imm = 0xDE1
xorl %r9d, %r9d
movl %r9d, %esi
movl $0x8227, (%rsp) # imm = 0x8227
movl %r11d, 0x8(%rsp)
movq %r10, 0x10(%rsp)
callq *%rax
movl $0xde1, %edi # imm = 0xDE1
movl $0x2801, %esi # imm = 0x2801
movl $0x2601, %edx # imm = 0x2601
leaq 0xbc4a4(%rip), %rax # 0x21c3c0
callq *(%rax)
movl $0xde1, %edi # imm = 0xDE1
movl $0x2800, %esi # imm = 0x2800
movl $0x2601, %edx # imm = 0x2601
leaq 0xbc48c(%rip), %rax # 0x21c3c0
callq *(%rax)
movl $0xde1, %edi # imm = 0xDE1
movl $0x2802, %esi # imm = 0x2802
movl $0x812f, %edx # imm = 0x812F
leaq 0xbc474(%rip), %rax # 0x21c3c0
callq *(%rax)
movl $0xde1, %edi # imm = 0xDE1
movl $0x2803, %esi # imm = 0x2803
movl $0x812f, %edx # imm = 0x812F
leaq 0xbc45c(%rip), %rax # 0x21c3c0
callq *(%rax)
movl $0xde1, %edi # imm = 0xDE1
xorl %esi, %esi
leaq 0xbae2c(%rip), %rax # 0x21ada0
callq *(%rax)
movl -0x28(%rbp), %eax
movl %eax, 0xea6a5(%rip) # 0x24a624
movq -0x18(%rbp), %rdi
callq 0x8490
jmp 0x160003
leaq 0x9c26f(%rip), %rax # 0x1fc200
movq (%rax), %rax
movl %eax, %ecx
leaq -0x48(%rbp), %rdi
leaq 0x2913f(%rip), %rsi # 0x1890e0
leaq 0x5c1d8(%rip), %rdx # 0x1bc180
callq 0xb3540
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
movl -0x4(%rbp), %ecx
movl -0x8(%rbp), %r8d
callq 0x167a0
movl %eax, 0xea643(%rip) # 0x24a624
leaq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xb3ed0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
|
r3d_texture_load_ibl_brdf_lut:
push rbp
mov rbp, rsp
sub rsp, 60h
lea rdi, [rbp+var_18]
xor esi, esi
mov edx, 18h
call _memset
mov [rbp+var_1C], 0
mov [rbp+var_20], 0
mov [rbp+var_24], 0
lea rax, TEX_IBL_BRDF_LUT_SIZE
mov rsi, [rax]
lea rdi, TEX_IBL_BRDF_LUT; "DDS |"
lea rdx, [rbp+var_1C]
lea rcx, [rbp+var_20]
lea r8, [rbp+var_24]
call r3d_load_dds_from_memory_ext
mov [rbp+var_18], rax
mov eax, [rbp+var_1C]
mov dword ptr [rbp+var_10], eax
mov eax, [rbp+var_20]
mov dword ptr [rbp+var_10+4], eax
cmp [rbp+var_18], 0
jz loc_15FF8A
cmp [rbp+var_24], 4
jz short loc_15FE7A
cmp [rbp+var_24], 8
jnz loc_15FF8A
loc_15FE7A:
mov edi, 1
lea rsi, [rbp+var_28]
lea rax, glad_glGenTextures
call qword ptr [rax]
lea rax, glad_glBindTexture
mov rax, [rax]
mov esi, [rbp+var_28]
mov edi, 0DE1h
call rax
mov edx, [rbp+var_24]
mov eax, 8230h
mov ecx, 822Fh
cmp edx, 4
cmovz eax, ecx
mov [rbp+var_2C], eax
mov edx, [rbp+var_24]
mov eax, 1406h
mov ecx, 140Bh
cmp edx, 4
cmovz eax, ecx
mov [rbp+var_30], eax
lea rax, glad_glTexImage2D
mov rax, [rax]
mov edx, [rbp+var_2C]
mov ecx, dword ptr [rbp+var_10]
mov r8d, dword ptr [rbp+var_10+4]
mov r11d, [rbp+var_30]
mov r10, [rbp+var_18]
mov edi, 0DE1h
xor r9d, r9d
mov esi, r9d
mov dword ptr [rsp+60h+var_60], 8227h
mov dword ptr [rsp+60h+var_58], r11d
mov [rsp+60h+var_50], r10
call rax
mov edi, 0DE1h
mov esi, 2801h
mov edx, 2601h
lea rax, glad_glTexParameteri
call qword ptr [rax]
mov edi, 0DE1h
mov esi, 2800h
mov edx, 2601h
lea rax, glad_glTexParameteri
call qword ptr [rax]
mov edi, 0DE1h
mov esi, 2802h
mov edx, 812Fh
lea rax, glad_glTexParameteri
call qword ptr [rax]
mov edi, 0DE1h
mov esi, 2803h
mov edx, 812Fh
lea rax, glad_glTexParameteri
call qword ptr [rax]
mov edi, 0DE1h
xor esi, esi
lea rax, glad_glBindTexture
call qword ptr [rax]
mov eax, [rbp+var_28]
mov cs:dword_24A624, eax
mov rdi, [rbp+var_18]
call _free
jmp short loc_160003
loc_15FF8A:
lea rax, TEX_IBL_BRDF_LUT_SIZE
mov rax, [rax]
mov ecx, eax
lea rdi, [rbp+var_48]
lea rsi, aDds; ".dds"
lea rdx, TEX_IBL_BRDF_LUT; "DDS |"
call LoadImageFromMemory
mov rax, [rbp+var_48]
mov [rbp+var_18], rax
mov rax, [rbp+var_40]
mov [rbp+var_10], rax
mov rax, [rbp+var_38]
mov [rbp+var_8], rax
mov rdi, [rbp+var_18]
mov esi, dword ptr [rbp+var_10]
mov edx, dword ptr [rbp+var_10+4]
mov ecx, dword ptr [rbp+var_8+4]
mov r8d, dword ptr [rbp+var_8]
call rlLoadTexture
mov cs:dword_24A624, eax
lea rax, [rbp+var_18]
mov rcx, [rax]
mov [rsp+60h+var_60], rcx
mov rcx, [rax+8]
mov [rsp+60h+var_58], rcx
mov rax, [rax+10h]
mov [rsp+60h+var_50], rax
call UnloadImage
loc_160003:
add rsp, 60h
pop rbp
retn
|
long long r3d_texture_load_ibl_brdf_lut()
{
int v0; // eax
int v1; // eax
int v3; // edi
int v4; // esi
int v5; // edx
int v6; // r8d
int v7; // r9d
long long v8; // [rsp+18h] [rbp-48h] BYREF
unsigned long long v9; // [rsp+20h] [rbp-40h]
long long v10; // [rsp+28h] [rbp-38h]
int v11; // [rsp+30h] [rbp-30h]
unsigned int v12; // [rsp+34h] [rbp-2Ch]
unsigned int v13; // [rsp+38h] [rbp-28h] BYREF
int v14; // [rsp+3Ch] [rbp-24h] BYREF
unsigned int v15; // [rsp+40h] [rbp-20h] BYREF
unsigned int v16; // [rsp+44h] [rbp-1Ch] BYREF
long long v17; // [rsp+48h] [rbp-18h] BYREF
unsigned long long v18; // [rsp+50h] [rbp-10h]
long long v19; // [rsp+58h] [rbp-8h]
memset(&v17, 0LL, 24LL);
v16 = 0;
v15 = 0;
v14 = 0;
v17 = r3d_load_dds_from_memory_ext("DDS |", *(_QWORD *)&TEX_IBL_BRDF_LUT_SIZE, &v16, &v15, &v14);
v18 = __PAIR64__(v15, v16);
if ( v17 && (v14 == 4 || v14 == 8) )
{
glad_glGenTextures(1LL, &v13);
glad_glBindTexture(3553LL, v13);
v0 = 33328;
if ( v14 == 4 )
v0 = 33327;
v12 = v0;
v1 = 5126;
if ( v14 == 4 )
v1 = 5131;
v11 = v1;
glad_glTexImage2D(3553LL, 0LL, v12, (unsigned int)v18, HIDWORD(v18), 0LL, 33319, v1, v17);
glad_glTexParameteri(3553LL, 10241LL, 9729LL);
glad_glTexParameteri(3553LL, 10240LL, 9729LL);
glad_glTexParameteri(3553LL, 10242LL, 33071LL);
glad_glTexParameteri(3553LL, 10243LL, 33071LL);
glad_glBindTexture(3553LL, 0LL);
dword_24A624 = v13;
return free(v17);
}
else
{
LoadImageFromMemory((long long)&v8, (long long)".dds", (long long)"DDS |", TEX_IBL_BRDF_LUT_SIZE);
v17 = v8;
v18 = v9;
v19 = v10;
v3 = v8;
v4 = v9;
dword_24A624 = rlLoadTexture(v8, v9, HIDWORD(v9), HIDWORD(v10), v10);
return UnloadImage(v3, v4, v5, v18, v6, v7, v17);
}
}
| |||
63,603
|
r3d_texture_load_ibl_brdf_lut
|
r3d/src/r3d_state.c
|
void r3d_texture_load_ibl_brdf_lut(void)
{
// TODO: Review in case 'R3D.support.TEX_R16G16F' is false
Image img = { 0 };
uint32_t width = 0, height = 0;
uint32_t special_format_size = 0; // should be 4 or 8 (RG16F or RG32F)
img.data = r3d_load_dds_from_memory_ext(TEX_IBL_BRDF_LUT, TEX_IBL_BRDF_LUT_SIZE, &width, &height, &special_format_size);
img.width = (int)width;
img.height = (int)height;
if (img.data && (special_format_size == 4 || special_format_size == 8)) {
GLuint texId;
glGenTextures(1, &texId);
glBindTexture(GL_TEXTURE_2D, texId);
GLenum internal_format = (special_format_size == 4) ? GL_RG16F : GL_RG32F;
GLenum data_type = (special_format_size == 4) ? GL_HALF_FLOAT : GL_FLOAT;
glTexImage2D(GL_TEXTURE_2D, 0, internal_format, img.width, img.height, 0, GL_RG, data_type, img.data);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_2D, 0);
R3D.texture.iblBrdfLut = texId;
RL_FREE(img.data);
}
else {
img = LoadImageFromMemory(".dds", TEX_IBL_BRDF_LUT, TEX_IBL_BRDF_LUT_SIZE);
R3D.texture.iblBrdfLut = rlLoadTexture(img.data, img.width, img.height, img.format, img.mipmaps);
UnloadImage(img);
}
}
|
O3
|
c
|
r3d_texture_load_ibl_brdf_lut:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
leaq 0xa3658(%rip), %rax # 0x163f70
movq (%rax), %rbx
xorl %r14d, %r14d
cmpq $0x80, %rbx
jb 0xc09b1
leaq 0x635be(%rip), %rax # 0x123ef0
cmpl $0x20534444, (%rax) # imm = 0x20534444
jne 0xc09b1
cmpl $0x7c, 0x4(%rax)
jne 0xc09b1
testb $0x4, 0x50(%rax)
je 0xc0984
cmpl $0x30315844, 0x54(%rax) # imm = 0x30315844
jne 0xc0984
cmpq $0x94, %rbx
jb 0xc09b1
movl 0x80(%rax), %ecx
movl $0x94, %r13d
cmpl $0x6f, %ecx
je 0xc0a23
movl $0x0, %r15d
cmpl $0x70, %ecx
jne 0xc09b4
movl $0x8, %edx
xorl %ecx, %ecx
jmp 0xc0a2a
cmpl $0x20, 0x58(%rax)
jne 0xc09b1
cmpl $0xffff, 0x5c(%rax) # imm = 0xFFFF
jne 0xc09b1
cmpl $0xffff0000, 0x60(%rax) # imm = 0xFFFF0000
movl $0x0, %r15d
jne 0xc09b4
movl $0x4, %edx
movb $0x1, %cl
movl $0x80, %r13d
jmp 0xc0a2a
xorl %r15d, %r15d
movq $0x0, -0x50(%rbp)
movl %r14d, -0x48(%rbp)
movl %r15d, -0x44(%rbp)
leaq 0x2eccd(%rip), %rsi # 0xef698
leaq 0x6351e(%rip), %rdx # 0x123ef0
leaq -0x50(%rbp), %r14
movq %r14, %rdi
movl %ebx, %ecx
callq 0x82301
movq (%r14), %rdi
movl 0x8(%r14), %esi
movl 0xc(%r14), %edx
movl 0x14(%r14), %ecx
movl 0x10(%r14), %r8d
callq 0x1c6b8
movl %eax, 0xf07a6(%rip) # 0x1b11a4
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movaps (%r14), %xmm0
movups %xmm0, (%rsp)
callq 0x82a5f
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x4, %edx
movb $0x1, %cl
movl 0xc(%rax), %r15d
movl 0x10(%rax), %r14d
movl %edx, %r12d
imulq %r14, %r12
imulq %r15, %r12
leaq (%r12,%r13), %rax
cmpq %rbx, %rax
ja 0xc09b4
movl %edx, -0x30(%rbp)
movl %ecx, -0x2c(%rbp)
movq %r12, %rdi
callq 0x84d0
testq %rax, %rax
je 0xc09b4
addq 0xbf538(%rip), %r13 # 0x17ffa0
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x82d0
movq -0x58(%rbp), %r13
movq %r13, -0x50(%rbp)
movl %r14d, -0x48(%rbp)
movl %r15d, -0x44(%rbp)
movl -0x30(%rbp), %eax
cmpl $0x8, %eax
je 0xc0a9c
cmpl $0x4, %eax
jne 0xc09c4
leaq 0xc15cd(%rip), %rax # 0x182070
leaq -0x5c(%rbp), %rbx
movl $0x1, %edi
movq %rbx, %rsi
callq *(%rax)
leaq 0xc0e68(%rip), %r12 # 0x181920
movl (%rbx), %esi
movl $0xde1, %edi # imm = 0xDE1
callq *(%r12)
movzbl -0x2c(%rbp), %eax
movl $0x8230, %edx # imm = 0x8230
subl %eax, %edx
leal (%rax,%rax,4), %eax
addl $0x1406, %eax # imm = 0x1406
leaq 0xc2423(%rip), %r10 # 0x182f00
movq %r13, 0x10(%rsp)
movl %eax, 0x8(%rsp)
movl $0x8227, (%rsp) # imm = 0x8227
movl $0xde1, %edi # imm = 0xDE1
xorl %esi, %esi
movl %r14d, %ecx
movl %r15d, %r8d
xorl %r9d, %r9d
callq *(%r10)
leaq 0xc2439(%rip), %r14 # 0x182f40
movl $0xde1, %edi # imm = 0xDE1
movl $0x2801, %esi # imm = 0x2801
movl $0x2601, %edx # imm = 0x2601
callq *(%r14)
movl $0xde1, %edi # imm = 0xDE1
movl $0x2800, %esi # imm = 0x2800
movl $0x2601, %edx # imm = 0x2601
callq *(%r14)
movl $0xde1, %edi # imm = 0xDE1
movl $0x2802, %esi # imm = 0x2802
movl $0x812f, %edx # imm = 0x812F
callq *(%r14)
movl $0xde1, %edi # imm = 0xDE1
movl $0x2803, %esi # imm = 0x2803
movl $0x812f, %edx # imm = 0x812F
callq *(%r14)
movl $0xde1, %edi # imm = 0xDE1
xorl %esi, %esi
callq *(%r12)
movl (%rbx), %eax
movl %eax, 0xf0642(%rip) # 0x1b11a4
movq %r13, %rdi
callq 0x8480
jmp 0xc0a14
|
r3d_texture_load_ibl_brdf_lut:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
xorps xmm0, xmm0
movaps [rbp+var_50], xmm0
mov [rbp+var_40], 0
lea rax, TEX_IBL_BRDF_LUT_SIZE
mov rbx, [rax]
xor r14d, r14d
cmp rbx, 80h
jb loc_C09B1
lea rax, TEX_IBL_BRDF_LUT; "DDS |"
cmp dword ptr [rax], 20534444h
jnz short loc_C09B1
cmp dword ptr [rax+4], 7Ch ; '|'
jnz short loc_C09B1
test byte ptr [rax+50h], 4
jz short loc_C0984
cmp dword ptr [rax+54h], 30315844h
jnz short loc_C0984
cmp rbx, 94h
jb short loc_C09B1
mov ecx, [rax+80h]
mov r13d, 94h
cmp ecx, 6Fh ; 'o'
jz loc_C0A23
mov r15d, 0
cmp ecx, 70h ; 'p'
jnz short loc_C09B4
mov edx, 8
xor ecx, ecx
jmp loc_C0A2A
loc_C0984:
cmp dword ptr [rax+58h], 20h ; ' '
jnz short loc_C09B1
cmp dword ptr [rax+5Ch], 0FFFFh
jnz short loc_C09B1
cmp dword ptr [rax+60h], 0FFFF0000h
mov r15d, 0
jnz short loc_C09B4
mov edx, 4
mov cl, 1
mov r13d, 80h
jmp short loc_C0A2A
loc_C09B1:
xor r15d, r15d
loc_C09B4:
mov qword ptr [rbp+var_50], 0
mov dword ptr [rbp+var_50+8], r14d
mov dword ptr [rbp+var_50+0Ch], r15d
loc_C09C4:
lea rsi, aDds; ".dds"
lea rdx, TEX_IBL_BRDF_LUT; "DDS |"
lea r14, [rbp+var_50]
mov rdi, r14
mov ecx, ebx
call LoadImageFromMemory
mov rdi, [r14]
mov esi, [r14+8]
mov edx, [r14+0Ch]
mov ecx, [r14+14h]
mov r8d, [r14+10h]
call rlLoadTexture
mov cs:dword_1B11A4, eax
mov rax, [r14+10h]
mov [rsp+80h+var_70], rax
movaps xmm0, xmmword ptr [r14]
movups [rsp+80h+var_80], xmm0
call UnloadImage
loc_C0A14:
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_C0A23:
mov edx, 4
mov cl, 1
loc_C0A2A:
mov r15d, [rax+0Ch]
mov r14d, [rax+10h]
mov r12d, edx
imul r12, r14
imul r12, r15
lea rax, [r12+r13]
cmp rax, rbx
ja loc_C09B4
mov [rbp+var_30], edx
mov [rbp+var_2C], ecx
mov rdi, r12
call _malloc
test rax, rax
jz loc_C09B4
add r13, cs:TEX_IBL_BRDF_LUT_ptr
mov [rbp+var_58], rax
mov rdi, [rbp+var_58]
mov rsi, r13
mov rdx, r12
call _memcpy
mov r13, [rbp+var_58]
mov qword ptr [rbp+var_50], r13
mov dword ptr [rbp+var_50+8], r14d
mov dword ptr [rbp+var_50+0Ch], r15d
mov eax, [rbp+var_30]
cmp eax, 8
jz short loc_C0A9C
cmp eax, 4
jnz loc_C09C4
loc_C0A9C:
lea rax, glad_glGenTextures
lea rbx, [rbp+var_5C]
mov edi, 1
mov rsi, rbx
call qword ptr [rax]
lea r12, glad_glBindTexture
mov esi, [rbx]
mov edi, 0DE1h
call qword ptr [r12]
movzx eax, byte ptr [rbp+var_2C]
mov edx, 8230h
sub edx, eax
lea eax, [rax+rax*4]
add eax, 1406h
lea r10, glad_glTexImage2D
mov [rsp+80h+var_70], r13
mov dword ptr [rsp+80h+var_80+8], eax
mov dword ptr [rsp+80h+var_80], 8227h
mov edi, 0DE1h
xor esi, esi
mov ecx, r14d
mov r8d, r15d
xor r9d, r9d
call qword ptr [r10]
lea r14, glad_glTexParameteri
mov edi, 0DE1h
mov esi, 2801h
mov edx, 2601h
call qword ptr [r14]
mov edi, 0DE1h
mov esi, 2800h
mov edx, 2601h
call qword ptr [r14]
mov edi, 0DE1h
mov esi, 2802h
mov edx, 812Fh
call qword ptr [r14]
mov edi, 0DE1h
mov esi, 2803h
mov edx, 812Fh
call qword ptr [r14]
mov edi, 0DE1h
xor esi, esi
call qword ptr [r12]
mov eax, [rbx]
mov cs:dword_1B11A4, eax
mov rdi, r13
call _free
jmp loc_C0A14
|
long long r3d_texture_load_ibl_brdf_lut(long long a1, long long a2, long long a3, int a4, int a5, int a6)
{
long long v6; // r14
long long v7; // r13
long long v8; // r15
unsigned int v9; // edx
long long v10; // rdi
long long v11; // rsi
long long v12; // rdx
long long v13; // rcx
long long v14; // r8
long long v15; // r9
long long v17; // r12
long long v18; // rax
long long v19; // r13
unsigned int v20; // [rsp+24h] [rbp-5Ch] BYREF
long long v21; // [rsp+28h] [rbp-58h]
__int128 v22; // [rsp+30h] [rbp-50h] BYREF
long long v23; // [rsp+40h] [rbp-40h]
unsigned int v24; // [rsp+50h] [rbp-30h]
int v25; // [rsp+54h] [rbp-2Ch]
v22 = 0LL;
v23 = 0LL;
LODWORD(v6) = 0;
if ( *(_QWORD *)&TEX_IBL_BRDF_LUT_SIZE < 0x80uLL || *(_DWORD *)"DDS |" != 542327876 || *(_DWORD *)"|" != 124 )
goto LABEL_14;
if ( (TEX_IBL_BRDF_LUT[80] & 4) == 0 || *(_DWORD *)&TEX_IBL_BRDF_LUT[84] != 808540228 )
{
if ( *(_DWORD *)&TEX_IBL_BRDF_LUT[88] == 32 && *(_DWORD *)&TEX_IBL_BRDF_LUT[92] == 0xFFFF )
{
LODWORD(v8) = 0;
if ( *(_DWORD *)&TEX_IBL_BRDF_LUT[96] == -65536 )
{
v9 = 4;
LOBYTE(a4) = 1;
v7 = 128LL;
goto LABEL_17;
}
LABEL_15:
*(_QWORD *)&v22 = 0LL;
*((_QWORD *)&v22 + 1) = __PAIR64__(v8, v6);
LoadImageFromMemory((long long)&v22, (long long)".dds", "DDS |", TEX_IBL_BRDF_LUT_SIZE, a5, a6);
v10 = v22;
v11 = DWORD2(v22);
dword_1B11A4 = rlLoadTexture(v22, DWORD2(v22), HIDWORD(v22), HIDWORD(v23), v23);
return UnloadImage(v10, v11, v12, v13, v14, v15, v22);
}
LABEL_14:
LODWORD(v8) = 0;
goto LABEL_15;
}
if ( *(_QWORD *)&TEX_IBL_BRDF_LUT_SIZE < 0x94uLL )
goto LABEL_14;
a4 = *(_DWORD *)&TEX_IBL_BRDF_LUT[128];
v7 = 148LL;
if ( a4 == 111 )
{
v9 = 4;
LOBYTE(a4) = 1;
goto LABEL_17;
}
LODWORD(v8) = 0;
if ( a4 != 112 )
goto LABEL_15;
v9 = 8;
a4 = 0;
LABEL_17:
v8 = *(unsigned int *)&TEX_IBL_BRDF_LUT[12];
v6 = *(unsigned int *)&TEX_IBL_BRDF_LUT[16];
v17 = v8 * v6 * v9;
if ( (unsigned long long)(v17 + v7) > *(_QWORD *)&TEX_IBL_BRDF_LUT_SIZE )
goto LABEL_15;
v24 = v9;
v25 = a4;
v18 = malloc(v8 * v6 * v9);
if ( !v18 )
goto LABEL_15;
v21 = v18;
memcpy(v18, &TEX_IBL_BRDF_LUT[v7], v17);
v19 = v21;
*(_QWORD *)&v22 = v21;
*((_QWORD *)&v22 + 1) = __PAIR64__(v8, v6);
glad_glGenTextures(1LL, &v20);
glad_glBindTexture(3553LL, v20);
glad_glTexImage2D(
3553LL,
0LL,
33328 - (unsigned int)(unsigned __int8)v25,
(unsigned int)v6,
(unsigned int)v8,
0LL,
33319,
5 * (unsigned int)(unsigned __int8)v25 + 5126,
v19);
glad_glTexParameteri(3553LL, 10241LL, 9729LL);
glad_glTexParameteri(3553LL, 10240LL, 9729LL);
glad_glTexParameteri(3553LL, 10242LL, 33071LL);
glad_glTexParameteri(3553LL, 10243LL, 33071LL);
glad_glBindTexture(3553LL, 0LL);
dword_1B11A4 = v20;
return free(v19);
}
|
r3d_texture_load_ibl_brdf_lut:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RBP + -0x50],XMM0
MOV qword ptr [RBP + -0x40],0x0
LEA RAX,[0x263f70]
MOV RBX,qword ptr [RAX]
XOR R14D,R14D
CMP RBX,0x80
JC 0x001c09b1
LEA RAX,[0x223ef0]
CMP dword ptr [RAX],0x20534444
JNZ 0x001c09b1
CMP dword ptr [RAX + 0x4],0x7c
JNZ 0x001c09b1
TEST byte ptr [RAX + 0x50],0x4
JZ 0x001c0984
CMP dword ptr [RAX + 0x54],0x30315844
JNZ 0x001c0984
CMP RBX,0x94
JC 0x001c09b1
MOV ECX,dword ptr [RAX + 0x80]
MOV R13D,0x94
CMP ECX,0x6f
JZ 0x001c0a23
MOV R15D,0x0
CMP ECX,0x70
JNZ 0x001c09b4
MOV EDX,0x8
XOR ECX,ECX
JMP 0x001c0a2a
LAB_001c0984:
CMP dword ptr [RAX + 0x58],0x20
JNZ 0x001c09b1
CMP dword ptr [RAX + 0x5c],0xffff
JNZ 0x001c09b1
CMP dword ptr [RAX + 0x60],0xffff0000
MOV R15D,0x0
JNZ 0x001c09b4
MOV EDX,0x4
MOV CL,0x1
MOV R13D,0x80
JMP 0x001c0a2a
LAB_001c09b1:
XOR R15D,R15D
LAB_001c09b4:
MOV qword ptr [RBP + -0x50],0x0
MOV dword ptr [RBP + -0x48],R14D
MOV dword ptr [RBP + -0x44],R15D
LAB_001c09c4:
LEA RSI,[0x1ef698]
LEA RDX,[0x223ef0]
LEA R14,[RBP + -0x50]
MOV RDI,R14
MOV ECX,EBX
CALL 0x00182301
MOV RDI,qword ptr [R14]
MOV ESI,dword ptr [R14 + 0x8]
MOV EDX,dword ptr [R14 + 0xc]
MOV ECX,dword ptr [R14 + 0x14]
MOV R8D,dword ptr [R14 + 0x10]
CALL 0x0011c6b8
MOV dword ptr [0x002b11a4],EAX
MOV RAX,qword ptr [R14 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVAPS XMM0,xmmword ptr [R14]
MOVUPS xmmword ptr [RSP],XMM0
CALL 0x00182a5f
LAB_001c0a14:
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001c0a23:
MOV EDX,0x4
MOV CL,0x1
LAB_001c0a2a:
MOV R15D,dword ptr [RAX + 0xc]
MOV R14D,dword ptr [RAX + 0x10]
MOV R12D,EDX
IMUL R12,R14
IMUL R12,R15
LEA RAX,[R12 + R13*0x1]
CMP RAX,RBX
JA 0x001c09b4
MOV dword ptr [RBP + -0x30],EDX
MOV dword ptr [RBP + -0x2c],ECX
MOV RDI,R12
CALL 0x001084d0
TEST RAX,RAX
JZ 0x001c09b4
ADD R13,qword ptr [0x0027ffa0]
MOV qword ptr [RBP + -0x58],RAX
MOV RDI,qword ptr [RBP + -0x58]
MOV RSI,R13
MOV RDX,R12
CALL 0x001082d0
MOV R13,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x50],R13
MOV dword ptr [RBP + -0x48],R14D
MOV dword ptr [RBP + -0x44],R15D
MOV EAX,dword ptr [RBP + -0x30]
CMP EAX,0x8
JZ 0x001c0a9c
CMP EAX,0x4
JNZ 0x001c09c4
LAB_001c0a9c:
LEA RAX,[0x282070]
LEA RBX,[RBP + -0x5c]
MOV EDI,0x1
MOV RSI,RBX
CALL qword ptr [RAX]
LEA R12,[0x281920]
MOV ESI,dword ptr [RBX]
MOV EDI,0xde1
CALL qword ptr [R12]
MOVZX EAX,byte ptr [RBP + -0x2c]
MOV EDX,0x8230
SUB EDX,EAX
LEA EAX,[RAX + RAX*0x4]
ADD EAX,0x1406
LEA R10,[0x282f00]
MOV qword ptr [RSP + 0x10],R13
MOV dword ptr [RSP + 0x8],EAX
MOV dword ptr [RSP],0x8227
MOV EDI,0xde1
XOR ESI,ESI
MOV ECX,R14D
MOV R8D,R15D
XOR R9D,R9D
CALL qword ptr [R10]
LEA R14,[0x282f40]
MOV EDI,0xde1
MOV ESI,0x2801
MOV EDX,0x2601
CALL qword ptr [R14]
MOV EDI,0xde1
MOV ESI,0x2800
MOV EDX,0x2601
CALL qword ptr [R14]
MOV EDI,0xde1
MOV ESI,0x2802
MOV EDX,0x812f
CALL qword ptr [R14]
MOV EDI,0xde1
MOV ESI,0x2803
MOV EDX,0x812f
CALL qword ptr [R14]
MOV EDI,0xde1
XOR ESI,ESI
CALL qword ptr [R12]
MOV EAX,dword ptr [RBX]
MOV dword ptr [0x002b11a4],EAX
MOV RDI,R13
CALL 0x00108480
JMP 0x001c0a14
|
void r3d_texture_load_ibl_brdf_lut(void)
{
uint uVar1;
uint uVar2;
ulong uVar3;
void *pvVar4;
uint uVar5;
int8 in_RCX;
uint uVar6;
size_t __size;
long lVar7;
uint uVar8;
uint uVar9;
int4 local_64;
void *local_60;
void *local_58;
int8 uStack_50;
int8 local_48;
uint local_38;
uint local_34;
uVar3 = TEX_IBL_BRDF_LUT_SIZE;
uVar2 = DAT_00223f00;
uVar1 = DAT_00223efc;
local_58 = (void *)0x0;
uStack_50 = 0;
local_48 = 0;
uVar8 = 0;
if (((TEX_IBL_BRDF_LUT_SIZE < 0x80) || (TEX_IBL_BRDF_LUT != 0x20534444)) || (DAT_00223ef4 != 0x7c)
) {
LAB_001c09b1:
uVar9 = 0;
}
else if (((DAT_00223f40 & 4) == 0) || (DAT_00223f44 != 0x30315844)) {
if ((DAT_00223f48 != 0x20) || (DAT_00223f4c != 0xffff)) goto LAB_001c09b1;
uVar9 = 0;
if (DAT_00223f50 == -0x10000) {
uVar6 = 4;
uVar5 = (uint)CONCAT71((int7)((ulong)in_RCX >> 8),1);
lVar7 = 0x80;
goto LAB_001c0a2a;
}
}
else {
if (TEX_IBL_BRDF_LUT_SIZE < 0x94) goto LAB_001c09b1;
lVar7 = 0x94;
if (DAT_00223f70 == 0x6f) {
uVar6 = 4;
uVar5 = 1;
}
else {
uVar9 = 0;
if (DAT_00223f70 != 0x70) goto LAB_001c09b4;
uVar6 = 8;
uVar5 = 0;
}
LAB_001c0a2a:
__size = (ulong)uVar6 * (ulong)DAT_00223f00 * (ulong)DAT_00223efc;
uVar8 = uVar2;
uVar9 = uVar1;
if ((__size + lVar7 <= TEX_IBL_BRDF_LUT_SIZE) &&
(local_38 = uVar6, local_34 = uVar5, pvVar4 = malloc(__size), pvVar4 != (void *)0x0)) {
local_60 = pvVar4;
memcpy(pvVar4,PTR_TEX_IBL_BRDF_LUT_0027ffa0 + lVar7,__size);
pvVar4 = local_60;
local_58 = local_60;
uStack_50 = CONCAT44(uVar1,uVar2);
if ((local_38 == 8) || (local_38 == 4)) {
(*glad_glGenTextures)(1,&local_64);
(*glad_glBindTexture)(0xde1,local_64);
(*glad_glTexImage2D)
(0xde1,0,0x8230 - (local_34 & 0xff),uVar2,uVar1,0,0x8227,
(local_34 & 0xff) + (local_34 & 0xff) * 4 + 0x1406,pvVar4);
(*glad_glTexParameteri)(0xde1,0x2801,0x2601);
(*glad_glTexParameteri)(0xde1,0x2800,0x2601);
(*glad_glTexParameteri)(0xde1,0x2802,0x812f);
(*glad_glTexParameteri)(0xde1,0x2803,0x812f);
(*glad_glBindTexture)(0xde1,0);
DAT_002b11a4 = local_64;
free(pvVar4);
return;
}
goto LAB_001c09c4;
}
}
LAB_001c09b4:
local_58 = (void *)0x0;
uStack_50 = CONCAT44(uVar9,uVar8);
LAB_001c09c4:
LoadImageFromMemory(&local_58,&DAT_001ef698,&TEX_IBL_BRDF_LUT,uVar3 & 0xffffffff);
DAT_002b11a4 = rlLoadTexture(local_58,uStack_50 & 0xffffffff,uStack_50._4_4_,local_48._4_4_,
local_48 & 0xffffffff);
UnloadImage();
return;
}
|
|
63,604
|
my_strnxfrm_czech
|
eloqsql/strings/ctype-czech.c
|
static size_t
my_strnxfrm_czech(CHARSET_INFO *cs __attribute__((unused)),
uchar *dest, size_t len,
uint nweights_arg __attribute__((unused)),
const uchar *src, size_t srclen, uint flags)
{
int value;
const uchar *p, * store;
int pass = 0;
size_t totlen = 0;
p = src; store = src;
if (!(flags & 0x0F)) /* All levels by default */
flags|= 0x0F;
do
{
int add= (1 << pass) & flags; /* If this level is needed */
NEXT_CMP_VALUE(src, p, store, pass, value, (int)srclen);
if (add)
ADD_TO_RESULT(dest, len, totlen, value);
}
while (value);
if ((flags & MY_STRXFRM_PAD_TO_MAXLEN) && len > totlen)
{
memset(dest + totlen, ' ', len - totlen);
totlen= len;
}
return totlen;
}
|
O0
|
c
|
my_strnxfrm_czech:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %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)
movl $0x0, -0x4c(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movl 0x10(%rbp), %eax
andl $0xf, %eax
cmpl $0x0, %eax
jne 0x10fb58
movl 0x10(%rbp), %eax
orl $0xf, %eax
movl %eax, 0x10(%rbp)
jmp 0x10fb5a
movl -0x4c(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
andl 0x10(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq -0x30(%rbp), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jl 0x10fbcd
movl $0x0, -0x34(%rbp)
cmpl $0x3, -0x4c(%rbp)
je 0x10fbc8
movl -0x4c(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x4c(%rbp)
cmpl $0x0, %eax
jne 0x10fbab
movq -0x48(%rbp), %rax
movq %rax, -0x98(%rbp)
jmp 0x10fbb6
movq -0x28(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x1, -0x34(%rbp)
jmp 0x10fe27
movslq -0x4c(%rbp), %rcx
leaq 0x1a5828(%rip), %rax # 0x2b5400
movq (%rax,%rcx,8), %rax
movq -0x40(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x10fc01
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x10fb6a
cmpl $0x2, -0x34(%rbp)
jne 0x10fd0d
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rcx
movq -0x28(%rbp), %rax
subq %rax, %rcx
movq -0x30(%rbp), %rax
movslq %eax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x99(%rbp)
jge 0x10fc60
movslq -0x4c(%rbp), %rcx
leaq 0x1a57bb(%rip), %rax # 0x2b5400
movq (%rax,%rcx,8), %rax
movq -0x70(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
cmpl $0x2, %eax
sete %al
movb %al, -0x99(%rbp)
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x10fc6c
jmp 0x10fc7a
movq -0x70(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x70(%rbp)
jmp 0x10fc1b
movq -0x70(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq -0x30(%rbp), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jl 0x10fc99
movq -0x70(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpl $0x2, -0x4c(%rbp)
jg 0x10fcbe
movq -0x70(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq -0x30(%rbp), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x10fcbe
movq -0x70(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq -0x30(%rbp), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jl 0x10fcda
jmp 0x10fb6a
cmpl $0x1, -0x4c(%rbp)
jle 0x10fce5
jmp 0x10fe27
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0x1, %eax
subl -0x4c(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x10fe27
cmpl $0xff, -0x34(%rbp)
jne 0x10fe1b
movl $0x0, -0x74(%rbp)
cmpl $0x50, -0x74(%rbp)
jge 0x10fe19
movslq -0x74(%rbp), %rcx
leaq 0x1a56ea(%rip), %rax # 0x2b5420
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x88(%rbp)
movl $0x0, -0x8c(%rbp)
movq -0x80(%rbp), %rax
movslq -0x8c(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x10fdc6
movq -0x88(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq -0x30(%rbp), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x10fda1
movq -0x88(%rbp), %rax
movsbl (%rax), %eax
movq -0x80(%rbp), %rcx
movslq -0x8c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x10fda3
jmp 0x10fdc6
movl -0x8c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8c(%rbp)
movq -0x88(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x88(%rbp)
jmp 0x10fd59
movq -0x80(%rbp), %rax
movslq -0x8c(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x10fe09
movslq -0x74(%rbp), %rcx
leaq 0x1a563e(%rip), %rax # 0x2b5420
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movslq -0x4c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x34(%rbp)
movq -0x88(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x10fe19
jmp 0x10fe0b
movl -0x74(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x74(%rbp)
jmp 0x10fd21
jmp 0x10fe1b
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
cmpl $0x0, -0x5c(%rbp)
je 0x10fe54
movq -0x58(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x10fe52
movl -0x34(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x58(%rbp)
movb %dl, (%rax,%rcx)
jmp 0x10fe54
jmp 0x10fe56
cmpl $0x0, -0x34(%rbp)
jne 0x10fb5a
movl 0x10(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x10fe99
movq -0x18(%rbp), %rax
cmpq -0x58(%rbp), %rax
jbe 0x10fe99
movq -0x10(%rbp), %rdi
addq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rdx
subq -0x58(%rbp), %rdx
movl $0x20, %esi
callq 0x2a2a0
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_strnxfrm_czech:
push rbp
mov rbp, rsp
sub rsp, 0A0h
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 [rbp+var_4C], 0
mov [rbp+var_58], 0
mov rax, [rbp+var_28]
mov [rbp+var_40], rax
mov rax, [rbp+var_28]
mov [rbp+var_48], rax
mov eax, [rbp+arg_0]
and eax, 0Fh
cmp eax, 0
jnz short loc_10FB58
mov eax, [rbp+arg_0]
or eax, 0Fh
mov [rbp+arg_0], eax
loc_10FB58:
jmp short $+2
loc_10FB5A:
mov ecx, [rbp+var_4C]
mov eax, 1
shl eax, cl
and eax, [rbp+arg_0]
mov [rbp+var_5C], eax
loc_10FB6A:
mov rax, [rbp+var_40]
mov rcx, [rbp+var_28]
sub rax, rcx
mov rcx, [rbp+var_30]
movsxd rcx, ecx
cmp rax, rcx
jl short loc_10FBCD
mov [rbp+var_34], 0
cmp [rbp+var_4C], 3
jz short loc_10FBC8
mov eax, [rbp+var_4C]
mov ecx, eax
add ecx, 1
mov [rbp+var_4C], ecx
cmp eax, 0
jnz short loc_10FBAB
mov rax, [rbp+var_48]
mov [rbp+var_98], rax
jmp short loc_10FBB6
loc_10FBAB:
mov rax, [rbp+var_28]
mov [rbp+var_98], rax
loc_10FBB6:
mov rax, [rbp+var_98]
mov [rbp+var_40], rax
mov [rbp+var_34], 1
loc_10FBC8:
jmp loc_10FE27
loc_10FBCD:
movsxd rcx, [rbp+var_4C]
lea rax, CZ_SORT_TABLE
mov rax, [rax+rcx*8]
mov rcx, [rbp+var_40]
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx]
mov [rbp+var_34], eax
cmp [rbp+var_34], 0
jnz short loc_10FC01
mov rax, [rbp+var_40]
add rax, 1
mov [rbp+var_40], rax
jmp loc_10FB6A
loc_10FC01:
cmp [rbp+var_34], 2
jnz loc_10FD0D
mov rax, [rbp+var_40]
add rax, 1
mov [rbp+var_40], rax
mov [rbp+var_70], rax
loc_10FC1B:
mov rcx, [rbp+var_70]
mov rax, [rbp+var_28]
sub rcx, rax
mov rax, [rbp+var_30]
movsxd rdx, eax
xor eax, eax
cmp rcx, rdx
mov [rbp+var_99], al
jge short loc_10FC60
movsxd rcx, [rbp+var_4C]
lea rax, CZ_SORT_TABLE
mov rax, [rax+rcx*8]
mov rcx, [rbp+var_70]
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx]
cmp eax, 2
setz al
mov [rbp+var_99], al
loc_10FC60:
mov al, [rbp+var_99]
test al, 1
jnz short loc_10FC6C
jmp short loc_10FC7A
loc_10FC6C:
mov rax, [rbp+var_70]
add rax, 1
mov [rbp+var_70], rax
jmp short loc_10FC1B
loc_10FC7A:
mov rax, [rbp+var_70]
mov rcx, [rbp+var_28]
sub rax, rcx
mov rcx, [rbp+var_30]
movsxd rcx, ecx
cmp rax, rcx
jl short loc_10FC99
mov rax, [rbp+var_70]
mov [rbp+var_40], rax
loc_10FC99:
cmp [rbp+var_4C], 2
jg short loc_10FCBE
mov rax, [rbp+var_70]
mov rcx, [rbp+var_28]
sub rax, rcx
mov rcx, [rbp+var_30]
movsxd rcx, ecx
cmp rax, rcx
jge short loc_10FCBE
mov rax, [rbp+var_70]
mov [rbp+var_40], rax
loc_10FCBE:
mov rax, [rbp+var_40]
mov rcx, [rbp+var_28]
sub rax, rcx
mov rcx, [rbp+var_30]
movsxd rcx, ecx
cmp rax, rcx
jl short loc_10FCDA
jmp loc_10FB6A
loc_10FCDA:
cmp [rbp+var_4C], 1
jle short loc_10FCE5
jmp loc_10FE27
loc_10FCE5:
mov rax, [rbp+var_40]
mov [rbp+var_68], rax
mov eax, 1
sub eax, [rbp+var_4C]
mov [rbp+var_4C], eax
mov rax, [rbp+var_48]
mov [rbp+var_40], rax
mov rax, [rbp+var_68]
mov [rbp+var_48], rax
jmp loc_10FE27
loc_10FD0D:
cmp [rbp+var_34], 0FFh
jnz loc_10FE1B
mov [rbp+var_74], 0
loc_10FD21:
cmp [rbp+var_74], 50h ; 'P'
jge loc_10FE19
movsxd rcx, [rbp+var_74]
lea rax, doubles
shl rcx, 4
add rax, rcx
mov rax, [rax]
mov [rbp+var_80], rax
mov rax, [rbp+var_40]
mov [rbp+var_88], rax
mov [rbp+var_8C], 0
loc_10FD59:
mov rax, [rbp+var_80]
movsxd rcx, [rbp+var_8C]
cmp byte ptr [rax+rcx], 0
jz short loc_10FDC6
mov rax, [rbp+var_88]
mov rcx, [rbp+var_28]
sub rax, rcx
mov rcx, [rbp+var_30]
movsxd rcx, ecx
cmp rax, rcx
jge short loc_10FDA1
mov rax, [rbp+var_88]
movsx eax, byte ptr [rax]
mov rcx, [rbp+var_80]
movsxd rdx, [rbp+var_8C]
movsx ecx, byte ptr [rcx+rdx]
cmp eax, ecx
jz short loc_10FDA3
loc_10FDA1:
jmp short loc_10FDC6
loc_10FDA3:
mov eax, [rbp+var_8C]
add eax, 1
mov [rbp+var_8C], eax
mov rax, [rbp+var_88]
add rax, 1
mov [rbp+var_88], rax
jmp short loc_10FD59
loc_10FDC6:
mov rax, [rbp+var_80]
movsxd rcx, [rbp+var_8C]
cmp byte ptr [rax+rcx], 0
jnz short loc_10FE09
movsxd rcx, [rbp+var_74]
lea rax, doubles
shl rcx, 4
add rax, rcx
mov rax, [rax+8]
movsxd rcx, [rbp+var_4C]
movzx eax, byte ptr [rax+rcx]
mov [rbp+var_34], eax
mov rax, [rbp+var_88]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_40], rax
jmp short loc_10FE19
loc_10FE09:
jmp short $+2
loc_10FE0B:
mov eax, [rbp+var_74]
add eax, 1
mov [rbp+var_74], eax
jmp loc_10FD21
loc_10FE19:
jmp short $+2
loc_10FE1B:
mov rax, [rbp+var_40]
add rax, 1
mov [rbp+var_40], rax
loc_10FE27:
cmp [rbp+var_5C], 0
jz short loc_10FE54
mov rax, [rbp+var_58]
cmp rax, [rbp+var_18]
jnb short loc_10FE52
mov eax, [rbp+var_34]
mov dl, al
mov rax, [rbp+var_10]
mov rcx, [rbp+var_58]
mov rsi, rcx
add rsi, 1
mov [rbp+var_58], rsi
mov [rax+rcx], dl
loc_10FE52:
jmp short $+2
loc_10FE54:
jmp short $+2
loc_10FE56:
cmp [rbp+var_34], 0
jnz loc_10FB5A
mov eax, [rbp+arg_0]
and eax, 80h
cmp eax, 0
jz short loc_10FE99
mov rax, [rbp+var_18]
cmp rax, [rbp+var_58]
jbe short loc_10FE99
mov rdi, [rbp+var_10]
add rdi, [rbp+var_58]
mov rdx, [rbp+var_18]
sub rdx, [rbp+var_58]
mov esi, 20h ; ' '
call _memset
mov rax, [rbp+var_18]
mov [rbp+var_58], rax
loc_10FE99:
mov rax, [rbp+var_58]
add rsp, 0A0h
pop rbp
retn
|
unsigned long long my_strnxfrm_czech(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
char *a5,
int a6,
int a7)
{
long long v8; // rcx
long long v9; // rcx
bool v11; // [rsp+7h] [rbp-99h]
char *v12; // [rsp+8h] [rbp-98h]
int k; // [rsp+14h] [rbp-8Ch]
char *v14; // [rsp+18h] [rbp-88h]
long long v15; // [rsp+20h] [rbp-80h]
int j; // [rsp+2Ch] [rbp-74h]
unsigned __int8 *i; // [rsp+30h] [rbp-70h]
char *v18; // [rsp+38h] [rbp-68h]
int v19; // [rsp+44h] [rbp-5Ch]
unsigned long long v20; // [rsp+48h] [rbp-58h]
int v21; // [rsp+54h] [rbp-4Ch]
char *v22; // [rsp+58h] [rbp-48h]
char *v23; // [rsp+60h] [rbp-40h]
int v24; // [rsp+6Ch] [rbp-34h]
v21 = 0;
v20 = 0LL;
v23 = a5;
v22 = a5;
if ( (a7 & 0xF) == 0 )
a7 |= 0xFu;
do
{
v19 = a7 & (1 << v21);
while ( 1 )
{
while ( 1 )
{
if ( v23 - a5 >= a6 )
{
v24 = 0;
if ( v21 != 3 )
{
if ( v21++ )
v12 = a5;
else
v12 = v22;
v23 = v12;
v24 = 1;
}
goto LABEL_40;
}
v8 = (unsigned __int8)*v23;
v24 = *((unsigned __int8 *)*(&CZ_SORT_TABLE + v21) + v8);
if ( *((_BYTE *)*(&CZ_SORT_TABLE + v21) + v8) )
break;
++v23;
}
if ( v24 != 2 )
break;
for ( i = (unsigned __int8 *)++v23; ; ++i )
{
v11 = 0;
if ( i - (unsigned __int8 *)a5 < a6 )
v11 = *((_BYTE *)*(&CZ_SORT_TABLE + v21) + *i) == 2;
if ( !v11 )
break;
}
if ( i - (unsigned __int8 *)a5 >= a6 )
v23 = (char *)i;
if ( v21 <= 2 && i - (unsigned __int8 *)a5 < a6 )
v23 = (char *)i;
if ( v23 - a5 < a6 )
{
if ( v21 <= 1 )
{
v18 = v23;
v21 = 1 - v21;
v23 = v22;
v22 = v18;
}
goto LABEL_40;
}
}
if ( v24 == 255 )
{
for ( j = 0; j < 80; ++j )
{
v15 = (long long)*(&doubles + 2 * j);
v14 = v23;
for ( k = 0; *(_BYTE *)(v15 + k) && v14 - a5 < a6 && *v14 == *(char *)(v15 + k); ++k )
++v14;
if ( !*(_BYTE *)(v15 + k) )
{
v24 = *((unsigned __int8 *)*(&doubles + 2 * j + 1) + v21);
v23 = v14 - 1;
break;
}
}
}
++v23;
LABEL_40:
if ( v19 && v20 < a3 )
{
v9 = v20++;
*(_BYTE *)(a2 + v9) = v24;
}
}
while ( v24 );
if ( (a7 & 0x80) != 0 && a3 > v20 )
{
memset(v20 + a2, 32LL, a3 - v20);
return a3;
}
return v20;
}
| |||
63,605
|
my_strnxfrm_czech
|
eloqsql/strings/ctype-czech.c
|
static size_t
my_strnxfrm_czech(CHARSET_INFO *cs __attribute__((unused)),
uchar *dest, size_t len,
uint nweights_arg __attribute__((unused)),
const uchar *src, size_t srclen, uint flags)
{
int value;
const uchar *p, * store;
int pass = 0;
size_t totlen = 0;
p = src; store = src;
if (!(flags & 0x0F)) /* All levels by default */
flags|= 0x0F;
do
{
int add= (1 << pass) & flags; /* If this level is needed */
NEXT_CMP_VALUE(src, p, store, pass, value, (int)srclen);
if (add)
ADD_TO_RESULT(dest, len, totlen, value);
}
while (value);
if ((flags & MY_STRXFRM_PAD_TO_MAXLEN) && len > totlen)
{
memset(dest + totlen, ' ', len - totlen);
totlen= len;
}
return totlen;
}
|
O3
|
c
|
my_strnxfrm_czech:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r15
movq %rdx, %rbx
movq %rsi, -0x48(%rbp)
movl 0x10(%rbp), %eax
movl %eax, %r11d
orl $0xf, %r11d
testb $0xf, %al
cmovnel %eax, %r11d
movslq %r9d, %rdx
movl $0x1, %eax
subq %r8, %rax
movq %rax, -0x50(%rbp)
xorl %ecx, %ecx
leaq 0x2ce1a8(%rip), %r13 # 0x37c310
movq %r8, %r14
xorl %r12d, %r12d
movq %rbx, -0x38(%rbp)
movl %r11d, -0x2c(%rbp)
movl $0x1, %esi
shll %cl, %esi
movq %r8, %rax
subq %r15, %rax
cmpq %rdx, %rax
jge 0xae207
movslq %ecx, %rax
movq %rax, -0x58(%rbp)
movq (%r13,%rax,8), %r9
movzbl (%r8), %eax
movzbl (%r9,%rax), %eax
testl %eax, %eax
je 0xae1d6
cmpl $0x2, %eax
jne 0xae23b
incq %r8
movq %r8, %rax
subq %r15, %rax
movq %r8, %r10
cmpq %rdx, %rax
jge 0xae1e4
movzbl (%r10), %edi
cmpb $0x2, (%r9,%rdi)
jne 0xae1e4
incq %r10
incq %rax
movq %r10, %rdi
cmpq %rdx, %rax
jl 0xae1bb
jmp 0xae1e7
incq %r8
movq %r8, %rax
subq %r15, %rax
movq %r8, %r10
jmp 0xae200
movq %r8, %rdi
cmpl $0x3, %ecx
cmovgeq %rdi, %r10
movq %r10, %rax
subq %r15, %rax
cmpq %rdx, %rax
jl 0xae2bc
movq %r10, %r8
cmpq %rdx, %rax
jl 0xae194
jmp 0xae20a
movq %r8, %r10
cmpl $0x3, %ecx
jne 0xae222
xorl %r9d, %r9d
movl $0x3, %ecx
movq %r14, %rax
movq %r10, %r8
jmp 0xae314
testl %ecx, %ecx
movq %r15, %r8
cmoveq %r14, %r8
incl %ecx
movl $0x1, %r9d
movq %r14, %rax
jmp 0xae314
cmpl $0xff, %eax
jne 0xae30a
movq %r12, -0x40(%rbp)
movq %r8, %r9
subq %r15, %r9
movq -0x50(%rbp), %rax
addq %r8, %rax
movq %rax, -0x60(%rbp)
xorl %ebx, %ebx
movq %rbx, %r11
shlq $0x4, %r11
leaq 0x2ce0c5(%rip), %rax # 0x37c330
movq (%r11,%rax), %r13
movb (%r13), %al
testb %al, %al
je 0xae2a8
cmpq %rdx, %r9
jge 0xae2a8
incq %r13
movq -0x60(%rbp), %r10
movq %r8, %r12
cmpb %al, (%r12)
jne 0xae2af
incq %r12
movb (%r13), %al
testb %al, %al
je 0xae2ab
incq %r13
leaq 0x1(%r10), %rdi
cmpq %rdx, %r10
movq %rdi, %r10
jl 0xae286
jmp 0xae2ab
movq %r8, %r12
testb %al, %al
je 0xae2dc
incq %rbx
cmpq $0x50, %rbx
jne 0xae25d
movb $-0x1, %al
jmp 0xae2f7
movl $0x2, %r9d
cmpl $0x1, %ecx
jg 0xae217
movl $0x1, %edi
subl %ecx, %edi
movq %r10, %rax
movl %edi, %ecx
movq %r14, %r8
jmp 0xae314
leaq 0x2ce04d(%rip), %rax # 0x37c330
addq %rax, %r11
movq 0x8(%r11), %rax
movq -0x58(%rbp), %rdi
movb (%rax,%rdi), %al
decq %r12
movq %r12, %r8
movq -0x38(%rbp), %rbx
movl -0x2c(%rbp), %r11d
movq -0x40(%rbp), %r12
leaq 0x2ce006(%rip), %r13 # 0x37c310
movzbl %al, %r9d
incq %r8
movq %r14, %rax
testl %r11d, %esi
setne %r10b
cmpq %rbx, %r12
setb %dil
andb %r10b, %dil
cmpb $0x1, %dil
jne 0xae336
movq -0x48(%rbp), %rsi
movb %r9b, (%rsi,%r12)
incq %r12
movq %rax, %r14
testl %r9d, %r9d
jne 0xae176
testb %r11b, %r11b
sets %al
movq %rbx, %rdx
subq %r12, %rdx
seta %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xae36b
movq -0x48(%rbp), %rdi
addq %r12, %rdi
movl $0x20, %esi
callq 0x292a0
jmp 0xae36e
movq %r12, %rbx
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_strnxfrm_czech:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r15, r8
mov rbx, rdx
mov [rbp+var_48], rsi
mov eax, [rbp+arg_0]
mov r11d, eax
or r11d, 0Fh
test al, 0Fh
cmovnz r11d, eax
movsxd rdx, r9d
mov eax, 1
sub rax, r8
mov [rbp+var_50], rax
xor ecx, ecx
lea r13, CZ_SORT_TABLE
mov r14, r8
xor r12d, r12d
mov [rbp+var_38], rbx
mov [rbp+var_2C], r11d
loc_AE176:
mov esi, 1
shl esi, cl
mov rax, r8
sub rax, r15
cmp rax, rdx
jge short loc_AE207
movsxd rax, ecx
mov [rbp+var_58], rax
mov r9, [r13+rax*8+0]
loc_AE194:
movzx eax, byte ptr [r8]
movzx eax, byte ptr [r9+rax]
test eax, eax
jz short loc_AE1D6
cmp eax, 2
jnz loc_AE23B
inc r8
mov rax, r8
sub rax, r15
mov r10, r8
cmp rax, rdx
jge short loc_AE1E4
loc_AE1BB:
movzx edi, byte ptr [r10]
cmp byte ptr [r9+rdi], 2
jnz short loc_AE1E4
inc r10
inc rax
mov rdi, r10
cmp rax, rdx
jl short loc_AE1BB
jmp short loc_AE1E7
loc_AE1D6:
inc r8
mov rax, r8
sub rax, r15
mov r10, r8
jmp short loc_AE200
loc_AE1E4:
mov rdi, r8
loc_AE1E7:
cmp ecx, 3
cmovge r10, rdi
mov rax, r10
sub rax, r15
cmp rax, rdx
jl loc_AE2BC
mov r8, r10
loc_AE200:
cmp rax, rdx
jl short loc_AE194
jmp short loc_AE20A
loc_AE207:
mov r10, r8
loc_AE20A:
cmp ecx, 3
jnz short loc_AE222
xor r9d, r9d
mov ecx, 3
loc_AE217:
mov rax, r14
mov r8, r10
jmp loc_AE314
loc_AE222:
test ecx, ecx
mov r8, r15
cmovz r8, r14
inc ecx
mov r9d, 1
mov rax, r14
jmp loc_AE314
loc_AE23B:
cmp eax, 0FFh
jnz loc_AE30A
mov [rbp+var_40], r12
mov r9, r8
sub r9, r15
mov rax, [rbp+var_50]
add rax, r8
mov [rbp+var_60], rax
xor ebx, ebx
loc_AE25D:
mov r11, rbx
shl r11, 4
lea rax, doubles
mov r13, [r11+rax]
mov al, [r13+0]
test al, al
jz short loc_AE2A8
cmp r9, rdx
jge short loc_AE2A8
inc r13
mov r10, [rbp+var_60]
mov r12, r8
loc_AE286:
cmp [r12], al
jnz short loc_AE2AF
inc r12
mov al, [r13+0]
test al, al
jz short loc_AE2AB
inc r13
lea rdi, [r10+1]
cmp r10, rdx
mov r10, rdi
jl short loc_AE286
jmp short loc_AE2AB
loc_AE2A8:
mov r12, r8
loc_AE2AB:
test al, al
jz short loc_AE2DC
loc_AE2AF:
inc rbx
cmp rbx, 50h ; 'P'
jnz short loc_AE25D
mov al, 0FFh
jmp short loc_AE2F7
loc_AE2BC:
mov r9d, 2
cmp ecx, 1
jg loc_AE217
mov edi, 1
sub edi, ecx
mov rax, r10
mov ecx, edi
mov r8, r14
jmp short loc_AE314
loc_AE2DC:
lea rax, doubles
add r11, rax
mov rax, [r11+8]
mov rdi, [rbp+var_58]
mov al, [rax+rdi]
dec r12
mov r8, r12
loc_AE2F7:
mov rbx, [rbp+var_38]
mov r11d, [rbp+var_2C]
mov r12, [rbp+var_40]
lea r13, CZ_SORT_TABLE
loc_AE30A:
movzx r9d, al
inc r8
mov rax, r14
loc_AE314:
test esi, r11d
setnz r10b
cmp r12, rbx
setb dil
and dil, r10b
cmp dil, 1
jnz short loc_AE336
mov rsi, [rbp+var_48]
mov [rsi+r12], r9b
inc r12
loc_AE336:
mov r14, rax
test r9d, r9d
jnz loc_AE176
test r11b, r11b
sets al
mov rdx, rbx
sub rdx, r12
setnbe cl
and cl, al
cmp cl, 1
jnz short loc_AE36B
mov rdi, [rbp+var_48]
add rdi, r12
mov esi, 20h ; ' '
call _memset
jmp short loc_AE36E
loc_AE36B:
mov rbx, r12
loc_AE36E:
mov rax, rbx
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
unsigned long long my_strnxfrm_czech(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
unsigned __int8 *a5,
int a6,
int a7)
{
unsigned __int8 *v7; // r15
int v9; // r11d
long long v10; // rdx
int v11; // ecx
unsigned __int8 *v12; // r14
unsigned long long v13; // r12
int v14; // esi
long long v15; // r9
int v16; // eax
unsigned __int8 *v17; // r8
long long v18; // rax
unsigned __int8 *v19; // r10
unsigned __int8 *v20; // rdi
unsigned __int8 *v21; // rax
int v22; // r9d
unsigned __int8 *v23; // rax
long long v24; // rbx
char *v25; // r13
char v26; // al
char *v27; // r13
unsigned __int8 *v28; // r10
_BYTE *v29; // r12
long long v32; // [rsp+10h] [rbp-50h]
unsigned long long v34; // [rsp+20h] [rbp-40h]
unsigned long long v35; // [rsp+28h] [rbp-38h]
int v36; // [rsp+34h] [rbp-2Ch]
v7 = a5;
v9 = a7 | 0xF;
if ( (a7 & 0xF) != 0 )
v9 = a7;
v10 = a6;
v32 = 1LL - (_QWORD)a5;
v11 = 0;
v12 = a5;
v13 = 0LL;
v35 = a3;
v36 = v9;
do
{
v14 = 1 << v11;
if ( a5 - v7 >= v10 )
{
v19 = a5;
LABEL_21:
if ( v11 != 3 )
{
a5 = v7;
if ( !v11 )
a5 = v12;
++v11;
v22 = 1;
v23 = v12;
goto LABEL_45;
}
v22 = 0;
v11 = 3;
LABEL_23:
v23 = v12;
a5 = v19;
goto LABEL_45;
}
v15 = (long long)*(&CZ_SORT_TABLE + v11);
while ( 1 )
{
v16 = *(unsigned __int8 *)(v15 + *a5);
if ( !*(_BYTE *)(v15 + *a5) )
{
v21 = (unsigned __int8 *)(++a5 - v7);
v19 = a5;
goto LABEL_18;
}
if ( v16 != 2 )
break;
v17 = a5 + 1;
v18 = v17 - v7;
v19 = v17;
if ( v17 - v7 < v10 )
{
while ( *(_BYTE *)(v15 + *v19) == 2 )
{
++v19;
++v18;
v20 = v19;
if ( v18 >= v10 )
goto LABEL_14;
}
}
v20 = v17;
LABEL_14:
if ( v11 >= 3 )
v19 = v20;
v21 = (unsigned __int8 *)(v19 - v7);
if ( v19 - v7 < v10 )
{
v22 = 2;
if ( v11 <= 1 )
{
v23 = v19;
v11 = 1 - v11;
a5 = v12;
goto LABEL_45;
}
goto LABEL_23;
}
a5 = v19;
LABEL_18:
if ( (long long)v21 >= v10 )
goto LABEL_21;
}
if ( v16 != 255 )
goto LABEL_44;
v34 = v13;
v24 = 0LL;
while ( 2 )
{
v25 = (char *)*(&doubles + 2 * v24);
v26 = *v25;
if ( *v25 && a5 - v7 < v10 )
{
v27 = v25 + 1;
v28 = &a5[v32];
v29 = a5;
while ( *v29 == v26 )
{
++v29;
v26 = *v27;
if ( *v27 )
{
++v27;
if ( (long long)v28++ < v10 )
continue;
}
goto LABEL_37;
}
goto LABEL_38;
}
v29 = a5;
LABEL_37:
if ( v26 )
{
LABEL_38:
if ( ++v24 == 80 )
{
LOBYTE(v16) = -1;
goto LABEL_43;
}
continue;
}
break;
}
LOBYTE(v16) = *((_BYTE *)*(&doubles + 2 * v24 + 1) + v11);
a5 = v29 - 1;
LABEL_43:
a3 = v35;
v9 = v36;
v13 = v34;
LABEL_44:
v22 = (unsigned __int8)v16;
++a5;
v23 = v12;
LABEL_45:
if ( (v9 & v14) != 0 && v13 < a3 )
*(_BYTE *)(a2 + v13++) = v22;
v12 = v23;
}
while ( v22 );
if ( (v9 & 0x80u) == 0 || a3 <= v13 )
return v13;
memset(v13 + a2, 32LL, a3 - v13);
return a3;
}
|
my_strnxfrm_czech:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R15,R8
MOV RBX,RDX
MOV qword ptr [RBP + -0x48],RSI
MOV EAX,dword ptr [RBP + 0x10]
MOV R11D,EAX
OR R11D,0xf
TEST AL,0xf
CMOVNZ R11D,EAX
MOVSXD RDX,R9D
MOV EAX,0x1
SUB RAX,R8
MOV qword ptr [RBP + -0x50],RAX
XOR ECX,ECX
LEA R13,[0x47c310]
MOV R14,R8
XOR R12D,R12D
MOV qword ptr [RBP + -0x38],RBX
MOV dword ptr [RBP + -0x2c],R11D
LAB_001ae176:
MOV ESI,0x1
SHL ESI,CL
MOV RAX,R8
SUB RAX,R15
CMP RAX,RDX
JGE 0x001ae207
MOVSXD RAX,ECX
MOV qword ptr [RBP + -0x58],RAX
MOV R9,qword ptr [R13 + RAX*0x8]
LAB_001ae194:
MOVZX EAX,byte ptr [R8]
MOVZX EAX,byte ptr [R9 + RAX*0x1]
TEST EAX,EAX
JZ 0x001ae1d6
CMP EAX,0x2
JNZ 0x001ae23b
INC R8
MOV RAX,R8
SUB RAX,R15
MOV R10,R8
CMP RAX,RDX
JGE 0x001ae1e4
LAB_001ae1bb:
MOVZX EDI,byte ptr [R10]
CMP byte ptr [R9 + RDI*0x1],0x2
JNZ 0x001ae1e4
INC R10
INC RAX
MOV RDI,R10
CMP RAX,RDX
JL 0x001ae1bb
JMP 0x001ae1e7
LAB_001ae1d6:
INC R8
MOV RAX,R8
SUB RAX,R15
MOV R10,R8
JMP 0x001ae200
LAB_001ae1e4:
MOV RDI,R8
LAB_001ae1e7:
CMP ECX,0x3
CMOVGE R10,RDI
MOV RAX,R10
SUB RAX,R15
CMP RAX,RDX
JL 0x001ae2bc
MOV R8,R10
LAB_001ae200:
CMP RAX,RDX
JL 0x001ae194
JMP 0x001ae20a
LAB_001ae207:
MOV R10,R8
LAB_001ae20a:
CMP ECX,0x3
JNZ 0x001ae222
XOR R9D,R9D
MOV ECX,0x3
LAB_001ae217:
MOV RAX,R14
MOV R8,R10
JMP 0x001ae314
LAB_001ae222:
TEST ECX,ECX
MOV R8,R15
CMOVZ R8,R14
INC ECX
MOV R9D,0x1
MOV RAX,R14
JMP 0x001ae314
LAB_001ae23b:
CMP EAX,0xff
JNZ 0x001ae30a
MOV qword ptr [RBP + -0x40],R12
MOV R9,R8
SUB R9,R15
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,R8
MOV qword ptr [RBP + -0x60],RAX
XOR EBX,EBX
LAB_001ae25d:
MOV R11,RBX
SHL R11,0x4
LEA RAX,[0x47c330]
MOV R13,qword ptr [R11 + RAX*0x1]
MOV AL,byte ptr [R13]
TEST AL,AL
JZ 0x001ae2a8
CMP R9,RDX
JGE 0x001ae2a8
INC R13
MOV R10,qword ptr [RBP + -0x60]
MOV R12,R8
LAB_001ae286:
CMP byte ptr [R12],AL
JNZ 0x001ae2af
INC R12
MOV AL,byte ptr [R13]
TEST AL,AL
JZ 0x001ae2ab
INC R13
LEA RDI,[R10 + 0x1]
CMP R10,RDX
MOV R10,RDI
JL 0x001ae286
JMP 0x001ae2ab
LAB_001ae2a8:
MOV R12,R8
LAB_001ae2ab:
TEST AL,AL
JZ 0x001ae2dc
LAB_001ae2af:
INC RBX
CMP RBX,0x50
JNZ 0x001ae25d
MOV AL,0xff
JMP 0x001ae2f7
LAB_001ae2bc:
MOV R9D,0x2
CMP ECX,0x1
JG 0x001ae217
MOV EDI,0x1
SUB EDI,ECX
MOV RAX,R10
MOV ECX,EDI
MOV R8,R14
JMP 0x001ae314
LAB_001ae2dc:
LEA RAX,[0x47c330]
ADD R11,RAX
MOV RAX,qword ptr [R11 + 0x8]
MOV RDI,qword ptr [RBP + -0x58]
MOV AL,byte ptr [RAX + RDI*0x1]
DEC R12
MOV R8,R12
LAB_001ae2f7:
MOV RBX,qword ptr [RBP + -0x38]
MOV R11D,dword ptr [RBP + -0x2c]
MOV R12,qword ptr [RBP + -0x40]
LEA R13,[0x47c310]
LAB_001ae30a:
MOVZX R9D,AL
INC R8
MOV RAX,R14
LAB_001ae314:
TEST ESI,R11D
SETNZ R10B
CMP R12,RBX
SETC DIL
AND DIL,R10B
CMP DIL,0x1
JNZ 0x001ae336
MOV RSI,qword ptr [RBP + -0x48]
MOV byte ptr [RSI + R12*0x1],R9B
INC R12
LAB_001ae336:
MOV R14,RAX
TEST R9D,R9D
JNZ 0x001ae176
TEST R11B,R11B
SETS AL
MOV RDX,RBX
SUB RDX,R12
SETA CL
AND CL,AL
CMP CL,0x1
JNZ 0x001ae36b
MOV RDI,qword ptr [RBP + -0x48]
ADD RDI,R12
MOV ESI,0x20
CALL 0x001292a0
JMP 0x001ae36e
LAB_001ae36b:
MOV RBX,R12
LAB_001ae36e:
MOV RAX,RBX
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong my_strnxfrm_czech(int8 param_1,long param_2,ulong param_3,int8 param_4,
byte *param_5,int param_6,uint param_7)
{
uint uVar1;
byte *pbVar2;
byte *pbVar3;
byte bVar4;
char cVar5;
long lVar6;
byte *pbVar7;
byte bVar8;
int iVar9;
long lVar10;
byte *pbVar11;
byte *pbVar12;
byte *pbVar13;
ulong uVar14;
byte *pbVar15;
uVar1 = param_7 | 0xf;
if ((param_7 & 0xf) != 0) {
uVar1 = param_7;
}
lVar10 = (long)param_6;
iVar9 = 0;
uVar14 = 0;
pbVar13 = param_5;
pbVar15 = param_5;
LAB_001ae176:
bVar8 = (byte)iVar9;
pbVar7 = pbVar15;
if ((long)pbVar13 - (long)param_5 < lVar10) {
do {
cVar5 = (&CZ_SORT_TABLE)[iVar9][*pbVar13];
if (cVar5 == '\0') {
pbVar13 = pbVar13 + 1;
lVar6 = (long)pbVar13 - (long)param_5;
}
else {
if (cVar5 != '\x02') {
if (cVar5 != -1) goto LAB_001ae30a;
lVar6 = 0;
goto LAB_001ae25d;
}
pbVar12 = pbVar13 + 1;
lVar6 = (long)pbVar12 - (long)param_5;
pbVar13 = pbVar12;
while ((pbVar11 = pbVar13, lVar6 < lVar10 &&
(pbVar11 = pbVar12, (&CZ_SORT_TABLE)[iVar9][*pbVar13] == '\x02'))) {
pbVar13 = pbVar13 + 1;
lVar6 = lVar6 + 1;
}
if (2 < iVar9) {
pbVar13 = pbVar11;
}
lVar6 = (long)pbVar13 - (long)param_5;
if (lVar6 < lVar10) {
cVar5 = '\x02';
if (iVar9 < 2) {
iVar9 = 1 - iVar9;
pbVar7 = pbVar13;
pbVar13 = pbVar15;
}
goto LAB_001ae314;
}
}
} while (lVar6 < lVar10);
}
if (iVar9 == 3) {
cVar5 = '\0';
iVar9 = 3;
}
else {
pbVar13 = param_5;
if (iVar9 == 0) {
pbVar13 = pbVar15;
}
iVar9 = iVar9 + 1;
cVar5 = '\x01';
}
goto LAB_001ae314;
LAB_001ae25d:
do {
pbVar15 = (&doubles)[lVar6 * 2];
bVar4 = *pbVar15;
pbVar12 = pbVar13;
pbVar3 = pbVar13 + (1 - (long)param_5);
pbVar11 = pbVar13 + -(long)param_5;
if (bVar4 != 0) {
while (pbVar2 = pbVar3, (long)pbVar11 < lVar10) {
pbVar15 = pbVar15 + 1;
if (*pbVar12 != bVar4) goto LAB_001ae2af;
pbVar12 = pbVar12 + 1;
bVar4 = *pbVar15;
if (bVar4 == 0) break;
pbVar3 = pbVar2 + 1;
pbVar11 = pbVar2;
}
}
if (bVar4 == 0) {
cVar5 = (&PTR_DAT_0047c338)[lVar6 * 2][iVar9];
pbVar13 = pbVar12 + -1;
goto LAB_001ae30a;
}
LAB_001ae2af:
lVar6 = lVar6 + 1;
} while (lVar6 != 0x50);
cVar5 = -1;
LAB_001ae30a:
pbVar13 = pbVar13 + 1;
LAB_001ae314:
if (uVar14 < param_3 && (1 << (bVar8 & 0x1f) & uVar1) != 0) {
*(char *)(param_2 + uVar14) = cVar5;
uVar14 = uVar14 + 1;
}
pbVar15 = pbVar7;
if (cVar5 == '\0') {
if ((uVar14 <= param_3 && param_3 - uVar14 != 0) && (char)uVar1 < '\0') {
memset((void *)(param_2 + uVar14),0x20,param_3 - uVar14);
uVar14 = param_3;
}
return uVar14;
}
goto LAB_001ae176;
}
|
|
63,606
|
mi_copy_status
|
eloqsql/storage/myisam/mi_locking.c
|
void mi_copy_status(void* to,void *from)
{
MI_INFO *info= (MI_INFO*) to;
DBUG_ENTER("mi_copy_status");
info->state= &((MI_INFO*) from)->save_state;
DBUG_PRINT("info",("key_file: %ld data_file: %ld",
(long) info->state->key_file_length,
(long) info->state->data_file_length));
DBUG_VOID_RETURN;
}
|
O0
|
c
|
mi_copy_status:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
addq $0x10, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xb09d6
jmp 0xb09d8
jmp 0xb09da
popq %rbp
retq
nopl (%rax)
|
mi_copy_status:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
mov rcx, [rbp+var_10]
add rcx, 10h
mov rax, [rbp+var_18]
mov [rax+8], rcx
jmp short $+2
loc_B09D6:
jmp short $+2
loc_B09D8:
jmp short $+2
loc_B09DA:
pop rbp
retn
|
long long mi_copy_status(long long a1, long long a2)
{
long long result; // rax
result = a1;
*(_QWORD *)(a1 + 8) = a2 + 16;
return result;
}
|
mi_copy_status:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
MOV RCX,qword ptr [RBP + -0x10]
ADD RCX,0x10
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x001b09d6
LAB_001b09d6:
JMP 0x001b09d8
LAB_001b09d8:
JMP 0x001b09da
LAB_001b09da:
POP RBP
RET
|
void mi_copy_status(long param_1,long param_2)
{
*(long *)(param_1 + 8) = param_2 + 0x10;
return;
}
|
|
63,607
|
JS_GetGlobalVarRef
|
bluesky950520[P]quickjs/quickjs.c
|
static int JS_GetGlobalVarRef(JSContext *ctx, JSAtom prop, JSValue *sp)
{
JSObject *p;
JSShapeProperty *prs;
JSProperty *pr;
/* no exotic behavior is possible in global_var_obj */
p = JS_VALUE_GET_OBJ(ctx->global_var_obj);
prs = find_own_property(&pr, p, prop);
if (prs) {
/* XXX: should handle JS_PROP_AUTOINIT properties? */
/* XXX: conformance: do these tests in
OP_put_var_ref/OP_get_var_ref ? */
if (unlikely(JS_IsUninitialized(pr->u.value))) {
JS_ThrowReferenceErrorUninitialized(ctx, prs->atom);
return -1;
}
if (unlikely(!(prs->flags & JS_PROP_WRITABLE))) {
return JS_ThrowTypeErrorReadOnly(ctx, JS_PROP_THROW, prop);
}
sp[0] = js_dup(ctx->global_var_obj);
} else {
int ret;
ret = JS_HasProperty(ctx, ctx->global_obj, prop);
if (ret < 0)
return -1;
if (ret) {
sp[0] = js_dup(ctx->global_obj);
} else {
sp[0] = JS_UNDEFINED;
}
}
sp[1] = JS_AtomToValue(ctx, prop);
return 0;
}
|
O0
|
c
|
JS_GetGlobalVarRef:
subq $0xe8, %rsp
movq %rdi, 0x98(%rsp)
movl %esi, 0x94(%rsp)
movq %rdx, 0x88(%rsp)
movq 0x98(%rsp), %rax
movq 0x1b0(%rax), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rcx
movl 0x94(%rsp), %eax
leaq 0x70(%rsp), %rdx
movq %rdx, 0xd8(%rsp)
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
movq 0xd0(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0xc0(%rsp)
movl 0xcc(%rsp), %eax
movq 0xc0(%rsp), %rcx
movl 0x20(%rcx), %ecx
andq %rcx, %rax
movq %rax, 0xa8(%rsp)
movq 0xc0(%rsp), %rdi
callq 0x63ba0
xorl %ecx, %ecx
subq 0xa8(%rsp), %rcx
subq $0x1, %rcx
movl (%rax,%rcx,4), %eax
movq %rax, 0xa8(%rsp)
movq 0xc0(%rsp), %rdi
callq 0x32570
movq %rax, 0xb0(%rsp)
cmpq $0x0, 0xa8(%rsp)
je 0x6d873
movq 0xb0(%rsp), %rax
movq 0xa8(%rsp), %rcx
subq $0x1, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0xb8(%rsp)
movq 0xb8(%rsp), %rax
movl 0x4(%rax), %eax
cmpl 0xcc(%rsp), %eax
sete %al
testb $0x1, %al
jne 0x6d819
jmp 0x6d855
movq 0xd0(%rsp), %rax
movq 0x20(%rax), %rcx
movq 0xa8(%rsp), %rax
subq $0x1, %rax
shlq $0x4, %rax
addq %rax, %rcx
movq 0xd8(%rsp), %rax
movq %rcx, (%rax)
movq 0xb8(%rsp), %rax
movq %rax, 0xe0(%rsp)
jmp 0x6d88e
movq 0xb8(%rsp), %rax
movl (%rax), %eax
andl $0x3ffffff, %eax # imm = 0x3FFFFFF
movl %eax, %eax
movq %rax, 0xa8(%rsp)
jmp 0x6d7cc
movq 0xd8(%rsp), %rax
movq $0x0, (%rax)
movq $0x0, 0xe0(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x78(%rsp)
cmpq $0x0, 0x78(%rsp)
je 0x6d999
movq 0x70(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x332f0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x6d8fe
movq 0x98(%rsp), %rdi
movq 0x78(%rsp), %rax
movl 0x4(%rax), %esi
callq 0x667c0
movq %rax, 0x60(%rsp)
movq %rdx, 0x68(%rsp)
movl $0xffffffff, 0xa4(%rsp) # imm = 0xFFFFFFFF
jmp 0x6daac
movq 0x78(%rsp), %rax
movl (%rax), %eax
shrl $0x1a, %eax
andl $0x2, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x6d949
movq 0x98(%rsp), %rdi
movl 0x94(%rsp), %edx
movl $0x4000, %esi # imm = 0x4000
callq 0x672c0
movl %eax, 0xa4(%rsp)
jmp 0x6daac
movq 0x88(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x98(%rsp), %rax
movq 0x1b0(%rax), %rdi
movq 0x1b8(%rax), %rsi
callq 0x279c0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x50(%rsp), %rcx
movq %rcx, (%rax)
movq 0x58(%rsp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x6da5e
movq 0x98(%rsp), %rdi
movq 0x98(%rsp), %rax
movl 0x94(%rsp), %ecx
movq 0x1a0(%rax), %rsi
movq 0x1a8(%rax), %rdx
callq 0x371c0
movl %eax, 0x4c(%rsp)
cmpl $0x0, 0x4c(%rsp)
jge 0x6d9de
movl $0xffffffff, 0xa4(%rsp) # imm = 0xFFFFFFFF
jmp 0x6daac
cmpl $0x0, 0x4c(%rsp)
je 0x6da32
movq 0x88(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x98(%rsp), %rax
movq 0x1a0(%rax), %rdi
movq 0x1a8(%rax), %rsi
callq 0x279c0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x38(%rsp), %rcx
movq %rcx, (%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x6da5c
movq 0x88(%rsp), %rax
movl $0x0, 0x28(%rsp)
movq $0x3, 0x30(%rsp)
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x6da5e
movq 0x88(%rsp), %rax
movq %rax, (%rsp)
movq 0x98(%rsp), %rdi
movl 0x94(%rsp), %esi
callq 0x2f120
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x18(%rax)
movl $0x0, 0xa4(%rsp)
movl 0xa4(%rsp), %eax
addq $0xe8, %rsp
retq
nopl (%rax,%rax)
|
JS_GetGlobalVarRef:
sub rsp, 0E8h
mov [rsp+0E8h+var_50], rdi
mov [rsp+0E8h+var_54], esi
mov [rsp+0E8h+var_60], rdx
mov rax, [rsp+0E8h+var_50]
mov rax, [rax+1B0h]
mov [rsp+0E8h+var_68], rax
mov rcx, [rsp+0E8h+var_68]
mov eax, [rsp+0E8h+var_54]
lea rdx, [rsp+0E8h+var_78]
mov [rsp+0E8h+var_10], rdx
mov [rsp+0E8h+var_18], rcx
mov [rsp+0E8h+var_1C], eax
mov rax, [rsp+0E8h+var_18]
mov rax, [rax+18h]
mov [rsp+0E8h+var_28], rax
mov eax, [rsp+0E8h+var_1C]
mov rcx, [rsp+0E8h+var_28]
mov ecx, [rcx+20h]
and rax, rcx
mov [rsp+0E8h+var_40], rax
mov rdi, [rsp+0E8h+var_28]
call prop_hash_end
xor ecx, ecx
sub rcx, [rsp+0E8h+var_40]
sub rcx, 1
mov eax, [rax+rcx*4]
mov [rsp+0E8h+var_40], rax
mov rdi, [rsp+0E8h+var_28]
call get_shape_prop
mov [rsp+0E8h+var_38], rax
loc_6D7CC:
cmp [rsp+0E8h+var_40], 0
jz loc_6D873
mov rax, [rsp+0E8h+var_38]
mov rcx, [rsp+0E8h+var_40]
sub rcx, 1
shl rcx, 3
add rax, rcx
mov [rsp+0E8h+var_30], rax
mov rax, [rsp+0E8h+var_30]
mov eax, [rax+4]
cmp eax, [rsp+0E8h+var_1C]
setz al
test al, 1
jnz short loc_6D819
jmp short loc_6D855
loc_6D819:
mov rax, [rsp+0E8h+var_18]
mov rcx, [rax+20h]
mov rax, [rsp+0E8h+var_40]
sub rax, 1
shl rax, 4
add rcx, rax
mov rax, [rsp+0E8h+var_10]
mov [rax], rcx
mov rax, [rsp+0E8h+var_30]
mov [rsp+0E8h+var_8], rax
jmp short loc_6D88E
loc_6D855:
mov rax, [rsp+0E8h+var_30]
mov eax, [rax]
and eax, 3FFFFFFh
mov eax, eax
mov [rsp+0E8h+var_40], rax
jmp loc_6D7CC
loc_6D873:
mov rax, [rsp+0E8h+var_10]
mov qword ptr [rax], 0
mov [rsp+0E8h+var_8], 0
loc_6D88E:
mov rax, [rsp+0E8h+var_8]
mov [rsp+0E8h+var_70], rax
cmp [rsp+0E8h+var_70], 0
jz loc_6D999
mov rax, [rsp+0E8h+var_78]
mov rdi, [rax]
mov rsi, [rax+8]
call JS_IsUninitialized
cmp eax, 0
setnz al
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_6D8FE
mov rdi, [rsp+0E8h+var_50]
mov rax, [rsp+0E8h+var_70]
mov esi, [rax+4]
call JS_ThrowReferenceErrorUninitialized
mov [rsp+0E8h+var_88], rax
mov [rsp+0E8h+var_80], rdx
mov [rsp+0E8h+var_44], 0FFFFFFFFh
jmp loc_6DAAC
loc_6D8FE:
mov rax, [rsp+0E8h+var_70]
mov eax, [rax]
shr eax, 1Ah
and eax, 2
cmp eax, 0
setnz al
xor al, 0FFh
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_6D949
mov rdi, [rsp+0E8h+var_50]
mov edx, [rsp+0E8h+var_54]
mov esi, 4000h
call JS_ThrowTypeErrorReadOnly
mov [rsp+0E8h+var_44], eax
jmp loc_6DAAC
loc_6D949:
mov rax, [rsp+0E8h+var_60]
mov [rsp+0E8h+var_D8], rax
mov rax, [rsp+0E8h+var_50]
mov rdi, [rax+1B0h]
mov rsi, [rax+1B8h]
call js_dup
mov rcx, rax
mov rax, [rsp+0E8h+var_D8]
mov [rsp+0E8h+var_98], rcx
mov [rsp+0E8h+var_90], rdx
mov rcx, [rsp+0E8h+var_98]
mov [rax], rcx
mov rcx, [rsp+0E8h+var_90]
mov [rax+8], rcx
jmp loc_6DA5E
loc_6D999:
mov rdi, [rsp+0E8h+var_50]
mov rax, [rsp+0E8h+var_50]
mov ecx, [rsp+0E8h+var_54]
mov rsi, [rax+1A0h]
mov rdx, [rax+1A8h]
call JS_HasProperty
mov [rsp+0E8h+var_9C], eax
cmp [rsp+0E8h+var_9C], 0
jge short loc_6D9DE
mov [rsp+0E8h+var_44], 0FFFFFFFFh
jmp loc_6DAAC
loc_6D9DE:
cmp [rsp+0E8h+var_9C], 0
jz short loc_6DA32
mov rax, [rsp+0E8h+var_60]
mov [rsp+0E8h+var_E0], rax
mov rax, [rsp+0E8h+var_50]
mov rdi, [rax+1A0h]
mov rsi, [rax+1A8h]
call js_dup
mov rcx, rax
mov rax, [rsp+0E8h+var_E0]
mov [rsp+0E8h+var_B0], rcx
mov [rsp+0E8h+var_A8], rdx
mov rcx, [rsp+0E8h+var_B0]
mov [rax], rcx
mov rcx, [rsp+0E8h+var_A8]
mov [rax+8], rcx
jmp short loc_6DA5C
loc_6DA32:
mov rax, [rsp+0E8h+var_60]
mov dword ptr [rsp+0E8h+var_C0], 0
mov [rsp+0E8h+var_B8], 3
mov rcx, [rsp+0E8h+var_C0]
mov [rax], rcx
mov rcx, [rsp+0E8h+var_B8]
mov [rax+8], rcx
loc_6DA5C:
jmp short $+2
loc_6DA5E:
mov rax, [rsp+0E8h+var_60]
mov [rsp+0E8h+var_E8], rax
mov rdi, [rsp+0E8h+var_50]
mov esi, [rsp+0E8h+var_54]
call JS_AtomToValue
mov rcx, rax
mov rax, [rsp+0E8h+var_E8]
mov [rsp+0E8h+var_D0], rcx
mov [rsp+0E8h+var_C8], rdx
mov rcx, [rsp+0E8h+var_D0]
mov [rax+10h], rcx
mov rcx, [rsp+0E8h+var_C8]
mov [rax+18h], rcx
mov [rsp+0E8h+var_44], 0
loc_6DAAC:
mov eax, [rsp+0E8h+var_44]
add rsp, 0E8h
retn
|
long long JS_GetGlobalVarRef(
long long a1,
unsigned int a2,
_QWORD *a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
long long v11; // rax
long long v12; // rdx
long long v13; // rcx
long long v14; // r8
long long v15; // r9
__m128 v16; // xmm4
__m128 v17; // xmm5
long long v18; // rdx
long long v19; // rdx
_QWORD *v20; // rax
long long v21; // rdx
_QWORD *v23; // [rsp+0h] [rbp-E8h]
_QWORD *v24; // [rsp+8h] [rbp-E0h]
_QWORD *v25; // [rsp+10h] [rbp-D8h]
long long v26; // [rsp+28h] [rbp-C0h]
int HasProperty; // [rsp+4Ch] [rbp-9Ch]
long long *v28; // [rsp+70h] [rbp-78h] BYREF
_DWORD *v29; // [rsp+78h] [rbp-70h]
long long v30; // [rsp+80h] [rbp-68h]
_QWORD *v31; // [rsp+88h] [rbp-60h]
unsigned int v32; // [rsp+94h] [rbp-54h]
long long v33; // [rsp+98h] [rbp-50h]
long long v35; // [rsp+A8h] [rbp-40h]
long long shape_prop; // [rsp+B0h] [rbp-38h]
_DWORD *v37; // [rsp+B8h] [rbp-30h]
long long v38; // [rsp+C0h] [rbp-28h]
unsigned int v39; // [rsp+CCh] [rbp-1Ch]
long long v40; // [rsp+D0h] [rbp-18h]
long long **v41; // [rsp+D8h] [rbp-10h]
_DWORD *v42; // [rsp+E0h] [rbp-8h]
v33 = a1;
v32 = a2;
v31 = a3;
v30 = *(_QWORD *)(a1 + 432);
v41 = &v28;
v40 = v30;
v39 = a2;
v38 = *(_QWORD *)(v30 + 24);
v35 = *(_DWORD *)(v38 + 32) & a2;
v11 = prop_hash_end(v38);
v35 = *(unsigned int *)(v11 + 4 * (-v35 - 1));
shape_prop = get_shape_prop(v38);
while ( v35 )
{
v37 = (_DWORD *)(8 * (v35 - 1) + shape_prop);
if ( v37[1] == v39 )
{
*v41 = (long long *)(16 * (v35 - 1) + *(_QWORD *)(v40 + 32));
v42 = v37;
goto LABEL_7;
}
v35 = *v37 & 0x3FFFFFF;
}
*v41 = 0LL;
v42 = 0LL;
LABEL_7:
v29 = v42;
if ( !v42 )
{
HasProperty = JS_HasProperty(v33, *(_QWORD *)(v33 + 416), *(_QWORD *)(v33 + 424), v32);
if ( HasProperty < 0 )
return (unsigned int)-1;
if ( HasProperty )
{
v24 = v31;
*v24 = js_dup(*(_DWORD **)(v33 + 416), *(_QWORD *)(v33 + 424));
v24[1] = v19;
}
else
{
v20 = v31;
LODWORD(v26) = 0;
*v31 = v26;
v20[1] = 3LL;
}
goto LABEL_18;
}
if ( !JS_IsUninitialized(*v28, v28[1]) )
{
if ( ((*v29 >> 26) & 2) == 0 )
return (unsigned int)JS_ThrowTypeErrorReadOnly(
v33,
0x4000,
v32,
a4,
a5,
a6,
a7,
*(double *)v16.m128_u64,
*(double *)v17.m128_u64,
a10,
a11);
v25 = v31;
*v25 = js_dup(*(_DWORD **)(v33 + 432), *(_QWORD *)(v33 + 440));
v25[1] = v18;
LABEL_18:
v23 = v31;
v23[2] = JS_AtomToValue(v33, v32);
v23[3] = v21;
return 0;
}
JS_ThrowReferenceErrorUninitialized(v33, v29[1], a4, a5, a6, a7, v16, v17, a10, a11, v12, v13, v14, v15);
return (unsigned int)-1;
}
|
JS_GetGlobalVarRef:
SUB RSP,0xe8
MOV qword ptr [RSP + 0x98],RDI
MOV dword ptr [RSP + 0x94],ESI
MOV qword ptr [RSP + 0x88],RDX
MOV RAX,qword ptr [RSP + 0x98]
MOV RAX,qword ptr [RAX + 0x1b0]
MOV qword ptr [RSP + 0x80],RAX
MOV RCX,qword ptr [RSP + 0x80]
MOV EAX,dword ptr [RSP + 0x94]
LEA RDX,[RSP + 0x70]
MOV qword ptr [RSP + 0xd8],RDX
MOV qword ptr [RSP + 0xd0],RCX
MOV dword ptr [RSP + 0xcc],EAX
MOV RAX,qword ptr [RSP + 0xd0]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RSP + 0xc0],RAX
MOV EAX,dword ptr [RSP + 0xcc]
MOV RCX,qword ptr [RSP + 0xc0]
MOV ECX,dword ptr [RCX + 0x20]
AND RAX,RCX
MOV qword ptr [RSP + 0xa8],RAX
MOV RDI,qword ptr [RSP + 0xc0]
CALL 0x00163ba0
XOR ECX,ECX
SUB RCX,qword ptr [RSP + 0xa8]
SUB RCX,0x1
MOV EAX,dword ptr [RAX + RCX*0x4]
MOV qword ptr [RSP + 0xa8],RAX
MOV RDI,qword ptr [RSP + 0xc0]
CALL 0x00132570
MOV qword ptr [RSP + 0xb0],RAX
LAB_0016d7cc:
CMP qword ptr [RSP + 0xa8],0x0
JZ 0x0016d873
MOV RAX,qword ptr [RSP + 0xb0]
MOV RCX,qword ptr [RSP + 0xa8]
SUB RCX,0x1
SHL RCX,0x3
ADD RAX,RCX
MOV qword ptr [RSP + 0xb8],RAX
MOV RAX,qword ptr [RSP + 0xb8]
MOV EAX,dword ptr [RAX + 0x4]
CMP EAX,dword ptr [RSP + 0xcc]
SETZ AL
TEST AL,0x1
JNZ 0x0016d819
JMP 0x0016d855
LAB_0016d819:
MOV RAX,qword ptr [RSP + 0xd0]
MOV RCX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RSP + 0xa8]
SUB RAX,0x1
SHL RAX,0x4
ADD RCX,RAX
MOV RAX,qword ptr [RSP + 0xd8]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RSP + 0xb8]
MOV qword ptr [RSP + 0xe0],RAX
JMP 0x0016d88e
LAB_0016d855:
MOV RAX,qword ptr [RSP + 0xb8]
MOV EAX,dword ptr [RAX]
AND EAX,0x3ffffff
MOV EAX,EAX
MOV qword ptr [RSP + 0xa8],RAX
JMP 0x0016d7cc
LAB_0016d873:
MOV RAX,qword ptr [RSP + 0xd8]
MOV qword ptr [RAX],0x0
MOV qword ptr [RSP + 0xe0],0x0
LAB_0016d88e:
MOV RAX,qword ptr [RSP + 0xe0]
MOV qword ptr [RSP + 0x78],RAX
CMP qword ptr [RSP + 0x78],0x0
JZ 0x0016d999
MOV RAX,qword ptr [RSP + 0x70]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x8]
CALL 0x001332f0
CMP EAX,0x0
SETNZ AL
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0016d8fe
MOV RDI,qword ptr [RSP + 0x98]
MOV RAX,qword ptr [RSP + 0x78]
MOV ESI,dword ptr [RAX + 0x4]
CALL 0x001667c0
MOV qword ptr [RSP + 0x60],RAX
MOV qword ptr [RSP + 0x68],RDX
MOV dword ptr [RSP + 0xa4],0xffffffff
JMP 0x0016daac
LAB_0016d8fe:
MOV RAX,qword ptr [RSP + 0x78]
MOV EAX,dword ptr [RAX]
SHR EAX,0x1a
AND EAX,0x2
CMP EAX,0x0
SETNZ AL
XOR AL,0xff
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0016d949
MOV RDI,qword ptr [RSP + 0x98]
MOV EDX,dword ptr [RSP + 0x94]
MOV ESI,0x4000
CALL 0x001672c0
MOV dword ptr [RSP + 0xa4],EAX
JMP 0x0016daac
LAB_0016d949:
MOV RAX,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x98]
MOV RDI,qword ptr [RAX + 0x1b0]
MOV RSI,qword ptr [RAX + 0x1b8]
CALL 0x001279c0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x50],RCX
MOV qword ptr [RSP + 0x58],RDX
MOV RCX,qword ptr [RSP + 0x50]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x58]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x0016da5e
LAB_0016d999:
MOV RDI,qword ptr [RSP + 0x98]
MOV RAX,qword ptr [RSP + 0x98]
MOV ECX,dword ptr [RSP + 0x94]
MOV RSI,qword ptr [RAX + 0x1a0]
MOV RDX,qword ptr [RAX + 0x1a8]
CALL 0x001371c0
MOV dword ptr [RSP + 0x4c],EAX
CMP dword ptr [RSP + 0x4c],0x0
JGE 0x0016d9de
MOV dword ptr [RSP + 0xa4],0xffffffff
JMP 0x0016daac
LAB_0016d9de:
CMP dword ptr [RSP + 0x4c],0x0
JZ 0x0016da32
MOV RAX,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSP + 0x98]
MOV RDI,qword ptr [RAX + 0x1a0]
MOV RSI,qword ptr [RAX + 0x1a8]
CALL 0x001279c0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x38],RCX
MOV qword ptr [RSP + 0x40],RDX
MOV RCX,qword ptr [RSP + 0x38]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x40]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x0016da5c
LAB_0016da32:
MOV RAX,qword ptr [RSP + 0x88]
MOV dword ptr [RSP + 0x28],0x0
MOV qword ptr [RSP + 0x30],0x3
MOV RCX,qword ptr [RSP + 0x28]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x30]
MOV qword ptr [RAX + 0x8],RCX
LAB_0016da5c:
JMP 0x0016da5e
LAB_0016da5e:
MOV RAX,qword ptr [RSP + 0x88]
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP + 0x98]
MOV ESI,dword ptr [RSP + 0x94]
CALL 0x0012f120
MOV RCX,RAX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x18],RCX
MOV qword ptr [RSP + 0x20],RDX
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX + 0x18],RCX
MOV dword ptr [RSP + 0xa4],0x0
LAB_0016daac:
MOV EAX,dword ptr [RSP + 0xa4]
ADD RSP,0xe8
RET
|
int4 JS_GetGlobalVarRef(long param_1,uint param_2,int1 (*param_3) [16])
{
int1 (*pauVar1) [16];
int iVar2;
int4 uVar3;
long lVar4;
int1 auVar5 [16];
uint uStack_bc;
int8 *local_78;
uint *local_70;
long local_68;
int1 (*local_60) [16];
uint local_54;
long local_50;
ulong local_40;
long local_38;
uint *local_30;
long local_28;
uint local_1c;
long local_18;
int8 **local_10;
uint *local_8;
local_68 = *(long *)(param_1 + 0x1b0);
local_10 = &local_78;
local_28 = *(long *)(local_68 + 0x18);
local_40 = (ulong)(param_2 & *(uint *)(local_28 + 0x20));
local_60 = param_3;
local_54 = param_2;
local_50 = param_1;
local_1c = param_2;
local_18 = local_68;
lVar4 = prop_hash_end(local_28);
local_40 = (ulong)*(uint *)(lVar4 + (-1 - local_40) * 4);
local_38 = get_shape_prop(local_28);
do {
if (local_40 == 0) {
*local_10 = (int8 *)0x0;
local_8 = (uint *)0x0;
LAB_0016d88e:
local_70 = local_8;
if (local_8 == (uint *)0x0) {
iVar2 = JS_HasProperty(local_50,*(int8 *)(local_50 + 0x1a0),
*(int8 *)(local_50 + 0x1a8),local_54);
pauVar1 = local_60;
if (iVar2 < 0) {
return 0xffffffff;
}
if (iVar2 == 0) {
*(ulong *)*local_60 = (ulong)uStack_bc << 0x20;
*(int8 *)(*local_60 + 8) = 3;
}
else {
auVar5 = js_dup(*(int8 *)(local_50 + 0x1a0),*(int8 *)(local_50 + 0x1a8));
*pauVar1 = auVar5;
}
}
else {
iVar2 = JS_IsUninitialized(*local_78,local_78[1]);
pauVar1 = local_60;
if (iVar2 != 0) {
JS_ThrowReferenceErrorUninitialized(local_50,local_70[1]);
return 0xffffffff;
}
if ((*local_70 >> 0x1a & 2) == 0) {
uVar3 = JS_ThrowTypeErrorReadOnly(local_50,0x4000,local_54);
return uVar3;
}
auVar5 = js_dup(*(int8 *)(local_50 + 0x1b0),*(int8 *)(local_50 + 0x1b8));
*pauVar1 = auVar5;
}
pauVar1 = local_60;
auVar5 = JS_AtomToValue(local_50,local_54);
pauVar1[1] = auVar5;
return 0;
}
local_30 = (uint *)(local_38 + (local_40 - 1) * 8);
if (local_30[1] == local_1c) {
*local_10 = (int8 *)(*(long *)(local_18 + 0x20) + (local_40 - 1) * 0x10);
local_8 = local_30;
goto LAB_0016d88e;
}
local_40 = (ulong)(*local_30 & 0x3ffffff);
} while( true );
}
|
|
63,608
|
ma_columndef_read
|
eloqsql/storage/maria/ma_open.c
|
uchar *_ma_columndef_read(uchar *ptr, MARIA_COLUMNDEF *columndef)
{
uint high_offset;
columndef->column_nr= mi_uint2korr(ptr); ptr+= 2;
columndef->offset= mi_uint2korr(ptr); ptr+= 2;
columndef->type= mi_sint2korr(ptr); ptr+= 2;
columndef->length= mi_uint2korr(ptr); ptr+= 2;
columndef->fill_length= mi_uint2korr(ptr); ptr+= 2;
columndef->null_pos= mi_uint2korr(ptr); ptr+= 2;
columndef->empty_pos= mi_uint2korr(ptr); ptr+= 2;
columndef->null_bit= (uint8) *ptr++;
columndef->empty_bit= (uint8) *ptr++;
high_offset= mi_uint2korr(ptr); ptr+= 2;
columndef->offset|= ((ulong) high_offset << 16);
ptr+= 2;
return ptr;
}
|
O0
|
c
|
ma_columndef_read:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %eax
movzwl %ax, %eax
movq -0x8(%rbp), %rcx
movzbl (%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0xa(%rax)
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %eax
movzwl %ax, %eax
movq -0x8(%rbp), %rcx
movzbl (%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzwl %ax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %eax
cwtl
movq -0x8(%rbp), %rcx
movzbl (%rcx), %ecx
movswl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movswl %ax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %eax
movzwl %ax, %eax
movq -0x8(%rbp), %rcx
movzbl (%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %eax
movzwl %ax, %eax
movq -0x8(%rbp), %rcx
movzbl (%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0xc(%rax)
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %eax
movzwl %ax, %eax
movq -0x8(%rbp), %rcx
movzbl (%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0xe(%rax)
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %eax
movzwl %ax, %eax
movq -0x8(%rbp), %rcx
movzbl (%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x10(%rax)
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x12(%rax)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x13(%rax)
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %eax
movzwl %ax, %eax
movq -0x8(%rbp), %rcx
movzbl (%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzwl %ax, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %edx
shlq $0x10, %rdx
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
orq %rdx, %rcx
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_ma_columndef_read:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
movzx eax, byte ptr [rax+1]
movzx eax, ax
mov rcx, [rbp+var_8]
movzx ecx, byte ptr [rcx]
movzx ecx, cx
shl ecx, 8
or eax, ecx
mov cx, ax
mov rax, [rbp+var_10]
mov [rax+0Ah], cx
mov rax, [rbp+var_8]
add rax, 2
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
movzx eax, byte ptr [rax+1]
movzx eax, ax
mov rcx, [rbp+var_8]
movzx ecx, byte ptr [rcx]
movzx ecx, cx
shl ecx, 8
or eax, ecx
movzx ecx, ax
mov rax, [rbp+var_10]
mov [rax+4], ecx
mov rax, [rbp+var_8]
add rax, 2
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
movzx eax, byte ptr [rax+1]
cwde
mov rcx, [rbp+var_8]
movzx ecx, byte ptr [rcx]
movsx ecx, cx
shl ecx, 8
or eax, ecx
movsx ecx, ax
mov rax, [rbp+var_10]
mov [rax], ecx
mov rax, [rbp+var_8]
add rax, 2
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
movzx eax, byte ptr [rax+1]
movzx eax, ax
mov rcx, [rbp+var_8]
movzx ecx, byte ptr [rcx]
movzx ecx, cx
shl ecx, 8
or eax, ecx
mov cx, ax
mov rax, [rbp+var_10]
mov [rax+8], cx
mov rax, [rbp+var_8]
add rax, 2
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
movzx eax, byte ptr [rax+1]
movzx eax, ax
mov rcx, [rbp+var_8]
movzx ecx, byte ptr [rcx]
movzx ecx, cx
shl ecx, 8
or eax, ecx
mov cx, ax
mov rax, [rbp+var_10]
mov [rax+0Ch], cx
mov rax, [rbp+var_8]
add rax, 2
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
movzx eax, byte ptr [rax+1]
movzx eax, ax
mov rcx, [rbp+var_8]
movzx ecx, byte ptr [rcx]
movzx ecx, cx
shl ecx, 8
or eax, ecx
mov cx, ax
mov rax, [rbp+var_10]
mov [rax+0Eh], cx
mov rax, [rbp+var_8]
add rax, 2
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
movzx eax, byte ptr [rax+1]
movzx eax, ax
mov rcx, [rbp+var_8]
movzx ecx, byte ptr [rcx]
movzx ecx, cx
shl ecx, 8
or eax, ecx
mov cx, ax
mov rax, [rbp+var_10]
mov [rax+10h], cx
mov rax, [rbp+var_8]
add rax, 2
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
mov rcx, rax
add rcx, 1
mov [rbp+var_8], rcx
mov cl, [rax]
mov rax, [rbp+var_10]
mov [rax+12h], cl
mov rax, [rbp+var_8]
mov rcx, rax
add rcx, 1
mov [rbp+var_8], rcx
mov cl, [rax]
mov rax, [rbp+var_10]
mov [rax+13h], cl
mov rax, [rbp+var_8]
movzx eax, byte ptr [rax+1]
movzx eax, ax
mov rcx, [rbp+var_8]
movzx ecx, byte ptr [rcx]
movzx ecx, cx
shl ecx, 8
or eax, ecx
movzx eax, ax
mov [rbp+var_14], eax
mov rax, [rbp+var_8]
add rax, 2
mov [rbp+var_8], rax
mov eax, [rbp+var_14]
mov edx, eax
shl rdx, 10h
mov rax, [rbp+var_10]
mov ecx, [rax+4]
or rcx, rdx
mov [rax+4], ecx
mov rax, [rbp+var_8]
add rax, 2
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
pop rbp
retn
|
long long ma_columndef_read(long long a1, long long a2)
{
*(_WORD *)(a2 + 10) = _byteswap_ushort(*(_WORD *)a1);
*(_DWORD *)(a2 + 4) = _byteswap_ushort(*(_WORD *)(a1 + 2));
*(_DWORD *)a2 = (__int16)_byteswap_ushort(*(_WORD *)(a1 + 4));
*(_WORD *)(a2 + 8) = _byteswap_ushort(*(_WORD *)(a1 + 6));
*(_WORD *)(a2 + 12) = _byteswap_ushort(*(_WORD *)(a1 + 8));
*(_WORD *)(a2 + 14) = _byteswap_ushort(*(_WORD *)(a1 + 10));
*(_WORD *)(a2 + 16) = _byteswap_ushort(*(_WORD *)(a1 + 12));
*(_BYTE *)(a2 + 18) = *(_BYTE *)(a1 + 14);
*(_BYTE *)(a2 + 19) = *(_BYTE *)(a1 + 15);
*(_DWORD *)(a2 + 4) |= _byteswap_ushort(*(_WORD *)(a1 + 16)) << 16;
return a1 + 20;
}
|
_ma_columndef_read:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOVZX EAX,byte ptr [RAX + 0x1]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x8]
MOVZX ECX,byte ptr [RCX]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x10]
MOV word ptr [RAX + 0xa],CX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x2
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOVZX EAX,byte ptr [RAX + 0x1]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x8]
MOVZX ECX,byte ptr [RCX]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOVZX ECX,AX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x4],ECX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x2
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOVZX EAX,byte ptr [RAX + 0x1]
CWDE
MOV RCX,qword ptr [RBP + -0x8]
MOVZX ECX,byte ptr [RCX]
MOVSX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOVSX ECX,AX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x2
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOVZX EAX,byte ptr [RAX + 0x1]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x8]
MOVZX ECX,byte ptr [RCX]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x10]
MOV word ptr [RAX + 0x8],CX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x2
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOVZX EAX,byte ptr [RAX + 0x1]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x8]
MOVZX ECX,byte ptr [RCX]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x10]
MOV word ptr [RAX + 0xc],CX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x2
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOVZX EAX,byte ptr [RAX + 0x1]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x8]
MOVZX ECX,byte ptr [RCX]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x10]
MOV word ptr [RAX + 0xe],CX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x2
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOVZX EAX,byte ptr [RAX + 0x1]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x8]
MOVZX ECX,byte ptr [RCX]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x10]
MOV word ptr [RAX + 0x10],CX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x2
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x8],RCX
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x12],CL
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x8],RCX
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x13],CL
MOV RAX,qword ptr [RBP + -0x8]
MOVZX EAX,byte ptr [RAX + 0x1]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x8]
MOVZX ECX,byte ptr [RCX]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOVZX EAX,AX
MOV dword ptr [RBP + -0x14],EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x2
MOV qword ptr [RBP + -0x8],RAX
MOV EAX,dword ptr [RBP + -0x14]
MOV EDX,EAX
SHL RDX,0x10
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x4]
OR RCX,RDX
MOV dword ptr [RAX + 0x4],ECX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x2
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
int1 * _ma_columndef_read(int1 *param_1,int *param_2)
{
*(ushort *)((long)param_2 + 10) = CONCAT11(*param_1,param_1[1]);
param_2[1] = (uint)CONCAT11(param_1[2],param_1[3]);
*param_2 = (int)(short)((ushort)(byte)param_1[5] |
(ushort)((int)(short)(ushort)(byte)param_1[4] << 8));
*(ushort *)(param_2 + 2) = CONCAT11(param_1[6],param_1[7]);
*(ushort *)(param_2 + 3) = CONCAT11(param_1[8],param_1[9]);
*(ushort *)((long)param_2 + 0xe) = CONCAT11(param_1[10],param_1[0xb]);
*(ushort *)(param_2 + 4) = CONCAT11(param_1[0xc],param_1[0xd]);
*(int1 *)((long)param_2 + 0x12) = param_1[0xe];
*(int1 *)((long)param_2 + 0x13) = param_1[0xf];
param_2[1] = param_2[1] | (uint)CONCAT11(param_1[0x10],param_1[0x11]) << 0x10;
return param_1 + 0x14;
}
|
|
63,609
|
LefDefParser::lefwMacroPinIV_Tables(char const*, char const*)
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp
|
int
lefwMacroPinIV_Tables(const char *lowName,
const char *highName)
{
lefwObsoleteNum = LEFW_MACRO_IV_TABLES;
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (!lefwDidInit)
return LEFW_BAD_ORDER;
if (!lefwIsMacroPin)
return LEFW_BAD_ORDER;
if (versionNum >= 5.4)
return LEFW_OBSOLETE;
if (!lowName || lowName == 0 || *lowName == 0)
return LEFW_BAD_DATA;
if (!highName || highName == 0 || *highName == 0)
return LEFW_BAD_DATA;
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*) " IV_TABLES %s %s ;\n", lowName, highName);
else
fprintf(lefwFile, " IV_TABLES %s %s ;\n", lowName, highName);
lefwLines++;
lefwState = LEFW_MACRO;
return LEFW_OK;
}
|
O0
|
cpp
|
LefDefParser::lefwMacroPinIV_Tables(char const*, char const*):
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movl $0x28, 0x109f1(%rip) # 0x32d48
leaq 0x10aa2(%rip), %rax # 0x32e00
cmpq $0x0, (%rax)
jne 0x22371
movl $0x1, 0x14(%rsp)
jmp 0x2248b
leaq 0x10cdc(%rip), %rax # 0x33054
cmpl $0x0, (%rax)
jne 0x2238a
movl $0x2, 0x14(%rsp)
jmp 0x2248b
leaq 0x10d0f(%rip), %rax # 0x330a0
cmpl $0x0, (%rax)
jne 0x223a3
movl $0x2, 0x14(%rsp)
jmp 0x2248b
movsd 0x10995(%rip), %xmm0 # 0x32d40
movsd 0x6e4d(%rip), %xmm1 # 0x29200
ucomisd %xmm1, %xmm0
jb 0x223c6
movl $0x7, 0x14(%rsp)
jmp 0x2248b
cmpq $0x0, 0x8(%rsp)
je 0x223e3
cmpq $0x0, 0x8(%rsp)
je 0x223e3
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x223f0
movl $0x3, 0x14(%rsp)
jmp 0x2248b
cmpq $0x0, (%rsp)
je 0x2240a
cmpq $0x0, (%rsp)
je 0x2240a
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x22414
movl $0x3, 0x14(%rsp)
jmp 0x2248b
cmpl $0x0, 0x10cd1(%rip) # 0x330ec
je 0x22440
leaq 0x109dc(%rip), %rax # 0x32e00
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
leaq 0x954d(%rip), %rsi # 0x2b984
movb $0x0, %al
callq 0x289b0
jmp 0x22461
leaq 0x109b9(%rip), %rax # 0x32e00
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
leaq 0x952a(%rip), %rsi # 0x2b984
movb $0x0, %al
callq 0x1100
leaq 0x10be4(%rip), %rax # 0x3304c
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x10bd8(%rip), %rax # 0x3304c
movl %ecx, (%rax)
leaq 0x10bd3(%rip), %rax # 0x33050
movl $0x21, (%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
|
_ZN12LefDefParser21lefwMacroPinIV_TablesEPKcS1_:
sub rsp, 18h
mov [rsp+18h+var_10], rdi
mov [rsp+18h+var_18], rsi
mov cs:_ZN12LefDefParserL15lefwObsoleteNumE, 28h ; '('; LefDefParser::lefwObsoleteNum
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
cmp qword ptr [rax], 0
jnz short loc_22371
mov [rsp+18h+var_4], 1
jmp loc_2248B
loc_22371:
lea rax, _ZN12LefDefParser11lefwDidInitE; LefDefParser::lefwDidInit
cmp dword ptr [rax], 0
jnz short loc_2238A
mov [rsp+18h+var_4], 2
jmp loc_2248B
loc_2238A:
lea rax, _ZN12LefDefParser14lefwIsMacroPinE; LefDefParser::lefwIsMacroPin
cmp dword ptr [rax], 0
jnz short loc_223A3
mov [rsp+18h+var_4], 2
jmp loc_2248B
loc_223A3:
movsd xmm0, cs:_ZN12LefDefParserL10versionNumE; LefDefParser::versionNum
movsd xmm1, cs:dbl_29200
ucomisd xmm0, xmm1
jb short loc_223C6
mov [rsp+18h+var_4], 7
jmp loc_2248B
loc_223C6:
cmp [rsp+18h+var_10], 0
jz short loc_223E3
cmp [rsp+18h+var_10], 0
jz short loc_223E3
mov rax, [rsp+18h+var_10]
movsx eax, byte ptr [rax]
cmp eax, 0
jnz short loc_223F0
loc_223E3:
mov [rsp+18h+var_4], 3
jmp loc_2248B
loc_223F0:
cmp [rsp+18h+var_18], 0
jz short loc_2240A
cmp [rsp+18h+var_18], 0
jz short loc_2240A
mov rax, [rsp+18h+var_18]
movsx eax, byte ptr [rax]
cmp eax, 0
jnz short loc_22414
loc_2240A:
mov [rsp+18h+var_4], 3
jmp short loc_2248B
loc_22414:
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 0; LefDefParser::lefwWriteEncrypt
jz short loc_22440
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
mov rdx, [rsp+18h+var_10]
mov rcx, [rsp+18h+var_18]
lea rsi, aIvTablesSS; " IV_TABLES %s %s ;\n"
mov al, 0
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_22461
loc_22440:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
mov rdx, [rsp+18h+var_10]
mov rcx, [rsp+18h+var_18]
lea rsi, aIvTablesSS; " IV_TABLES %s %s ;\n"
mov al, 0
call _fprintf
loc_22461:
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov ecx, [rax]
add ecx, 1
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov [rax], ecx
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
mov dword ptr [rax], 21h ; '!'
mov [rsp+18h+var_4], 0
loc_2248B:
mov eax, [rsp+18h+var_4]
add rsp, 18h
retn
|
long long LefDefParser::lefwMacroPinIV_Tables(
LefDefParser *this,
const char *a2,
const char *a3,
long long a4,
int a5,
int a6)
{
LefDefParser::lefwObsoleteNum = 40;
if ( *(_QWORD *)&LefDefParser::lefwFile )
{
if ( LefDefParser::lefwDidInit )
{
if ( LefDefParser::lefwIsMacroPin )
{
if ( *(double *)&LefDefParser::versionNum < 5.4 )
{
if ( this && *(_BYTE *)this )
{
if ( a2 && *a2 )
{
if ( LefDefParser::lefwWriteEncrypt )
LefDefParser::encPrint(
LefDefParser::lefwFile,
(unsigned int)" IV_TABLES %s %s ;\n",
(_DWORD)this,
(_DWORD)a2,
a5,
a6);
else
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " IV_TABLES %s %s ;\n", (const char *)this, a2);
++LefDefParser::lefwLines;
LefDefParser::lefwState = 33;
return 0;
}
else
{
return 3;
}
}
else
{
return 3;
}
}
else
{
return 7;
}
}
else
{
return 2;
}
}
else
{
return 2;
}
}
else
{
return 1;
}
}
|
lefwMacroPinIV_Tables:
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDI
MOV qword ptr [RSP],RSI
MOV dword ptr [0x00132d48],0x28
LEA RAX,[0x132e00]
CMP qword ptr [RAX],0x0
JNZ 0x00122371
MOV dword ptr [RSP + 0x14],0x1
JMP 0x0012248b
LAB_00122371:
LEA RAX,[0x133054]
CMP dword ptr [RAX],0x0
JNZ 0x0012238a
MOV dword ptr [RSP + 0x14],0x2
JMP 0x0012248b
LAB_0012238a:
LEA RAX,[0x1330a0]
CMP dword ptr [RAX],0x0
JNZ 0x001223a3
MOV dword ptr [RSP + 0x14],0x2
JMP 0x0012248b
LAB_001223a3:
MOVSD XMM0,qword ptr [0x00132d40]
MOVSD XMM1,qword ptr [0x00129200]
UCOMISD XMM0,XMM1
JC 0x001223c6
MOV dword ptr [RSP + 0x14],0x7
JMP 0x0012248b
LAB_001223c6:
CMP qword ptr [RSP + 0x8],0x0
JZ 0x001223e3
CMP qword ptr [RSP + 0x8],0x0
JZ 0x001223e3
MOV RAX,qword ptr [RSP + 0x8]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JNZ 0x001223f0
LAB_001223e3:
MOV dword ptr [RSP + 0x14],0x3
JMP 0x0012248b
LAB_001223f0:
CMP qword ptr [RSP],0x0
JZ 0x0012240a
CMP qword ptr [RSP],0x0
JZ 0x0012240a
MOV RAX,qword ptr [RSP]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JNZ 0x00122414
LAB_0012240a:
MOV dword ptr [RSP + 0x14],0x3
JMP 0x0012248b
LAB_00122414:
CMP dword ptr [0x001330ec],0x0
JZ 0x00122440
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
MOV RDX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP]
LEA RSI,[0x12b984]
MOV AL,0x0
CALL 0x001289b0
JMP 0x00122461
LAB_00122440:
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
MOV RDX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP]
LEA RSI,[0x12b984]
MOV AL,0x0
CALL 0x00101100
LAB_00122461:
LEA RAX,[0x13304c]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x13304c]
MOV dword ptr [RAX],ECX
LEA RAX,[0x133050]
MOV dword ptr [RAX],0x21
MOV dword ptr [RSP + 0x14],0x0
LAB_0012248b:
MOV EAX,dword ptr [RSP + 0x14]
ADD RSP,0x18
RET
|
/* LefDefParser::lefwMacroPinIV_Tables(char const*, char const*) */
int4 LefDefParser::lefwMacroPinIV_Tables(char *param_1,char *param_2)
{
int4 local_4;
lefwObsoleteNum = 0x28;
if (lefwFile == (_IO_FILE *)0x0) {
local_4 = 1;
}
else if (lefwDidInit == 0) {
local_4 = 2;
}
else if (lefwIsMacroPin == 0) {
local_4 = 2;
}
else if (versionNum < DAT_00129200) {
if (((param_1 == (char *)0x0) || (param_1 == (char *)0x0)) || (*param_1 == '\0')) {
local_4 = 3;
}
else if (((param_2 == (char *)0x0) || (param_2 == (char *)0x0)) || (*param_2 == '\0')) {
local_4 = 3;
}
else {
if (lefwWriteEncrypt == 0) {
fprintf(lefwFile," IV_TABLES %s %s ;\n",param_1,param_2);
}
else {
encPrint(lefwFile," IV_TABLES %s %s ;\n",param_1,param_2);
}
lefwLines = lefwLines + 1;
lefwState = 0x21;
local_4 = 0;
}
}
else {
local_4 = 7;
}
return local_4;
}
|
|
63,610
|
LefDefParser::lefwMacroPinIV_Tables(char const*, char const*)
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp
|
int
lefwMacroPinIV_Tables(const char *lowName,
const char *highName)
{
lefwObsoleteNum = LEFW_MACRO_IV_TABLES;
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (!lefwDidInit)
return LEFW_BAD_ORDER;
if (!lefwIsMacroPin)
return LEFW_BAD_ORDER;
if (versionNum >= 5.4)
return LEFW_OBSOLETE;
if (!lowName || lowName == 0 || *lowName == 0)
return LEFW_BAD_DATA;
if (!highName || highName == 0 || *highName == 0)
return LEFW_BAD_DATA;
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*) " IV_TABLES %s %s ;\n", lowName, highName);
else
fprintf(lefwFile, " IV_TABLES %s %s ;\n", lowName, highName);
lefwLines++;
lefwState = LEFW_MACRO;
return LEFW_OK;
}
|
O3
|
cpp
|
LefDefParser::lefwMacroPinIV_Tables(char const*, char const*):
movq %rdi, %rdx
movl $0x28, 0x1023e(%rip) # 0x24d48
leaq 0x102ef(%rip), %rax # 0x24e00
movq (%rax), %rdi
testq %rdi, %rdi
je 0x14b87
leaq 0x10534(%rip), %rax # 0x25054
cmpl $0x0, (%rax)
movl $0x2, %eax
je 0x14bb7
movq %rsi, %rcx
leaq 0x10568(%rip), %rsi # 0x250a0
cmpl $0x0, (%rsi)
je 0x14bb7
movsd 0x101fb(%rip), %xmm0 # 0x24d40
movl $0x7, %eax
ucomisd 0x45c6(%rip), %xmm0 # 0x19118
jae 0x14bb7
movl $0x3, %eax
testq %rdx, %rdx
je 0x14bb7
testq %rcx, %rcx
je 0x14bb7
cmpb $0x0, (%rdx)
je 0x14bb7
cmpb $0x0, (%rcx)
je 0x14bb7
pushq %rax
cmpb $0x1, 0x10577(%rip) # 0x250ec
jne 0x14b8d
leaq 0x70c2(%rip), %rsi # 0x1bc40
xorl %eax, %eax
callq 0x18c35
jmp 0x14b9b
movl $0x1, %eax
retq
leaq 0x70ac(%rip), %rsi # 0x1bc40
xorl %eax, %eax
callq 0x10f0
leaq 0x104aa(%rip), %rax # 0x2504c
incl (%rax)
leaq 0x104a5(%rip), %rax # 0x25050
movl $0x21, (%rax)
xorl %eax, %eax
addq $0x8, %rsp
retq
|
_ZN12LefDefParser21lefwMacroPinIV_TablesEPKcS1_:
mov rdx, rdi
mov cs:_ZN12LefDefParserL15lefwObsoleteNumE, 28h ; '('; LefDefParser::lefwObsoleteNum
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
test rdi, rdi
jz short loc_14B87
lea rax, _ZN12LefDefParser11lefwDidInitE; LefDefParser::lefwDidInit
cmp dword ptr [rax], 0
mov eax, 2
jz locret_14BB7
mov rcx, rsi
lea rsi, _ZN12LefDefParser14lefwIsMacroPinE; LefDefParser::lefwIsMacroPin
cmp dword ptr [rsi], 0
jz short locret_14BB7
movsd xmm0, cs:_ZN12LefDefParserL10versionNumE; LefDefParser::versionNum
mov eax, 7
ucomisd xmm0, cs:dbl_19118
jnb short locret_14BB7
mov eax, 3
test rdx, rdx
jz short locret_14BB7
test rcx, rcx
jz short locret_14BB7
cmp byte ptr [rdx], 0
jz short locret_14BB7
cmp byte ptr [rcx], 0
jz short locret_14BB7
push rax
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 1; LefDefParser::lefwWriteEncrypt
jnz short loc_14B8D
lea rsi, aIvTablesSS; " IV_TABLES %s %s ;\n"
xor eax, eax
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_14B9B
loc_14B87:
mov eax, 1
retn
loc_14B8D:
lea rsi, aIvTablesSS; " IV_TABLES %s %s ;\n"
xor eax, eax
call _fprintf
loc_14B9B:
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
inc dword ptr [rax]
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
mov dword ptr [rax], 21h ; '!'
xor eax, eax
add rsp, 8
locret_14BB7:
retn
|
long long LefDefParser::lefwMacroPinIV_Tables(
LefDefParser *this,
const char *a2,
const char *a3,
long long a4,
int a5,
int a6)
{
long long result; // rax
LefDefParser::lefwObsoleteNum = 40;
if ( !*(_QWORD *)&LefDefParser::lefwFile )
return 1LL;
result = 2LL;
if ( LefDefParser::lefwDidInit )
{
if ( LefDefParser::lefwIsMacroPin )
{
result = 7LL;
if ( *(double *)&LefDefParser::versionNum < 5.4 )
{
result = 3LL;
if ( this )
{
if ( a2 && *(_BYTE *)this && *a2 )
{
if ( LefDefParser::lefwWriteEncrypt == 1 )
LefDefParser::encPrint(
LefDefParser::lefwFile,
(unsigned int)" IV_TABLES %s %s ;\n",
(_DWORD)this,
(_DWORD)a2,
a5,
a6);
else
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " IV_TABLES %s %s ;\n", (const char *)this, a2);
++LefDefParser::lefwLines;
LefDefParser::lefwState = 33;
return 0LL;
}
}
}
}
}
return result;
}
|
lefwMacroPinIV_Tables:
MOV RDX,RDI
MOV dword ptr [0x00124d48],0x28
LEA RAX,[0x124e00]
MOV RDI,qword ptr [RAX]
TEST RDI,RDI
JZ 0x00114b87
LEA RAX,[0x125054]
CMP dword ptr [RAX],0x0
MOV EAX,0x2
JZ 0x00114bb7
MOV RCX,RSI
LEA RSI,[0x1250a0]
CMP dword ptr [RSI],0x0
JZ 0x00114bb7
MOVSD XMM0,qword ptr [0x00124d40]
MOV EAX,0x7
UCOMISD XMM0,qword ptr [0x00119118]
JNC 0x00114bb7
MOV EAX,0x3
TEST RDX,RDX
JZ 0x00114bb7
TEST RCX,RCX
JZ 0x00114bb7
CMP byte ptr [RDX],0x0
JZ 0x00114bb7
CMP byte ptr [RCX],0x0
JZ 0x00114bb7
PUSH RAX
CMP byte ptr [0x001250ec],0x1
JNZ 0x00114b8d
LEA RSI,[0x11bc40]
XOR EAX,EAX
CALL 0x00118c35
JMP 0x00114b9b
LAB_00114b87:
MOV EAX,0x1
RET
LAB_00114b8d:
LEA RSI,[0x11bc40]
XOR EAX,EAX
CALL 0x001010f0
LAB_00114b9b:
LEA RAX,[0x12504c]
INC dword ptr [RAX]
LEA RAX,[0x125050]
MOV dword ptr [RAX],0x21
XOR EAX,EAX
ADD RSP,0x8
LAB_00114bb7:
RET
|
/* LefDefParser::lefwMacroPinIV_Tables(char const*, char const*) */
int8 LefDefParser::lefwMacroPinIV_Tables(char *param_1,char *param_2)
{
int8 uVar1;
lefwObsoleteNum = 0x28;
if (lefwFile != (_IO_FILE *)0x0) {
uVar1 = 2;
if ((lefwDidInit != 0) && (lefwIsMacroPin != 0)) {
uVar1 = 7;
if (((versionNum < DAT_00119118) &&
(((uVar1 = 3, param_1 != (char *)0x0 && (param_2 != (char *)0x0)) && (*param_1 != '\0'))))
&& (*param_2 != '\0')) {
if (lefwWriteEncrypt == '\x01') {
encPrint(lefwFile," IV_TABLES %s %s ;\n");
}
else {
fprintf(lefwFile," IV_TABLES %s %s ;\n");
}
lefwLines = lefwLines + 1;
lefwState = 0x21;
uVar1 = 0;
}
}
return uVar1;
}
return 1;
}
|
|
63,611
|
ma_log_change
|
eloqsql/storage/maria/ma_write.c
|
my_bool _ma_log_change(MARIA_PAGE *ma_page, const uchar *key_pos, uint length,
enum en_key_debug debug_marker __attribute__((unused)))
{
LSN lsn;
uchar log_data[FILEID_STORE_SIZE + PAGE_STORE_SIZE + 2 + 6 + 7], *log_pos;
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 4];
uint offset= (uint) (key_pos - ma_page->buff), translog_parts;
MARIA_HA *info= ma_page->info;
my_off_t page= ma_page->pos / info->s->block_size;
DBUG_ENTER("_ma_log_change");
DBUG_PRINT("enter", ("page: %lu length: %u", (ulong) page, length));
DBUG_ASSERT(info->s->now_transactional);
DBUG_ASSERT(offset + length <= ma_page->size);
DBUG_ASSERT(ma_page->org_size == ma_page->size);
/* Store address of new root page */
page= ma_page->pos / info->s->block_size;
page_store(log_data + FILEID_STORE_SIZE, page);
log_pos= log_data+ FILEID_STORE_SIZE + PAGE_STORE_SIZE;
#ifdef EXTRA_DEBUG_KEY_CHANGES
(*log_pos++)= KEY_OP_DEBUG;
(*log_pos++)= debug_marker;
#endif
log_pos[0]= KEY_OP_OFFSET;
int2store(log_pos+1, offset);
log_pos[3]= KEY_OP_CHANGE;
int2store(log_pos+4, length);
log_pos+= 6;
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= log_data;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= (log_pos - log_data);
log_array[TRANSLOG_INTERNAL_PARTS + 1].str= key_pos;
log_array[TRANSLOG_INTERNAL_PARTS + 1].length= length;
translog_parts= 2;
_ma_log_key_changes(ma_page,
log_array + TRANSLOG_INTERNAL_PARTS + translog_parts,
log_pos, &length, &translog_parts);
if (translog_write_record(&lsn, LOGREC_REDO_INDEX,
info->trn, info,
(translog_size_t) (log_pos - log_data) + length,
TRANSLOG_INTERNAL_PARTS + translog_parts,
log_array, log_data, NULL))
DBUG_RETURN(1);
DBUG_RETURN(0);
}
|
O0
|
c
|
ma_log_change:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movl %edx, -0x3c(%rbp)
movl %ecx, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0xb4(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xc0(%rbp)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq -0xc0(%rbp), %rcx
movq (%rcx), %rcx
movl 0x7bc(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0xc8(%rbp)
jmp 0x6767f
jmp 0x67681
jmp 0x67683
jmp 0x67685
jmp 0x67687
jmp 0x67689
jmp 0x6768b
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq -0xc0(%rbp), %rcx
movq (%rcx), %rcx
movl 0x7bc(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0xc8(%rbp)
leaq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0xd0(%rbp)
movq -0xc8(%rbp), %rax
movl %eax, %ecx
movq -0xd0(%rbp), %rax
movl %ecx, (%rax)
movq -0xc8(%rbp), %rax
shrq $0x20, %rax
movb %al, %cl
movq -0xd0(%rbp), %rax
movb %cl, 0x4(%rax)
leaq -0x20(%rbp), %rax
addq $0x2, %rax
addq $0x5, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movb $0x1, (%rax)
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xd8(%rbp)
movl -0xb4(%rbp), %eax
movw %ax, %cx
movq -0xd8(%rbp), %rax
movw %cx, (%rax)
movq -0x50(%rbp), %rax
movb $0x3, 0x3(%rax)
movq -0x50(%rbp), %rax
addq $0x4, %rax
movq %rax, -0xe0(%rbp)
movl -0x3c(%rbp), %eax
movw %ax, %cx
movq -0xe0(%rbp), %rax
movw %cx, (%rax)
movq -0x50(%rbp), %rax
addq $0x6, %rax
movq %rax, -0x50(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x50(%rbp), %rax
leaq -0x20(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x88(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x80(%rbp)
movl -0x3c(%rbp), %eax
movq %rax, -0x78(%rbp)
movl $0x2, -0xb8(%rbp)
movq -0xc0(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0xc0(%rbp), %rcx
movq -0x50(%rbp), %rax
leaq -0x20(%rbp), %rsi
subq %rsi, %rax
movl %eax, %r8d
addl -0x3c(%rbp), %r8d
movl -0xb8(%rbp), %r9d
addl $0x2, %r9d
leaq -0xb0(%rbp), %r10
leaq -0x20(%rbp), %rax
leaq -0x48(%rbp), %rdi
movl $0xc, %esi
xorl %r11d, %r11d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
callq 0x8bc40
cmpb $0x0, %al
je 0x677f2
jmp 0x677ec
movb $0x1, -0x21(%rbp)
jmp 0x677f8
jmp 0x677f4
movb $0x0, -0x21(%rbp)
movb -0x21(%rbp), %al
movb %al, -0xe1(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x67822
movb -0xe1(%rbp), %al
addq $0x100, %rsp # imm = 0x100
popq %rbp
retq
callq 0x2a260
nopw (%rax,%rax)
|
_ma_log_change:
push rbp
mov rbp, rsp
sub rsp, 100h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_30], rdi
mov [rbp+var_38], rsi
mov [rbp+var_3C], edx
mov [rbp+var_40], ecx
mov rax, [rbp+var_38]
mov rcx, [rbp+var_30]
mov rcx, [rcx+10h]
sub rax, rcx
mov [rbp+var_B4], eax
mov rax, [rbp+var_30]
mov rax, [rax]
mov [rbp+var_C0], rax
mov rax, [rbp+var_30]
mov rax, [rax+18h]
mov rcx, [rbp+var_C0]
mov rcx, [rcx]
mov ecx, [rcx+7BCh]
xor edx, edx
div rcx
mov [rbp+var_C8], rax
jmp short $+2
loc_6767F:
jmp short $+2
loc_67681:
jmp short $+2
loc_67683:
jmp short $+2
loc_67685:
jmp short $+2
loc_67687:
jmp short $+2
loc_67689:
jmp short $+2
loc_6768B:
mov rax, [rbp+var_30]
mov rax, [rax+18h]
mov rcx, [rbp+var_C0]
mov rcx, [rcx]
mov ecx, [rcx+7BCh]
xor edx, edx
div rcx
mov [rbp+var_C8], rax
lea rax, [rbp+var_20]
add rax, 2
mov [rbp+var_D0], rax
mov rax, [rbp+var_C8]
mov ecx, eax
mov rax, [rbp+var_D0]
mov [rax], ecx
mov rax, [rbp+var_C8]
shr rax, 20h
mov cl, al
mov rax, [rbp+var_D0]
mov [rax+4], cl
lea rax, [rbp+var_20]
add rax, 2
add rax, 5
mov [rbp+var_50], rax
mov rax, [rbp+var_50]
mov byte ptr [rax], 1
mov rax, [rbp+var_50]
add rax, 1
mov [rbp+var_D8], rax
mov eax, [rbp+var_B4]
mov cx, ax
mov rax, [rbp+var_D8]
mov [rax], cx
mov rax, [rbp+var_50]
mov byte ptr [rax+3], 3
mov rax, [rbp+var_50]
add rax, 4
mov [rbp+var_E0], rax
mov eax, [rbp+var_3C]
mov cx, ax
mov rax, [rbp+var_E0]
mov [rax], cx
mov rax, [rbp+var_50]
add rax, 6
mov [rbp+var_50], rax
lea rax, [rbp+var_20]
mov [rbp+var_90], rax
mov rax, [rbp+var_50]
lea rcx, [rbp+var_20]
sub rax, rcx
mov [rbp+var_88], rax
mov rax, [rbp+var_38]
mov [rbp+var_80], rax
mov eax, [rbp+var_3C]
mov [rbp+var_78], rax
mov [rbp+var_B8], 2
mov rax, [rbp+var_C0]
mov rdx, [rax+8]
mov rcx, [rbp+var_C0]
mov rax, [rbp+var_50]
lea rsi, [rbp+var_20]
sub rax, rsi
mov r8d, eax
add r8d, [rbp+var_3C]
mov r9d, [rbp+var_B8]
add r9d, 2
lea r10, [rbp+var_B0]
lea rax, [rbp+var_20]
lea rdi, [rbp+var_48]
mov esi, 0Ch
xor r11d, r11d
mov [rsp+100h+var_100], r10
mov [rsp+100h+var_F8], rax
mov [rsp+100h+var_F0], 0
call translog_write_record
cmp al, 0
jz short loc_677F2
jmp short $+2
loc_677EC:
mov [rbp+var_21], 1
jmp short loc_677F8
loc_677F2:
jmp short $+2
loc_677F4:
mov [rbp+var_21], 0
loc_677F8:
mov al, [rbp+var_21]
mov [rbp+var_E1], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_67822
mov al, [rbp+var_E1]
add rsp, 100h
pop rbp
retn
loc_67822:
call ___stack_chk_fail
|
bool ma_log_change(_QWORD *a1, long long a2, unsigned int a3, int a4)
{
unsigned long long v5; // [rsp+38h] [rbp-C8h]
long long v6; // [rsp+40h] [rbp-C0h]
__int16 v7; // [rsp+4Ch] [rbp-B4h]
_BYTE v8[32]; // [rsp+50h] [rbp-B0h] BYREF
_BYTE *v9; // [rsp+70h] [rbp-90h]
long long v10; // [rsp+78h] [rbp-88h]
long long v11; // [rsp+80h] [rbp-80h]
long long v12; // [rsp+88h] [rbp-78h]
_BYTE *v13; // [rsp+B0h] [rbp-50h]
char v14; // [rsp+B8h] [rbp-48h] BYREF
int v15; // [rsp+C0h] [rbp-40h]
unsigned int v16; // [rsp+C4h] [rbp-3Ch]
long long v17; // [rsp+C8h] [rbp-38h]
_QWORD *v18; // [rsp+D0h] [rbp-30h]
_BYTE v19[2]; // [rsp+E0h] [rbp-20h] BYREF
int v20; // [rsp+E2h] [rbp-1Eh]
char v21; // [rsp+E6h] [rbp-1Ah]
char v22; // [rsp+E7h] [rbp-19h]
__int16 v23; // [rsp+E8h] [rbp-18h]
char v24; // [rsp+EAh] [rbp-16h]
__int16 v25; // [rsp+EBh] [rbp-15h]
_BYTE v26[19]; // [rsp+EDh] [rbp-13h] BYREF
long long savedregs; // [rsp+100h] [rbp+0h] BYREF
*(_QWORD *)&v26[11] = __readfsqword(0x28u);
v18 = a1;
v17 = a2;
v16 = a3;
v15 = a4;
v7 = a2 - a1[2];
v6 = *a1;
v5 = a1[3] / (unsigned long long)*(unsigned int *)(*(_QWORD *)*a1 + 1980LL);
v20 = v5;
v21 = BYTE4(v5);
v22 = 1;
v23 = v7;
v24 = 3;
v25 = a3;
v13 = v26;
v9 = v19;
v10 = 13LL;
v11 = a2;
v12 = a3;
return (unsigned __int8)translog_write_record(
(unsigned int)&v14,
12,
*(_QWORD *)(v6 + 8),
v6,
a3 + (unsigned int)v26 - ((unsigned int)&savedregs - 32),
4,
(long long)v8,
(long long)v19,
0LL) != 0;
}
|
_ma_log_change:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x100
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x30],RDI
MOV qword ptr [RBP + -0x38],RSI
MOV dword ptr [RBP + -0x3c],EDX
MOV dword ptr [RBP + -0x40],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RCX + 0x10]
SUB RAX,RCX
MOV dword ptr [RBP + -0xb4],EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0xc0],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RBP + -0xc0]
MOV RCX,qword ptr [RCX]
MOV ECX,dword ptr [RCX + 0x7bc]
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0xc8],RAX
JMP 0x0016767f
LAB_0016767f:
JMP 0x00167681
LAB_00167681:
JMP 0x00167683
LAB_00167683:
JMP 0x00167685
LAB_00167685:
JMP 0x00167687
LAB_00167687:
JMP 0x00167689
LAB_00167689:
JMP 0x0016768b
LAB_0016768b:
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RBP + -0xc0]
MOV RCX,qword ptr [RCX]
MOV ECX,dword ptr [RCX + 0x7bc]
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0xc8],RAX
LEA RAX,[RBP + -0x20]
ADD RAX,0x2
MOV qword ptr [RBP + -0xd0],RAX
MOV RAX,qword ptr [RBP + -0xc8]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0xd0]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0xc8]
SHR RAX,0x20
MOV CL,AL
MOV RAX,qword ptr [RBP + -0xd0]
MOV byte ptr [RAX + 0x4],CL
LEA RAX,[RBP + -0x20]
ADD RAX,0x2
ADD RAX,0x5
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV byte ptr [RAX],0x1
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x1
MOV qword ptr [RBP + -0xd8],RAX
MOV EAX,dword ptr [RBP + -0xb4]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0xd8]
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RBP + -0x50]
MOV byte ptr [RAX + 0x3],0x3
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x4
MOV qword ptr [RBP + -0xe0],RAX
MOV EAX,dword ptr [RBP + -0x3c]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0xe0]
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x6
MOV qword ptr [RBP + -0x50],RAX
LEA RAX,[RBP + -0x20]
MOV qword ptr [RBP + -0x90],RAX
MOV RAX,qword ptr [RBP + -0x50]
LEA RCX,[RBP + -0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x80],RAX
MOV EAX,dword ptr [RBP + -0x3c]
MOV qword ptr [RBP + -0x78],RAX
MOV dword ptr [RBP + -0xb8],0x2
MOV RAX,qword ptr [RBP + -0xc0]
MOV RDX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0xc0]
MOV RAX,qword ptr [RBP + -0x50]
LEA RSI,[RBP + -0x20]
SUB RAX,RSI
MOV R8D,EAX
ADD R8D,dword ptr [RBP + -0x3c]
MOV R9D,dword ptr [RBP + -0xb8]
ADD R9D,0x2
LEA R10,[RBP + -0xb0]
LEA RAX,[RBP + -0x20]
LEA RDI,[RBP + -0x48]
MOV ESI,0xc
XOR R11D,R11D
MOV qword ptr [RSP],R10
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],0x0
CALL 0x0018bc40
CMP AL,0x0
JZ 0x001677f2
JMP 0x001677ec
LAB_001677ec:
MOV byte ptr [RBP + -0x21],0x1
JMP 0x001677f8
LAB_001677f2:
JMP 0x001677f4
LAB_001677f4:
MOV byte ptr [RBP + -0x21],0x0
LAB_001677f8:
MOV AL,byte ptr [RBP + -0x21]
MOV byte ptr [RBP + -0xe1],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00167822
MOV AL,byte ptr [RBP + -0xe1]
ADD RSP,0x100
POP RBP
RET
LAB_00167822:
CALL 0x0012a260
|
int8 _ma_log_change(long *param_1,int8 param_2,uint param_3,int4 param_4)
{
long *plVar1;
char cVar2;
ulong uVar3;
long in_FS_OFFSET;
int1 local_b8 [32];
int1 *local_98;
long local_90;
int8 local_88;
ulong local_80;
int1 *local_58;
int1 local_50 [8];
int4 local_48;
uint local_44;
int8 local_40;
long *local_38;
int1 local_29;
int1 local_28 [2];
int4 local_26;
int1 local_22;
int1 local_21;
short local_20;
int1 local_1e;
int2 local_1d;
int1 auStack_1b [11];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_20 = (short)param_2 - (short)param_1[2];
plVar1 = (long *)*param_1;
uVar3 = (ulong)param_1[3] / (ulong)*(uint *)(*plVar1 + 0x7bc);
local_26 = (int4)uVar3;
local_22 = (int1)(uVar3 >> 0x20);
local_21 = 1;
local_1e = 3;
local_1d = (int2)param_3;
local_58 = auStack_1b;
local_98 = local_28;
local_90 = (long)local_58 - (long)local_28;
local_80 = (ulong)param_3;
local_88 = param_2;
local_48 = param_4;
local_44 = param_3;
local_40 = param_2;
local_38 = param_1;
cVar2 = translog_write_record
(local_50,0xc,plVar1[1],plVar1,((int)local_58 - (int)local_28) + param_3,4,
local_b8,local_28,0);
local_29 = cVar2 != '\0';
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),local_29);
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
63,612
|
translog_set_file_size
|
eloqsql/storage/maria/ma_loghandler.c
|
void translog_set_file_size(uint32 size)
{
struct st_translog_buffer *old_buffer= NULL;
DBUG_ENTER("translog_set_file_size");
translog_lock();
DBUG_PRINT("enter", ("Size: %lu", (ulong) size));
DBUG_ASSERT(size % TRANSLOG_PAGE_SIZE == 0);
DBUG_ASSERT(size >= TRANSLOG_MIN_FILE_SIZE);
log_descriptor.log_file_max_size= size;
/* if current file longer then finish it*/
if (LSN_OFFSET(log_descriptor.horizon) >= log_descriptor.log_file_max_size)
{
old_buffer= log_descriptor.bc.buffer;
translog_buffer_next(&log_descriptor.horizon, &log_descriptor.bc, 1);
translog_buffer_unlock(old_buffer);
}
translog_unlock();
if (old_buffer)
{
translog_buffer_lock(old_buffer);
translog_buffer_flush(old_buffer);
translog_buffer_unlock(old_buffer);
}
DBUG_VOID_RETURN;
}
|
O0
|
c
|
translog_set_file_size:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq $0x0, -0x10(%rbp)
callq 0x4faa0
jmp 0x576ca
jmp 0x576cc
jmp 0x576ce
jmp 0x576d0
jmp 0x576d2
movl -0x4(%rbp), %eax
movl %eax, 0x420cf5(%rip) # 0x4783d0
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq 0xc2191c(%rip), %rax # 0xc79008
movl 0x420cde(%rip), %ecx # 0x4783d0
cmpq %rcx, %rax
jb 0x5772d
movq 0xc2193a(%rip), %rax # 0xc79038
movq %rax, -0x10(%rbp)
leaq 0x420cb7(%rip), %rsi # 0x4783c0
movq %rsi, %rdi
addq $0x800c48, %rdi # imm = 0x800C48
addq $0x800c50, %rsi # imm = 0x800C50
movl $0x1, %edx
callq 0x57760
movq -0x10(%rbp), %rdi
callq 0x4fb60
callq 0x4fb90
cmpq $0x0, -0x10(%rbp)
je 0x57754
movq -0x10(%rbp), %rdi
callq 0x4fb20
movq -0x10(%rbp), %rdi
callq 0x55d50
movq -0x10(%rbp), %rdi
callq 0x4fb60
jmp 0x57756
jmp 0x57758
addq $0x10, %rsp
popq %rbp
retq
nop
|
translog_set_file_size:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_4], edi
mov [rbp+var_10], 0
call translog_lock
jmp short $+2
loc_576CA:
jmp short $+2
loc_576CC:
jmp short $+2
loc_576CE:
jmp short $+2
loc_576D0:
jmp short $+2
loc_576D2:
mov eax, [rbp+var_4]
mov cs:dword_4783D0, eax
mov rax, 0FFFFFFFFh
and rax, cs:qword_C79008
mov ecx, cs:dword_4783D0
cmp rax, rcx
jb short loc_5772D
mov rax, cs:qword_C79038
mov [rbp+var_10], rax
lea rsi, log_descriptor
mov rdi, rsi
add rdi, 800C48h
add rsi, 800C50h
mov edx, 1
call translog_buffer_next
mov rdi, [rbp+var_10]
call translog_buffer_unlock
loc_5772D:
call translog_unlock
cmp [rbp+var_10], 0
jz short loc_57754
mov rdi, [rbp+var_10]
call translog_buffer_lock
mov rdi, [rbp+var_10]
call translog_buffer_flush
mov rdi, [rbp+var_10]
call translog_buffer_unlock
loc_57754:
jmp short $+2
loc_57756:
jmp short $+2
loc_57758:
add rsp, 10h
pop rbp
retn
|
long long translog_set_file_size(unsigned int a1)
{
long long result; // rax
long long v2; // [rsp+0h] [rbp-10h]
v2 = 0LL;
translog_lock();
dword_4783D0 = a1;
if ( (unsigned int)qword_C79008 >= (unsigned long long)a1 )
{
v2 = qword_C79038;
translog_buffer_next(&log_descriptor[1048969], &log_descriptor[1048970], 1LL);
translog_buffer_unlock(v2);
}
result = translog_unlock();
if ( v2 )
{
translog_buffer_lock(v2);
translog_buffer_flush(v2);
return translog_buffer_unlock(v2);
}
return result;
}
|
translog_set_file_size:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],0x0
CALL 0x0014faa0
JMP 0x001576ca
LAB_001576ca:
JMP 0x001576cc
LAB_001576cc:
JMP 0x001576ce
LAB_001576ce:
JMP 0x001576d0
LAB_001576d0:
JMP 0x001576d2
LAB_001576d2:
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [0x005783d0],EAX
MOV RAX,0xffffffff
AND RAX,qword ptr [0x00d79008]
MOV ECX,dword ptr [0x005783d0]
CMP RAX,RCX
JC 0x0015772d
MOV RAX,qword ptr [0x00d79038]
MOV qword ptr [RBP + -0x10],RAX
LEA RSI,[0x5783c0]
MOV RDI,RSI
ADD RDI,0x800c48
ADD RSI,0x800c50
MOV EDX,0x1
CALL 0x00157760
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0014fb60
LAB_0015772d:
CALL 0x0014fb90
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00157754
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0014fb20
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00155d50
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0014fb60
LAB_00157754:
JMP 0x00157756
LAB_00157756:
JMP 0x00157758
LAB_00157758:
ADD RSP,0x10
POP RBP
RET
|
void translog_set_file_size(uint param_1)
{
long lVar1;
long local_18;
local_18 = 0;
translog_lock();
lVar1 = DAT_00d79038;
DAT_005783d0 = param_1;
if ((ulong)param_1 <= (DAT_00d79008 & 0xffffffff)) {
local_18 = DAT_00d79038;
translog_buffer_next(&DAT_00d79008,&DAT_00d79010,1);
translog_buffer_unlock(lVar1);
}
translog_unlock();
if (local_18 != 0) {
translog_buffer_lock(local_18);
translog_buffer_flush(local_18);
translog_buffer_unlock(local_18);
}
return;
}
|
|
63,613
|
inflateReset
|
3fs/build_O3/src/apache-arrow-cpp/cpp/zlib_ep-prefix/src/zlib_ep/inflate.c
|
int ZEXPORT inflateReset(strm)
z_streamp strm;
{
struct inflate_state FAR *state;
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
state->wsize = 0;
state->whave = 0;
state->wnext = 0;
return inflateResetKeep(strm);
}
|
O3
|
c
|
inflateReset:
pushq %rbx
movq %rdi, %rbx
callq 0x8c49
testl %eax, %eax
je 0x8c95
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
popq %rbx
retq
movq 0x38(%rbx), %rax
movq $0x0, 0x3c(%rax)
movl $0x0, 0x44(%rax)
movq %rbx, %rdi
popq %rbx
jmp 0x30f0
|
inflateReset:
push rbx
mov rbx, rdi
call inflateStateCheck
test eax, eax
jz short loc_8C95
mov eax, 0FFFFFFFEh
pop rbx
retn
loc_8C95:
mov rax, [rbx+38h]
mov qword ptr [rax+3Ch], 0
mov dword ptr [rax+44h], 0
mov rdi, rbx
pop rbx
jmp _inflateResetKeep
|
long long inflateReset(_QWORD *a1)
{
long long v2; // rax
if ( inflateStateCheck(a1) )
return 4294967294LL;
v2 = a1[7];
*(_QWORD *)(v2 + 60) = 0LL;
*(_DWORD *)(v2 + 68) = 0;
return inflateResetKeep((long long)a1);
}
|
inflateReset:
PUSH RBX
MOV RBX,RDI
CALL 0x00108c49
TEST EAX,EAX
JZ 0x00108c95
MOV EAX,0xfffffffe
POP RBX
RET
LAB_00108c95:
MOV RAX,qword ptr [RBX + 0x38]
MOV qword ptr [RAX + 0x3c],0x0
MOV dword ptr [RAX + 0x44],0x0
MOV RDI,RBX
POP RBX
JMP 0x001030f0
|
int8 inflateReset(long param_1)
{
long lVar1;
int iVar2;
int8 uVar3;
iVar2 = inflateStateCheck();
if (iVar2 != 0) {
return 0xfffffffe;
}
lVar1 = *(long *)(param_1 + 0x38);
*(int8 *)(lVar1 + 0x3c) = 0;
*(int4 *)(lVar1 + 0x44) = 0;
uVar3 = inflateResetKeep(param_1);
return uVar3;
}
|
|
63,614
|
post_line_by_Px2
|
corpus-core[P]colibri-stateless/build_O3/_deps/blst-src/src/pairing.c
|
static void post_line_by_Px2(vec384fp6 out, const vec384fp6 in,
const POINTonE1_affine *Px2)
{
vec_copy(out[0], in[0], sizeof(out[0]));
mul_fp(out[1][0], in[1][0], Px2->X); /* "b01" *= -2*P->X */
mul_fp(out[1][1], in[1][1], Px2->X);
mul_fp(out[2][0], in[2][0], Px2->Y); /* "b11" *= 2*P->Y */
mul_fp(out[2][1], in[2][1], Px2->Y);
}
|
O3
|
c
|
post_line_by_Px2:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0xc, %ecx
rep movsq (%rsi), %es:(%rdi)
leaq 0x60(%r15), %rdi
leaq 0x60(%r14), %rsi
leaq 0x174be(%rip), %r12 # 0x3fb10
movabsq $-0x760c000300030003, %r13 # imm = 0x89F3FFFCFFFCFFFD
movq %r12, %rcx
movq %r13, %r8
callq 0x344a0
movl $0x90, %esi
leaq (%r15,%rsi), %rdi
addq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
movq %r13, %r8
callq 0x344a0
movl $0xc0, %esi
leaq (%r15,%rsi), %rdi
addq %r14, %rsi
addq $0x30, %rbx
movq %rbx, %rdx
movq %r12, %rcx
movq %r13, %r8
callq 0x344a0
movl $0xf0, %eax
addq %rax, %r15
addq %rax, %r14
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
movq %r13, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x344a0
|
post_line_by_Px2:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov ecx, 0Ch
rep movsq
lea rdi, [r15+60h]
lea rsi, [r14+60h]
lea r12, BLS12_381_P
mov r13, 89F3FFFCFFFCFFFDh
mov rcx, r12
mov r8, r13
call mul_mont_384
mov esi, 90h
lea rdi, [r15+rsi]
add rsi, r14
mov rdx, rbx
mov rcx, r12
mov r8, r13
call mul_mont_384
mov esi, 0C0h
lea rdi, [r15+rsi]
add rsi, r14
add rbx, 30h ; '0'
mov rdx, rbx
mov rcx, r12
mov r8, r13
call mul_mont_384
mov eax, 0F0h
add r15, rax
add r14, rax
mov rdi, r15
mov rsi, r14
mov rdx, rbx
mov rcx, r12
mov r8, r13
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp mul_mont_384
|
long long post_line_by_Px2(char *a1, char *a2, long long a3)
{
long long v3; // rbx
v3 = a3;
qmemcpy(a1, a2, 0x60uLL);
mul_mont_384(a1 + 96, a2 + 96, a3, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
mul_mont_384(a1 + 144, a2 + 144, v3, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
v3 += 48LL;
mul_mont_384(a1 + 192, a2 + 192, v3, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
return mul_mont_384(a1 + 240, a2 + 240, v3, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
}
|
post_line_by_Px2:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV ECX,0xc
MOVSQ.REP RDI,RSI
LEA RDI,[R15 + 0x60]
LEA RSI,[R14 + 0x60]
LEA R12,[0x13fb10]
MOV R13,-0x760c000300030003
MOV RCX,R12
MOV R8,R13
CALL 0x001344a0
MOV ESI,0x90
LEA RDI,[R15 + RSI*0x1]
ADD RSI,R14
MOV RDX,RBX
MOV RCX,R12
MOV R8,R13
CALL 0x001344a0
MOV ESI,0xc0
LEA RDI,[R15 + RSI*0x1]
ADD RSI,R14
ADD RBX,0x30
MOV RDX,RBX
MOV RCX,R12
MOV R8,R13
CALL 0x001344a0
MOV EAX,0xf0
ADD R15,RAX
ADD R14,RAX
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
MOV RCX,R12
MOV R8,R13
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001344a0
|
void post_line_by_Px2(int8 *param_1,int8 *param_2,long param_3)
{
long lVar1;
int8 *puVar2;
int8 *puVar3;
puVar2 = param_2;
puVar3 = param_1;
for (lVar1 = 0xc; lVar1 != 0; lVar1 = lVar1 + -1) {
*puVar3 = *puVar2;
puVar2 = puVar2 + 1;
puVar3 = puVar3 + 1;
}
mul_mont_384(param_1 + 0xc,param_2 + 0xc,param_3,BLS12_381_P,0x89f3fffcfffcfffd);
mul_mont_384(param_1 + 0x12,param_2 + 0x12,param_3,BLS12_381_P,0x89f3fffcfffcfffd);
mul_mont_384(param_1 + 0x18,param_2 + 0x18,param_3 + 0x30,BLS12_381_P,0x89f3fffcfffcfffd);
mul_mont_384(param_1 + 0x1e,param_2 + 0x1e,param_3 + 0x30,BLS12_381_P,0x89f3fffcfffcfffd);
return;
}
|
|
63,615
|
my_numcells_eucjpms
|
eloqsql/strings/ctype-eucjpms.c
|
static
size_t my_numcells_eucjpms(CHARSET_INFO *cs __attribute__((unused)),
const char *str, const char *str_end)
{
size_t clen;
const uchar *b= (const uchar *) str;
const uchar *e= (const uchar *) str_end;
for (clen= 0; b < e; )
{
if (*b == 0x8E)
{
clen++;
b+= 2;
}
else if (*b == 0x8F)
{
clen+= 2;
b+= 3;
}
else if (*b & 0x80)
{
clen+= 2;
b+= 2;
}
else
{
clen++;
b++;
}
}
return clen;
}
|
O3
|
c
|
my_numcells_eucjpms:
cmpq %rdx, %rsi
jae 0x327b9
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movzbl (%rsi), %edi
cmpl $0x8e, %edi
je 0x32792
cmpl $0x8f, %edi
jne 0x3279e
movl $0x3, %edi
movl $0x2, %ecx
jmp 0x327ac
movl $0x2, %edi
movl $0x1, %ecx
jmp 0x327ac
xorl %ecx, %ecx
testb %dil, %dil
sets %cl
incq %rcx
movq %rcx, %rdi
addq %rcx, %rax
addq %rdi, %rsi
cmpq %rdx, %rsi
jb 0x32773
popq %rbp
retq
xorl %eax, %eax
retq
|
my_numcells_eucjpms:
cmp rsi, rdx
jnb short loc_327B9
push rbp
mov rbp, rsp
xor eax, eax
loc_32773:
movzx edi, byte ptr [rsi]
cmp edi, 8Eh
jz short loc_32792
cmp edi, 8Fh
jnz short loc_3279E
mov edi, 3
mov ecx, 2
jmp short loc_327AC
loc_32792:
mov edi, 2
mov ecx, 1
jmp short loc_327AC
loc_3279E:
xor ecx, ecx
test dil, dil
sets cl
inc rcx
mov rdi, rcx
loc_327AC:
add rax, rcx
add rsi, rdi
cmp rsi, rdx
jb short loc_32773
pop rbp
retn
loc_327B9:
xor eax, eax
retn
|
long long my_numcells_eucjpms(long long a1, unsigned __int8 *a2, unsigned long long a3)
{
long long result; // rax
int v4; // edi
long long v5; // rdi
long long v6; // rcx
if ( (unsigned long long)a2 >= a3 )
return 0LL;
result = 0LL;
do
{
v4 = *a2;
if ( v4 == 142 )
{
v5 = 2LL;
v6 = 1LL;
}
else if ( v4 == 143 )
{
v5 = 3LL;
v6 = 2LL;
}
else
{
v6 = ((v4 & 0x80u) != 0) + 1LL;
v5 = v6;
}
result += v6;
a2 += v5;
}
while ( (unsigned long long)a2 < a3 );
return result;
}
|
my_numcells_eucjpms:
CMP RSI,RDX
JNC 0x001327b9
PUSH RBP
MOV RBP,RSP
XOR EAX,EAX
LAB_00132773:
MOVZX EDI,byte ptr [RSI]
CMP EDI,0x8e
JZ 0x00132792
CMP EDI,0x8f
JNZ 0x0013279e
MOV EDI,0x3
MOV ECX,0x2
JMP 0x001327ac
LAB_00132792:
MOV EDI,0x2
MOV ECX,0x1
JMP 0x001327ac
LAB_0013279e:
XOR ECX,ECX
TEST DIL,DIL
SETS CL
INC RCX
MOV RDI,RCX
LAB_001327ac:
ADD RAX,RCX
ADD RSI,RDI
CMP RSI,RDX
JC 0x00132773
POP RBP
RET
LAB_001327b9:
XOR EAX,EAX
RET
|
long my_numcells_eucjpms(int8 param_1,char *param_2,char *param_3)
{
char cVar1;
long lVar2;
long lVar3;
long lVar4;
if (param_2 < param_3) {
lVar2 = 0;
do {
cVar1 = *param_2;
if (cVar1 == -0x72) {
lVar4 = 2;
lVar3 = 1;
}
else if (cVar1 == -0x71) {
lVar3 = 2;
lVar4 = 3;
}
else {
lVar3 = (ulong)(cVar1 < '\0') + 1;
lVar4 = lVar3;
}
lVar2 = lVar2 + lVar3;
param_2 = param_2 + lVar4;
} while (param_2 < param_3);
return lVar2;
}
return 0;
}
|
|
63,616
|
minja::Parser::parseStringConcat()
|
monkey531[P]llama/common/minja.hpp
|
std::shared_ptr<Expression> parseStringConcat() {
auto left = parseMathPow();
if (!left) throw std::runtime_error("Expected left side of 'string concat' expression");
static std::regex concat_tok(R"(~(?!\}))");
if (!consumeToken(concat_tok).empty()) {
auto right = parseLogicalAnd();
if (!right) throw std::runtime_error("Expected right side of 'string concat' expression");
left = std::make_shared<BinaryOpExpr>(get_location(), std::move(left), std::move(right), BinaryOpExpr::Op::StrConcat);
}
return left;
}
|
O3
|
cpp
|
minja::Parser::parseStringConcat():
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0xabb60
cmpq $0x0, (%rbx)
je 0xaba30
leaq 0xabbff(%rip), %rax # 0x157510
movb (%rax), %al
testb %al, %al
je 0xaba67
leaq 0xabbce(%rip), %rdx # 0x1574f0
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movl $0x1, %ecx
callq 0xa7b1a
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
movq -0x8(%rax), %r15
cmpq %rax, %rdi
je 0xab953
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1dc50
testq %r15, %r15
je 0xaba23
movq %rsp, %rdi
movq %r14, %rsi
callq 0xa90e6
cmpq $0x0, (%rsp)
je 0xababe
movq (%r14), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%r14), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0xab99d
movq 0xaa5f1(%rip), %rcx # 0x155f80
cmpb $0x0, (%rcx)
je 0xab999
incl 0x8(%rax)
jmp 0xab99d
lock
incl 0x8(%rax)
movq 0x20(%r14), %rax
subq 0x10(%r14), %rax
movq %rax, 0x20(%rsp)
movl $0x58, %edi
callq 0x1dc20
movq %rax, %r14
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x8(%r14)
leaq 0xa8f9c(%rip), %rax # 0x154968
addq $0x10, %rax
movq %rax, (%r14)
movq %r14, %r15
addq $0x10, %r15
leaq 0x10(%rsp), %rsi
movq %rsp, %rcx
movq %r15, %rdi
movq %rbx, %rdx
xorl %r8d, %r8d
callq 0xb9a58
movq %r15, (%rbx)
movq 0x8(%rbx), %rdi
movq %r14, 0x8(%rbx)
testq %rdi, %rdi
je 0xaba05
callq 0x516f8
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xaba14
callq 0x516f8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xaba23
callq 0x516f8
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x1d5b0
movq %rax, %r15
leaq 0x699a6(%rip), %rsi # 0x1153ea
movq %rax, %rdi
callq 0x1d410
movq 0xaa595(%rip), %rsi # 0x155fe8
movq 0xaa4fe(%rip), %rdx # 0x155f58
movq %r15, %rdi
callq 0x1e5b0
jmp 0xabaf0
leaq 0xabaa2(%rip), %rdi # 0x157510
callq 0x1e6f0
testl %eax, %eax
je 0xab91b
leaq 0xaba6e(%rip), %rdi # 0x1574f0
leaq 0x69992(%rip), %rsi # 0x11541b
movl $0x10, %edx
callq 0x934aa
leaq -0x66de4(%rip), %rdi # 0x44cb6
leaq 0xaba4f(%rip), %rsi # 0x1574f0
leaq 0xab200(%rip), %rdx # 0x156ca8
callq 0x1da80
leaq 0xaba5c(%rip), %rdi # 0x157510
callq 0x1d7c0
jmp 0xab91b
movl $0x10, %edi
callq 0x1d5b0
movq %rax, %r15
leaq 0x69951(%rip), %rsi # 0x115423
movq %rax, %rdi
callq 0x1d410
movq 0xaa507(%rip), %rsi # 0x155fe8
movq 0xaa470(%rip), %rdx # 0x155f58
movq %r15, %rdi
callq 0x1e5b0
movq %rax, %r14
leaq 0xaba16(%rip), %rdi # 0x157510
callq 0x1d7a0
jmp 0xabb4a
movq %rax, %r14
jmp 0xabb34
movq %rax, %r14
movq %r15, %rdi
callq 0x1d8c0
jmp 0xabb34
jmp 0xabb47
movq %rax, %r14
movq %r15, %rdi
callq 0x1d8c0
jmp 0xabb4a
movq %rax, %r14
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xabb34
callq 0x516f8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xabb4a
callq 0x516f8
jmp 0xabb4a
jmp 0xabb47
movq %rax, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xabb58
callq 0x516f8
movq %r14, %rdi
callq 0x1e660
|
_ZN5minja6Parser17parseStringConcatEv:
push r15
push r14
push rbx
sub rsp, 30h
mov r14, rsi
mov rbx, rdi
call _ZN5minja6Parser12parseMathPowEv; minja::Parser::parseMathPow(void)
cmp qword ptr [rbx], 0
jz loc_ABA30
lea rax, _ZGVZN5minja6Parser17parseStringConcatEvE10concat_tokB5cxx11; `guard variable for'minja::Parser::parseStringConcat(void)::concat_tok
mov al, [rax]
test al, al
jz loc_ABA67
loc_AB91B:
lea rdx, _ZZN5minja6Parser17parseStringConcatEvE10concat_tokB5cxx11; minja::Parser::parseStringConcat(void)::concat_tok
lea rdi, [rsp+48h+var_38]
mov rsi, r14
mov ecx, 1
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::basic_regex<char,std::regex_traits<char>> const&,minja::SpaceHandling)
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
mov r15, [rax-8]
cmp rdi, rax
jz short loc_AB953
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_AB953:
test r15, r15
jz loc_ABA23
mov rdi, rsp; this
mov rsi, r14
call _ZN5minja6Parser15parseLogicalAndEv; minja::Parser::parseLogicalAnd(void)
cmp [rsp+48h+var_48], 0
jz loc_ABABE
mov rax, [r14]
mov [rsp+48h+var_38], rax
mov rax, [r14+8]
mov [rsp+48h+var_30], rax
test rax, rax
jz short loc_AB99D
mov rcx, cs:__libc_single_threaded_ptr
cmp byte ptr [rcx], 0
jz short loc_AB999
inc dword ptr [rax+8]
jmp short loc_AB99D
loc_AB999:
lock inc dword ptr [rax+8]
loc_AB99D:
mov rax, [r14+20h]
sub rax, [r14+10h]
mov [rsp+48h+var_28], rax
mov edi, 58h ; 'X'; unsigned __int64
call __Znwm; operator new(ulong)
mov r14, rax
mov rax, 100000001h
mov [r14+8], rax
lea rax, _ZTVSt23_Sp_counted_ptr_inplaceIN5minja12BinaryOpExprESaIS1_ELN9__gnu_cxx12_Lock_policyE2EE; `vtable for'std::_Sp_counted_ptr_inplace<minja::BinaryOpExpr,std::allocator<minja::BinaryOpExpr>,(__gnu_cxx::_Lock_policy)2>
add rax, 10h
mov [r14], rax
mov r15, r14
add r15, 10h
lea rsi, [rsp+48h+var_38]
mov rcx, rsp
mov rdi, r15
mov rdx, rbx
xor r8d, r8d
call _ZN5minja12BinaryOpExprC2ERKNS_8LocationEOSt10shared_ptrINS_10ExpressionEES7_NS0_2OpE; minja::BinaryOpExpr::BinaryOpExpr(minja::Location const&,std::shared_ptr<minja::Expression> &&,std::shared_ptr<minja::Expression> &,minja::BinaryOpExpr::Op)
mov [rbx], r15
mov rdi, [rbx+8]
mov [rbx+8], r14
test rdi, rdi
jz short loc_ABA05
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_ABA05:
mov rdi, [rsp+48h+var_30]
test rdi, rdi
jz short loc_ABA14
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_ABA14:
mov rdi, [rsp+48h+var_40]
test rdi, rdi
jz short loc_ABA23
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_ABA23:
mov rax, rbx
add rsp, 30h
pop rbx
pop r14
pop r15
retn
loc_ABA30:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rsi, aExpectedLeftSi_2; "Expected left side of 'string concat' e"...
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
jmp loc_ABAF0
loc_ABA67:
lea rdi, _ZGVZN5minja6Parser17parseStringConcatEvE10concat_tokB5cxx11; __guard *
call ___cxa_guard_acquire
test eax, eax
jz loc_AB91B
lea rdi, _ZZN5minja6Parser17parseStringConcatEvE10concat_tokB5cxx11; minja::Parser::parseStringConcat(void)::concat_tok
lea rsi, asc_11541B; "~(?!\\})"
mov edx, 10h
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2EPKcNSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex(char const*,std::regex_constants::syntax_option_type)
lea rdi, _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; lpfunc
lea rsi, _ZZN5minja6Parser17parseStringConcatEvE10concat_tokB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZN5minja6Parser17parseStringConcatEvE10concat_tokB5cxx11; __guard *
call ___cxa_guard_release
jmp loc_AB91B
loc_ABABE:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rsi, aExpectedRightS_2; "Expected right side of 'string concat' "...
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
loc_ABAF0:
mov r14, rax
lea rdi, _ZGVZN5minja6Parser17parseStringConcatEvE10concat_tokB5cxx11; __guard *
call ___cxa_guard_abort
jmp short loc_ABB4A
mov r14, rax
jmp short loc_ABB34
mov r14, rax
mov rdi, r15; void *
call ___cxa_free_exception
jmp short loc_ABB34
jmp short loc_ABB47
mov r14, rax
mov rdi, r15; void *
call ___cxa_free_exception
jmp short loc_ABB4A
mov r14, rax
mov rdi, [rsp+48h+var_30]
test rdi, rdi
jz short loc_ABB34
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_ABB34:
mov rdi, [rsp+48h+var_40]
test rdi, rdi
jz short loc_ABB4A
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
jmp short loc_ABB4A
jmp short $+2
loc_ABB47:
mov r14, rax
loc_ABB4A:
mov rdi, [rbx+8]
test rdi, rdi
jz short loc_ABB58
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_ABB58:
mov rdi, r14
call __Unwind_Resume
|
minja::Parser * minja::Parser::parseStringConcat(volatile signed __int32 **this, long long *a2)
{
volatile signed __int32 *v3; // r15
volatile signed __int32 *v4; // rax
volatile signed __int32 *v5; // r14
volatile signed __int32 *v6; // rdi
std::runtime_error *exception; // r15
std::runtime_error *v9; // r15
volatile signed __int32 *v10; // [rsp+0h] [rbp-48h] BYREF
volatile signed __int32 *v11; // [rsp+8h] [rbp-40h]
long long *v12; // [rsp+10h] [rbp-38h] BYREF
volatile signed __int32 *v13; // [rsp+18h] [rbp-30h]
long long v14; // [rsp+20h] [rbp-28h] BYREF
minja::Parser::parseMathPow((minja::Parser *)this);
if ( !*this )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Expected left side of 'string concat' expression");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( !(_BYTE)`guard variable for'minja::Parser::parseStringConcat(void)::concat_tok[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'minja::Parser::parseStringConcat(void)::concat_tok[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&minja::Parser::parseStringConcat(void)::concat_tok[abi:cxx11],
(long long)"~(?!\\})",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&minja::Parser::parseStringConcat(void)::concat_tok[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'minja::Parser::parseStringConcat(void)::concat_tok[abi:cxx11]);
}
minja::Parser::consumeToken(
(long long)&v12,
(long long)a2,
(long long)&minja::Parser::parseStringConcat(void)::concat_tok[abi:cxx11],
1u);
v3 = v13;
if ( v12 != &v14 )
operator delete(v12, v14 + 1);
if ( v3 )
{
minja::Parser::parseLogicalAnd(&v10, a2);
if ( !v10 )
{
v9 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v9, "Expected right side of 'string concat' expression");
__cxa_throw(
v9,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v12 = (long long *)*a2;
v4 = (volatile signed __int32 *)a2[1];
v13 = v4;
if ( v4 )
{
if ( _libc_single_threaded )
++*((_DWORD *)v4 + 2);
else
_InterlockedIncrement(v4 + 2);
}
v14 = a2[4] - a2[2];
v5 = (volatile signed __int32 *)operator new(0x58uLL);
*((_QWORD *)v5 + 1) = 0x100000001LL;
*(_QWORD *)v5 = &`vtable for'std::_Sp_counted_ptr_inplace<minja::BinaryOpExpr,std::allocator<minja::BinaryOpExpr>,(__gnu_cxx::_Lock_policy)2>
+ 2;
minja::BinaryOpExpr::BinaryOpExpr(v5 + 4, &v12, this, &v10, 0LL);
*this = v5 + 4;
v6 = this[1];
this[1] = v5;
if ( v6 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v6);
if ( v13 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v13);
if ( v11 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v11);
}
return (minja::Parser *)this;
}
|
parseStringConcat:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RSI
MOV RBX,RDI
CALL 0x001abb60
CMP qword ptr [RBX],0x0
JZ 0x001aba30
LEA RAX,[0x257510]
MOV AL,byte ptr [RAX]
TEST AL,AL
JZ 0x001aba67
LAB_001ab91b:
LEA RDX,[0x2574f0]
LEA RDI,[RSP + 0x10]
MOV RSI,R14
MOV ECX,0x1
CALL 0x001a7b1a
LEA RAX,[RSP + 0x20]
MOV RDI,qword ptr [RAX + -0x10]
MOV R15,qword ptr [RAX + -0x8]
CMP RDI,RAX
JZ 0x001ab953
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
CALL 0x0011dc50
LAB_001ab953:
TEST R15,R15
JZ 0x001aba23
LAB_001ab95c:
MOV RDI,RSP
MOV RSI,R14
CALL 0x001a90e6
CMP qword ptr [RSP],0x0
JZ 0x001ababe
MOV RAX,qword ptr [R14]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [R14 + 0x8]
MOV qword ptr [RSP + 0x18],RAX
TEST RAX,RAX
JZ 0x001ab99d
MOV RCX,qword ptr [0x00255f80]
CMP byte ptr [RCX],0x0
JZ 0x001ab999
INC dword ptr [RAX + 0x8]
JMP 0x001ab99d
LAB_001ab999:
INC.LOCK dword ptr [RAX + 0x8]
LAB_001ab99d:
MOV RAX,qword ptr [R14 + 0x20]
SUB RAX,qword ptr [R14 + 0x10]
MOV qword ptr [RSP + 0x20],RAX
LAB_001ab9aa:
MOV EDI,0x58
CALL 0x0011dc20
LAB_001ab9b4:
MOV R14,RAX
MOV RAX,0x100000001
MOV qword ptr [R14 + 0x8],RAX
LEA RAX,[0x254968]
ADD RAX,0x10
MOV qword ptr [R14],RAX
MOV R15,R14
ADD R15,0x10
LEA RSI,[RSP + 0x10]
MOV RCX,RSP
MOV RDI,R15
MOV RDX,RBX
XOR R8D,R8D
CALL 0x001b9a58
MOV qword ptr [RBX],R15
MOV RDI,qword ptr [RBX + 0x8]
MOV qword ptr [RBX + 0x8],R14
TEST RDI,RDI
JZ 0x001aba05
CALL 0x001516f8
LAB_001aba05:
MOV RDI,qword ptr [RSP + 0x18]
TEST RDI,RDI
JZ 0x001aba14
CALL 0x001516f8
LAB_001aba14:
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x001aba23
CALL 0x001516f8
LAB_001aba23:
MOV RAX,RBX
ADD RSP,0x30
POP RBX
POP R14
POP R15
RET
LAB_001aba30:
MOV EDI,0x10
CALL 0x0011d5b0
MOV R15,RAX
LAB_001aba3d:
LEA RSI,[0x2153ea]
MOV RDI,RAX
CALL 0x0011d410
LAB_001aba4c:
MOV RSI,qword ptr [0x00255fe8]
MOV RDX,qword ptr [0x00255f58]
MOV RDI,R15
CALL 0x0011e5b0
LAB_001aba67:
LEA RDI,[0x257510]
CALL 0x0011e6f0
TEST EAX,EAX
JZ 0x001ab91b
LAB_001aba7b:
LEA RDI,[0x2574f0]
LEA RSI,[0x21541b]
MOV EDX,0x10
CALL 0x001934aa
LAB_001aba93:
LEA RDI,[0x144cb6]
LEA RSI,[0x2574f0]
LEA RDX,[0x256ca8]
CALL 0x0011da80
LEA RDI,[0x257510]
CALL 0x0011d7c0
JMP 0x001ab91b
LAB_001ababe:
MOV EDI,0x10
CALL 0x0011d5b0
MOV R15,RAX
LAB_001abacb:
LEA RSI,[0x215423]
MOV RDI,RAX
CALL 0x0011d410
LAB_001abada:
MOV RSI,qword ptr [0x00255fe8]
MOV RDX,qword ptr [0x00255f58]
MOV RDI,R15
CALL 0x0011e5b0
|
/* minja::Parser::parseStringConcat() */
void minja::Parser::parseStringConcat(void)
{
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *this;
int iVar1;
int8 *puVar2;
runtime_error *prVar3;
int8 *in_RSI;
long *in_RDI;
long local_48;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_40;
long *local_38;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_30;
long local_28 [2];
parseMathPow();
if (*in_RDI == 0) {
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001aba3d to 001aba4b has its CatchHandler @ 001abb15 */
std::runtime_error::runtime_error(prVar3,"Expected left side of \'string concat\' expression");
/* try { // try from 001aba4c to 001aba61 has its CatchHandler @ 001abb13 */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_00255fe8,PTR__runtime_error_00255f58);
}
if (parseStringConcat()::concat_tok_abi_cxx11_ == '\0') {
iVar1 = __cxa_guard_acquire(&parseStringConcat()::concat_tok_abi_cxx11_);
if (iVar1 != 0) {
/* try { // try from 001aba7b to 001aba92 has its CatchHandler @ 001abaf0 */
std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::basic_regex
((basic_regex<char,std::__cxx11::regex_traits<char>> *)
parseStringConcat()::concat_tok_abi_cxx11_,"~(?!\\})",0x10);
__cxa_atexit(std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::~basic_regex,
parseStringConcat()::concat_tok_abi_cxx11_,&__dso_handle);
__cxa_guard_release(&parseStringConcat()::concat_tok_abi_cxx11_);
}
}
/* try { // try from 001ab91b to 001ab933 has its CatchHandler @ 001abb47 */
consumeToken(&local_38);
if (local_38 != local_28) {
operator_delete(local_38,local_28[0] + 1);
}
if (local_30 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
/* try { // try from 001ab95c to 001ab966 has its CatchHandler @ 001abb45 */
parseLogicalAnd();
if (local_48 == 0) {
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001abacb to 001abad9 has its CatchHandler @ 001abb06 */
std::runtime_error::runtime_error
(prVar3,"Expected right side of \'string concat\' expression");
/* try { // try from 001abada to 001abaef has its CatchHandler @ 001abb01 */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_00255fe8,PTR__runtime_error_00255f58);
}
local_38 = (long *)*in_RSI;
local_30 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)in_RSI[1];
if (local_30 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
if (*PTR___libc_single_threaded_00255f80 == '\0') {
LOCK();
*(int *)(local_30 + 8) = *(int *)(local_30 + 8) + 1;
UNLOCK();
}
else {
*(int *)(local_30 + 8) = *(int *)(local_30 + 8) + 1;
}
}
local_28[0] = in_RSI[4] - in_RSI[2];
/* try { // try from 001ab9aa to 001ab9b3 has its CatchHandler @ 001abb22 */
puVar2 = (int8 *)operator_new(0x58);
puVar2[1] = 0x100000001;
*puVar2 = &PTR___Sp_counted_ptr_inplace_00254978;
BinaryOpExpr::BinaryOpExpr((BinaryOpExpr *)(puVar2 + 2),&local_38);
*in_RDI = (long)(puVar2 + 2);
this = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)in_RDI[1];
in_RDI[1] = (long)puVar2;
if (this != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(this);
}
if (local_30 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_30);
}
if (local_40 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_40);
}
}
return;
}
|
|
63,617
|
my_numcells_eucjp
|
eloqsql/strings/ctype-ujis.c
|
static
size_t my_numcells_eucjp(CHARSET_INFO *cs __attribute__((unused)),
const char *str, const char *str_end)
{
size_t clen;
const uchar *b= (const uchar *) str;
const uchar *e= (const uchar *) str_end;
for (clen= 0; b < e; )
{
if (*b == 0x8E)
{
clen++;
b+= 2;
}
else if (*b == 0x8F)
{
clen+= 2;
b+= 3;
}
else if (*b & 0x80)
{
clen+= 2;
b+= 2;
}
else
{
clen++;
b++;
}
}
return clen;
}
|
O3
|
c
|
my_numcells_eucjp:
cmpq %rdx, %rsi
jae 0x4ce46
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movzbl (%rsi), %edi
cmpl $0x8e, %edi
je 0x4ce1f
cmpl $0x8f, %edi
jne 0x4ce2b
movl $0x3, %edi
movl $0x2, %ecx
jmp 0x4ce39
movl $0x2, %edi
movl $0x1, %ecx
jmp 0x4ce39
xorl %ecx, %ecx
testb %dil, %dil
sets %cl
incq %rcx
movq %rcx, %rdi
addq %rcx, %rax
addq %rdi, %rsi
cmpq %rdx, %rsi
jb 0x4ce00
popq %rbp
retq
xorl %eax, %eax
retq
|
my_numcells_eucjp:
cmp rsi, rdx
jnb short loc_4CE46
push rbp
mov rbp, rsp
xor eax, eax
loc_4CE00:
movzx edi, byte ptr [rsi]
cmp edi, 8Eh
jz short loc_4CE1F
cmp edi, 8Fh
jnz short loc_4CE2B
mov edi, 3
mov ecx, 2
jmp short loc_4CE39
loc_4CE1F:
mov edi, 2
mov ecx, 1
jmp short loc_4CE39
loc_4CE2B:
xor ecx, ecx
test dil, dil
sets cl
inc rcx
mov rdi, rcx
loc_4CE39:
add rax, rcx
add rsi, rdi
cmp rsi, rdx
jb short loc_4CE00
pop rbp
retn
loc_4CE46:
xor eax, eax
retn
|
long long my_numcells_eucjp(long long a1, unsigned __int8 *a2, unsigned long long a3)
{
long long result; // rax
int v4; // edi
long long v5; // rdi
long long v6; // rcx
if ( (unsigned long long)a2 >= a3 )
return 0LL;
result = 0LL;
do
{
v4 = *a2;
if ( v4 == 142 )
{
v5 = 2LL;
v6 = 1LL;
}
else if ( v4 == 143 )
{
v5 = 3LL;
v6 = 2LL;
}
else
{
v6 = ((v4 & 0x80u) != 0) + 1LL;
v5 = v6;
}
result += v6;
a2 += v5;
}
while ( (unsigned long long)a2 < a3 );
return result;
}
|
my_numcells_eucjp:
CMP RSI,RDX
JNC 0x0014ce46
PUSH RBP
MOV RBP,RSP
XOR EAX,EAX
LAB_0014ce00:
MOVZX EDI,byte ptr [RSI]
CMP EDI,0x8e
JZ 0x0014ce1f
CMP EDI,0x8f
JNZ 0x0014ce2b
MOV EDI,0x3
MOV ECX,0x2
JMP 0x0014ce39
LAB_0014ce1f:
MOV EDI,0x2
MOV ECX,0x1
JMP 0x0014ce39
LAB_0014ce2b:
XOR ECX,ECX
TEST DIL,DIL
SETS CL
INC RCX
MOV RDI,RCX
LAB_0014ce39:
ADD RAX,RCX
ADD RSI,RDI
CMP RSI,RDX
JC 0x0014ce00
POP RBP
RET
LAB_0014ce46:
XOR EAX,EAX
RET
|
long my_numcells_eucjp(int8 param_1,char *param_2,char *param_3)
{
char cVar1;
long lVar2;
long lVar3;
long lVar4;
if (param_2 < param_3) {
lVar2 = 0;
do {
cVar1 = *param_2;
if (cVar1 == -0x72) {
lVar4 = 2;
lVar3 = 1;
}
else if (cVar1 == -0x71) {
lVar3 = 2;
lVar4 = 3;
}
else {
lVar3 = (ulong)(cVar1 < '\0') + 1;
lVar4 = lVar3;
}
lVar2 = lVar2 + lVar3;
param_2 = param_2 + lVar4;
} while (param_2 < param_3);
return lVar2;
}
return 0;
}
|
|
63,618
|
nlohmann::json_abi_v3_12_0::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_12_0::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::push_back(nlohmann::json_abi_v3_12_0::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_12_0::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&&)
|
shubhamoy[P]dir2txt/include/nlohmann/json.hpp
|
void push_back(basic_json&& val)
{
// push_back only works for null objects or arrays
if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
{
JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
}
// transform null object into an array
if (is_null())
{
m_data.m_type = value_t::array;
m_data.m_value = value_t::array;
assert_invariant();
}
// add element to array (move semantics)
const auto old_capacity = m_data.m_value.array->capacity();
m_data.m_value.array->push_back(std::move(val));
set_parent(m_data.m_value.array->back(), old_capacity);
// if val is moved from, basic_json move constructor marks it null, so we do not call the destructor
}
|
O1
|
cpp
|
nlohmann::json_abi_v3_12_0::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_12_0::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::push_back(nlohmann::json_abi_v3_12_0::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_12_0::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
testl %eax, %eax
je 0x31e30
cmpl $0x2, %eax
je 0x31e5d
movl $0x20, %edi
callq 0x81d0
movq %rax, %rbx
movq %r14, %rdi
callq 0x2dd2a
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x6ba4(%rip), %rsi # 0x3899a
leaq 0x10(%rsp), %rdi
callq 0x2c5a4
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x134, %esi # imm = 0x134
movq %r14, %rcx
callq 0x31eac
xorl %ebp, %ebp
leaq 0x1bdff(%rip), %rsi # 0x4dc20
leaq -0x33c4(%rip), %rdx # 0x2ea64
movq %rbx, %rdi
callq 0x85c0
movb $0x2, (%r14)
movl $0x18, %edi
callq 0x8370
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x29abe
movq 0x8(%r14), %rdi
movq %rbx, %rsi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x29fe2
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x31e97
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x8380
jmp 0x31e97
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x31ea4
movq %rbx, %rdi
callq 0x82a0
movq %r14, %rdi
callq 0x85d0
|
_ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9push_backEOSD_:
push rbp; char
push r14; int
push rbx; __int64
sub rsp, 30h
mov rbx, rsi
mov r14, rdi
movzx eax, byte ptr [rdi]
test eax, eax
jz short loc_31E30
cmp eax, 2
jz loc_31E5D
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aCannotUsePushB; "cannot use push_back() with "
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_12_06detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA29_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_12_0::detail::concat<std::string,char const(&)[29],char const*>(char const(&)[29],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 134h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_12_06detail10type_error6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_12_06detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_12_06detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_31E30:
mov byte ptr [r14], 2
mov edi, 18h; unsigned __int64
call __Znwm; operator new(ulong)
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
mov qword ptr [rax+10h], 0
mov [r14+8], rax
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
loc_31E5D:
mov rdi, [r14+8]
mov rsi, rbx
add rsp, 30h
pop rbx
pop r14
pop rbp
jmp _ZNSt6vectorIN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void> &&)
mov r14, rax
lea rax, [rsp+arg_18]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_31E97
mov rsi, [rsp+arg_18]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_31E97
mov r14, rax
mov bpl, 1
loc_31E97:
test bpl, bpl
jz short loc_31EA4
mov rdi, rbx; void *
call ___cxa_free_exception
loc_31EA4:
mov rdi, r14
call __Unwind_Resume
|
push_back:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV RBX,RSI
MOV R14,RDI
MOVZX EAX,byte ptr [RDI]
TEST EAX,EAX
JZ 0x00131e30
CMP EAX,0x2
JZ 0x00131e5d
MOV EDI,0x20
CALL 0x001081d0
MOV RBX,RAX
MOV RDI,R14
CALL 0x0012dd2a
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_00131def:
LEA RSI,[0x13899a]
LEA RDI,[RSP + 0x10]
CALL 0x0012c5a4
MOV BPL,0x1
LAB_00131e03:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x134
MOV RCX,R14
CALL 0x00131eac
XOR EBP,EBP
LEA RSI,[0x14dc20]
LEA RDX,[0x12ea64]
MOV RDI,RBX
CALL 0x001085c0
LAB_00131e30:
MOV byte ptr [R14],0x2
MOV EDI,0x18
CALL 0x00108370
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOV qword ptr [RAX + 0x10],0x0
MOV qword ptr [R14 + 0x8],RAX
MOV RDI,R14
MOV ESI,0x1
CALL 0x00129abe
LAB_00131e5d:
MOV RDI,qword ptr [R14 + 0x8]
MOV RSI,RBX
ADD RSP,0x30
POP RBX
POP R14
POP RBP
JMP 0x00129fe2
|
/* nlohmann::json_abi_v3_12_0::basic_json<std::map, std::vector, std::__cxx11::string, bool, long,
unsigned long, double, std::allocator, nlohmann::json_abi_v3_12_0::adl_serializer,
std::vector<unsigned char, std::allocator<unsigned char> >,
void>::push_back(nlohmann::json_abi_v3_12_0::basic_json<std::map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_12_0::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>&&) */
void __thiscall
nlohmann::json_abi_v3_12_0::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::push_back(basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,basic_json *param_1)
{
int8 uVar1;
int8 *puVar2;
char *local_40;
detail local_38 [32];
if (*this == (basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0) {
*this = (basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2;
puVar2 = (int8 *)operator_new(0x18);
*puVar2 = 0;
puVar2[1] = 0;
puVar2[2] = 0;
*(int8 **)(this + 8) = puVar2;
assert_invariant(SUB81(this,0));
}
else if (*this != (basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2) {
uVar1 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name(this);
/* try { // try from 00131def to 00131dff has its CatchHandler @ 00131e91 */
detail::concat<std::__cxx11::string,char_const(&)[29],char_const*>
(local_38,"cannot use push_back() with ",&local_40);
/* try { // try from 00131e03 to 00131e2f has its CatchHandler @ 00131e71 */
_ZN8nlohmann16json_abi_v3_12_06detail10type_error6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar1,0x134,local_38,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::type_error::typeinfo,detail::exception::~exception);
}
std::
vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(*(vector<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(this + 8),param_1);
return;
}
|
||
63,619
|
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_string()
|
llama.cpp/common/json.hpp
|
token_type scan_string()
{
// reset token_buffer (ignore opening quote)
reset();
// we entered the function by reading an open quote
JSON_ASSERT(current == '\"');
while (true)
{
// get next character
switch (get())
{
// end of file while parsing string
case char_traits<char_type>::eof():
{
error_message = "invalid string: missing closing quote";
return token_type::parse_error;
}
// closing quote
case '\"':
{
return token_type::value_string;
}
// escapes
case '\\':
{
switch (get())
{
// quotation mark
case '\"':
add('\"');
break;
// reverse solidus
case '\\':
add('\\');
break;
// solidus
case '/':
add('/');
break;
// backspace
case 'b':
add('\b');
break;
// form feed
case 'f':
add('\f');
break;
// line feed
case 'n':
add('\n');
break;
// carriage return
case 'r':
add('\r');
break;
// tab
case 't':
add('\t');
break;
// unicode escapes
case 'u':
{
const int codepoint1 = get_codepoint();
int codepoint = codepoint1; // start with codepoint1
if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1))
{
error_message = "invalid string: '\\u' must be followed by 4 hex digits";
return token_type::parse_error;
}
// check if code point is a high surrogate
if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)
{
// expect next \uxxxx entry
if (JSON_HEDLEY_LIKELY(get() == '\\' && get() == 'u'))
{
const int codepoint2 = get_codepoint();
if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1))
{
error_message = "invalid string: '\\u' must be followed by 4 hex digits";
return token_type::parse_error;
}
// check if codepoint2 is a low surrogate
if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 && codepoint2 <= 0xDFFF))
{
// overwrite codepoint
codepoint = static_cast<int>(
// high surrogate occupies the most significant 22 bits
(static_cast<unsigned int>(codepoint1) << 10u)
// low surrogate occupies the least significant 15 bits
+ static_cast<unsigned int>(codepoint2)
// there is still the 0xD800, 0xDC00 and 0x10000 noise
// in the result, so we have to subtract with:
// (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
- 0x35FDC00u);
}
else
{
error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
return token_type::parse_error;
}
}
else
{
error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
return token_type::parse_error;
}
}
else
{
if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF))
{
error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
return token_type::parse_error;
}
}
// result of the above calculation yields a proper codepoint
JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
// translate codepoint into bytes
if (codepoint < 0x80)
{
// 1-byte characters: 0xxxxxxx (ASCII)
add(static_cast<char_int_type>(codepoint));
}
else if (codepoint <= 0x7FF)
{
// 2-byte characters: 110xxxxx 10xxxxxx
add(static_cast<char_int_type>(0xC0u | (static_cast<unsigned int>(codepoint) >> 6u)));
add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
}
else if (codepoint <= 0xFFFF)
{
// 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
add(static_cast<char_int_type>(0xE0u | (static_cast<unsigned int>(codepoint) >> 12u)));
add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
}
else
{
// 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
add(static_cast<char_int_type>(0xF0u | (static_cast<unsigned int>(codepoint) >> 18u)));
add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu)));
add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
}
break;
}
// other characters after escape
default:
error_message = "invalid string: forbidden character after backslash";
return token_type::parse_error;
}
break;
}
// invalid control characters
case 0x00:
{
error_message = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
return token_type::parse_error;
}
case 0x01:
{
error_message = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
return token_type::parse_error;
}
case 0x02:
{
error_message = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";
return token_type::parse_error;
}
case 0x03:
{
error_message = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
return token_type::parse_error;
}
case 0x04:
{
error_message = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
return token_type::parse_error;
}
case 0x05:
{
error_message = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
return token_type::parse_error;
}
case 0x06:
{
error_message = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
return token_type::parse_error;
}
case 0x07:
{
error_message = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
return token_type::parse_error;
}
case 0x08:
{
error_message = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
return token_type::parse_error;
}
case 0x09:
{
error_message = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
return token_type::parse_error;
}
case 0x0A:
{
error_message = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
return token_type::parse_error;
}
case 0x0B:
{
error_message = "invalid string: control character U+000B (VT) must be escaped to \\u000B";
return token_type::parse_error;
}
case 0x0C:
{
error_message = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
return token_type::parse_error;
}
case 0x0D:
{
error_message = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
return token_type::parse_error;
}
case 0x0E:
{
error_message = "invalid string: control character U+000E (SO) must be escaped to \\u000E";
return token_type::parse_error;
}
case 0x0F:
{
error_message = "invalid string: control character U+000F (SI) must be escaped to \\u000F";
return token_type::parse_error;
}
case 0x10:
{
error_message = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
return token_type::parse_error;
}
case 0x11:
{
error_message = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
return token_type::parse_error;
}
case 0x12:
{
error_message = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
return token_type::parse_error;
}
case 0x13:
{
error_message = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
return token_type::parse_error;
}
case 0x14:
{
error_message = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
return token_type::parse_error;
}
case 0x15:
{
error_message = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
return token_type::parse_error;
}
case 0x16:
{
error_message = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
return token_type::parse_error;
}
case 0x17:
{
error_message = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
return token_type::parse_error;
}
case 0x18:
{
error_message = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
return token_type::parse_error;
}
case 0x19:
{
error_message = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";
return token_type::parse_error;
}
case 0x1A:
{
error_message = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";
return token_type::parse_error;
}
case 0x1B:
{
error_message = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";
return token_type::parse_error;
}
case 0x1C:
{
error_message = "invalid string: control character U+001C (FS) must be escaped to \\u001C";
return token_type::parse_error;
}
case 0x1D:
{
error_message = "invalid string: control character U+001D (GS) must be escaped to \\u001D";
return token_type::parse_error;
}
case 0x1E:
{
error_message = "invalid string: control character U+001E (RS) must be escaped to \\u001E";
return token_type::parse_error;
}
case 0x1F:
{
error_message = "invalid string: control character U+001F (US) must be escaped to \\u001F";
return token_type::parse_error;
}
// U+0020..U+007F (except U+0022 (quote) and U+005C (backspace))
case 0x20:
case 0x21:
case 0x23:
case 0x24:
case 0x25:
case 0x26:
case 0x27:
case 0x28:
case 0x29:
case 0x2A:
case 0x2B:
case 0x2C:
case 0x2D:
case 0x2E:
case 0x2F:
case 0x30:
case 0x31:
case 0x32:
case 0x33:
case 0x34:
case 0x35:
case 0x36:
case 0x37:
case 0x38:
case 0x39:
case 0x3A:
case 0x3B:
case 0x3C:
case 0x3D:
case 0x3E:
case 0x3F:
case 0x40:
case 0x41:
case 0x42:
case 0x43:
case 0x44:
case 0x45:
case 0x46:
case 0x47:
case 0x48:
case 0x49:
case 0x4A:
case 0x4B:
case 0x4C:
case 0x4D:
case 0x4E:
case 0x4F:
case 0x50:
case 0x51:
case 0x52:
case 0x53:
case 0x54:
case 0x55:
case 0x56:
case 0x57:
case 0x58:
case 0x59:
case 0x5A:
case 0x5B:
case 0x5D:
case 0x5E:
case 0x5F:
case 0x60:
case 0x61:
case 0x62:
case 0x63:
case 0x64:
case 0x65:
case 0x66:
case 0x67:
case 0x68:
case 0x69:
case 0x6A:
case 0x6B:
case 0x6C:
case 0x6D:
case 0x6E:
case 0x6F:
case 0x70:
case 0x71:
case 0x72:
case 0x73:
case 0x74:
case 0x75:
case 0x76:
case 0x77:
case 0x78:
case 0x79:
case 0x7A:
case 0x7B:
case 0x7C:
case 0x7D:
case 0x7E:
case 0x7F:
{
add(current);
break;
}
// U+0080..U+07FF: bytes C2..DF 80..BF
case 0xC2:
case 0xC3:
case 0xC4:
case 0xC5:
case 0xC6:
case 0xC7:
case 0xC8:
case 0xC9:
case 0xCA:
case 0xCB:
case 0xCC:
case 0xCD:
case 0xCE:
case 0xCF:
case 0xD0:
case 0xD1:
case 0xD2:
case 0xD3:
case 0xD4:
case 0xD5:
case 0xD6:
case 0xD7:
case 0xD8:
case 0xD9:
case 0xDA:
case 0xDB:
case 0xDC:
case 0xDD:
case 0xDE:
case 0xDF:
{
if (JSON_HEDLEY_UNLIKELY(!next_byte_in_range({0x80, 0xBF})))
{
return token_type::parse_error;
}
break;
}
// U+0800..U+0FFF: bytes E0 A0..BF 80..BF
case 0xE0:
{
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
break;
}
// U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF
// U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF
case 0xE1:
case 0xE2:
case 0xE3:
case 0xE4:
case 0xE5:
case 0xE6:
case 0xE7:
case 0xE8:
case 0xE9:
case 0xEA:
case 0xEB:
case 0xEC:
case 0xEE:
case 0xEF:
{
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
break;
}
// U+D000..U+D7FF: bytes ED 80..9F 80..BF
case 0xED:
{
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
break;
}
// U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
case 0xF0:
{
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
break;
}
// U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF
case 0xF1:
case 0xF2:
case 0xF3:
{
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
break;
}
// U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
case 0xF4:
{
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
break;
}
// remaining bytes (80..C1 and F5..FF) are ill-formed
default:
{
error_message = "invalid string: ill-formed UTF-8 byte";
return token_type::parse_error;
}
}
}
}
|
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_string():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x82ab0
cmpl $0x22, 0x14(%rbx)
jne 0x826a9
leaq 0x50(%rbx), %r14
leaq 0xa5a75(%rip), %r12 # 0x127d14
leaq 0x9e5ea(%rip), %r13 # 0x120890
movq %rbx, %rdi
callq 0x226b0
incl %eax
cmpl $0xf5, %eax
ja 0x82678
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movabsq $0xbf00000080, %rax # imm = 0xBF00000080
movq %rsp, %rsi
movq %rax, (%rsi)
movl $0x2, %edx
jmp 0x82346
movaps 0x9e43d(%rip), %xmm0 # 0x120720
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movl $0x4, %edx
jmp 0x82346
movb 0x14(%rbx), %r15b
movsbl %r15b, %esi
movq %r14, %rdi
callq 0x22440
jmp 0x822a6
movups 0xa828f(%rip), %xmm0 # 0x12a598
jmp 0x8232d
movaps 0x9e3fe(%rip), %xmm0 # 0x120710
jmp 0x822e3
movaps 0x9e415(%rip), %xmm0 # 0x120730
jmp 0x822e3
movups 0xa828c(%rip), %xmm0 # 0x12a5b0
jmp 0x8232d
movups 0xa8253(%rip), %xmm0 # 0x12a580
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movabsq $0xbf00000080, %rax # imm = 0xBF00000080
movq %rax, 0x10(%rsi)
movl $0x6, %edx
movq %rbx, %rdi
callq 0x82b34
testb %al, %al
jne 0x822a6
jmp 0x82683
movq %rbx, %rdi
callq 0x226b0
leaq 0xa592d(%rip), %rbp # 0x127c97
cmpl $0x61, %eax
jle 0x82495
leal -0x6e(%rax), %ecx
cmpl $0x7, %ecx
ja 0x824b0
leaq 0x9e8e2(%rip), %rax # 0x120c68
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq %rbx, %rdi
callq 0x82aee
leaq 0xa5808(%rip), %rbp # 0x127ba6
cmpl $-0x1, %eax
je 0x8267f
movl %eax, %r15d
andl $0xfffffc00, %eax # imm = 0xFFFFFC00
cmpl $0xd800, %eax # imm = 0xD800
jne 0x82460
movq %rbx, %rdi
callq 0x226b0
cmpl $0x5c, %eax
jne 0x82697
movq %rbx, %rdi
callq 0x226b0
cmpl $0x75, %eax
jne 0x82697
movq %rbx, %rdi
callq 0x82aee
cmpl $-0x1, %eax
je 0x8267f
movl %eax, %ecx
andl $0xfffffc00, %ecx # imm = 0xFFFFFC00
leaq 0xa57e0(%rip), %rbp # 0x127bdc
cmpl $0xdc00, %ecx # imm = 0xDC00
jne 0x8267f
shll $0xa, %r15d
addl %eax, %r15d
addl $0xfca02400, %r15d # imm = 0xFCA02400
movl %r15d, %eax
shrl $0x12, %eax
orb $-0x10, %al
movsbl %al, %esi
movq %r14, %rdi
callq 0x22440
movl %r15d, %eax
shrl $0xc, %eax
andb $0x3f, %al
orb $-0x80, %al
movsbl %al, %esi
movq %r14, %rdi
callq 0x22440
movl %r15d, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movsbl %al, %esi
movq %r14, %rdi
callq 0x22440
andb $0x3f, %r15b
orb $-0x80, %r15b
jmp 0x822f4
cmpl $0xdc00, %eax # imm = 0xDC00
je 0x826a0
cmpl $0x110000, %r15d # imm = 0x110000
jae 0x826c5
cmpl $0x7f, %r15d
jbe 0x822f4
cmpl $0x7ff, %r15d # imm = 0x7FF
ja 0x824c6
movl %r15d, %eax
shrl $0x6, %eax
orb $-0x40, %al
jmp 0x82448
cmpl $0x22, %eax
je 0x824e8
cmpl $0x2f, %eax
je 0x824e0
cmpl $0x5c, %eax
jne 0x8267f
movb $0x5c, %r15b
jmp 0x822f4
cmpl $0x62, %eax
je 0x82508
cmpl $0x66, %eax
jne 0x8267f
movb $0xc, %r15b
jmp 0x822f4
cmpl $0xffff, %r15d # imm = 0xFFFF
ja 0x82416
movl %r15d, %eax
shrl $0xc, %eax
orb $-0x20, %al
jmp 0x82433
movb $0x2f, %r15b
jmp 0x822f4
movb $0x22, %r15b
jmp 0x822f4
movb $0x9, %r15b
jmp 0x822f4
movb $0xa, %r15b
jmp 0x822f4
movb $0xd, %r15b
jmp 0x822f4
movb $0x8, %r15b
jmp 0x822f4
movl $0x4, %eax
jmp 0x82688
leaq 0xa6093(%rip), %rbp # 0x1285b4
jmp 0x8267f
leaq 0xa5ed5(%rip), %rbp # 0x128402
jmp 0x8267f
leaq 0xa6033(%rip), %rbp # 0x12856c
jmp 0x8267f
leaq 0xa5b00(%rip), %rbp # 0x128045
jmp 0x8267f
leaq 0xa5f8b(%rip), %rbp # 0x1284dc
jmp 0x8267f
leaq 0xa5e5c(%rip), %rbp # 0x1283b9
jmp 0x8267f
leaq 0xa5886(%rip), %rbp # 0x127def
jmp 0x8267f
leaq 0xa599e(%rip), %rbp # 0x127f13
jmp 0x8267f
leaq 0xa5825(%rip), %rbp # 0x127da6
jmp 0x8267f
leaq 0xa58f4(%rip), %rbp # 0x127e81
jmp 0x8267f
leaq 0xa5931(%rip), %rbp # 0x127eca
jmp 0x8267f
movq %r12, %rbp
jmp 0x8267f
leaq 0xa5bc4(%rip), %rbp # 0x128171
jmp 0x8267f
leaq 0xa5b28(%rip), %rbp # 0x1280e1
jmp 0x8267f
leaq 0xa55bb(%rip), %rbp # 0x127b80
jmp 0x8267f
leaq 0xa5867(%rip), %rbp # 0x127e38
jmp 0x8267f
leaq 0xa5bdd(%rip), %rbp # 0x1281ba
jmp 0x8267f
leaq 0xa56e2(%rip), %rbp # 0x127ccb
jmp 0x8267f
leaq 0xa5768(%rip), %rbp # 0x127d5d
jmp 0x8267f
leaq 0xa5c4b(%rip), %rbp # 0x12824c
jmp 0x8267f
leaq 0xa5c8b(%rip), %rbp # 0x128295
jmp 0x8267f
leaq 0xa5e80(%rip), %rbp # 0x128493
jmp 0x8267f
leaq 0xa5945(%rip), %rbp # 0x127f61
jmp 0x8267f
leaq 0xa5cb9(%rip), %rbp # 0x1282de
jmp 0x8267f
leaq 0xa5a65(%rip), %rbp # 0x128093
jmp 0x8267f
leaq 0xa5e13(%rip), %rbp # 0x12844a
jmp 0x8267f
leaq 0xa596f(%rip), %rbp # 0x127faf
jmp 0x8267f
leaq 0xa59b4(%rip), %rbp # 0x127ffd
jmp 0x8267f
leaq 0xa5bb1(%rip), %rbp # 0x128203
jmp 0x8267f
leaq 0xa5ace(%rip), %rbp # 0x128129
jmp 0x8267f
leaq 0xa5ec0(%rip), %rbp # 0x128524
jmp 0x8267f
leaq 0xa5cba(%rip), %rbp # 0x128327
jmp 0x8267f
leaq 0xa5cfa(%rip), %rbp # 0x128370
jmp 0x8267f
leaq 0xa5f7d(%rip), %rbp # 0x1285fc
movq %rbp, 0x70(%rbx)
movl $0xe, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa553e(%rip), %rbp # 0x127bdc
jmp 0x8267f
leaq 0xa5581(%rip), %rbp # 0x127c28
jmp 0x8267f
leaq 0xa5269(%rip), %rdi # 0x127919
leaq 0x9d4a1(%rip), %rdx # 0x11fb58
leaq 0xa54b2(%rip), %rcx # 0x127b70
movl $0x1dd1, %esi # imm = 0x1DD1
jmp 0x826df
leaq 0xa524d(%rip), %rdi # 0x127919
leaq 0x9d485(%rip), %rdx # 0x11fb58
leaq 0xa5592(%rip), %rcx # 0x127c6c
movl $0x1e49, %esi # imm = 0x1E49
xorl %eax, %eax
callq 0x21ef0
|
_ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE11scan_stringEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE5resetEv; 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>::reset(void)
cmp dword ptr [rbx+14h], 22h ; '"'
jnz loc_826A9
lea r14, [rbx+50h]
lea r12, aInvalidStringC; "invalid string: control character U+000"...
lea r13, jpt_822C3
loc_822A6:
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; switch 246 cases
cmp eax, 0F5h
ja def_822C3; jumptable 00000000000822C3 default case, cases 128-193
movsxd rax, ds:(jpt_822C3 - 120890h)[r13+rax*4]
add rax, r13
jmp rax; switch jump
loc_822C5:
mov rax, 0BF00000080h; jumptable 00000000000822C3 cases 194-223
mov rsi, rsp
mov [rsi], rax
mov edx, 2
jmp short loc_82346
loc_822DC:
movaps xmm0, cs:xmmword_120720; jumptable 00000000000822C3 cases 225-236,238,239
loc_822E3:
mov rsi, rsp
movaps xmmword ptr [rsi], xmm0
mov edx, 4
jmp short loc_82346
loc_822F0:
mov r15b, [rbx+14h]; jumptable 00000000000822C3 cases 32,33,35-91,93-127
loc_822F4:
movsx esi, r15b
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
jmp short loc_822A6
loc_82302:
movups xmm0, cs:xmmword_12A598; jumptable 00000000000822C3 cases 241-243
jmp short loc_8232D
loc_8230B:
movaps xmm0, cs:xmmword_120710; jumptable 00000000000822C3 case 237
jmp short loc_822E3
loc_82314:
movaps xmm0, cs:xmmword_120730; jumptable 00000000000822C3 case 224
jmp short loc_822E3
loc_8231D:
movups xmm0, cs:xmmword_12A5B0; jumptable 00000000000822C3 case 244
jmp short loc_8232D
loc_82326:
movups xmm0, cs:xmmword_12A580; jumptable 00000000000822C3 case 240
loc_8232D:
mov rsi, rsp
movaps xmmword ptr [rsi], xmm0
mov rax, 0BF00000080h
mov [rsi+10h], rax
mov edx, 6
loc_82346:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE18next_byte_in_rangeESt16initializer_listIiE; 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>)
test al, al
jnz loc_822A6
jmp loc_82683
loc_8235B:
mov rdi, rbx; jumptable 00000000000822C3 case 92
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 rbp, aInvalidStringF; "invalid string: forbidden character aft"...
cmp eax, 61h ; 'a'
jle loc_82495
lea ecx, [rax-6Eh]; switch 8 cases
cmp ecx, 7
ja def_8238D; jumptable 000000000008238D default case
lea rax, jpt_8238D
movsxd rcx, ds:(jpt_8238D - 120C68h)[rax+rcx*4]
add rcx, rax
jmp rcx; switch jump
loc_8238F:
mov rdi, rbx; jumptable 000000000008238D case 117
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE13get_codepointEv; 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_codepoint(void)
lea rbp, aInvalidStringU; "invalid string: '\\u' must be followed "...
cmp eax, 0FFFFFFFFh
jz loc_8267F; jumptable 000000000008238D cases 111-113,115
mov r15d, eax
and eax, 0FFFFFC00h
cmp eax, 0D800h
jnz loc_82460
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, 5Ch ; '\'
jnz loc_82697
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, 75h ; 'u'
jnz loc_82697
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE13get_codepointEv; 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_codepoint(void)
cmp eax, 0FFFFFFFFh
jz loc_8267F; jumptable 000000000008238D cases 111-113,115
mov ecx, eax
and ecx, 0FFFFFC00h
lea rbp, aInvalidStringS; "invalid string: surrogate U+D800..U+DBF"...
cmp ecx, 0DC00h
jnz loc_8267F; jumptable 000000000008238D cases 111-113,115
shl r15d, 0Ah
add r15d, eax
add r15d, 0FCA02400h
loc_82416:
mov eax, r15d
shr eax, 12h
or al, 0F0h
movsx esi, al
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov eax, r15d
shr eax, 0Ch
and al, 3Fh
or al, 80h
loc_82433:
movsx esi, al
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov eax, r15d
shr eax, 6
and al, 3Fh
or al, 80h
loc_82448:
movsx esi, al
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
and r15b, 3Fh
or r15b, 80h
jmp loc_822F4
loc_82460:
cmp eax, 0DC00h
jz loc_826A0
cmp r15d, offset loc_110000
jnb loc_826C5
cmp r15d, 7Fh
jbe loc_822F4
cmp r15d, 7FFh
ja short loc_824C6
mov eax, r15d
shr eax, 6
or al, 0C0h
jmp short loc_82448
loc_82495:
cmp eax, 22h ; '"'
jz short loc_824E8
cmp eax, 2Fh ; '/'
jz short loc_824E0
cmp eax, 5Ch ; '\'
jnz loc_8267F; jumptable 000000000008238D cases 111-113,115
mov r15b, 5Ch ; '\'
jmp loc_822F4
def_8238D:
cmp eax, 62h ; 'b'; jumptable 000000000008238D default case
jz short loc_82508
cmp eax, 66h ; 'f'
jnz loc_8267F; jumptable 000000000008238D cases 111-113,115
mov r15b, 0Ch
jmp loc_822F4
loc_824C6:
cmp r15d, 0FFFFh
ja loc_82416
mov eax, r15d
shr eax, 0Ch
or al, 0E0h
jmp loc_82433
loc_824E0:
mov r15b, 2Fh ; '/'
jmp loc_822F4
loc_824E8:
mov r15b, 22h ; '"'
jmp loc_822F4
loc_824F0:
mov r15b, 9; jumptable 000000000008238D case 116
jmp loc_822F4
loc_824F8:
mov r15b, 0Ah; jumptable 000000000008238D case 110
jmp loc_822F4
loc_82500:
mov r15b, 0Dh; jumptable 000000000008238D case 114
jmp loc_822F4
loc_82508:
mov r15b, 8
jmp loc_822F4
loc_82510:
mov eax, 4; jumptable 00000000000822C3 case 34
jmp loc_82688
loc_8251A:
lea rbp, aInvalidStringC_0; jumptable 00000000000822C3 case 31
jmp loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_82526:
lea rbp, aInvalidStringC_1; jumptable 00000000000822C3 case 25
jmp loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_82532:
lea rbp, aInvalidStringC_2; jumptable 00000000000822C3 case 30
jmp loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_8253E:
lea rbp, aInvalidStringC_3; jumptable 00000000000822C3 case 12
jmp loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_8254A:
lea rbp, aInvalidStringC_4; jumptable 00000000000822C3 case 28
jmp loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_82556:
lea rbp, aInvalidStringC_5; jumptable 00000000000822C3 case 24
jmp loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_82562:
lea rbp, aInvalidStringC_6; jumptable 00000000000822C3 case 4
jmp loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_8256E:
lea rbp, aInvalidStringC_7; jumptable 00000000000822C3 case 8
jmp loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_8257A:
lea rbp, aInvalidStringC_8; jumptable 00000000000822C3 case 3
jmp loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_82586:
lea rbp, aInvalidStringC_9; jumptable 00000000000822C3 case 6
jmp loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_82592:
lea rbp, aInvalidStringC_10; jumptable 00000000000822C3 case 7
jmp loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_8259E:
mov rbp, r12; jumptable 00000000000822C3 case 1
jmp loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_825A6:
lea rbp, aInvalidStringC_11; jumptable 00000000000822C3 case 16
jmp loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_825B2:
lea rbp, aInvalidStringC_12; jumptable 00000000000822C3 case 14
jmp loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_825BE:
lea rbp, aInvalidStringM; jumptable 00000000000822C3 case -1
jmp loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_825CA:
lea rbp, aInvalidStringC_13; jumptable 00000000000822C3 case 5
jmp loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_825D6:
lea rbp, aInvalidStringC_14; jumptable 00000000000822C3 case 17
jmp loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_825E2:
lea rbp, aInvalidStringC_15; jumptable 00000000000822C3 case 0
jmp loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_825EE:
lea rbp, aInvalidStringC_16; jumptable 00000000000822C3 case 2
jmp loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_825FA:
lea rbp, aInvalidStringC_17; jumptable 00000000000822C3 case 19
jmp short loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_82603:
lea rbp, aInvalidStringC_18; jumptable 00000000000822C3 case 20
jmp short loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_8260C:
lea rbp, aInvalidStringC_19; jumptable 00000000000822C3 case 27
jmp short loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_82615:
lea rbp, aInvalidStringC_20; jumptable 00000000000822C3 case 9
jmp short loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_8261E:
lea rbp, aInvalidStringC_21; jumptable 00000000000822C3 case 21
jmp short loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_82627:
lea rbp, aInvalidStringC_22; jumptable 00000000000822C3 case 13
jmp short loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_82630:
lea rbp, aInvalidStringC_23; jumptable 00000000000822C3 case 26
jmp short loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_82639:
lea rbp, aInvalidStringC_24; jumptable 00000000000822C3 case 10
jmp short loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_82642:
lea rbp, aInvalidStringC_25; jumptable 00000000000822C3 case 11
jmp short loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_8264B:
lea rbp, aInvalidStringC_26; jumptable 00000000000822C3 case 18
jmp short loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_82654:
lea rbp, aInvalidStringC_27; jumptable 00000000000822C3 case 15
jmp short loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_8265D:
lea rbp, aInvalidStringC_28; jumptable 00000000000822C3 case 29
jmp short loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_82666:
lea rbp, aInvalidStringC_29; jumptable 00000000000822C3 case 22
jmp short loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_8266F:
lea rbp, aInvalidStringC_30; jumptable 00000000000822C3 case 23
jmp short loc_8267F; jumptable 000000000008238D cases 111-113,115
def_822C3:
lea rbp, aInvalidStringI; jumptable 00000000000822C3 default case, cases 128-193
loc_8267F:
mov [rbx+70h], rbp; jumptable 000000000008238D cases 111-113,115
loc_82683:
mov eax, 0Eh
loc_82688:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_82697:
lea rbp, aInvalidStringS; "invalid string: surrogate U+D800..U+DBF"...
jmp short loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_826A0:
lea rbp, aInvalidStringS_0; "invalid string: surrogate U+DC00..U+DFF"...
jmp short loc_8267F; jumptable 000000000008238D cases 111-113,115
loc_826A9:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCurrent; "current == '\\\"'"
mov esi, 1DD1h
jmp short loc_826DF
loc_826C5:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, a0x00CodepointC; "0x00 <= codepoint && codepoint <= 0x10F"...
mov esi, 1E49h
loc_826DF:
xor eax, eax
call _ggml_abort
|
long long nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::scan_string(
__m128i *this)
{
long long v1; // rcx
long long v2; // r8
long long v3; // r9
long long v4; // rdx
__int128 v5; // xmm0
unsigned int v6; // r15d
__int128 v7; // xmm0
int v8; // eax
const char *v9; // rbp
unsigned int codepoint; // eax
unsigned int v11; // eax
int v12; // eax
char v13; // al
char v14; // al
__int128 v16; // [rsp+0h] [rbp-48h] BYREF
long long v17; // [rsp+10h] [rbp-38h]
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>::reset();
if ( this[1].m128i_i32[1] != 34 )
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
7633LL,
"GGML_ASSERT(%s) failed",
"current == '\\\"'");
return 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_number((nlohmann::json_abi_v3_11_3::detail::input_stream_adapter *)"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp");
}
while ( 2 )
{
while ( 2 )
{
switch ( (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) )
{
case 0xFFFFFFFF:
v9 = "invalid string: missing closing quote";
goto LABEL_83;
case 0u:
v9 = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
goto LABEL_83;
case 1u:
v9 = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
goto LABEL_83;
case 2u:
v9 = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";
goto LABEL_83;
case 3u:
v9 = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
goto LABEL_83;
case 4u:
v9 = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
goto LABEL_83;
case 5u:
v9 = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
goto LABEL_83;
case 6u:
v9 = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
goto LABEL_83;
case 7u:
v9 = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
goto LABEL_83;
case 8u:
v9 = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
goto LABEL_83;
case 9u:
v9 = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
goto LABEL_83;
case 0xAu:
v9 = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
goto LABEL_83;
case 0xBu:
v9 = "invalid string: control character U+000B (VT) must be escaped to \\u000B";
goto LABEL_83;
case 0xCu:
v9 = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
goto LABEL_83;
case 0xDu:
v9 = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
goto LABEL_83;
case 0xEu:
v9 = "invalid string: control character U+000E (SO) must be escaped to \\u000E";
goto LABEL_83;
case 0xFu:
v9 = "invalid string: control character U+000F (SI) must be escaped to \\u000F";
goto LABEL_83;
case 0x10u:
v9 = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
goto LABEL_83;
case 0x11u:
v9 = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
goto LABEL_83;
case 0x12u:
v9 = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
goto LABEL_83;
case 0x13u:
v9 = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
goto LABEL_83;
case 0x14u:
v9 = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
goto LABEL_83;
case 0x15u:
v9 = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
goto LABEL_83;
case 0x16u:
v9 = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
goto LABEL_83;
case 0x17u:
v9 = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
goto LABEL_83;
case 0x18u:
v9 = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
goto LABEL_83;
case 0x19u:
v9 = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";
goto LABEL_83;
case 0x1Au:
v9 = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";
goto LABEL_83;
case 0x1Bu:
v9 = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";
goto LABEL_83;
case 0x1Cu:
v9 = "invalid string: control character U+001C (FS) must be escaped to \\u001C";
goto LABEL_83;
case 0x1Du:
v9 = "invalid string: control character U+001D (GS) must be escaped to \\u001D";
goto LABEL_83;
case 0x1Eu:
v9 = "invalid string: control character U+001E (RS) must be escaped to \\u001E";
goto LABEL_83;
case 0x1Fu:
v9 = "invalid string: control character U+001F (US) must be escaped to \\u001F";
goto LABEL_83;
case 0x20u:
case 0x21u:
case 0x23u:
case 0x24u:
case 0x25u:
case 0x26u:
case 0x27u:
case 0x28u:
case 0x29u:
case 0x2Au:
case 0x2Bu:
case 0x2Cu:
case 0x2Du:
case 0x2Eu:
case 0x2Fu:
case 0x30u:
case 0x31u:
case 0x32u:
case 0x33u:
case 0x34u:
case 0x35u:
case 0x36u:
case 0x37u:
case 0x38u:
case 0x39u:
case 0x3Au:
case 0x3Bu:
case 0x3Cu:
case 0x3Du:
case 0x3Eu:
case 0x3Fu:
case 0x40u:
case 0x41u:
case 0x42u:
case 0x43u:
case 0x44u:
case 0x45u:
case 0x46u:
case 0x47u:
case 0x48u:
case 0x49u:
case 0x4Au:
case 0x4Bu:
case 0x4Cu:
case 0x4Du:
case 0x4Eu:
case 0x4Fu:
case 0x50u:
case 0x51u:
case 0x52u:
case 0x53u:
case 0x54u:
case 0x55u:
case 0x56u:
case 0x57u:
case 0x58u:
case 0x59u:
case 0x5Au:
case 0x5Bu:
case 0x5Du:
case 0x5Eu:
case 0x5Fu:
case 0x60u:
case 0x61u:
case 0x62u:
case 0x63u:
case 0x64u:
case 0x65u:
case 0x66u:
case 0x67u:
case 0x68u:
case 0x69u:
case 0x6Au:
case 0x6Bu:
case 0x6Cu:
case 0x6Du:
case 0x6Eu:
case 0x6Fu:
case 0x70u:
case 0x71u:
case 0x72u:
case 0x73u:
case 0x74u:
case 0x75u:
case 0x76u:
case 0x77u:
case 0x78u:
case 0x79u:
case 0x7Au:
case 0x7Bu:
case 0x7Cu:
case 0x7Du:
case 0x7Eu:
case 0x7Fu:
LOBYTE(v6) = this[1].m128i_i8[4];
goto LABEL_7;
case 0x22u:
return 4LL;
case 0x5Cu:
v8 = 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);
v9 = "invalid string: forbidden character after backslash";
if ( v8 <= 97 )
{
switch ( v8 )
{
case '"':
LOBYTE(v6) = 34;
break;
case '/':
LOBYTE(v6) = 47;
break;
case '\\':
LOBYTE(v6) = 92;
break;
default:
goto LABEL_83;
}
goto LABEL_7;
}
break;
case 0xC2u:
case 0xC3u:
case 0xC4u:
case 0xC5u:
case 0xC6u:
case 0xC7u:
case 0xC8u:
case 0xC9u:
case 0xCAu:
case 0xCBu:
case 0xCCu:
case 0xCDu:
case 0xCEu:
case 0xCFu:
case 0xD0u:
case 0xD1u:
case 0xD2u:
case 0xD3u:
case 0xD4u:
case 0xD5u:
case 0xD6u:
case 0xD7u:
case 0xD8u:
case 0xD9u:
case 0xDAu:
case 0xDBu:
case 0xDCu:
case 0xDDu:
case 0xDEu:
case 0xDFu:
*(_QWORD *)&v16 = 0xBF00000080LL;
v4 = 2LL;
goto LABEL_14;
case 0xE0u:
v5 = xmmword_120730;
goto LABEL_5;
case 0xE1u:
case 0xE2u:
case 0xE3u:
case 0xE4u:
case 0xE5u:
case 0xE6u:
case 0xE7u:
case 0xE8u:
case 0xE9u:
case 0xEAu:
case 0xEBu:
case 0xECu:
case 0xEEu:
case 0xEFu:
v5 = xmmword_120720;
goto LABEL_5;
case 0xEDu:
v5 = xmmword_120710;
LABEL_5:
v16 = v5;
v4 = 4LL;
goto LABEL_14;
case 0xF0u:
v7 = xmmword_12A580;
goto LABEL_13;
case 0xF1u:
case 0xF2u:
case 0xF3u:
v7 = xmmword_12A598;
goto LABEL_13;
case 0xF4u:
v7 = xmmword_12A5B0;
LABEL_13:
v16 = v7;
v17 = 0xBF00000080LL;
v4 = 6LL;
LABEL_14:
if ( !(unsigned __int8)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(
this,
&v16,
v4,
v1,
v2,
v3,
v16,
*((_QWORD *)&v16 + 1),
v17) )
return 14LL;
continue;
default:
v9 = "invalid string: ill-formed UTF-8 byte";
goto LABEL_83;
}
break;
}
switch ( v8 )
{
case 'n':
LOBYTE(v6) = 10;
goto LABEL_7;
case 'o':
case 'p':
case 'q':
case 's':
goto LABEL_83;
case 'r':
LOBYTE(v6) = 13;
goto LABEL_7;
case 't':
LOBYTE(v6) = 9;
goto LABEL_7;
case 'u':
codepoint = 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_codepoint(this);
v9 = "invalid string: '\\u' must be followed by 4 hex digits";
if ( codepoint == -1 )
goto LABEL_83;
v6 = codepoint;
v11 = codepoint & 0xFFFFFC00;
if ( v11 == 55296 )
{
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) != 92
|| (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) != 117 )
{
v9 = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
LABEL_83:
this[7].m128i_i64[0] = (long long)v9;
return 14LL;
}
v12 = 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_codepoint(this);
if ( v12 == -1 )
goto LABEL_83;
v9 = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
if ( (v12 & 0xFFFFFC00) != 0xDC00 )
goto LABEL_83;
v6 = v12 + (v6 << 10) - 56613888;
goto LABEL_25;
}
if ( v11 == 56320 )
{
v9 = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
goto LABEL_83;
}
if ( v6 < (unsigned int)&loc_110000 )
{
if ( v6 > 0x7F )
{
if ( v6 <= 0x7FF )
{
v14 = (v6 >> 6) | 0xC0;
goto LABEL_27;
}
if ( v6 <= 0xFFFF )
{
v13 = (v6 >> 12) | 0xE0;
goto LABEL_26;
}
LABEL_25:
std::string::push_back(&this[5], (unsigned int)(char)((v6 >> 18) | 0xF0));
v13 = (v6 >> 12) & 0x3F | 0x80;
LABEL_26:
std::string::push_back(&this[5], (unsigned int)v13);
v14 = (v6 >> 6) & 0x3F | 0x80;
LABEL_27:
std::string::push_back(&this[5], (unsigned int)v14);
LOBYTE(v6) = v6 & 0x3F | 0x80;
}
LABEL_7:
std::string::push_back(&this[5], (unsigned int)(char)v6);
continue;
}
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
7753LL,
"GGML_ASSERT(%s) failed",
"0x00 <= codepoint && codepoint <= 0x10FFFF");
return 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_number((nlohmann::json_abi_v3_11_3::detail::input_stream_adapter *)"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp");
default:
if ( v8 == 98 )
{
LOBYTE(v6) = 8;
}
else
{
if ( v8 != 102 )
goto LABEL_83;
LOBYTE(v6) = 12;
}
goto LABEL_7;
}
}
}
|
scan_string:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
CALL 0x00182ab0
CMP dword ptr [RBX + 0x14],0x22
JNZ 0x001826a9
LEA R14,[RBX + 0x50]
LEA R12,[0x227d14]
LEA R13,[0x220890]
LAB_001822a6:
MOV RDI,RBX
CALL 0x001226b0
INC EAX
CMP EAX,0xf5
JA 0x00182678
MOVSXD RAX,dword ptr [R13 + RAX*0x4]
ADD RAX,R13
switchD:
JMP RAX
caseD_c2:
MOV RAX,0xbf00000080
MOV RSI,RSP
MOV qword ptr [RSI],RAX
MOV EDX,0x2
JMP 0x00182346
caseD_e1:
MOVAPS XMM0,xmmword ptr [0x00220720]
LAB_001822e3:
MOV RSI,RSP
MOVAPS xmmword ptr [RSI],XMM0
MOV EDX,0x4
JMP 0x00182346
caseD_20:
MOV R15B,byte ptr [RBX + 0x14]
LAB_001822f4:
MOVSX ESI,R15B
MOV RDI,R14
CALL 0x00122440
JMP 0x001822a6
caseD_f1:
MOVUPS XMM0,xmmword ptr [0x0022a598]
JMP 0x0018232d
caseD_ed:
MOVAPS XMM0,xmmword ptr [0x00220710]
JMP 0x001822e3
caseD_e0:
MOVAPS XMM0,xmmword ptr [0x00220730]
JMP 0x001822e3
caseD_f4:
MOVUPS XMM0,xmmword ptr [0x0022a5b0]
JMP 0x0018232d
caseD_f0:
MOVUPS XMM0,xmmword ptr [0x0022a580]
LAB_0018232d:
MOV RSI,RSP
MOVAPS xmmword ptr [RSI],XMM0
MOV RAX,0xbf00000080
MOV qword ptr [RSI + 0x10],RAX
MOV EDX,0x6
LAB_00182346:
MOV RDI,RBX
CALL 0x00182b34
TEST AL,AL
JNZ 0x001822a6
JMP 0x00182683
caseD_5c:
MOV RDI,RBX
CALL 0x001226b0
LEA RBP,[0x227c97]
CMP EAX,0x61
JLE 0x00182495
LEA ECX,[RAX + -0x6e]
CMP ECX,0x7
JA 0x001824b0
LEA RAX,[0x220c68]
MOVSXD RCX,dword ptr [RAX + RCX*0x4]
ADD RCX,RAX
switchD:
JMP RCX
caseD_75:
MOV RDI,RBX
CALL 0x00182aee
LEA RBP,[0x227ba6]
CMP EAX,-0x1
JZ 0x0018267f
MOV R15D,EAX
AND EAX,0xfffffc00
CMP EAX,0xd800
JNZ 0x00182460
MOV RDI,RBX
CALL 0x001226b0
CMP EAX,0x5c
JNZ 0x00182697
MOV RDI,RBX
CALL 0x001226b0
CMP EAX,0x75
JNZ 0x00182697
MOV RDI,RBX
CALL 0x00182aee
CMP EAX,-0x1
JZ 0x0018267f
MOV ECX,EAX
AND ECX,0xfffffc00
LEA RBP,[0x227bdc]
CMP ECX,0xdc00
JNZ 0x0018267f
SHL R15D,0xa
ADD R15D,EAX
ADD R15D,0xfca02400
LAB_00182416:
MOV EAX,R15D
SHR EAX,0x12
OR AL,0xf0
MOVSX ESI,AL
MOV RDI,R14
CALL 0x00122440
MOV EAX,R15D
SHR EAX,0xc
AND AL,0x3f
OR AL,0x80
LAB_00182433:
MOVSX ESI,AL
MOV RDI,R14
CALL 0x00122440
MOV EAX,R15D
SHR EAX,0x6
AND AL,0x3f
OR AL,0x80
LAB_00182448:
MOVSX ESI,AL
MOV RDI,R14
CALL 0x00122440
AND R15B,0x3f
OR R15B,0x80
JMP 0x001822f4
LAB_00182460:
CMP EAX,0xdc00
JZ 0x001826a0
CMP R15D,0x110000
JNC 0x001826c5
CMP R15D,0x7f
JBE 0x001822f4
CMP R15D,0x7ff
JA 0x001824c6
MOV EAX,R15D
SHR EAX,0x6
OR AL,0xc0
JMP 0x00182448
LAB_00182495:
CMP EAX,0x22
JZ 0x001824e8
CMP EAX,0x2f
JZ 0x001824e0
CMP EAX,0x5c
JNZ 0x0018267f
MOV R15B,0x5c
JMP 0x001822f4
default:
CMP EAX,0x62
JZ 0x00182508
CMP EAX,0x66
JNZ 0x0018267f
MOV R15B,0xc
JMP 0x001822f4
LAB_001824c6:
CMP R15D,0xffff
JA 0x00182416
MOV EAX,R15D
SHR EAX,0xc
OR AL,0xe0
JMP 0x00182433
LAB_001824e0:
MOV R15B,0x2f
JMP 0x001822f4
LAB_001824e8:
MOV R15B,0x22
JMP 0x001822f4
caseD_74:
MOV R15B,0x9
JMP 0x001822f4
caseD_6e:
MOV R15B,0xa
JMP 0x001822f4
caseD_72:
MOV R15B,0xd
JMP 0x001822f4
LAB_00182508:
MOV R15B,0x8
JMP 0x001822f4
caseD_22:
MOV EAX,0x4
JMP 0x00182688
caseD_1f:
LEA RBP,[0x2285b4]
JMP 0x0018267f
caseD_19:
LEA RBP,[0x228402]
JMP 0x0018267f
caseD_1e:
LEA RBP,[0x22856c]
JMP 0x0018267f
caseD_c:
LEA RBP,[0x228045]
JMP 0x0018267f
caseD_1c:
LEA RBP,[0x2284dc]
JMP 0x0018267f
caseD_18:
LEA RBP,[0x2283b9]
JMP 0x0018267f
caseD_4:
LEA RBP,[0x227def]
JMP 0x0018267f
caseD_8:
LEA RBP,[0x227f13]
JMP 0x0018267f
caseD_3:
LEA RBP,[0x227da6]
JMP 0x0018267f
caseD_6:
LEA RBP,[0x227e81]
JMP 0x0018267f
caseD_7:
LEA RBP,[0x227eca]
JMP 0x0018267f
caseD_1:
MOV RBP,R12
JMP 0x0018267f
caseD_10:
LEA RBP,[0x228171]
JMP 0x0018267f
caseD_e:
LEA RBP,[0x2280e1]
JMP 0x0018267f
caseD_ffffffff:
LEA RBP,[0x227b80]
JMP 0x0018267f
caseD_5:
LEA RBP,[0x227e38]
JMP 0x0018267f
caseD_11:
LEA RBP,[0x2281ba]
JMP 0x0018267f
caseD_0:
LEA RBP,[0x227ccb]
JMP 0x0018267f
caseD_2:
LEA RBP,[0x227d5d]
JMP 0x0018267f
caseD_13:
LEA RBP,[0x22824c]
JMP 0x0018267f
caseD_14:
LEA RBP,[0x228295]
JMP 0x0018267f
caseD_1b:
LEA RBP,[0x228493]
JMP 0x0018267f
caseD_9:
LEA RBP,[0x227f61]
JMP 0x0018267f
caseD_15:
LEA RBP,[0x2282de]
JMP 0x0018267f
caseD_d:
LEA RBP,[0x228093]
JMP 0x0018267f
caseD_1a:
LEA RBP,[0x22844a]
JMP 0x0018267f
caseD_a:
LEA RBP,[0x227faf]
JMP 0x0018267f
caseD_b:
LEA RBP,[0x227ffd]
JMP 0x0018267f
caseD_12:
LEA RBP,[0x228203]
JMP 0x0018267f
caseD_f:
LEA RBP,[0x228129]
JMP 0x0018267f
caseD_1d:
LEA RBP,[0x228524]
JMP 0x0018267f
caseD_16:
LEA RBP,[0x228327]
JMP 0x0018267f
caseD_17:
LEA RBP,[0x228370]
JMP 0x0018267f
caseD_80:
LEA RBP,[0x2285fc]
caseD_6f:
MOV qword ptr [RBX + 0x70],RBP
LAB_00182683:
MOV EAX,0xe
LAB_00182688:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00182697:
LEA RBP,[0x227bdc]
JMP 0x0018267f
LAB_001826a0:
LEA RBP,[0x227c28]
JMP 0x0018267f
LAB_001826a9:
LEA RDI,[0x227919]
LEA RDX,[0x21fb58]
LEA RCX,[0x227b70]
MOV ESI,0x1dd1
JMP 0x001826df
LAB_001826c5:
LEA RDI,[0x227919]
LEA RDX,[0x21fb58]
LEA RCX,[0x227c6c]
MOV ESI,0x1e49
LAB_001826df:
XOR EAX,EAX
CALL 0x00121ef0
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* 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_string() */
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_string(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)
{
char cVar1;
int4 uVar2;
int iVar3;
uint uVar4;
char *pcVar5;
int8 uVar6;
char cVar7;
int4 uVar8;
int8 local_48;
int4 uStack_40;
int4 uStack_3c;
int8 local_38;
reset(this);
if (*(int *)(this + 0x14) != 0x22) {
pcVar5 = "current == \'\\\"\'";
uVar6 = 0x1dd1;
LAB_001826df:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",uVar6,
"GGML_ASSERT(%s) failed",pcVar5);
}
cVar7 = (char)this + 'P';
LAB_001822a6:
uVar2 = get(this);
switch(uVar2) {
case 0:
pcVar5 = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
break;
case 1:
pcVar5 = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
break;
case 2:
pcVar5 = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";
break;
case 3:
pcVar5 = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
break;
case 4:
pcVar5 = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
break;
case 5:
pcVar5 = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
break;
case 6:
pcVar5 = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
break;
case 7:
pcVar5 = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
break;
case 8:
pcVar5 = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
break;
case 9:
pcVar5 = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
break;
case 10:
pcVar5 = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
break;
case 0xb:
pcVar5 = "invalid string: control character U+000B (VT) must be escaped to \\u000B";
break;
case 0xc:
pcVar5 = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
break;
case 0xd:
pcVar5 = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
break;
case 0xe:
pcVar5 = "invalid string: control character U+000E (SO) must be escaped to \\u000E";
break;
case 0xf:
pcVar5 = "invalid string: control character U+000F (SI) must be escaped to \\u000F";
break;
case 0x10:
pcVar5 = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
break;
case 0x11:
pcVar5 = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
break;
case 0x12:
pcVar5 = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
break;
case 0x13:
pcVar5 = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
break;
case 0x14:
pcVar5 = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
break;
case 0x15:
pcVar5 = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
break;
case 0x16:
pcVar5 = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
break;
case 0x17:
pcVar5 = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
break;
case 0x18:
pcVar5 = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
break;
case 0x19:
pcVar5 = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";
break;
case 0x1a:
pcVar5 = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";
break;
case 0x1b:
pcVar5 = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";
break;
case 0x1c:
pcVar5 = "invalid string: control character U+001C (FS) must be escaped to \\u001C";
break;
case 0x1d:
pcVar5 = "invalid string: control character U+001D (GS) must be escaped to \\u001D";
break;
case 0x1e:
pcVar5 = "invalid string: control character U+001E (RS) must be escaped to \\u001E";
break;
case 0x1f:
pcVar5 = "invalid string: control character U+001F (US) must be escaped to \\u001F";
break;
case 0x20:
case 0x21:
case 0x23:
case 0x24:
case 0x25:
case 0x26:
case 0x27:
case 0x28:
case 0x29:
case 0x2a:
case 0x2b:
case 0x2c:
case 0x2d:
case 0x2e:
case 0x2f:
case 0x30:
case 0x31:
case 0x32:
case 0x33:
case 0x34:
case 0x35:
case 0x36:
case 0x37:
case 0x38:
case 0x39:
case 0x3a:
case 0x3b:
case 0x3c:
case 0x3d:
case 0x3e:
case 0x3f:
case 0x40:
case 0x41:
case 0x42:
case 0x43:
case 0x44:
case 0x45:
case 0x46:
case 0x47:
case 0x48:
case 0x49:
case 0x4a:
case 0x4b:
case 0x4c:
case 0x4d:
case 0x4e:
case 0x4f:
case 0x50:
case 0x51:
case 0x52:
case 0x53:
case 0x54:
case 0x55:
case 0x56:
case 0x57:
case 0x58:
case 0x59:
case 0x5a:
case 0x5b:
case 0x5d:
case 0x5e:
case 0x5f:
case 0x60:
case 0x61:
case 0x62:
case 99:
case 100:
case 0x65:
case 0x66:
case 0x67:
case 0x68:
case 0x69:
case 0x6a:
case 0x6b:
case 0x6c:
case 0x6d:
case 0x6e:
case 0x6f:
case 0x70:
case 0x71:
case 0x72:
case 0x73:
case 0x74:
case 0x75:
case 0x76:
case 0x77:
case 0x78:
case 0x79:
case 0x7a:
case 0x7b:
case 0x7c:
case 0x7d:
case 0x7e:
case 0x7f:
goto LAB_001822f4;
case 0x22:
return 4;
case 0x5c:
iVar3 = get(this);
pcVar5 = "invalid string: forbidden character after backslash";
if (iVar3 < 0x62) {
if (((iVar3 != 0x22) && (iVar3 != 0x2f)) && (iVar3 != 0x5c)) break;
}
else {
switch(iVar3) {
case 0x6e:
break;
case 0x6f:
case 0x70:
case 0x71:
case 0x73:
goto switchD_0018238d_caseD_6f;
case 0x72:
break;
case 0x74:
break;
case 0x75:
uVar4 = get_codepoint(this);
pcVar5 = "invalid string: \'\\u\' must be followed by 4 hex digits";
if (uVar4 == 0xffffffff) goto switchD_0018238d_caseD_6f;
if ((uVar4 & 0xfffffc00) == 0xd800) {
iVar3 = get(this);
if ((iVar3 != 0x5c) || (iVar3 = get(this), iVar3 != 0x75)) {
pcVar5 = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
goto switchD_0018238d_caseD_6f;
}
uVar4 = get_codepoint(this);
if ((uVar4 == 0xffffffff) ||
(pcVar5 = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF"
, (uVar4 & 0xfffffc00) != 0xdc00)) goto switchD_0018238d_caseD_6f;
LAB_00182416:
std::__cxx11::string::push_back(cVar7);
LAB_00182433:
std::__cxx11::string::push_back(cVar7);
}
else {
if ((uVar4 & 0xfffffc00) == 0xdc00) {
pcVar5 = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
goto switchD_0018238d_caseD_6f;
}
if (0x10ffff < uVar4) {
pcVar5 = "0x00 <= codepoint && codepoint <= 0x10FFFF";
uVar6 = 0x1e49;
goto LAB_001826df;
}
if (uVar4 < 0x80) break;
if (0x7ff < uVar4) {
if (0xffff < uVar4) goto LAB_00182416;
goto LAB_00182433;
}
}
std::__cxx11::string::push_back(cVar7);
break;
default:
if ((iVar3 != 0x62) && (iVar3 != 0x66)) goto switchD_0018238d_caseD_6f;
}
}
LAB_001822f4:
std::__cxx11::string::push_back(cVar7);
goto LAB_001822a6;
default:
pcVar5 = "invalid string: ill-formed UTF-8 byte";
break;
case 0xc2:
case 0xc3:
case 0xc4:
case 0xc5:
case 0xc6:
case 199:
case 200:
case 0xc9:
case 0xca:
case 0xcb:
case 0xcc:
case 0xcd:
case 0xce:
case 0xcf:
case 0xd0:
case 0xd1:
case 0xd2:
case 0xd3:
case 0xd4:
case 0xd5:
case 0xd6:
case 0xd7:
case 0xd8:
case 0xd9:
case 0xda:
case 0xdb:
case 0xdc:
case 0xdd:
case 0xde:
case 0xdf:
local_48 = 0xbf00000080;
uVar6 = 2;
goto LAB_00182346;
case 0xe0:
uVar2 = _DAT_00220730;
uVar8 = _UNK_00220734;
uStack_40 = _UNK_00220738;
uStack_3c = _UNK_0022073c;
goto LAB_001822e3;
case 0xe1:
case 0xe2:
case 0xe3:
case 0xe4:
case 0xe5:
case 0xe6:
case 0xe7:
case 0xe8:
case 0xe9:
case 0xea:
case 0xeb:
case 0xec:
case 0xee:
case 0xef:
uVar2 = _DAT_00220720;
uVar8 = _UNK_00220724;
uStack_40 = _UNK_00220728;
uStack_3c = _UNK_0022072c;
goto LAB_001822e3;
case 0xed:
uVar2 = _DAT_00220710;
uVar8 = _UNK_00220714;
uStack_40 = _UNK_00220718;
uStack_3c = _UNK_0022071c;
LAB_001822e3:
local_48 = CONCAT44(uVar8,uVar2);
uVar6 = 4;
LAB_00182346:
cVar1 = next_byte_in_range(this,&local_48,uVar6);
if (cVar1 == '\0') {
return 0xe;
}
goto LAB_001822a6;
case 0xf0:
uVar2 = _DAT_0022a580;
uVar8 = _UNK_0022a584;
uStack_40 = _UNK_0022a588;
uStack_3c = _UNK_0022a58c;
goto LAB_0018232d;
case 0xf1:
case 0xf2:
case 0xf3:
uVar2 = _DAT_0022a598;
uVar8 = _UNK_0022a59c;
uStack_40 = _UNK_0022a5a0;
uStack_3c = _UNK_0022a5a4;
goto LAB_0018232d;
case 0xf4:
uVar2 = _DAT_0022a5b0;
uVar8 = _UNK_0022a5b4;
uStack_40 = _UNK_0022a5b8;
uStack_3c = _UNK_0022a5bc;
LAB_0018232d:
local_48 = CONCAT44(uVar8,uVar2);
local_38 = 0xbf00000080;
uVar6 = 6;
goto LAB_00182346;
case 0xffffffff:
pcVar5 = "invalid string: missing closing quote";
}
switchD_0018238d_caseD_6f:
*(char **)(this + 0x70) = pcVar5;
return 0xe;
}
|
|
63,620
|
minja::Parser::parseLogicalOr()
|
monkey531[P]llama/common/minja.hpp
|
std::shared_ptr<Expression> parseLogicalOr() {
auto left = parseLogicalAnd();
if (!left) throw std::runtime_error("Expected left side of 'logical or' expression");
static std::regex or_tok(R"(or\b)");
auto location = get_location();
while (!consumeToken(or_tok).empty()) {
auto right = parseLogicalAnd();
if (!right) throw std::runtime_error("Expected right side of 'or' expression");
left = std::make_shared<BinaryOpExpr>(location, std::move(left), std::move(right), BinaryOpExpr::Op::Or);
}
return left;
}
|
O2
|
cpp
|
minja::Parser::parseLogicalOr():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x4c94a
cmpq $0x0, (%rbx)
je 0x4c62d
leaq 0x97c98(%rip), %rax # 0xe41d8
movb (%rax), %al
testb %al, %al
je 0x4c65d
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x4ae82
leaq 0x28(%rsp), %rbp
leaq 0x48(%rsp), %r12
leaq 0xc(%rsp), %r13
movq %rbp, %rdi
movq %r14, %rsi
leaq 0x97c45(%rip), %rdx # 0xe41b8
pushq $0x1
popq %rcx
callq 0x4b2a6
movq 0x30(%rsp), %r15
movq %rbp, %rdi
callq 0x22f98
testq %r15, %r15
je 0x4c5df
movq %rbp, %rdi
movq %r14, %rsi
callq 0x4c94a
cmpq $0x0, 0x28(%rsp)
je 0x4c5fb
movl $0xf, 0xc(%rsp)
movq %r12, %rdi
leaq 0x10(%rsp), %rsi
movq %rbx, %rdx
movq %rbp, %rcx
movq %r13, %r8
callq 0x4cb4c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x63c32
leaq 0x50(%rsp), %rdi
callq 0x3542e
leaq 0x30(%rsp), %rdi
callq 0x3542e
jmp 0x4c566
leaq 0x18(%rsp), %rdi
callq 0x3542e
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x223e0
movq %rax, %r15
leaq 0x51595(%rip), %rsi # 0x9dba2
movq %rax, %rdi
callq 0x222b0
movq 0x969d4(%rip), %rsi # 0xe2ff0
movq 0x96945(%rip), %rdx # 0xe2f68
movq %r15, %rdi
callq 0x22d40
jmp 0x4c65d
pushq $0x10
popq %rdi
callq 0x223e0
movq %rax, %r15
leaq 0x51530(%rip), %rsi # 0x9db6f
movq %rax, %rdi
callq 0x222b0
movq 0x969a2(%rip), %rsi # 0xe2ff0
movq 0x96913(%rip), %rdx # 0xe2f68
movq %r15, %rdi
callq 0x22d40
leaq 0x97b74(%rip), %rdi # 0xe41d8
callq 0x22e00
testl %eax, %eax
je 0x4c54a
leaq 0x97b40(%rip), %rdi # 0xe41b8
leaq 0x5151e(%rip), %rsi # 0x9db9d
pushq $0x10
popq %rdx
callq 0x29ce4
leaq -0x226ee(%rip), %rdi # 0x29fa0
leaq 0x97b23(%rip), %rsi # 0xe41b8
leaq 0x9713c(%rip), %rdx # 0xe37d8
callq 0x226c0
leaq 0x97b30(%rip), %rdi # 0xe41d8
callq 0x22500
jmp 0x4c54a
movq %rax, %r14
leaq 0x97b1c(%rip), %rdi # 0xe41d8
callq 0x224f0
jmp 0x4c704
jmp 0x4c6d2
movq %rax, %r14
movq %r15, %rdi
callq 0x225c0
jmp 0x4c704
movq %rax, %r14
jmp 0x4c704
jmp 0x4c6e8
movq %rax, %r14
movq %r15, %rdi
callq 0x225c0
jmp 0x4c6eb
jmp 0x4c6f7
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x3542e
jmp 0x4c6fa
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x3542e
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x3542e
movq %r14, %rdi
callq 0x22da0
|
_ZN5minja6Parser14parseLogicalOrEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov r14, rsi
mov rbx, rdi
call _ZN5minja6Parser15parseLogicalAndEv; minja::Parser::parseLogicalAnd(void)
cmp qword ptr [rbx], 0
jz loc_4C62D
lea rax, _ZGVZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11; `guard variable for'minja::Parser::parseLogicalOr(void)::or_tok
mov al, [rax]
test al, al
jz loc_4C65D
loc_4C54A:
lea rdi, [rsp+88h+var_78]; this
mov rsi, r14
call _ZNK5minja6Parser12get_locationEv; minja::Parser::get_location(void)
lea rbp, [rsp+88h+var_60]
lea r12, [rsp+88h+var_40]
lea r13, [rsp+88h+var_7C]
loc_4C566:
mov rdi, rbp
mov rsi, r14
lea rdx, _ZZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11; minja::Parser::parseLogicalOr(void)::or_tok
push 1
pop rcx
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::basic_regex<char,std::regex_traits<char>> const&,minja::SpaceHandling)
mov r15, [rsp+88h+var_58]
mov rdi, rbp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test r15, r15
jz short loc_4C5DF
mov rdi, rbp; this
mov rsi, r14
call _ZN5minja6Parser15parseLogicalAndEv; minja::Parser::parseLogicalAnd(void)
cmp [rsp+88h+var_60], 0
jz short loc_4C5FB
mov [rsp+88h+var_7C], 0Fh
mov rdi, r12
lea rsi, [rsp+88h+var_78]
mov rdx, rbx
mov rcx, rbp
mov r8, r13
call _ZSt11make_sharedIN5minja12BinaryOpExprEJRNS0_8LocationESt10shared_ptrINS0_10ExpressionEES6_NS1_2OpEEES4_IT_EDpOT0_; std::make_shared<minja::BinaryOpExpr,minja::Location &,std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>,minja::BinaryOpExpr::Op>(minja::Location &,std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>,minja::BinaryOpExpr::Op &&)
mov rdi, rbx
mov rsi, r12
call _ZNSt12__shared_ptrIN5minja10ExpressionELN9__gnu_cxx12_Lock_policyE2EEaSINS0_12BinaryOpExprEEENSt9enable_ifIXsr20__sp_compatible_withIPT_PS1_EE5valueERS4_E4typeEOS_IS8_LS3_2EE
lea rdi, [rsp+88h+var_38]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+88h+var_58]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp short loc_4C566
loc_4C5DF:
lea rdi, [rsp+88h+var_70]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rax, rbx
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4C5FB:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rsi, aExpectedRightS; "Expected right side of 'or' expression"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
jmp short loc_4C65D
loc_4C62D:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rsi, aExpectedLeftSi; "Expected left side of 'logical or' expr"...
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
loc_4C65D:
lea rdi, _ZGVZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11; __guard *
call ___cxa_guard_acquire
test eax, eax
jz loc_4C54A
lea rdi, _ZZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11; minja::Parser::parseLogicalOr(void)::or_tok
lea rsi, aOrB; "or\\b"
push 10h
pop rdx
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2EPKcNSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex(char const*,std::regex_constants::syntax_option_type)
lea rdi, _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; lpfunc
lea rsi, _ZZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11; __guard *
call ___cxa_guard_release
jmp loc_4C54A
mov r14, rax
lea rdi, _ZGVZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11; __guard *
call ___cxa_guard_abort
jmp short loc_4C704
jmp short loc_4C6D2
mov r14, rax
mov rdi, r15; void *
call ___cxa_free_exception
jmp short loc_4C704
loc_4C6D2:
mov r14, rax
jmp short loc_4C704
jmp short loc_4C6E8
mov r14, rax
mov rdi, r15; void *
call ___cxa_free_exception
jmp short loc_4C6EB
jmp short loc_4C6F7
loc_4C6E8:
mov r14, rax
loc_4C6EB:
lea rdi, [rsp+arg_28]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp short loc_4C6FA
loc_4C6F7:
mov r14, rax
loc_4C6FA:
lea rdi, [rsp+arg_10]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
loc_4C704:
add rbx, 8
mov rdi, rbx
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, r14
call __Unwind_Resume
|
minja::Parser * minja::Parser::parseLogicalOr(minja::Parser *this, _QWORD *a2)
{
long long v2; // r15
std::runtime_error *v4; // r15
std::runtime_error *exception; // r15
int v6; // [rsp+Ch] [rbp-7Ch] BYREF
_BYTE v7[8]; // [rsp+10h] [rbp-78h] BYREF
long long v8; // [rsp+18h] [rbp-70h] BYREF
long long v9; // [rsp+28h] [rbp-60h] BYREF
_QWORD v10[3]; // [rsp+30h] [rbp-58h] BYREF
_BYTE v11[8]; // [rsp+48h] [rbp-40h] BYREF
_QWORD v12[7]; // [rsp+50h] [rbp-38h] BYREF
minja::Parser::parseLogicalAnd(this);
if ( !*(_QWORD *)this )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Expected left side of 'logical or' expression");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( !(_BYTE)`guard variable for'minja::Parser::parseLogicalOr(void)::or_tok[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'minja::Parser::parseLogicalOr(void)::or_tok[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&minja::Parser::parseLogicalOr(void)::or_tok[abi:cxx11],
(long long)"or\\b",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&minja::Parser::parseLogicalOr(void)::or_tok[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'minja::Parser::parseLogicalOr(void)::or_tok[abi:cxx11]);
}
minja::Parser::get_location((minja::Parser *)v7, a2);
while ( 1 )
{
minja::Parser::consumeToken(&v9, (long long)a2, (long long)&minja::Parser::parseLogicalOr(void)::or_tok[abi:cxx11], 1u);
v2 = v10[0];
std::string::~string(&v9);
if ( !v2 )
break;
minja::Parser::parseLogicalAnd((minja::Parser *)&v9);
if ( !v9 )
{
v4 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v4, "Expected right side of 'or' expression");
__cxa_throw(
v4,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v6 = 15;
std::make_shared<minja::BinaryOpExpr,minja::Location &,std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>,minja::BinaryOpExpr::Op>(
v11,
v7,
this,
&v9,
&v6);
std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator=<minja::BinaryOpExpr>(this, v11);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(v12);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(v10);
}
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v8);
return this;
}
|
parseLogicalOr:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R14,RSI
MOV RBX,RDI
CALL 0x0014c94a
CMP qword ptr [RBX],0x0
JZ 0x0014c62d
LEA RAX,[0x1e41d8]
MOV AL,byte ptr [RAX]
TEST AL,AL
JZ 0x0014c65d
LAB_0014c54a:
LEA RDI,[RSP + 0x10]
MOV RSI,R14
CALL 0x0014ae82
LEA RBP,[RSP + 0x28]
LEA R12,[RSP + 0x48]
LEA R13,[RSP + 0xc]
LAB_0014c566:
MOV RDI,RBP
MOV RSI,R14
LEA RDX,[0x1e41b8]
PUSH 0x1
POP RCX
CALL 0x0014b2a6
MOV R15,qword ptr [RSP + 0x30]
MOV RDI,RBP
CALL 0x00122f98
TEST R15,R15
JZ 0x0014c5df
LAB_0014c58d:
MOV RDI,RBP
MOV RSI,R14
CALL 0x0014c94a
CMP qword ptr [RSP + 0x28],0x0
JZ 0x0014c5fb
MOV dword ptr [RSP + 0xc],0xf
LAB_0014c5a8:
MOV RDI,R12
LEA RSI,[RSP + 0x10]
MOV RDX,RBX
MOV RCX,RBP
MOV R8,R13
CALL 0x0014cb4c
LAB_0014c5be:
MOV RDI,RBX
MOV RSI,R12
CALL 0x00163c32
LEA RDI,[RSP + 0x50]
CALL 0x0013542e
LEA RDI,[RSP + 0x30]
CALL 0x0013542e
JMP 0x0014c566
LAB_0014c5df:
LEA RDI,[RSP + 0x18]
CALL 0x0013542e
MOV RAX,RBX
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0014c5fb:
PUSH 0x10
POP RDI
CALL 0x001223e0
MOV R15,RAX
LAB_0014c606:
LEA RSI,[0x19dba2]
MOV RDI,RAX
CALL 0x001222b0
LAB_0014c615:
MOV RSI,qword ptr [0x001e2ff0]
MOV RDX,qword ptr [0x001e2f68]
MOV RDI,R15
CALL 0x00122d40
LAB_0014c62d:
PUSH 0x10
POP RDI
CALL 0x001223e0
MOV R15,RAX
LAB_0014c638:
LEA RSI,[0x19db6f]
MOV RDI,RAX
CALL 0x001222b0
LAB_0014c647:
MOV RSI,qword ptr [0x001e2ff0]
MOV RDX,qword ptr [0x001e2f68]
MOV RDI,R15
CALL 0x00122d40
LAB_0014c65d:
LEA RDI,[0x1e41d8]
CALL 0x00122e00
TEST EAX,EAX
JZ 0x0014c54a
LAB_0014c671:
LEA RDI,[0x1e41b8]
LEA RSI,[0x19db9d]
PUSH 0x10
POP RDX
CALL 0x00129ce4
LAB_0014c687:
LEA RDI,[0x129fa0]
LEA RSI,[0x1e41b8]
LEA RDX,[0x1e37d8]
CALL 0x001226c0
LEA RDI,[0x1e41d8]
CALL 0x00122500
JMP 0x0014c54a
|
/* minja::Parser::parseLogicalOr() */
void minja::Parser::parseLogicalOr(void)
{
long lVar1;
int iVar2;
runtime_error *prVar3;
__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2> *in_RDI;
shared_ptr local_78 [8];
__shared_count<(__gnu_cxx::_Lock_policy)2> local_70 [16];
long local_60;
long local_58 [3];
Location local_40 [8];
__shared_count<(__gnu_cxx::_Lock_policy)2> local_38 [8];
parseLogicalAnd();
if (*(long *)in_RDI == 0) {
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0014c638 to 0014c646 has its CatchHandler @ 0014c6c5 */
std::runtime_error::runtime_error(prVar3,"Expected left side of \'logical or\' expression");
/* try { // try from 0014c647 to 0014c65c has its CatchHandler @ 0014c6c3 */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_001e2ff0,PTR__runtime_error_001e2f68);
}
if (parseLogicalOr()::or_tok_abi_cxx11_ == '\0') {
iVar2 = __cxa_guard_acquire(&parseLogicalOr()::or_tok_abi_cxx11_);
if (iVar2 != 0) {
/* try { // try from 0014c671 to 0014c686 has its CatchHandler @ 0014c6b2 */
std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::basic_regex
((basic_regex<char,std::__cxx11::regex_traits<char>> *)
parseLogicalOr()::or_tok_abi_cxx11_,&DAT_0019db9d,0x10);
__cxa_atexit(std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::~basic_regex,
parseLogicalOr()::or_tok_abi_cxx11_,&__dso_handle);
__cxa_guard_release(&parseLogicalOr()::or_tok_abi_cxx11_);
}
}
/* try { // try from 0014c54a to 0014c556 has its CatchHandler @ 0014c6d2 */
get_location();
while( true ) {
/* try { // try from 0014c566 to 0014c57a has its CatchHandler @ 0014c6f7 */
consumeToken((string *)&local_60);
lVar1 = local_58[0];
std::__cxx11::string::~string((string *)&local_60);
if (lVar1 == 0) {
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_70);
return;
}
/* try { // try from 0014c58d to 0014c597 has its CatchHandler @ 0014c6e6 */
parseLogicalAnd();
if (local_60 == 0) break;
/* try { // try from 0014c5a8 to 0014c5bd has its CatchHandler @ 0014c6e8 */
std::
make_shared<minja::BinaryOpExpr,minja::Location&,std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>,minja::BinaryOpExpr::Op>
(local_40,local_78,in_RDI,(Op *)&local_60);
std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator=
(in_RDI,(__shared_ptr *)local_40);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_38);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)local_58);
}
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0014c606 to 0014c614 has its CatchHandler @ 0014c6d9 */
std::runtime_error::runtime_error(prVar3,"Expected right side of \'or\' expression");
/* try { // try from 0014c615 to 0014c62a has its CatchHandler @ 0014c6d7 */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_001e2ff0,PTR__runtime_error_001e2f68);
}
|
|
63,621
|
my_strnxfrm_czech
|
eloqsql/strings/ctype-czech.c
|
static size_t
my_strnxfrm_czech(CHARSET_INFO *cs __attribute__((unused)),
uchar *dest, size_t len,
uint nweights_arg __attribute__((unused)),
const uchar *src, size_t srclen, uint flags)
{
int value;
const uchar *p, * store;
int pass = 0;
size_t totlen = 0;
p = src; store = src;
if (!(flags & 0x0F)) /* All levels by default */
flags|= 0x0F;
do
{
int add= (1 << pass) & flags; /* If this level is needed */
NEXT_CMP_VALUE(src, p, store, pass, value, (int)srclen);
if (add)
ADD_TO_RESULT(dest, len, totlen, value);
}
while (value);
if ((flags & MY_STRXFRM_PAD_TO_MAXLEN) && len > totlen)
{
memset(dest + totlen, ' ', len - totlen);
totlen= len;
}
return totlen;
}
|
O3
|
c
|
my_strnxfrm_czech:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r15
movq %rdx, %rbx
movq %rsi, -0x48(%rbp)
movl 0x10(%rbp), %eax
movl %eax, %r11d
orl $0xf, %r11d
testb $0xf, %al
cmovnel %eax, %r11d
movslq %r9d, %rdx
movl $0x1, %eax
subq %r8, %rax
movq %rax, -0x50(%rbp)
xorl %ecx, %ecx
leaq 0x2b5f08(%rip), %r13 # 0x2e7660
movq %r8, %r14
xorl %r12d, %r12d
movq %rbx, -0x38(%rbp)
movl %r11d, -0x2c(%rbp)
movl $0x1, %esi
shll %cl, %esi
movq %r8, %rax
subq %r15, %rax
cmpq %rdx, %rax
jge 0x317f7
movslq %ecx, %rax
movq %rax, -0x58(%rbp)
movq (%r13,%rax,8), %r9
movzbl (%r8), %eax
movzbl (%r9,%rax), %eax
testl %eax, %eax
je 0x317c6
cmpl $0x2, %eax
jne 0x3182b
incq %r8
movq %r8, %rax
subq %r15, %rax
movq %r8, %r10
cmpq %rdx, %rax
jge 0x317d4
movzbl (%r10), %edi
cmpb $0x2, (%r9,%rdi)
jne 0x317d4
incq %r10
incq %rax
movq %r10, %rdi
cmpq %rdx, %rax
jl 0x317ab
jmp 0x317d7
incq %r8
movq %r8, %rax
subq %r15, %rax
movq %r8, %r10
jmp 0x317f0
movq %r8, %rdi
cmpl $0x3, %ecx
cmovgeq %rdi, %r10
movq %r10, %rax
subq %r15, %rax
cmpq %rdx, %rax
jl 0x318ac
movq %r10, %r8
cmpq %rdx, %rax
jl 0x31784
jmp 0x317fa
movq %r8, %r10
cmpl $0x3, %ecx
jne 0x31812
xorl %r9d, %r9d
movl $0x3, %ecx
movq %r14, %rax
movq %r10, %r8
jmp 0x31904
testl %ecx, %ecx
movq %r15, %r8
cmoveq %r14, %r8
incl %ecx
movl $0x1, %r9d
movq %r14, %rax
jmp 0x31904
cmpl $0xff, %eax
jne 0x318fa
movq %r12, -0x40(%rbp)
movq %r8, %r9
subq %r15, %r9
movq -0x50(%rbp), %rax
addq %r8, %rax
movq %rax, -0x60(%rbp)
xorl %ebx, %ebx
movq %rbx, %r11
shlq $0x4, %r11
leaq 0x2b5e25(%rip), %rax # 0x2e7680
movq (%r11,%rax), %r13
movb (%r13), %al
testb %al, %al
je 0x31898
cmpq %rdx, %r9
jge 0x31898
incq %r13
movq -0x60(%rbp), %r10
movq %r8, %r12
cmpb %al, (%r12)
jne 0x3189f
incq %r12
movb (%r13), %al
testb %al, %al
je 0x3189b
incq %r13
leaq 0x1(%r10), %rdi
cmpq %rdx, %r10
movq %rdi, %r10
jl 0x31876
jmp 0x3189b
movq %r8, %r12
testb %al, %al
je 0x318cc
incq %rbx
cmpq $0x50, %rbx
jne 0x3184d
movb $-0x1, %al
jmp 0x318e7
movl $0x2, %r9d
cmpl $0x1, %ecx
jg 0x31807
movl $0x1, %edi
subl %ecx, %edi
movq %r10, %rax
movl %edi, %ecx
movq %r14, %r8
jmp 0x31904
leaq 0x2b5dad(%rip), %rax # 0x2e7680
addq %rax, %r11
movq 0x8(%r11), %rax
movq -0x58(%rbp), %rdi
movb (%rax,%rdi), %al
decq %r12
movq %r12, %r8
movq -0x38(%rbp), %rbx
movl -0x2c(%rbp), %r11d
movq -0x40(%rbp), %r12
leaq 0x2b5d66(%rip), %r13 # 0x2e7660
movzbl %al, %r9d
incq %r8
movq %r14, %rax
testl %r11d, %esi
setne %r10b
cmpq %rbx, %r12
setb %dil
andb %r10b, %dil
cmpb $0x1, %dil
jne 0x31926
movq -0x48(%rbp), %rsi
movb %r9b, (%rsi,%r12)
incq %r12
movq %rax, %r14
testl %r9d, %r9d
jne 0x31766
testb %r11b, %r11b
sets %al
movq %rbx, %rdx
subq %r12, %rdx
seta %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x3195b
movq -0x48(%rbp), %rdi
addq %r12, %rdi
movl $0x20, %esi
callq 0x24180
jmp 0x3195e
movq %r12, %rbx
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_strnxfrm_czech:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r15, r8
mov rbx, rdx
mov [rbp+var_48], rsi
mov eax, [rbp+arg_0]
mov r11d, eax
or r11d, 0Fh
test al, 0Fh
cmovnz r11d, eax
movsxd rdx, r9d
mov eax, 1
sub rax, r8
mov [rbp+var_50], rax
xor ecx, ecx
lea r13, CZ_SORT_TABLE
mov r14, r8
xor r12d, r12d
mov [rbp+var_38], rbx
mov [rbp+var_2C], r11d
loc_31766:
mov esi, 1
shl esi, cl
mov rax, r8
sub rax, r15
cmp rax, rdx
jge short loc_317F7
movsxd rax, ecx
mov [rbp+var_58], rax
mov r9, [r13+rax*8+0]
loc_31784:
movzx eax, byte ptr [r8]
movzx eax, byte ptr [r9+rax]
test eax, eax
jz short loc_317C6
cmp eax, 2
jnz loc_3182B
inc r8
mov rax, r8
sub rax, r15
mov r10, r8
cmp rax, rdx
jge short loc_317D4
loc_317AB:
movzx edi, byte ptr [r10]
cmp byte ptr [r9+rdi], 2
jnz short loc_317D4
inc r10
inc rax
mov rdi, r10
cmp rax, rdx
jl short loc_317AB
jmp short loc_317D7
loc_317C6:
inc r8
mov rax, r8
sub rax, r15
mov r10, r8
jmp short loc_317F0
loc_317D4:
mov rdi, r8
loc_317D7:
cmp ecx, 3
cmovge r10, rdi
mov rax, r10
sub rax, r15
cmp rax, rdx
jl loc_318AC
mov r8, r10
loc_317F0:
cmp rax, rdx
jl short loc_31784
jmp short loc_317FA
loc_317F7:
mov r10, r8
loc_317FA:
cmp ecx, 3
jnz short loc_31812
xor r9d, r9d
mov ecx, 3
loc_31807:
mov rax, r14
mov r8, r10
jmp loc_31904
loc_31812:
test ecx, ecx
mov r8, r15
cmovz r8, r14
inc ecx
mov r9d, 1
mov rax, r14
jmp loc_31904
loc_3182B:
cmp eax, 0FFh
jnz loc_318FA
mov [rbp+var_40], r12
mov r9, r8
sub r9, r15
mov rax, [rbp+var_50]
add rax, r8
mov [rbp+var_60], rax
xor ebx, ebx
loc_3184D:
mov r11, rbx
shl r11, 4
lea rax, doubles
mov r13, [r11+rax]
mov al, [r13+0]
test al, al
jz short loc_31898
cmp r9, rdx
jge short loc_31898
inc r13
mov r10, [rbp+var_60]
mov r12, r8
loc_31876:
cmp [r12], al
jnz short loc_3189F
inc r12
mov al, [r13+0]
test al, al
jz short loc_3189B
inc r13
lea rdi, [r10+1]
cmp r10, rdx
mov r10, rdi
jl short loc_31876
jmp short loc_3189B
loc_31898:
mov r12, r8
loc_3189B:
test al, al
jz short loc_318CC
loc_3189F:
inc rbx
cmp rbx, 50h ; 'P'
jnz short loc_3184D
mov al, 0FFh
jmp short loc_318E7
loc_318AC:
mov r9d, 2
cmp ecx, 1
jg loc_31807
mov edi, 1
sub edi, ecx
mov rax, r10
mov ecx, edi
mov r8, r14
jmp short loc_31904
loc_318CC:
lea rax, doubles
add r11, rax
mov rax, [r11+8]
mov rdi, [rbp+var_58]
mov al, [rax+rdi]
dec r12
mov r8, r12
loc_318E7:
mov rbx, [rbp+var_38]
mov r11d, [rbp+var_2C]
mov r12, [rbp+var_40]
lea r13, CZ_SORT_TABLE
loc_318FA:
movzx r9d, al
inc r8
mov rax, r14
loc_31904:
test esi, r11d
setnz r10b
cmp r12, rbx
setb dil
and dil, r10b
cmp dil, 1
jnz short loc_31926
mov rsi, [rbp+var_48]
mov [rsi+r12], r9b
inc r12
loc_31926:
mov r14, rax
test r9d, r9d
jnz loc_31766
test r11b, r11b
sets al
mov rdx, rbx
sub rdx, r12
setnbe cl
and cl, al
cmp cl, 1
jnz short loc_3195B
mov rdi, [rbp+var_48]
add rdi, r12
mov esi, 20h ; ' '
call _memset
jmp short loc_3195E
loc_3195B:
mov rbx, r12
loc_3195E:
mov rax, rbx
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
unsigned long long my_strnxfrm_czech(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
unsigned __int8 *a5,
int a6,
int a7)
{
unsigned __int8 *v7; // r15
int v9; // r11d
long long v10; // rdx
int v11; // ecx
unsigned __int8 *v12; // r14
unsigned long long v13; // r12
int v14; // esi
long long v15; // r9
int v16; // eax
unsigned __int8 *v17; // r8
long long v18; // rax
unsigned __int8 *v19; // r10
unsigned __int8 *v20; // rdi
unsigned __int8 *v21; // rax
int v22; // r9d
unsigned __int8 *v23; // rax
long long v24; // rbx
char *v25; // r13
char v26; // al
char *v27; // r13
unsigned __int8 *v28; // r10
_BYTE *v29; // r12
long long v32; // [rsp+10h] [rbp-50h]
unsigned long long v34; // [rsp+20h] [rbp-40h]
unsigned long long v35; // [rsp+28h] [rbp-38h]
int v36; // [rsp+34h] [rbp-2Ch]
v7 = a5;
v9 = a7 | 0xF;
if ( (a7 & 0xF) != 0 )
v9 = a7;
v10 = a6;
v32 = 1LL - (_QWORD)a5;
v11 = 0;
v12 = a5;
v13 = 0LL;
v35 = a3;
v36 = v9;
do
{
v14 = 1 << v11;
if ( a5 - v7 >= v10 )
{
v19 = a5;
LABEL_21:
if ( v11 != 3 )
{
a5 = v7;
if ( !v11 )
a5 = v12;
++v11;
v22 = 1;
v23 = v12;
goto LABEL_45;
}
v22 = 0;
v11 = 3;
LABEL_23:
v23 = v12;
a5 = v19;
goto LABEL_45;
}
v15 = (long long)*(&CZ_SORT_TABLE + v11);
while ( 1 )
{
v16 = *(unsigned __int8 *)(v15 + *a5);
if ( !*(_BYTE *)(v15 + *a5) )
{
v21 = (unsigned __int8 *)(++a5 - v7);
v19 = a5;
goto LABEL_18;
}
if ( v16 != 2 )
break;
v17 = a5 + 1;
v18 = v17 - v7;
v19 = v17;
if ( v17 - v7 < v10 )
{
while ( *(_BYTE *)(v15 + *v19) == 2 )
{
++v19;
++v18;
v20 = v19;
if ( v18 >= v10 )
goto LABEL_14;
}
}
v20 = v17;
LABEL_14:
if ( v11 >= 3 )
v19 = v20;
v21 = (unsigned __int8 *)(v19 - v7);
if ( v19 - v7 < v10 )
{
v22 = 2;
if ( v11 <= 1 )
{
v23 = v19;
v11 = 1 - v11;
a5 = v12;
goto LABEL_45;
}
goto LABEL_23;
}
a5 = v19;
LABEL_18:
if ( (long long)v21 >= v10 )
goto LABEL_21;
}
if ( v16 != 255 )
goto LABEL_44;
v34 = v13;
v24 = 0LL;
while ( 2 )
{
v25 = (char *)*(&doubles + 2 * v24);
v26 = *v25;
if ( *v25 && a5 - v7 < v10 )
{
v27 = v25 + 1;
v28 = &a5[v32];
v29 = a5;
while ( *v29 == v26 )
{
++v29;
v26 = *v27;
if ( *v27 )
{
++v27;
if ( (long long)v28++ < v10 )
continue;
}
goto LABEL_37;
}
goto LABEL_38;
}
v29 = a5;
LABEL_37:
if ( v26 )
{
LABEL_38:
if ( ++v24 == 80 )
{
LOBYTE(v16) = -1;
goto LABEL_43;
}
continue;
}
break;
}
LOBYTE(v16) = *((_BYTE *)*(&doubles + 2 * v24 + 1) + v11);
a5 = v29 - 1;
LABEL_43:
a3 = v35;
v9 = v36;
v13 = v34;
LABEL_44:
v22 = (unsigned __int8)v16;
++a5;
v23 = v12;
LABEL_45:
if ( (v9 & v14) != 0 && v13 < a3 )
*(_BYTE *)(a2 + v13++) = v22;
v12 = v23;
}
while ( v22 );
if ( (v9 & 0x80u) == 0 || a3 <= v13 )
return v13;
memset(v13 + a2, 32LL, a3 - v13);
return a3;
}
|
my_strnxfrm_czech:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R15,R8
MOV RBX,RDX
MOV qword ptr [RBP + -0x48],RSI
MOV EAX,dword ptr [RBP + 0x10]
MOV R11D,EAX
OR R11D,0xf
TEST AL,0xf
CMOVNZ R11D,EAX
MOVSXD RDX,R9D
MOV EAX,0x1
SUB RAX,R8
MOV qword ptr [RBP + -0x50],RAX
XOR ECX,ECX
LEA R13,[0x3e7660]
MOV R14,R8
XOR R12D,R12D
MOV qword ptr [RBP + -0x38],RBX
MOV dword ptr [RBP + -0x2c],R11D
LAB_00131766:
MOV ESI,0x1
SHL ESI,CL
MOV RAX,R8
SUB RAX,R15
CMP RAX,RDX
JGE 0x001317f7
MOVSXD RAX,ECX
MOV qword ptr [RBP + -0x58],RAX
MOV R9,qword ptr [R13 + RAX*0x8]
LAB_00131784:
MOVZX EAX,byte ptr [R8]
MOVZX EAX,byte ptr [R9 + RAX*0x1]
TEST EAX,EAX
JZ 0x001317c6
CMP EAX,0x2
JNZ 0x0013182b
INC R8
MOV RAX,R8
SUB RAX,R15
MOV R10,R8
CMP RAX,RDX
JGE 0x001317d4
LAB_001317ab:
MOVZX EDI,byte ptr [R10]
CMP byte ptr [R9 + RDI*0x1],0x2
JNZ 0x001317d4
INC R10
INC RAX
MOV RDI,R10
CMP RAX,RDX
JL 0x001317ab
JMP 0x001317d7
LAB_001317c6:
INC R8
MOV RAX,R8
SUB RAX,R15
MOV R10,R8
JMP 0x001317f0
LAB_001317d4:
MOV RDI,R8
LAB_001317d7:
CMP ECX,0x3
CMOVGE R10,RDI
MOV RAX,R10
SUB RAX,R15
CMP RAX,RDX
JL 0x001318ac
MOV R8,R10
LAB_001317f0:
CMP RAX,RDX
JL 0x00131784
JMP 0x001317fa
LAB_001317f7:
MOV R10,R8
LAB_001317fa:
CMP ECX,0x3
JNZ 0x00131812
XOR R9D,R9D
MOV ECX,0x3
LAB_00131807:
MOV RAX,R14
MOV R8,R10
JMP 0x00131904
LAB_00131812:
TEST ECX,ECX
MOV R8,R15
CMOVZ R8,R14
INC ECX
MOV R9D,0x1
MOV RAX,R14
JMP 0x00131904
LAB_0013182b:
CMP EAX,0xff
JNZ 0x001318fa
MOV qword ptr [RBP + -0x40],R12
MOV R9,R8
SUB R9,R15
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,R8
MOV qword ptr [RBP + -0x60],RAX
XOR EBX,EBX
LAB_0013184d:
MOV R11,RBX
SHL R11,0x4
LEA RAX,[0x3e7680]
MOV R13,qword ptr [R11 + RAX*0x1]
MOV AL,byte ptr [R13]
TEST AL,AL
JZ 0x00131898
CMP R9,RDX
JGE 0x00131898
INC R13
MOV R10,qword ptr [RBP + -0x60]
MOV R12,R8
LAB_00131876:
CMP byte ptr [R12],AL
JNZ 0x0013189f
INC R12
MOV AL,byte ptr [R13]
TEST AL,AL
JZ 0x0013189b
INC R13
LEA RDI,[R10 + 0x1]
CMP R10,RDX
MOV R10,RDI
JL 0x00131876
JMP 0x0013189b
LAB_00131898:
MOV R12,R8
LAB_0013189b:
TEST AL,AL
JZ 0x001318cc
LAB_0013189f:
INC RBX
CMP RBX,0x50
JNZ 0x0013184d
MOV AL,0xff
JMP 0x001318e7
LAB_001318ac:
MOV R9D,0x2
CMP ECX,0x1
JG 0x00131807
MOV EDI,0x1
SUB EDI,ECX
MOV RAX,R10
MOV ECX,EDI
MOV R8,R14
JMP 0x00131904
LAB_001318cc:
LEA RAX,[0x3e7680]
ADD R11,RAX
MOV RAX,qword ptr [R11 + 0x8]
MOV RDI,qword ptr [RBP + -0x58]
MOV AL,byte ptr [RAX + RDI*0x1]
DEC R12
MOV R8,R12
LAB_001318e7:
MOV RBX,qword ptr [RBP + -0x38]
MOV R11D,dword ptr [RBP + -0x2c]
MOV R12,qword ptr [RBP + -0x40]
LEA R13,[0x3e7660]
LAB_001318fa:
MOVZX R9D,AL
INC R8
MOV RAX,R14
LAB_00131904:
TEST ESI,R11D
SETNZ R10B
CMP R12,RBX
SETC DIL
AND DIL,R10B
CMP DIL,0x1
JNZ 0x00131926
MOV RSI,qword ptr [RBP + -0x48]
MOV byte ptr [RSI + R12*0x1],R9B
INC R12
LAB_00131926:
MOV R14,RAX
TEST R9D,R9D
JNZ 0x00131766
TEST R11B,R11B
SETS AL
MOV RDX,RBX
SUB RDX,R12
SETA CL
AND CL,AL
CMP CL,0x1
JNZ 0x0013195b
MOV RDI,qword ptr [RBP + -0x48]
ADD RDI,R12
MOV ESI,0x20
CALL 0x00124180
JMP 0x0013195e
LAB_0013195b:
MOV RBX,R12
LAB_0013195e:
MOV RAX,RBX
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong my_strnxfrm_czech(int8 param_1,long param_2,ulong param_3,int8 param_4,
byte *param_5,int param_6,uint param_7)
{
uint uVar1;
byte *pbVar2;
byte *pbVar3;
byte bVar4;
char cVar5;
long lVar6;
byte *pbVar7;
byte bVar8;
int iVar9;
long lVar10;
byte *pbVar11;
byte *pbVar12;
byte *pbVar13;
ulong uVar14;
byte *pbVar15;
uVar1 = param_7 | 0xf;
if ((param_7 & 0xf) != 0) {
uVar1 = param_7;
}
lVar10 = (long)param_6;
iVar9 = 0;
uVar14 = 0;
pbVar13 = param_5;
pbVar15 = param_5;
LAB_00131766:
bVar8 = (byte)iVar9;
pbVar7 = pbVar15;
if ((long)pbVar13 - (long)param_5 < lVar10) {
do {
cVar5 = (&CZ_SORT_TABLE)[iVar9][*pbVar13];
if (cVar5 == '\0') {
pbVar13 = pbVar13 + 1;
lVar6 = (long)pbVar13 - (long)param_5;
}
else {
if (cVar5 != '\x02') {
if (cVar5 != -1) goto LAB_001318fa;
lVar6 = 0;
goto LAB_0013184d;
}
pbVar12 = pbVar13 + 1;
lVar6 = (long)pbVar12 - (long)param_5;
pbVar13 = pbVar12;
while ((pbVar11 = pbVar13, lVar6 < lVar10 &&
(pbVar11 = pbVar12, (&CZ_SORT_TABLE)[iVar9][*pbVar13] == '\x02'))) {
pbVar13 = pbVar13 + 1;
lVar6 = lVar6 + 1;
}
if (2 < iVar9) {
pbVar13 = pbVar11;
}
lVar6 = (long)pbVar13 - (long)param_5;
if (lVar6 < lVar10) {
cVar5 = '\x02';
if (iVar9 < 2) {
iVar9 = 1 - iVar9;
pbVar7 = pbVar13;
pbVar13 = pbVar15;
}
goto LAB_00131904;
}
}
} while (lVar6 < lVar10);
}
if (iVar9 == 3) {
cVar5 = '\0';
iVar9 = 3;
}
else {
pbVar13 = param_5;
if (iVar9 == 0) {
pbVar13 = pbVar15;
}
iVar9 = iVar9 + 1;
cVar5 = '\x01';
}
goto LAB_00131904;
LAB_0013184d:
do {
pbVar15 = (&doubles)[lVar6 * 2];
bVar4 = *pbVar15;
pbVar12 = pbVar13;
pbVar3 = pbVar13 + (1 - (long)param_5);
pbVar11 = pbVar13 + -(long)param_5;
if (bVar4 != 0) {
while (pbVar2 = pbVar3, (long)pbVar11 < lVar10) {
pbVar15 = pbVar15 + 1;
if (*pbVar12 != bVar4) goto LAB_0013189f;
pbVar12 = pbVar12 + 1;
bVar4 = *pbVar15;
if (bVar4 == 0) break;
pbVar3 = pbVar2 + 1;
pbVar11 = pbVar2;
}
}
if (bVar4 == 0) {
cVar5 = (&PTR_DAT_003e7688)[lVar6 * 2][iVar9];
pbVar13 = pbVar12 + -1;
goto LAB_001318fa;
}
LAB_0013189f:
lVar6 = lVar6 + 1;
} while (lVar6 != 0x50);
cVar5 = -1;
LAB_001318fa:
pbVar13 = pbVar13 + 1;
LAB_00131904:
if (uVar14 < param_3 && (1 << (bVar8 & 0x1f) & uVar1) != 0) {
*(char *)(param_2 + uVar14) = cVar5;
uVar14 = uVar14 + 1;
}
pbVar15 = pbVar7;
if (cVar5 == '\0') {
if ((uVar14 <= param_3 && param_3 - uVar14 != 0) && (char)uVar1 < '\0') {
memset((void *)(param_2 + uVar14),0x20,param_3 - uVar14);
uVar14 = param_3;
}
return uVar14;
}
goto LAB_00131766;
}
|
|
63,622
|
my_getcputime
|
eloqsql/mysys/my_getsystime.c
|
ulonglong my_getcputime()
{
#ifdef CLOCK_THREAD_CPUTIME_ID
struct timespec tp;
if (clock_gettime(CLOCK_THREAD_CPUTIME_ID, &tp))
return 0;
return (ulonglong)tp.tv_sec*10000000+(ulonglong)tp.tv_nsec/100;
#elif defined(__NR_clock_gettime)
struct timespec tp;
if (syscall(__NR_clock_gettime, CLOCK_THREAD_CPUTIME_ID, &tp))
return 0;
return (ulonglong)tp.tv_sec*10000000+(ulonglong)tp.tv_nsec/100;
#endif /* CLOCK_THREAD_CPUTIME_ID */
return 0;
}
|
O3
|
c
|
my_getcputime:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x10(%rbp), %rsi
movl $0x3, %edi
callq 0x24290
testl %eax, %eax
je 0x2c3a4
xorl %eax, %eax
jmp 0x2c3cb
imulq $0x989680, -0x10(%rbp), %rcx # imm = 0x989680
movq -0x8(%rbp), %rax
shrq $0x2, %rax
movabsq $0x28f5c28f5c28f5c3, %rdx # imm = 0x28F5C28F5C28F5C3
mulq %rdx
movq %rdx, %rax
shrq $0x2, %rax
addq %rcx, %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
|
my_getcputime:
push rbp
mov rbp, rsp
sub rsp, 10h
lea rsi, [rbp+var_10]
mov edi, 3
call _clock_gettime
test eax, eax
jz short loc_2C3A4
xor eax, eax
jmp short loc_2C3CB
loc_2C3A4:
imul rcx, [rbp+var_10], 989680h
mov rax, [rbp+var_8]
shr rax, 2
mov rdx, 28F5C28F5C28F5C3h
mul rdx
mov rax, rdx
shr rax, 2
add rax, rcx
loc_2C3CB:
add rsp, 10h
pop rbp
retn
|
unsigned long long my_getcputime()
{
long long v1; // [rsp+0h] [rbp-10h] BYREF
unsigned long long v2; // [rsp+8h] [rbp-8h]
if ( (unsigned int)clock_gettime(3LL, &v1) )
return 0LL;
else
return 10000000 * v1 + v2 / 0x64;
}
|
my_getcputime:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
LEA RSI,[RBP + -0x10]
MOV EDI,0x3
CALL 0x00124290
TEST EAX,EAX
JZ 0x0012c3a4
XOR EAX,EAX
JMP 0x0012c3cb
LAB_0012c3a4:
IMUL RCX,qword ptr [RBP + -0x10],0x989680
MOV RAX,qword ptr [RBP + -0x8]
SHR RAX,0x2
MOV RDX,0x28f5c28f5c28f5c3
MUL RDX
MOV RAX,RDX
SHR RAX,0x2
ADD RAX,RCX
LAB_0012c3cb:
ADD RSP,0x10
POP RBP
RET
|
long my_getcputime(void)
{
int iVar1;
long lVar2;
timespec local_18;
iVar1 = clock_gettime(3,&local_18);
if (iVar1 == 0) {
lVar2 = (ulong)local_18.tv_nsec / 100 + local_18.tv_sec * 10000000;
}
else {
lVar2 = 0;
}
return lVar2;
}
|
|
63,623
|
my_casedn_ucs2
|
eloqsql/strings/ctype-ucs2.c
|
static size_t my_casedn_ucs2(CHARSET_INFO *cs, const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
int res;
const char *srcend= src + srclen;
char *dstend= dst + dstlen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(srclen <= dstlen);
while ((src < srcend) &&
(res= my_ucs2_uni(cs, &wc, (uchar*) src, (uchar*) srcend)) > 0)
{
my_tolower_ucs2(uni_plane, &wc);
if (res != my_uni_ucs2(cs, wc, (uchar*) dst, (uchar*) dstend))
break;
src+= res;
dst+= res;
}
return srclen;
}
|
O0
|
c
|
my_casedn_ucs2:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0x5a842
jmp 0x5a844
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x51(%rbp)
jae 0x5a874
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x40(%rbp), %rcx
leaq -0x30(%rbp), %rsi
callq 0x5a670
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x5a87d
jmp 0x5a8d7
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5f600
movl -0x34(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0x5a6a0
movl %eax, %ecx
movl -0x58(%rbp), %eax
cmpl %ecx, %eax
je 0x5a8b0
jmp 0x5a8d7
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x34(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x5a844
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_casedn_ucs2:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rax, [rbp+var_20]
add rax, [rbp+var_28]
mov [rbp+var_48], rax
mov rax, [rbp+var_8]
mov rax, [rax+78h]
mov [rbp+var_50], rax
jmp short $+2
loc_5A842:
jmp short $+2
loc_5A844:
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_51], al
jnb short loc_5A874
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_40]
lea rsi, [rbp+var_30]
call my_ucs2_uni
mov [rbp+var_34], eax
cmp eax, 0
setnle al
mov [rbp+var_51], al
loc_5A874:
mov al, [rbp+var_51]
test al, 1
jnz short loc_5A87D
jmp short loc_5A8D7
loc_5A87D:
mov rdi, [rbp+var_50]
lea rsi, [rbp+var_30]
call my_tolower_ucs2
mov eax, [rbp+var_34]
mov [rbp+var_58], eax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_48]
call my_uni_ucs2
mov ecx, eax
mov eax, [rbp+var_58]
cmp eax, ecx
jz short loc_5A8B0
jmp short loc_5A8D7
loc_5A8B0:
mov ecx, [rbp+var_34]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
mov ecx, [rbp+var_34]
mov rax, [rbp+var_20]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_20], rax
jmp loc_5A844
loc_5A8D7:
mov rax, [rbp+var_18]
add rsp, 60h
pop rbp
retn
|
long long my_casedn_ucs2(long long a1, unsigned long long a2, long long a3, _BYTE *a4, long long a5, long long a6)
{
bool v7; // [rsp+Fh] [rbp-51h]
long long v8; // [rsp+10h] [rbp-50h]
unsigned long long v9; // [rsp+18h] [rbp-48h]
unsigned long long v10; // [rsp+20h] [rbp-40h]
int v11; // [rsp+2Ch] [rbp-34h]
unsigned long long v12[2]; // [rsp+30h] [rbp-30h] BYREF
_BYTE *v13; // [rsp+40h] [rbp-20h]
long long v14; // [rsp+48h] [rbp-18h]
unsigned long long v15; // [rsp+50h] [rbp-10h]
long long v16; // [rsp+58h] [rbp-8h]
v16 = a1;
v15 = a2;
v14 = a3;
v13 = a4;
v12[1] = a5;
v10 = a3 + a2;
v9 = (unsigned long long)&a4[a5];
v8 = *(_QWORD *)(a1 + 120);
while ( 1 )
{
v7 = 0;
if ( v15 < v10 )
{
v11 = my_ucs2_uni(v16, (long long)v12, v15, v10, a5, a6);
v7 = v11 > 0;
}
if ( !v7 )
break;
my_tolower_ucs2(v8, v12);
if ( v11 != (unsigned int)my_uni_ucs2(v16, v12[0], v13, v9) )
break;
v15 += v11;
v13 += v11;
}
return v14;
}
|
my_casedn_ucs2:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x78]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x0015a842
LAB_0015a842:
JMP 0x0015a844
LAB_0015a844:
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x51],AL
JNC 0x0015a874
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x40]
LEA RSI,[RBP + -0x30]
CALL 0x0015a670
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
SETG AL
MOV byte ptr [RBP + -0x51],AL
LAB_0015a874:
MOV AL,byte ptr [RBP + -0x51]
TEST AL,0x1
JNZ 0x0015a87d
JMP 0x0015a8d7
LAB_0015a87d:
MOV RDI,qword ptr [RBP + -0x50]
LEA RSI,[RBP + -0x30]
CALL 0x0015f600
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x58],EAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x48]
CALL 0x0015a6a0
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x58]
CMP EAX,ECX
JZ 0x0015a8b0
JMP 0x0015a8d7
LAB_0015a8b0:
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0015a844
LAB_0015a8d7:
MOV RAX,qword ptr [RBP + -0x18]
ADD RSP,0x60
POP RBP
RET
|
long my_casedn_ucs2(long param_1,ulong param_2,long param_3,long param_4,long param_5)
{
int8 uVar1;
bool bVar2;
int iVar3;
int local_3c;
int8 local_38;
long local_30;
long local_28;
long local_20;
ulong local_18;
long local_10;
uVar1 = *(int8 *)(param_1 + 0x78);
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
bVar2 = false;
if (local_18 < param_2 + param_3) {
local_3c = my_ucs2_uni(local_10,&local_38,local_18,param_2 + param_3);
bVar2 = 0 < local_3c;
}
if (!bVar2) break;
my_tolower_ucs2(uVar1,&local_38);
iVar3 = my_uni_ucs2(local_10,local_38,local_28,param_4 + param_5);
if (local_3c != iVar3) {
return local_20;
}
local_18 = local_18 + (long)local_3c;
local_28 = local_28 + local_3c;
}
return local_20;
}
|
|
63,624
|
file_get
|
corpus-core[P]colibri-stateless/src/util/plugin.c
|
static bool file_get(char* filename, buffer_t* data) {
unsigned char buffer[1024];
size_t bytesRead;
char* full_path = combine_filename(filename);
if (full_path == NULL) return false;
FILE* file = strcmp(filename, "-") ? fopen(full_path, "rb") : stdin;
safe_free(full_path);
if (file == NULL) return false;
while ((bytesRead = fread(buffer, 1, 1024, file)) == sizeof(buffer))
buffer_append(data, bytes(buffer, bytesRead));
if (bytesRead > 0) buffer_append(data, bytes(buffer, bytesRead));
#ifndef __clang_analyzer__
if (file != stdin)
#endif
fclose(file);
return true;
}
|
O0
|
c
|
file_get:
pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp # imm = 0x460
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1fc80
movq %rax, -0x430(%rbp)
cmpq $0x0, -0x430(%rbp)
jne 0x1fa26
movb $0x0, -0x1(%rbp)
jmp 0x1fb54
movq -0x10(%rbp), %rdi
leaq 0x355cf(%rip), %rsi # 0x55000
callq 0x5250
cmpl $0x0, %eax
je 0x1fa57
movq -0x430(%rbp), %rdi
leaq 0x345fa(%rip), %rsi # 0x54043
callq 0x5320
movq %rax, -0x460(%rbp)
jmp 0x1fa68
movq 0x4f592(%rip), %rax # 0x6eff0
movq (%rax), %rax
movq %rax, -0x460(%rbp)
movq -0x460(%rbp), %rax
movq %rax, -0x438(%rbp)
movq -0x430(%rbp), %rdi
callq 0x18740
cmpq $0x0, -0x438(%rbp)
jne 0x1fa95
movb $0x0, -0x1(%rbp)
jmp 0x1fb54
jmp 0x1fa97
leaq -0x420(%rbp), %rdi
movq -0x438(%rbp), %rcx
movl $0x1, %esi
movl $0x400, %edx # imm = 0x400
callq 0x51b0
movq %rax, -0x428(%rbp)
cmpq $0x400, %rax # imm = 0x400
jne 0x1faf6
movq -0x18(%rbp), %rdi
movq -0x428(%rbp), %rax
movl %eax, -0x448(%rbp)
leaq -0x420(%rbp), %rax
movq %rax, -0x440(%rbp)
movl -0x448(%rbp), %esi
movq -0x440(%rbp), %rdx
callq 0x18bd0
jmp 0x1fa97
cmpq $0x0, -0x428(%rbp)
jbe 0x1fb31
movq -0x18(%rbp), %rdi
movq -0x428(%rbp), %rax
movl %eax, -0x458(%rbp)
leaq -0x420(%rbp), %rax
movq %rax, -0x450(%rbp)
movl -0x458(%rbp), %esi
movq -0x450(%rbp), %rdx
callq 0x18bd0
movq -0x438(%rbp), %rax
movq 0x4f4b1(%rip), %rcx # 0x6eff0
cmpq (%rcx), %rax
je 0x1fb50
movq -0x438(%rbp), %rdi
callq 0x5140
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x460, %rsp # imm = 0x460
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
file_get:
push rbp
mov rbp, rsp
sub rsp, 460h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rdi, [rbp+var_10]
call combine_filename
mov [rbp+var_430], rax
cmp [rbp+var_430], 0
jnz short loc_1FA26
mov [rbp+var_1], 0
jmp loc_1FB54
loc_1FA26:
mov rdi, [rbp+var_10]
lea rsi, aH2cOversizeDst+10h; "-"
call _strcmp
cmp eax, 0
jz short loc_1FA57
mov rdi, [rbp+var_430]
lea rsi, aRb; "rb"
call _fopen
mov [rbp+var_460], rax
jmp short loc_1FA68
loc_1FA57:
mov rax, cs:stdin_ptr
mov rax, [rax]
mov [rbp+var_460], rax
loc_1FA68:
mov rax, [rbp+var_460]
mov [rbp+var_438], rax
mov rdi, [rbp+var_430]
call safe_free
cmp [rbp+var_438], 0
jnz short loc_1FA95
mov [rbp+var_1], 0
jmp loc_1FB54
loc_1FA95:
jmp short $+2
loc_1FA97:
lea rdi, [rbp+var_420]
mov rcx, [rbp+var_438]
mov esi, 1
mov edx, 400h
call _fread
mov [rbp+var_428], rax
cmp rax, 400h
jnz short loc_1FAF6
mov rdi, [rbp+var_18]
mov rax, [rbp+var_428]
mov [rbp+var_448], eax
lea rax, [rbp+var_420]
mov [rbp+var_440], rax
mov esi, [rbp+var_448]
mov rdx, [rbp+var_440]
call buffer_append
jmp short loc_1FA97
loc_1FAF6:
cmp [rbp+var_428], 0
jbe short loc_1FB31
mov rdi, [rbp+var_18]
mov rax, [rbp+var_428]
mov [rbp+var_458], eax
lea rax, [rbp+var_420]
mov [rbp+var_450], rax
mov esi, [rbp+var_458]
mov rdx, [rbp+var_450]
call buffer_append
loc_1FB31:
mov rax, [rbp+var_438]
mov rcx, cs:stdin_ptr
cmp rax, [rcx]
jz short loc_1FB50
mov rdi, [rbp+var_438]
call _fclose
loc_1FB50:
mov [rbp+var_1], 1
loc_1FB54:
mov al, [rbp+var_1]
and al, 1
add rsp, 460h
pop rbp
retn
|
char file_get(long long a1, unsigned int *a2)
{
long long v3; // [rsp+0h] [rbp-460h]
long long v4; // [rsp+30h] [rbp-430h]
long long v5; // [rsp+38h] [rbp-428h]
_BYTE v6[1032]; // [rsp+40h] [rbp-420h] BYREF
unsigned int *v7; // [rsp+448h] [rbp-18h]
long long v8; // [rsp+450h] [rbp-10h]
v8 = a1;
v7 = a2;
v4 = combine_filename(a1);
if ( !v4 )
return 0;
if ( !(unsigned int)strcmp(v8, "-") )
v3 = stdin;
else
v3 = fopen(v4, "rb");
safe_free(v4);
if ( !v3 )
return 0;
while ( 1 )
{
v5 = fread(v6, 1LL, 1024LL, v3);
if ( v5 != 1024 )
break;
buffer_append(v7, 0x400u, (long long)v6);
}
if ( v5 )
buffer_append(v7, v5, (long long)v6);
if ( v3 != stdin )
fclose(v3);
return 1;
}
|
file_get:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x460
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0011fc80
MOV qword ptr [RBP + -0x430],RAX
CMP qword ptr [RBP + -0x430],0x0
JNZ 0x0011fa26
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0011fb54
LAB_0011fa26:
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x155000]
CALL 0x00105250
CMP EAX,0x0
JZ 0x0011fa57
MOV RDI,qword ptr [RBP + -0x430]
LEA RSI,[0x154043]
CALL 0x00105320
MOV qword ptr [RBP + -0x460],RAX
JMP 0x0011fa68
LAB_0011fa57:
MOV RAX,qword ptr [0x0016eff0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x460],RAX
LAB_0011fa68:
MOV RAX,qword ptr [RBP + -0x460]
MOV qword ptr [RBP + -0x438],RAX
MOV RDI,qword ptr [RBP + -0x430]
CALL 0x00118740
CMP qword ptr [RBP + -0x438],0x0
JNZ 0x0011fa95
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0011fb54
LAB_0011fa95:
JMP 0x0011fa97
LAB_0011fa97:
LEA RDI,[RBP + -0x420]
MOV RCX,qword ptr [RBP + -0x438]
MOV ESI,0x1
MOV EDX,0x400
CALL 0x001051b0
MOV qword ptr [RBP + -0x428],RAX
CMP RAX,0x400
JNZ 0x0011faf6
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x428]
MOV dword ptr [RBP + -0x448],EAX
LEA RAX,[RBP + -0x420]
MOV qword ptr [RBP + -0x440],RAX
MOV ESI,dword ptr [RBP + -0x448]
MOV RDX,qword ptr [RBP + -0x440]
CALL 0x00118bd0
JMP 0x0011fa97
LAB_0011faf6:
CMP qword ptr [RBP + -0x428],0x0
JBE 0x0011fb31
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x428]
MOV dword ptr [RBP + -0x458],EAX
LEA RAX,[RBP + -0x420]
MOV qword ptr [RBP + -0x450],RAX
MOV ESI,dword ptr [RBP + -0x458]
MOV RDX,qword ptr [RBP + -0x450]
CALL 0x00118bd0
LAB_0011fb31:
MOV RAX,qword ptr [RBP + -0x438]
MOV RCX,qword ptr [0x0016eff0]
CMP RAX,qword ptr [RCX]
JZ 0x0011fb50
MOV RDI,qword ptr [RBP + -0x438]
CALL 0x00105140
LAB_0011fb50:
MOV byte ptr [RBP + -0x1],0x1
LAB_0011fb54:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0x460
POP RBP
RET
|
int1 file_get(char *param_1,int8 param_2)
{
int iVar1;
char *__filename;
size_t sVar2;
FILE *local_468;
int1 local_428 [1032];
int8 local_20;
char *local_18;
int1 local_9;
local_20 = param_2;
local_18 = param_1;
__filename = (char *)combine_filename(param_1);
if (__filename == (char *)0x0) {
local_9 = 0;
}
else {
iVar1 = strcmp(local_18,"-");
if (iVar1 == 0) {
local_468 = *(FILE **)PTR_stdin_0016eff0;
}
else {
local_468 = fopen(__filename,"rb");
}
safe_free(__filename);
if (local_468 == (FILE *)0x0) {
local_9 = 0;
}
else {
while (sVar2 = fread(local_428,1,0x400,local_468), sVar2 == 0x400) {
buffer_append(local_20,0x400,local_428);
}
if (sVar2 != 0) {
buffer_append(local_20,sVar2 & 0xffffffff,local_428);
}
if (local_468 != *(FILE **)PTR_stdin_0016eff0) {
fclose(local_468);
}
local_9 = 1;
}
}
return local_9;
}
|
|
63,625
|
file_get
|
corpus-core[P]colibri-stateless/src/util/plugin.c
|
static bool file_get(char* filename, buffer_t* data) {
unsigned char buffer[1024];
size_t bytesRead;
char* full_path = combine_filename(filename);
if (full_path == NULL) return false;
FILE* file = strcmp(filename, "-") ? fopen(full_path, "rb") : stdin;
safe_free(full_path);
if (file == NULL) return false;
while ((bytesRead = fread(buffer, 1, 1024, file)) == sizeof(buffer))
buffer_append(data, bytes(buffer, bytesRead));
if (bytesRead > 0) buffer_append(data, bytes(buffer, bytesRead));
#ifndef __clang_analyzer__
if (file != stdin)
#endif
fclose(file);
return true;
}
|
O1
|
c
|
file_get:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x408, %rsp # imm = 0x408
movq %rsi, %rbx
movq %rdi, %r14
callq 0x16fe9
testq %rax, %rax
je 0x16eb0
movq %rax, %r15
leaq 0x28f90(%rip), %rsi # 0x3fe20
movq %r14, %rdi
callq 0x5280
testl %eax, %eax
je 0x16eb4
leaq 0x28150(%rip), %rsi # 0x3eff3
movq %r15, %rdi
callq 0x5330
movq %rax, %r14
jmp 0x16ebe
xorl %ebp, %ebp
jmp 0x16f27
movq 0x43135(%rip), %rax # 0x59ff0
movq (%rax), %r14
movq %r15, %rdi
callq 0x128b8
testq %r14, %r14
setne %bpl
je 0x16f27
movq %rsp, %r15
movl $0x1, %esi
movl $0x400, %edx # imm = 0x400
movq %r15, %rdi
movq %r14, %rcx
callq 0x51d0
cmpq $0x400, %rax # imm = 0x400
jne 0x16f01
movq %rbx, %rdi
movl $0x400, %esi # imm = 0x400
movq %r15, %rdx
callq 0x1294d
jmp 0x16ed2
testq %rax, %rax
je 0x16f13
movq %rsp, %rdx
movq %rbx, %rdi
movl %eax, %esi
callq 0x1294d
movq 0x430d6(%rip), %rax # 0x59ff0
cmpq (%rax), %r14
je 0x16f27
movq %r14, %rdi
callq 0x5160
movl %ebp, %eax
addq $0x408, %rsp # imm = 0x408
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
file_get:
push rbp
push r15
push r14
push rbx
sub rsp, 408h
mov rbx, rsi
mov r14, rdi
call combine_filename
test rax, rax
jz short loc_16EB0
mov r15, rax
lea rsi, aH2cOversizeDst+10h; "-"
mov rdi, r14
call _strcmp
test eax, eax
jz short loc_16EB4
lea rsi, aRb; "rb"
mov rdi, r15
call _fopen
mov r14, rax
jmp short loc_16EBE
loc_16EB0:
xor ebp, ebp
jmp short loc_16F27
loc_16EB4:
mov rax, cs:stdin_ptr
mov r14, [rax]
loc_16EBE:
mov rdi, r15
call safe_free
test r14, r14
setnz bpl
jz short loc_16F27
mov r15, rsp
loc_16ED2:
mov esi, 1
mov edx, 400h
mov rdi, r15
mov rcx, r14
call _fread
cmp rax, 400h
jnz short loc_16F01
mov rdi, rbx
mov esi, 400h
mov rdx, r15
call buffer_append
jmp short loc_16ED2
loc_16F01:
test rax, rax
jz short loc_16F13
mov rdx, rsp
mov rdi, rbx
mov esi, eax
call buffer_append
loc_16F13:
mov rax, cs:stdin_ptr
cmp r14, [rax]
jz short loc_16F27
mov rdi, r14
call _fclose
loc_16F27:
mov eax, ebp
add rsp, 408h
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long file_get(long long a1, unsigned int *a2)
{
unsigned int v2; // ebp
long long v3; // rax
long long v4; // r15
long long v5; // r14
long long v6; // rax
_BYTE v8[1064]; // [rsp+0h] [rbp-428h] BYREF
v3 = combine_filename();
if ( v3 )
{
v4 = v3;
if ( !(unsigned int)strcmp(a1, "-") )
v5 = stdin;
else
v5 = fopen(v4, "rb");
safe_free(v4);
LOBYTE(v2) = v5 != 0;
if ( v5 )
{
while ( 1 )
{
v6 = fread(v8, 1LL, 1024LL, v5);
if ( v6 != 1024 )
break;
buffer_append(a2, 0x400u, (long long)v8);
}
if ( v6 )
buffer_append(a2, v6, (long long)v8);
if ( v5 != stdin )
fclose(v5);
}
}
else
{
return 0;
}
return v2;
}
|
file_get:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x408
MOV RBX,RSI
MOV R14,RDI
CALL 0x00116fe9
TEST RAX,RAX
JZ 0x00116eb0
MOV R15,RAX
LEA RSI,[0x13fe20]
MOV RDI,R14
CALL 0x00105280
TEST EAX,EAX
JZ 0x00116eb4
LEA RSI,[0x13eff3]
MOV RDI,R15
CALL 0x00105330
MOV R14,RAX
JMP 0x00116ebe
LAB_00116eb0:
XOR EBP,EBP
JMP 0x00116f27
LAB_00116eb4:
MOV RAX,qword ptr [0x00159ff0]
MOV R14,qword ptr [RAX]
LAB_00116ebe:
MOV RDI,R15
CALL 0x001128b8
TEST R14,R14
SETNZ BPL
JZ 0x00116f27
MOV R15,RSP
LAB_00116ed2:
MOV ESI,0x1
MOV EDX,0x400
MOV RDI,R15
MOV RCX,R14
CALL 0x001051d0
CMP RAX,0x400
JNZ 0x00116f01
MOV RDI,RBX
MOV ESI,0x400
MOV RDX,R15
CALL 0x0011294d
JMP 0x00116ed2
LAB_00116f01:
TEST RAX,RAX
JZ 0x00116f13
MOV RDX,RSP
MOV RDI,RBX
MOV ESI,EAX
CALL 0x0011294d
LAB_00116f13:
MOV RAX,qword ptr [0x00159ff0]
CMP R14,qword ptr [RAX]
JZ 0x00116f27
MOV RDI,R14
CALL 0x00105160
LAB_00116f27:
MOV EAX,EBP
ADD RSP,0x408
POP RBX
POP R14
POP R15
POP RBP
RET
|
ulong file_get(char *param_1,int8 param_2)
{
int iVar1;
char *__filename;
FILE *__stream;
size_t sVar2;
int8 unaff_RBP;
ulong uVar3;
int1 auStack_428 [1032];
__filename = (char *)combine_filename();
if (__filename == (char *)0x0) {
uVar3 = 0;
}
else {
iVar1 = strcmp(param_1,"-");
if (iVar1 == 0) {
__stream = *(FILE **)PTR_stdin_00159ff0;
}
else {
__stream = fopen(__filename,"rb");
}
safe_free(__filename);
uVar3 = CONCAT71((int7)((ulong)unaff_RBP >> 8),__stream != (FILE *)0x0);
if (__stream != (FILE *)0x0) {
while (sVar2 = fread(auStack_428,1,0x400,__stream), sVar2 == 0x400) {
buffer_append(param_2,0x400,auStack_428);
}
if (sVar2 != 0) {
buffer_append(param_2,sVar2 & 0xffffffff,auStack_428);
}
if (__stream != *(FILE **)PTR_stdin_00159ff0) {
fclose(__stream);
}
}
}
return uVar3 & 0xffffffff;
}
|
|
63,626
|
parse_connection_string
|
eloqsql/libmariadb/libmariadb/mariadb_lib.c
|
static int parse_connection_string(MYSQL *mysql, const char *unused __attribute__((unused)),
const char *conn_str, ssize_t len)
{
char *conn_save,
*end, *pos,
*key= NULL, *val= NULL;
my_bool in_curly_brace= 0;
if (len == -1)
len= strlen(conn_str);
/* don't modify original dsn */
conn_save= (char *)malloc(len + 1);
memcpy(conn_save, conn_str, len);
conn_save[len]= 0;
/* start and end */
pos= conn_save;
end= conn_save + len;
while (pos <= end)
{
/* ignore white space, unless it is between curly braces */
if (isspace(*pos) && !in_curly_brace)
{
pos++;
continue;
}
switch (*pos) {
case '{':
if (!key)
goto error;
if (!in_curly_brace)
{
in_curly_brace= 1;
if (pos < end)
{
pos++;
val= pos;
continue;
}
}
break;
case '}':
if (in_curly_brace)
{
if (!key)
goto error;
if (pos < end && *(pos + 1) == '}')
{
memmove(pos, pos + 1, end - pos - 1);
end--;
pos += 2;
continue;
}
if (in_curly_brace)
in_curly_brace= 0;
else
goto error;
*pos++= 0;
continue;
}
break;
case '=':
if (in_curly_brace)
{
pos++;
continue;
}
if (!key)
goto error;
*pos++= 0;
if (pos < end)
val= pos;
continue;
break;
case ';':
if (in_curly_brace)
{
pos++;
continue;
}
if (!key)
goto error;
*pos++= 0;
if (key && strcasecmp(key, "connection") != 0)
_mariadb_set_conf_option(mysql, key, val);
key= val= NULL;
continue;
break;
}
if (!key && *pos)
key= pos;
pos++;
}
if (key && strcasecmp(key, "connection") != 0)
_mariadb_set_conf_option(mysql, key, val);
free(conn_save);
return 0;
error:
my_set_error(mysql, CR_CONNSTR_PARSE_ERROR, SQLSTATE_UNKNOWN, 0, pos - conn_save);
free(conn_save);
return 1;
}
|
O0
|
c
|
parse_connection_string:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movb $0x0, -0x51(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0x319f0
movq -0x20(%rbp), %rdi
callq 0x141a0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
callq 0x145c0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x14370
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x38(%rbp), %rax
ja 0x31c74
callq 0x14480
movq (%rax), %rax
movq -0x40(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax # imm = 0x2000
cmpl $0x0, %eax
je 0x31a74
cmpb $0x0, -0x51(%rbp)
jne 0x31a74
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x31a32
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x58(%rbp)
subl $0x3b, %eax
je 0x31bd1
jmp 0x31a89
movl -0x58(%rbp), %eax
subl $0x3d, %eax
je 0x31b85
jmp 0x31a97
movl -0x58(%rbp), %eax
subl $0x7b, %eax
je 0x31aae
jmp 0x31aa1
movl -0x58(%rbp), %eax
subl $0x7d, %eax
je 0x31aee
jmp 0x31c48
cmpq $0x0, -0x48(%rbp)
jne 0x31aba
jmp 0x31cb3
cmpb $0x0, -0x51(%rbp)
jne 0x31ae9
movb $0x1, -0x51(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x31ae7
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x31a32
jmp 0x31ae9
jmp 0x31c48
cmpb $0x0, -0x51(%rbp)
je 0x31b80
cmpq $0x0, -0x48(%rbp)
jne 0x31b04
jmp 0x31cb3
movq -0x40(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x31b58
movq -0x40(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x7d, %eax
jne 0x31b58
movq -0x40(%rbp), %rdi
movq -0x40(%rbp), %rsi
addq $0x1, %rsi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rax
subq %rax, %rdx
subq $0x1, %rdx
callq 0x14700
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x40(%rbp)
jmp 0x31a32
cmpb $0x0, -0x51(%rbp)
je 0x31b64
movb $0x0, -0x51(%rbp)
jmp 0x31b69
jmp 0x31cb3
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x40(%rbp)
movb $0x0, (%rax)
jmp 0x31a32
jmp 0x31c48
cmpb $0x0, -0x51(%rbp)
je 0x31b9c
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x31a32
cmpq $0x0, -0x48(%rbp)
jne 0x31ba8
jmp 0x31cb3
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x40(%rbp)
movb $0x0, (%rax)
movq -0x40(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x31bcc
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x31a32
cmpb $0x0, -0x51(%rbp)
je 0x31be8
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x31a32
cmpq $0x0, -0x48(%rbp)
jne 0x31bf4
jmp 0x31cb3
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x40(%rbp)
movb $0x0, (%rax)
cmpq $0x0, -0x48(%rbp)
je 0x31c33
movq -0x48(%rbp), %rdi
leaq 0x391ca(%rip), %rsi # 0x6ade2
callq 0x14490
cmpl $0x0, %eax
je 0x31c33
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x31d00
movq $0x0, -0x50(%rbp)
movq $0x0, -0x48(%rbp)
jmp 0x31a32
cmpq $0x0, -0x48(%rbp)
jne 0x31c63
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x31c63
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x31a32
cmpq $0x0, -0x48(%rbp)
je 0x31ca1
movq -0x48(%rbp), %rdi
leaq 0x3915c(%rip), %rsi # 0x6ade2
callq 0x14490
cmpl $0x0, %eax
je 0x31ca1
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x31d00
movq -0x30(%rbp), %rdi
callq 0x14530
movl $0x0, -0x4(%rbp)
jmp 0x31cec
movq -0x10(%rbp), %rdi
leaq 0x4f1e2(%rip), %rax # 0x80ea0
movq (%rax), %rdx
movq -0x40(%rbp), %r8
movq -0x30(%rbp), %rax
subq %rax, %r8
movl $0x1393, %esi # imm = 0x1393
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x307d0
movq -0x30(%rbp), %rdi
callq 0x14530
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
parse_connection_string:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_48], 0
mov [rbp+var_50], 0
mov [rbp+var_51], 0
cmp [rbp+var_28], 0FFFFFFFFFFFFFFFFh
jnz short loc_319F0
mov rdi, [rbp+var_20]
call _strlen
mov [rbp+var_28], rax
loc_319F0:
mov rdi, [rbp+var_28]
add rdi, 1
call _malloc
mov [rbp+var_30], rax
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
call _memcpy
mov rax, [rbp+var_30]
mov rcx, [rbp+var_28]
mov byte ptr [rax+rcx], 0
mov rax, [rbp+var_30]
mov [rbp+var_40], rax
mov rax, [rbp+var_30]
add rax, [rbp+var_28]
mov [rbp+var_38], rax
loc_31A32:
mov rax, [rbp+var_40]
cmp rax, [rbp+var_38]
ja loc_31C74
call ___ctype_b_loc
mov rax, [rax]
mov rcx, [rbp+var_40]
movsx ecx, byte ptr [rcx]
movsxd rcx, ecx
movzx eax, word ptr [rax+rcx*2]
and eax, 2000h
cmp eax, 0
jz short loc_31A74
cmp [rbp+var_51], 0
jnz short loc_31A74
mov rax, [rbp+var_40]
add rax, 1
mov [rbp+var_40], rax
jmp short loc_31A32
loc_31A74:
mov rax, [rbp+var_40]
movsx eax, byte ptr [rax]
mov [rbp+var_58], eax
sub eax, 3Bh ; ';'
jz loc_31BD1
jmp short $+2
loc_31A89:
mov eax, [rbp+var_58]
sub eax, 3Dh ; '='
jz loc_31B85
jmp short $+2
loc_31A97:
mov eax, [rbp+var_58]
sub eax, 7Bh ; '{'
jz short loc_31AAE
jmp short $+2
loc_31AA1:
mov eax, [rbp+var_58]
sub eax, 7Dh ; '}'
jz short loc_31AEE
jmp loc_31C48
loc_31AAE:
cmp [rbp+var_48], 0
jnz short loc_31ABA
jmp loc_31CB3
loc_31ABA:
cmp [rbp+var_51], 0
jnz short loc_31AE9
mov [rbp+var_51], 1
mov rax, [rbp+var_40]
cmp rax, [rbp+var_38]
jnb short loc_31AE7
mov rax, [rbp+var_40]
add rax, 1
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov [rbp+var_50], rax
jmp loc_31A32
loc_31AE7:
jmp short $+2
loc_31AE9:
jmp loc_31C48
loc_31AEE:
cmp [rbp+var_51], 0
jz loc_31B80
cmp [rbp+var_48], 0
jnz short loc_31B04
jmp loc_31CB3
loc_31B04:
mov rax, [rbp+var_40]
cmp rax, [rbp+var_38]
jnb short loc_31B58
mov rax, [rbp+var_40]
movsx eax, byte ptr [rax+1]
cmp eax, 7Dh ; '}'
jnz short loc_31B58
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_40]
add rsi, 1
mov rdx, [rbp+var_38]
mov rax, [rbp+var_40]
sub rdx, rax
sub rdx, 1
call _memmove
mov rax, [rbp+var_38]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_38], rax
mov rax, [rbp+var_40]
add rax, 2
mov [rbp+var_40], rax
jmp loc_31A32
loc_31B58:
cmp [rbp+var_51], 0
jz short loc_31B64
mov [rbp+var_51], 0
jmp short loc_31B69
loc_31B64:
jmp loc_31CB3
loc_31B69:
mov rax, [rbp+var_40]
mov rcx, rax
add rcx, 1
mov [rbp+var_40], rcx
mov byte ptr [rax], 0
jmp loc_31A32
loc_31B80:
jmp loc_31C48
loc_31B85:
cmp [rbp+var_51], 0
jz short loc_31B9C
mov rax, [rbp+var_40]
add rax, 1
mov [rbp+var_40], rax
jmp loc_31A32
loc_31B9C:
cmp [rbp+var_48], 0
jnz short loc_31BA8
jmp loc_31CB3
loc_31BA8:
mov rax, [rbp+var_40]
mov rcx, rax
add rcx, 1
mov [rbp+var_40], rcx
mov byte ptr [rax], 0
mov rax, [rbp+var_40]
cmp rax, [rbp+var_38]
jnb short loc_31BCC
mov rax, [rbp+var_40]
mov [rbp+var_50], rax
loc_31BCC:
jmp loc_31A32
loc_31BD1:
cmp [rbp+var_51], 0
jz short loc_31BE8
mov rax, [rbp+var_40]
add rax, 1
mov [rbp+var_40], rax
jmp loc_31A32
loc_31BE8:
cmp [rbp+var_48], 0
jnz short loc_31BF4
jmp loc_31CB3
loc_31BF4:
mov rax, [rbp+var_40]
mov rcx, rax
add rcx, 1
mov [rbp+var_40], rcx
mov byte ptr [rax], 0
cmp [rbp+var_48], 0
jz short loc_31C33
mov rdi, [rbp+var_48]
lea rsi, aConnection; "connection"
call _strcasecmp
cmp eax, 0
jz short loc_31C33
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_48]
mov rdx, [rbp+var_50]
call _mariadb_set_conf_option
loc_31C33:
mov [rbp+var_50], 0
mov [rbp+var_48], 0
jmp loc_31A32
loc_31C48:
cmp [rbp+var_48], 0
jnz short loc_31C63
mov rax, [rbp+var_40]
movsx eax, byte ptr [rax]
cmp eax, 0
jz short loc_31C63
mov rax, [rbp+var_40]
mov [rbp+var_48], rax
loc_31C63:
mov rax, [rbp+var_40]
add rax, 1
mov [rbp+var_40], rax
jmp loc_31A32
loc_31C74:
cmp [rbp+var_48], 0
jz short loc_31CA1
mov rdi, [rbp+var_48]
lea rsi, aConnection; "connection"
call _strcasecmp
cmp eax, 0
jz short loc_31CA1
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_48]
mov rdx, [rbp+var_50]
call _mariadb_set_conf_option
loc_31CA1:
mov rdi, [rbp+var_30]
call _free
mov [rbp+var_4], 0
jmp short loc_31CEC
loc_31CB3:
mov rdi, [rbp+var_10]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
mov r8, [rbp+var_40]
mov rax, [rbp+var_30]
sub r8, rax
mov esi, 1393h
xor eax, eax
mov ecx, eax
mov al, 0
call my_set_error
mov rdi, [rbp+var_30]
call _free
mov [rbp+var_4], 1
loc_31CEC:
mov eax, [rbp+var_4]
add rsp, 60h
pop rbp
retn
|
long long parse_connection_string(long long a1, long long a2, long long a3, long long a4)
{
char *v4; // rax
char *v5; // rax
char *v6; // rax
int v8; // [rsp+8h] [rbp-58h]
char v9; // [rsp+Fh] [rbp-51h]
char *v10; // [rsp+10h] [rbp-50h]
char *v11; // [rsp+18h] [rbp-48h]
char *v12; // [rsp+20h] [rbp-40h]
unsigned long long v13; // [rsp+28h] [rbp-38h]
long long v14; // [rsp+30h] [rbp-30h]
long long v15; // [rsp+38h] [rbp-28h]
v15 = a4;
v11 = 0LL;
v10 = 0LL;
v9 = 0;
if ( a4 == -1 )
v15 = strlen(a3);
v14 = malloc(v15 + 1);
memcpy(v14, a3, v15);
*(_BYTE *)(v14 + v15) = 0;
v12 = (char *)v14;
v13 = v15 + v14;
while ( (unsigned long long)v12 <= v13 )
{
if ( (*(_WORD *)(*(_QWORD *)__ctype_b_loc() + 2LL * *v12) & 0x2000) == 0 || v9 )
{
v8 = *v12;
switch ( v8 )
{
case ';':
if ( v9 )
{
++v12;
}
else
{
if ( !v11 )
{
LABEL_45:
my_set_error(a1, 0x1393u, (long long)SQLSTATE_UNKNOWN, 0LL, &v12[-v14]);
free(v14);
return 1;
}
v6 = v12++;
*v6 = 0;
if ( (unsigned int)strcasecmp(v11, "connection") )
mariadb_set_conf_option(a1, v11, v10);
v10 = 0LL;
v11 = 0LL;
}
break;
case '=':
if ( v9 )
{
++v12;
}
else
{
if ( !v11 )
goto LABEL_45;
v5 = v12++;
*v5 = 0;
if ( (unsigned long long)v12 < v13 )
v10 = v12;
}
break;
case '{':
if ( !v11 )
goto LABEL_45;
if ( v9 || (v9 = 1, (unsigned long long)v12 >= v13) )
{
LABEL_37:
if ( !v11 )
{
if ( *v12 )
v11 = v12;
}
++v12;
}
else
{
v10 = ++v12;
}
break;
default:
if ( v8 != 125 || !v9 )
goto LABEL_37;
if ( !v11 )
goto LABEL_45;
if ( (unsigned long long)v12 < v13 && v12[1] == 125 )
{
memmove(v12, v12 + 1, v13 - (_QWORD)v12 - 1);
--v13;
v12 += 2;
}
else
{
v9 = 0;
v4 = v12++;
*v4 = 0;
}
break;
}
}
else
{
++v12;
}
}
if ( v11 && (unsigned int)strcasecmp(v11, "connection") )
mariadb_set_conf_option(a1, v11, v10);
free(v14);
return 0;
}
|
parse_connection_string:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x48],0x0
MOV qword ptr [RBP + -0x50],0x0
MOV byte ptr [RBP + -0x51],0x0
CMP qword ptr [RBP + -0x28],-0x1
JNZ 0x001319f0
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001141a0
MOV qword ptr [RBP + -0x28],RAX
LAB_001319f0:
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x1
CALL 0x001145c0
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
CALL 0x00114370
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + RCX*0x1],0x0
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x38],RAX
LAB_00131a32:
MOV RAX,qword ptr [RBP + -0x40]
CMP RAX,qword ptr [RBP + -0x38]
JA 0x00131c74
CALL 0x00114480
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x40]
MOVSX ECX,byte ptr [RCX]
MOVSXD RCX,ECX
MOVZX EAX,word ptr [RAX + RCX*0x2]
AND EAX,0x2000
CMP EAX,0x0
JZ 0x00131a74
CMP byte ptr [RBP + -0x51],0x0
JNZ 0x00131a74
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x1
MOV qword ptr [RBP + -0x40],RAX
JMP 0x00131a32
LAB_00131a74:
MOV RAX,qword ptr [RBP + -0x40]
MOVSX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x58],EAX
SUB EAX,0x3b
JZ 0x00131bd1
JMP 0x00131a89
LAB_00131a89:
MOV EAX,dword ptr [RBP + -0x58]
SUB EAX,0x3d
JZ 0x00131b85
JMP 0x00131a97
LAB_00131a97:
MOV EAX,dword ptr [RBP + -0x58]
SUB EAX,0x7b
JZ 0x00131aae
JMP 0x00131aa1
LAB_00131aa1:
MOV EAX,dword ptr [RBP + -0x58]
SUB EAX,0x7d
JZ 0x00131aee
JMP 0x00131c48
LAB_00131aae:
CMP qword ptr [RBP + -0x48],0x0
JNZ 0x00131aba
JMP 0x00131cb3
LAB_00131aba:
CMP byte ptr [RBP + -0x51],0x0
JNZ 0x00131ae9
MOV byte ptr [RBP + -0x51],0x1
MOV RAX,qword ptr [RBP + -0x40]
CMP RAX,qword ptr [RBP + -0x38]
JNC 0x00131ae7
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x1
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00131a32
LAB_00131ae7:
JMP 0x00131ae9
LAB_00131ae9:
JMP 0x00131c48
LAB_00131aee:
CMP byte ptr [RBP + -0x51],0x0
JZ 0x00131b80
CMP qword ptr [RBP + -0x48],0x0
JNZ 0x00131b04
JMP 0x00131cb3
LAB_00131b04:
MOV RAX,qword ptr [RBP + -0x40]
CMP RAX,qword ptr [RBP + -0x38]
JNC 0x00131b58
MOV RAX,qword ptr [RBP + -0x40]
MOVSX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x7d
JNZ 0x00131b58
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x40]
ADD RSI,0x1
MOV RDX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x40]
SUB RDX,RAX
SUB RDX,0x1
CALL 0x00114700
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x2
MOV qword ptr [RBP + -0x40],RAX
JMP 0x00131a32
LAB_00131b58:
CMP byte ptr [RBP + -0x51],0x0
JZ 0x00131b64
MOV byte ptr [RBP + -0x51],0x0
JMP 0x00131b69
LAB_00131b64:
JMP 0x00131cb3
LAB_00131b69:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x40],RCX
MOV byte ptr [RAX],0x0
JMP 0x00131a32
LAB_00131b80:
JMP 0x00131c48
LAB_00131b85:
CMP byte ptr [RBP + -0x51],0x0
JZ 0x00131b9c
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x1
MOV qword ptr [RBP + -0x40],RAX
JMP 0x00131a32
LAB_00131b9c:
CMP qword ptr [RBP + -0x48],0x0
JNZ 0x00131ba8
JMP 0x00131cb3
LAB_00131ba8:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x40],RCX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x40]
CMP RAX,qword ptr [RBP + -0x38]
JNC 0x00131bcc
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x50],RAX
LAB_00131bcc:
JMP 0x00131a32
LAB_00131bd1:
CMP byte ptr [RBP + -0x51],0x0
JZ 0x00131be8
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x1
MOV qword ptr [RBP + -0x40],RAX
JMP 0x00131a32
LAB_00131be8:
CMP qword ptr [RBP + -0x48],0x0
JNZ 0x00131bf4
JMP 0x00131cb3
LAB_00131bf4:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x40],RCX
MOV byte ptr [RAX],0x0
CMP qword ptr [RBP + -0x48],0x0
JZ 0x00131c33
MOV RDI,qword ptr [RBP + -0x48]
LEA RSI,[0x16ade2]
CALL 0x00114490
CMP EAX,0x0
JZ 0x00131c33
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x50]
CALL 0x00131d00
LAB_00131c33:
MOV qword ptr [RBP + -0x50],0x0
MOV qword ptr [RBP + -0x48],0x0
JMP 0x00131a32
LAB_00131c48:
CMP qword ptr [RBP + -0x48],0x0
JNZ 0x00131c63
MOV RAX,qword ptr [RBP + -0x40]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JZ 0x00131c63
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x48],RAX
LAB_00131c63:
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x1
MOV qword ptr [RBP + -0x40],RAX
JMP 0x00131a32
LAB_00131c74:
CMP qword ptr [RBP + -0x48],0x0
JZ 0x00131ca1
MOV RDI,qword ptr [RBP + -0x48]
LEA RSI,[0x16ade2]
CALL 0x00114490
CMP EAX,0x0
JZ 0x00131ca1
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x50]
CALL 0x00131d00
LAB_00131ca1:
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00114530
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00131cec
LAB_00131cb3:
MOV RDI,qword ptr [RBP + -0x10]
LEA RAX,[0x180ea0]
MOV RDX,qword ptr [RAX]
MOV R8,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x30]
SUB R8,RAX
MOV ESI,0x1393
XOR EAX,EAX
MOV ECX,EAX
MOV AL,0x0
CALL 0x001307d0
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00114530
MOV dword ptr [RBP + -0x4],0x1
LAB_00131cec:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x60
POP RBP
RET
|
int4
parse_connection_string(int8 param_1,int8 param_2,char *param_3,size_t param_4)
{
char cVar1;
bool bVar2;
int iVar3;
char *__dest;
ushort **ppuVar4;
char *pcVar5;
char *local_58;
char *local_50;
char *local_48;
char *local_40;
size_t local_30;
local_50 = (char *)0x0;
local_58 = (char *)0x0;
bVar2 = false;
local_30 = param_4;
if (param_4 == 0xffffffffffffffff) {
local_30 = strlen(param_3);
}
__dest = (char *)malloc(local_30 + 1);
memcpy(__dest,param_3,local_30);
__dest[local_30] = '\0';
local_40 = __dest + local_30;
local_48 = __dest;
LAB_00131a32:
while( true ) {
while( true ) {
if (local_40 < local_48) {
if ((local_50 != (char *)0x0) && (iVar3 = strcasecmp(local_50,"connection"), iVar3 != 0)) {
_mariadb_set_conf_option(param_1,local_50,local_58);
}
free(__dest);
return 0;
}
ppuVar4 = __ctype_b_loc();
if ((((*ppuVar4)[(int)*local_48] & 0x2000) == 0) || (bVar2)) break;
local_48 = local_48 + 1;
}
cVar1 = *local_48;
if (cVar1 != ';') break;
if (bVar2) {
local_48 = local_48 + 1;
}
else {
if (local_50 == (char *)0x0) goto LAB_00131cb3;
*local_48 = '\0';
if ((local_50 != (char *)0x0) && (iVar3 = strcasecmp(local_50,"connection"), iVar3 != 0)) {
_mariadb_set_conf_option(param_1,local_50,local_58);
}
local_58 = (char *)0x0;
local_50 = (char *)0x0;
local_48 = local_48 + 1;
}
}
if (cVar1 == '=') {
if (bVar2) {
local_48 = local_48 + 1;
goto LAB_00131a32;
}
if (local_50 != (char *)0x0) {
pcVar5 = local_48 + 1;
*local_48 = '\0';
local_48 = pcVar5;
if (pcVar5 < local_40) {
local_58 = pcVar5;
}
goto LAB_00131a32;
}
LAB_00131cb3:
my_set_error(param_1,0x1393,SQLSTATE_UNKNOWN,0,(long)local_48 - (long)__dest);
free(__dest);
return 1;
}
if (cVar1 == '{') {
if (local_50 == (char *)0x0) goto LAB_00131cb3;
if ((!bVar2) && (bVar2 = true, local_48 < local_40)) {
local_58 = local_48 + 1;
local_48 = local_48 + 1;
goto LAB_00131a32;
}
}
else if ((cVar1 == '}') && (bVar2)) {
if (local_50 == (char *)0x0) goto LAB_00131cb3;
if ((local_48 < local_40) && (local_48[1] == '}')) {
memmove(local_48,local_48 + 1,(size_t)(local_40 + (-1 - (long)local_48)));
local_40 = local_40 + -1;
local_48 = local_48 + 2;
goto LAB_00131a32;
}
if (bVar2) {
bVar2 = false;
*local_48 = '\0';
local_48 = local_48 + 1;
goto LAB_00131a32;
}
goto LAB_00131cb3;
}
if ((local_50 == (char *)0x0) && (*local_48 != '\0')) {
local_50 = local_48;
}
local_48 = local_48 + 1;
goto LAB_00131a32;
}
|
|
63,627
|
object_pool_free
|
tsotchke[P]eshkol/src/core/memory/object_pool.c
|
void object_pool_free(ObjectPool* pool, void* object) {
assert(pool != NULL);
assert(object != NULL);
// Add object to free list
FreeListEntry* entry = (FreeListEntry*)object;
entry->next = pool->free_list;
pool->free_list = entry;
// Update counts
pool->allocated_count--;
pool->free_count++;
}
|
O3
|
c
|
object_pool_free:
pushq %rax
testq %rdi, %rdi
je 0x2630
testq %rsi, %rsi
je 0x264f
movq 0x10(%rdi), %rax
movq %rax, (%rsi)
movq %rsi, 0x10(%rdi)
movdqu 0x28(%rdi), %xmm0
paddq 0x1357(%rip), %xmm0 # 0x3980
movdqu %xmm0, 0x28(%rdi)
popq %rax
retq
leaq 0xa86(%rip), %rdi # 0x30bd
leaq 0x1352(%rip), %rsi # 0x3990
leaq 0x143c(%rip), %rcx # 0x3a81
movl $0x84, %edx
callq 0x1070
leaq 0x1457(%rip), %rdi # 0x3aad
leaq 0x1333(%rip), %rsi # 0x3990
leaq 0x141d(%rip), %rcx # 0x3a81
movl $0x85, %edx
callq 0x1070
|
object_pool_free:
push rax
test rdi, rdi
jz short loc_2630
test rsi, rsi
jz short loc_264F
mov rax, [rdi+10h]
mov [rsi], rax
mov [rdi+10h], rsi
movdqu xmm0, xmmword ptr [rdi+28h]
paddq xmm0, cs:xmmword_3980
movdqu xmmword ptr [rdi+28h], xmm0
pop rax
retn
loc_2630:
lea rdi, aPoolNull; "pool != NULL"
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidObjectPool_0; "void object_pool_free(ObjectPool *, voi"...
mov edx, 84h
call ___assert_fail
loc_264F:
lea rdi, aObjectNull; "object != NULL"
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidObjectPool_0; "void object_pool_free(ObjectPool *, voi"...
mov edx, 85h
call ___assert_fail
|
void __spoils<rdx,rcx,r8,r9,r10,r11,xmm0,xmm4,xmm5> object_pool_free(long long a1, _QWORD *a2)
{
if ( !a1 )
__assert_fail(
"pool != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/memory/object_pool.c",
132LL,
"void object_pool_free(ObjectPool *, void *)");
if ( !a2 )
__assert_fail(
"object != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/memory/object_pool.c",
133LL,
"void object_pool_free(ObjectPool *, void *)");
*a2 = *(_QWORD *)(a1 + 16);
*(_QWORD *)(a1 + 16) = a2;
*(__m128i *)(a1 + 40) = _mm_add_epi64(_mm_loadu_si128((const __m128i *)(a1 + 40)), (__m128i)xmmword_3980);
}
|
object_pool_free:
PUSH RAX
TEST RDI,RDI
JZ 0x00102630
TEST RSI,RSI
JZ 0x0010264f
MOV RAX,qword ptr [RDI + 0x10]
MOV qword ptr [RSI],RAX
MOV qword ptr [RDI + 0x10],RSI
MOVDQU XMM0,xmmword ptr [RDI + 0x28]
PADDQ XMM0,xmmword ptr [0x00103980]
MOVDQU xmmword ptr [RDI + 0x28],XMM0
POP RAX
RET
LAB_00102630:
LEA RDI,[0x1030bd]
LEA RSI,[0x103990]
LEA RCX,[0x103a81]
MOV EDX,0x84
CALL 0x00101070
LAB_0010264f:
LEA RDI,[0x103aad]
LEA RSI,[0x103990]
LEA RCX,[0x103a81]
MOV EDX,0x85
CALL 0x00101070
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8 object_pool_free(long param_1,int8 *param_2)
{
int8 in_RAX;
long lVar1;
if (param_1 == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("pool != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/memory/object_pool.c"
,0x84,"void object_pool_free(ObjectPool *, void *)");
}
if (param_2 != (int8 *)0x0) {
*param_2 = *(int8 *)(param_1 + 0x10);
*(int8 **)(param_1 + 0x10) = param_2;
lVar1 = *(long *)(param_1 + 0x30) + _UNK_00103988;
*(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + _DAT_00103980;
*(long *)(param_1 + 0x30) = lVar1;
return in_RAX;
}
/* WARNING: Subroutine does not return */
__assert_fail("object != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/memory/object_pool.c"
,0x85,"void object_pool_free(ObjectPool *, void *)");
}
|
|
63,628
|
ma_bitmap_unpin_all
|
eloqsql/storage/maria/ma_bitmap.c
|
static void _ma_bitmap_unpin_all(MARIA_SHARE *share)
{
MARIA_FILE_BITMAP *bitmap= &share->bitmap;
MARIA_PINNED_PAGE *page_link= ((MARIA_PINNED_PAGE*)
dynamic_array_ptr(&bitmap->pinned_pages, 0));
MARIA_PINNED_PAGE *pinned_page= page_link + bitmap->pinned_pages.elements;
DBUG_ENTER("_ma_bitmap_unpin_all");
DBUG_PRINT("info", ("pinned: %u", bitmap->pinned_pages.elements));
while (pinned_page-- != page_link)
pagecache_unlock_by_link(share->pagecache, pinned_page->link,
pinned_page->unlock, PAGECACHE_UNPIN,
LSN_IMPOSSIBLE, LSN_IMPOSSIBLE, FALSE, TRUE);
bitmap->pinned_pages.elements= 0;
DBUG_VOID_RETURN;
}
|
O0
|
c
|
ma_bitmap_unpin_all:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa10, %rax # imm = 0xA10
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x140(%rax), %rax
movq -0x10(%rbp), %rcx
imull $0x0, 0x154(%rcx), %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x148(%rcx), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x423c4
jmp 0x423c6
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $-0x18, %rcx
movq %rcx, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
je 0x42419
movq -0x8(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edx
movl $0x3, %ecx
xorl %eax, %eax
movl %eax, %r9d
xorl %eax, %eax
movq %r9, %r8
movl $0x0, (%rsp)
movl $0x1, 0x8(%rsp)
callq 0x2d6e0
jmp 0x423c6
movq -0x10(%rbp), %rax
movl $0x0, 0x148(%rax)
jmp 0x42429
addq $0x30, %rsp
popq %rbp
retq
nop
|
_ma_bitmap_unpin_all:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
add rax, 0A10h
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rax, [rax+140h]
mov rcx, [rbp+var_10]
imul ecx, [rcx+154h], 0
mov ecx, ecx
add rax, rcx
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
mov ecx, [rcx+148h]
imul rcx, 18h
add rax, rcx
mov [rbp+var_20], rax
jmp short $+2
loc_423C4:
jmp short $+2
loc_423C6:
mov rax, [rbp+var_20]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFE8h
mov [rbp+var_20], rcx
cmp rax, [rbp+var_18]
jz short loc_42419
mov rax, [rbp+var_8]
mov rdi, [rax+600h]
mov rax, [rbp+var_20]
mov rsi, [rax]
mov rax, [rbp+var_20]
mov edx, [rax+8]
mov ecx, 3
xor eax, eax
mov r9d, eax
xor eax, eax
mov r8, r9
mov [rsp+30h+var_30], 0
mov [rsp+30h+var_28], 1
call pagecache_unlock_by_link
jmp short loc_423C6
loc_42419:
mov rax, [rbp+var_10]
mov dword ptr [rax+148h], 0
jmp short $+2
loc_42429:
add rsp, 30h
pop rbp
retn
|
long long ma_bitmap_unpin_all(long long a1)
{
long long v1; // rax
long long result; // rax
long long i; // [rsp+10h] [rbp-20h]
long long v4; // [rsp+18h] [rbp-18h]
v4 = *(_QWORD *)(a1 + 2896);
for ( i = 24LL * *(unsigned int *)(a1 + 2904) + v4;
;
pagecache_unlock_by_link(*(_QWORD **)(a1 + 1536), *(_QWORD *)i, *(_DWORD *)(i + 8), 3, 0LL, 0LL, 0, 1) )
{
v1 = i;
i -= 24LL;
if ( v1 == v4 )
break;
}
result = a1 + 2576;
*(_DWORD *)(a1 + 2904) = 0;
return result;
}
|
_ma_bitmap_unpin_all:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0xa10
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x140]
MOV RCX,qword ptr [RBP + -0x10]
IMUL ECX,dword ptr [RCX + 0x154],0x0
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0x148]
IMUL RCX,RCX,0x18
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001423c4
LAB_001423c4:
JMP 0x001423c6
LAB_001423c6:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,RAX
ADD RCX,-0x18
MOV qword ptr [RBP + -0x20],RCX
CMP RAX,qword ptr [RBP + -0x18]
JZ 0x00142419
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x600]
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RAX + 0x8]
MOV ECX,0x3
XOR EAX,EAX
MOV R9D,EAX
XOR EAX,EAX
MOV R8,R9
MOV dword ptr [RSP],0x0
MOV dword ptr [RSP + 0x8],0x1
CALL 0x0012d6e0
JMP 0x001423c6
LAB_00142419:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x148],0x0
JMP 0x00142429
LAB_00142429:
ADD RSP,0x30
POP RBP
RET
|
void _ma_bitmap_unpin_all(long param_1)
{
int8 *puVar1;
int8 *local_28;
puVar1 = *(int8 **)(param_1 + 0xb50);
local_28 = puVar1 + (ulong)*(uint *)(param_1 + 0xb58) * 3;
while (local_28 != puVar1) {
pagecache_unlock_by_link
(*(int8 *)(param_1 + 0x600),local_28[-3],*(int4 *)(local_28 + -2),3,0,0,0,
1);
local_28 = local_28 + -3;
}
*(int4 *)(param_1 + 0xb58) = 0;
return;
}
|
|
63,629
|
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LegacyGregoryHelper::FinalizeQuadOffsets(std::vector<unsigned int, std::allocator<unsigned int>>&)::QuadOffset::Assign(OpenSubdiv::v3_6_0::Vtr::internal::Level const&, int, unsigned int*)
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchTableFactory.cpp
|
static int Assign(Level const& level, Index faceIndex,
unsigned int offsets[]) {
ConstIndexArray fVerts = level.getFaceVertices(faceIndex);
for (int i = 0; i < 4; ++i) {
ConstIndexArray vFaces = level.getVertexFaces(fVerts[i]);
int faceInVFaces = vFaces.FindIndex(faceIndex);
// we have to use number of incident edges to modulo the local
// index as there could be 2 consecutive edges in the face
// belonging to the patch
int vOffset0 = faceInVFaces;
int vOffset1 = (faceInVFaces + 1) %
level.getVertexEdges(fVerts[i]).size();
offsets[i] = vOffset0 | (vOffset1 << 8);
}
return 4;
}
|
O0
|
cpp
|
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LegacyGregoryHelper::FinalizeQuadOffsets(std::vector<unsigned int, std::allocator<unsigned int>>&)::QuadOffset::Assign(OpenSubdiv::v3_6_0::Vtr::internal::Level const&, int, unsigned int*):
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xce580
movl %edx, -0x30(%rbp)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x3c(%rbp)
cmpl $0x4, -0x3c(%rbp)
jge 0x14c28d
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl -0x3c(%rbp), %esi
leaq -0x28(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0xcabf0
movq -0xb0(%rbp), %rdi
movl (%rax), %esi
callq 0xd7810
movl %edx, -0x58(%rbp)
movq %rax, -0x60(%rbp)
movl -0x58(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0xc(%rbp), %esi
leaq -0x50(%rbp), %rdi
callq 0xccd70
movq -0xa8(%rbp), %rdi
movl %eax, -0x64(%rbp)
movl -0x64(%rbp), %eax
movl %eax, -0x68(%rbp)
movl -0x64(%rbp), %eax
incl %eax
movl %eax, -0x94(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movl -0x3c(%rbp), %esi
callq 0xcabf0
movq -0xa0(%rbp), %rdi
movl (%rax), %esi
callq 0xd31e0
movl %edx, -0x88(%rbp)
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x80(%rbp)
movl -0x88(%rbp), %eax
movl %eax, -0x78(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xcc250
movl %eax, %ecx
movl -0x94(%rbp), %eax
cltd
idivl %ecx
movl %edx, -0x6c(%rbp)
movl -0x68(%rbp), %edx
movl -0x6c(%rbp), %eax
shll $0x8, %eax
orl %eax, %edx
movq -0x18(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x14c19e
movl $0x4, %eax
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
_ZZN10OpenSubdiv6v3_6_03Far17PatchTableBuilder19LegacyGregoryHelper19FinalizeQuadOffsetsERSt6vectorIjSaIjEEEN10QuadOffset6AssignERKNS0_3Vtr8internal5LevelEiPj:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov rdi, [rbp+var_8]; this
mov esi, [rbp+var_C]; int
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level15getFaceVerticesEi; OpenSubdiv::v3_6_0::Vtr::internal::Level::getFaceVertices(int)
mov [rbp+var_30], edx
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov [rbp+var_28], rax
mov eax, [rbp+var_30]
mov [rbp+var_20], eax
mov [rbp+var_3C], 0
loc_14C19E:
cmp [rbp+var_3C], 4
jge loc_14C28D
mov rax, [rbp+var_8]
mov [rbp+var_B0], rax
mov esi, [rbp+var_3C]
lea rdi, [rbp+var_28]
mov [rbp+var_A8], rdi
call __ZNK10OpenSubdiv6v3_6_03Vtr10ConstArrayIiEixEi; OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::operator[](int)
mov rdi, [rbp+var_B0]; this
mov esi, [rax]; int
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level14getVertexFacesEi; OpenSubdiv::v3_6_0::Vtr::internal::Level::getVertexFaces(int)
mov [rbp+var_58], edx
mov [rbp+var_60], rax
mov eax, [rbp+var_58]
mov [rbp+var_48], eax
mov rax, [rbp+var_60]
mov [rbp+var_50], rax
mov esi, [rbp+var_C]
lea rdi, [rbp+var_50]
call __ZNK10OpenSubdiv6v3_6_03Vtr10ConstArrayIiE9FindIndexEi; OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::FindIndex(int)
mov rdi, [rbp+var_A8]
mov [rbp+var_64], eax
mov eax, [rbp+var_64]
mov [rbp+var_68], eax
mov eax, [rbp+var_64]
inc eax
mov [rbp+var_94], eax
mov rax, [rbp+var_8]
mov [rbp+var_A0], rax
mov esi, [rbp+var_3C]
call __ZNK10OpenSubdiv6v3_6_03Vtr10ConstArrayIiEixEi; OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::operator[](int)
mov rdi, [rbp+var_A0]; this
mov esi, [rax]; int
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level14getVertexEdgesEi; OpenSubdiv::v3_6_0::Vtr::internal::Level::getVertexEdges(int)
mov [rbp+var_88], edx
mov [rbp+var_90], rax
mov rax, [rbp+var_90]
mov [rbp+var_80], rax
mov eax, [rbp+var_88]
mov [rbp+var_78], eax
lea rdi, [rbp+var_80]
call __ZNK10OpenSubdiv6v3_6_03Vtr10ConstArrayIiE4sizeEv; OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::size(void)
mov ecx, eax
mov eax, [rbp+var_94]
cdq
idiv ecx
mov [rbp+var_6C], edx
mov edx, [rbp+var_68]
mov eax, [rbp+var_6C]
shl eax, 8
or edx, eax
mov rax, [rbp+var_18]
movsxd rcx, [rbp+var_3C]
mov [rax+rcx*4], edx
mov eax, [rbp+var_3C]
add eax, 1
mov [rbp+var_3C], eax
jmp loc_14C19E
loc_14C28D:
mov eax, 4
add rsp, 0B0h
pop rbp
retn
|
long long OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LegacyGregoryHelper::FinalizeQuadOffsets(std::vector<unsigned int> &)::QuadOffset::Assign(
OpenSubdiv::v3_6_0::Vtr::internal::Level *a1,
int a2,
long long a3)
{
long long FaceVertices; // rax
int v4; // edx
int *v5; // rax
long long VertexFaces; // rax
int v7; // edx
int *v8; // rax
int v9; // edx
OpenSubdiv::v3_6_0::Vtr::internal::Level *v11; // [rsp+0h] [rbp-B0h]
OpenSubdiv::v3_6_0::Vtr::internal::Level *v12; // [rsp+10h] [rbp-A0h]
int v13; // [rsp+1Ch] [rbp-94h]
long long VertexEdges; // [rsp+30h] [rbp-80h] BYREF
int v15; // [rsp+38h] [rbp-78h]
int v16; // [rsp+44h] [rbp-6Ch]
int v17; // [rsp+48h] [rbp-68h]
int Index; // [rsp+4Ch] [rbp-64h]
long long v19; // [rsp+50h] [rbp-60h]
int v20; // [rsp+58h] [rbp-58h]
long long v21; // [rsp+60h] [rbp-50h] BYREF
int v22; // [rsp+68h] [rbp-48h]
int i; // [rsp+74h] [rbp-3Ch]
long long v24; // [rsp+78h] [rbp-38h]
int v25; // [rsp+80h] [rbp-30h]
long long v26; // [rsp+88h] [rbp-28h] BYREF
int v27; // [rsp+90h] [rbp-20h]
long long v28; // [rsp+98h] [rbp-18h]
int v29; // [rsp+A4h] [rbp-Ch]
OpenSubdiv::v3_6_0::Vtr::internal::Level *v30; // [rsp+A8h] [rbp-8h]
v30 = a1;
v29 = a2;
v28 = a3;
FaceVertices = OpenSubdiv::v3_6_0::Vtr::internal::Level::getFaceVertices(a1, a2);
v25 = v4;
v24 = FaceVertices;
v26 = FaceVertices;
v27 = v4;
for ( i = 0; i < 4; ++i )
{
v11 = v30;
v5 = (int *)OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::operator[](&v26, (unsigned int)i);
VertexFaces = OpenSubdiv::v3_6_0::Vtr::internal::Level::getVertexFaces(v11, *v5);
v20 = v7;
v19 = VertexFaces;
v22 = v7;
v21 = VertexFaces;
Index = OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::FindIndex(&v21, (unsigned int)v29);
v17 = Index;
v13 = Index + 1;
v12 = v30;
v8 = (int *)OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::operator[](&v26, (unsigned int)i);
VertexEdges = OpenSubdiv::v3_6_0::Vtr::internal::Level::getVertexEdges(v12, *v8);
v15 = v9;
v16 = v13 % (int)OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::size(&VertexEdges);
*(_DWORD *)(v28 + 4LL * i) = (v16 << 8) | v17;
}
return 4LL;
}
| |||
63,630
|
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LegacyGregoryHelper::FinalizeQuadOffsets(std::vector<unsigned int, std::allocator<unsigned int>>&)::QuadOffset::Assign(OpenSubdiv::v3_6_0::Vtr::internal::Level const&, int, unsigned int*)
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchTableFactory.cpp
|
static int Assign(Level const& level, Index faceIndex,
unsigned int offsets[]) {
ConstIndexArray fVerts = level.getFaceVertices(faceIndex);
for (int i = 0; i < 4; ++i) {
ConstIndexArray vFaces = level.getVertexFaces(fVerts[i]);
int faceInVFaces = vFaces.FindIndex(faceIndex);
// we have to use number of incident edges to modulo the local
// index as there could be 2 consecutive edges in the face
// belonging to the patch
int vOffset0 = faceInVFaces;
int vOffset1 = (faceInVFaces + 1) %
level.getVertexEdges(fVerts[i]).size();
offsets[i] = vOffset0 | (vOffset1 << 8);
}
return 4;
}
|
O1
|
cpp
|
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LegacyGregoryHelper::FinalizeQuadOffsets(std::vector<unsigned int, std::allocator<unsigned int>>&)::QuadOffset::Assign(OpenSubdiv::v3_6_0::Vtr::internal::Level const&, int, unsigned int*):
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rcx
leal 0x1(%rsi,%rsi), %eax
cltq
movq 0x18(%rdi), %rdx
movslq (%rdx,%rax,4), %r8
shlq $0x2, %r8
addq 0x30(%rdi), %r8
movq 0x108(%rdi), %r9
movq 0x120(%rdi), %r10
movq 0x150(%rdi), %rdi
xorl %r11d, %r11d
movslq (%r8,%r11,4), %rdx
leaq (%rdx,%rdx), %rax
movslq %eax, %r14
movslq (%r9,%r14,4), %rax
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
testq %rax, %rax
jle 0x6e27c
movslq 0x4(%r9,%rdx,8), %rdx
leaq (%r10,%rdx,4), %r15
xorl %edx, %edx
cmpl %esi, (%r15,%rdx,4)
je 0x6e27a
incq %rdx
cmpq %rdx, %rax
jne 0x6e26a
jmp 0x6e27c
movl %edx, %ebx
leal 0x1(%rbx), %eax
cltd
idivl (%rdi,%r14,4)
shll $0x8, %edx
orl %ebx, %edx
movl %edx, (%rcx,%r11,4)
incq %r11
cmpq $0x4, %r11
jne 0x6e246
popq %rbx
popq %r14
popq %r15
retq
|
_ZZN10OpenSubdiv6v3_6_03Far17PatchTableBuilder19LegacyGregoryHelper19FinalizeQuadOffsetsERSt6vectorIjSaIjEEEN10QuadOffset6AssignERKNS0_3Vtr8internal5LevelEiPj:
push r15
push r14
push rbx
mov rcx, rdx
lea eax, [rsi+rsi+1]
cdqe
mov rdx, [rdi+18h]
movsxd r8, dword ptr [rdx+rax*4]
shl r8, 2
add r8, [rdi+30h]
mov r9, [rdi+108h]
mov r10, [rdi+120h]
mov rdi, [rdi+150h]
xor r11d, r11d
loc_6E246:
movsxd rdx, dword ptr [r8+r11*4]
lea rax, [rdx+rdx]
movsxd r14, eax
movsxd rax, dword ptr [r9+r14*4]
mov ebx, 0FFFFFFFFh
test rax, rax
jle short loc_6E27C
movsxd rdx, dword ptr [r9+rdx*8+4]
lea r15, [r10+rdx*4]
xor edx, edx
loc_6E26A:
cmp [r15+rdx*4], esi
jz short loc_6E27A
inc rdx
cmp rax, rdx
jnz short loc_6E26A
jmp short loc_6E27C
loc_6E27A:
mov ebx, edx
loc_6E27C:
lea eax, [rbx+1]
cdq
idiv dword ptr [rdi+r14*4]
shl edx, 8
or edx, ebx
mov [rcx+r11*4], edx
inc r11
cmp r11, 4
jnz short loc_6E246
pop rbx
pop r14
pop r15
retn
|
long long OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LegacyGregoryHelper::FinalizeQuadOffsets(std::vector<unsigned int> &)::QuadOffset::Assign(
_QWORD *a1,
int a2,
long long a3)
{
long long v4; // r8
long long v5; // r9
long long v6; // r10
long long v7; // rdi
long long i; // r11
long long v9; // rdx
long long v10; // r14
long long v11; // rax
int v12; // ebx
long long v13; // r15
long long v14; // rdx
long long result; // rax
v4 = a1[6] + 4LL * *(int *)(a1[3] + 4LL * (2 * a2 + 1));
v5 = a1[33];
v6 = a1[36];
v7 = a1[42];
for ( i = 0LL; i != 4; ++i )
{
v9 = *(int *)(v4 + 4 * i);
v10 = 2 * (int)v9;
v11 = *(int *)(v5 + 4 * v10);
v12 = -1;
if ( v11 > 0 )
{
v13 = v6 + 4LL * *(int *)(v5 + 8 * v9 + 4);
v14 = 0LL;
while ( *(_DWORD *)(v13 + 4 * v14) != a2 )
{
if ( v11 == ++v14 )
goto LABEL_8;
}
v12 = v14;
}
LABEL_8:
result = (unsigned int)((v12 + 1) / *(_DWORD *)(v7 + 4 * v10));
*(_DWORD *)(a3 + 4 * i) = v12 | (((v12 + 1) % *(_DWORD *)(v7 + 4 * v10)) << 8);
}
return result;
}
|
Level_const&,int,unsigned_int*):
PUSH R15
PUSH R14
PUSH RBX
MOV RCX,RDX
LEA EAX,[RSI + RSI*0x1 + 0x1]
CDQE
MOV RDX,qword ptr [RDI + 0x18]
MOVSXD R8,dword ptr [RDX + RAX*0x4]
SHL R8,0x2
ADD R8,qword ptr [RDI + 0x30]
MOV R9,qword ptr [RDI + 0x108]
MOV R10,qword ptr [RDI + 0x120]
MOV RDI,qword ptr [RDI + 0x150]
XOR R11D,R11D
LAB_0016e246:
MOVSXD RDX,dword ptr [R8 + R11*0x4]
LEA RAX,[RDX + RDX*0x1]
MOVSXD R14,EAX
MOVSXD RAX,dword ptr [R9 + R14*0x4]
MOV EBX,0xffffffff
TEST RAX,RAX
JLE 0x0016e27c
MOVSXD RDX,dword ptr [R9 + RDX*0x8 + 0x4]
LEA R15,[R10 + RDX*0x4]
XOR EDX,EDX
LAB_0016e26a:
CMP dword ptr [R15 + RDX*0x4],ESI
JZ 0x0016e27a
INC RDX
CMP RAX,RDX
JNZ 0x0016e26a
JMP 0x0016e27c
LAB_0016e27a:
MOV EBX,EDX
LAB_0016e27c:
LEA EAX,[RBX + 0x1]
CDQ
IDIV dword ptr [RDI + R14*0x4]
SHL EDX,0x8
OR EDX,EBX
MOV dword ptr [RCX + R11*0x4],EDX
INC R11
CMP R11,0x4
JNZ 0x0016e246
POP RBX
POP R14
POP R15
RET
|
/* OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LegacyGregoryHelper::FinalizeQuadOffsets(std::vector<unsigned
int, std::allocator<unsigned int>
>&)::QuadOffset::Assign(OpenSubdiv::v3_6_0::Vtr::internal::Level const&, int, unsigned int*) */
ulong OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LegacyGregoryHelper::FinalizeQuadOffsets(std::
vector<unsigned_int,std::allocator<unsigned_int>>&)::QuadOffset::Assign(OpenSubdiv::v3_6_0::
Vtr::internal::Level_const__int_unsigned_int__(long param_1,int param_2,long param_3)
{
int iVar1;
int iVar2;
long lVar3;
long lVar4;
long lVar5;
long lVar6;
long lVar7;
long lVar8;
uint uVar9;
long lVar10;
long lVar11;
iVar1 = *(int *)(*(long *)(param_1 + 0x18) + (long)(param_2 * 2 + 1) * 4);
lVar3 = *(long *)(param_1 + 0x30);
lVar4 = *(long *)(param_1 + 0x108);
lVar5 = *(long *)(param_1 + 0x120);
lVar6 = *(long *)(param_1 + 0x150);
lVar10 = 0;
do {
iVar2 = *(int *)((long)iVar1 * 4 + lVar3 + lVar10 * 4);
lVar11 = (long)(iVar2 * 2);
lVar7 = (long)*(int *)(lVar4 + lVar11 * 4);
uVar9 = 0xffffffff;
if (0 < lVar7) {
lVar8 = 0;
do {
if (*(int *)(lVar5 + (long)*(int *)(lVar4 + 4 + (long)iVar2 * 8) * 4 + lVar8 * 4) == param_2
) {
uVar9 = (uint)lVar8;
break;
}
lVar8 = lVar8 + 1;
} while (lVar7 != lVar8);
}
iVar2 = *(int *)(lVar6 + lVar11 * 4);
*(uint *)(param_3 + lVar10 * 4) = (int)(uVar9 + 1) % iVar2 << 8 | uVar9;
lVar10 = lVar10 + 1;
if (lVar10 == 4) {
return (long)(int)(uVar9 + 1) / (long)iVar2 & 0xffffffff;
}
} while( true );
}
|
|
63,631
|
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LegacyGregoryHelper::FinalizeQuadOffsets(std::vector<unsigned int, std::allocator<unsigned int>>&)::QuadOffset::Assign(OpenSubdiv::v3_6_0::Vtr::internal::Level const&, int, unsigned int*)
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchTableFactory.cpp
|
static int Assign(Level const& level, Index faceIndex,
unsigned int offsets[]) {
ConstIndexArray fVerts = level.getFaceVertices(faceIndex);
for (int i = 0; i < 4; ++i) {
ConstIndexArray vFaces = level.getVertexFaces(fVerts[i]);
int faceInVFaces = vFaces.FindIndex(faceIndex);
// we have to use number of incident edges to modulo the local
// index as there could be 2 consecutive edges in the face
// belonging to the patch
int vOffset0 = faceInVFaces;
int vOffset1 = (faceInVFaces + 1) %
level.getVertexEdges(fVerts[i]).size();
offsets[i] = vOffset0 | (vOffset1 << 8);
}
return 4;
}
|
O2
|
cpp
|
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LegacyGregoryHelper::FinalizeQuadOffsets(std::vector<unsigned int, std::allocator<unsigned int>>&)::QuadOffset::Assign(OpenSubdiv::v3_6_0::Vtr::internal::Level const&, int, unsigned int*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, (%rsp)
movl %esi, %ebp
movq %rdi, %r14
callq 0x52db0
movq %rax, %r15
xorl %ebx, %ebx
cmpq $0x4, %rbx
je 0x7fe39
movl (%r15,%rbx,4), %esi
movq %r14, %rdi
callq 0x55df0
movq %rax, 0x8(%rsp)
movl %edx, 0x10(%rsp)
leaq 0x8(%rsp), %rdi
movl %ebp, %esi
callq 0x52640
movl %eax, %r13d
leal 0x1(%r13), %r12d
movl (%r15,%rbx,4), %esi
movq %r14, %rdi
callq 0x54550
movl %edx, %ecx
movl %r12d, %eax
cltd
idivl %ecx
shll $0x8, %edx
orl %r13d, %edx
movq (%rsp), %rax
movl %edx, (%rax,%rbx,4)
incq %rbx
jmp 0x7fde5
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ZZN10OpenSubdiv6v3_6_03Far17PatchTableBuilder19LegacyGregoryHelper19FinalizeQuadOffsetsERSt6vectorIjSaIjEEEN10QuadOffset6AssignERKNS0_3Vtr8internal5LevelEiPj:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov [rsp+48h+var_48], rdx
mov ebp, esi
mov r14, rdi
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level15getFaceVerticesEi; OpenSubdiv::v3_6_0::Vtr::internal::Level::getFaceVertices(int)
mov r15, rax
xor ebx, ebx
loc_7FDE5:
cmp rbx, 4
jz short loc_7FE39
mov esi, [r15+rbx*4]; int
mov rdi, r14; this
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level14getVertexFacesEi; OpenSubdiv::v3_6_0::Vtr::internal::Level::getVertexFaces(int)
mov [rsp+48h+var_40], rax
mov [rsp+48h+var_38], edx
lea rdi, [rsp+48h+var_40]
mov esi, ebp
call __ZNK10OpenSubdiv6v3_6_03Vtr10ConstArrayIiE9FindIndexEi; OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::FindIndex(int)
mov r13d, eax
lea r12d, [r13+1]
mov esi, [r15+rbx*4]; int
mov rdi, r14; this
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level14getVertexEdgesEi; OpenSubdiv::v3_6_0::Vtr::internal::Level::getVertexEdges(int)
mov ecx, edx
mov eax, r12d
cdq
idiv ecx
shl edx, 8
or edx, r13d
mov rax, [rsp+48h+var_48]
mov [rax+rbx*4], edx
inc rbx
jmp short loc_7FDE5
loc_7FE39:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LegacyGregoryHelper::FinalizeQuadOffsets(std::vector<unsigned int> &)::QuadOffset::Assign(
OpenSubdiv::v3_6_0::Vtr::internal::Level *this,
unsigned int a2,
long long a3)
{
long long result; // rax
long long v4; // r15
long long i; // rbx
int v6; // edx
int Index; // r13d
int v8; // edx
long long VertexFaces; // [rsp+8h] [rbp-40h] BYREF
int v11; // [rsp+10h] [rbp-38h]
result = OpenSubdiv::v3_6_0::Vtr::internal::Level::getFaceVertices(this, a2);
v4 = result;
for ( i = 0LL; i != 4; ++i )
{
VertexFaces = OpenSubdiv::v3_6_0::Vtr::internal::Level::getVertexFaces(this, *(_DWORD *)(v4 + 4 * i));
v11 = v6;
Index = OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::FindIndex(&VertexFaces, a2);
OpenSubdiv::v3_6_0::Vtr::internal::Level::getVertexEdges(this, *(_DWORD *)(v4 + 4 * i));
result = a3;
*(_DWORD *)(a3 + 4 * i) = Index | (((Index + 1) % v8) << 8);
}
return result;
}
|
Level_const&,int,unsigned_int*):
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP],RDX
MOV EBP,ESI
MOV R14,RDI
CALL 0x00152db0
MOV R15,RAX
XOR EBX,EBX
LAB_0017fde5:
CMP RBX,0x4
JZ 0x0017fe39
MOV ESI,dword ptr [R15 + RBX*0x4]
MOV RDI,R14
CALL 0x00155df0
MOV qword ptr [RSP + 0x8],RAX
MOV dword ptr [RSP + 0x10],EDX
LEA RDI,[RSP + 0x8]
MOV ESI,EBP
CALL 0x00152640
MOV R13D,EAX
LEA R12D,[R13 + 0x1]
MOV ESI,dword ptr [R15 + RBX*0x4]
MOV RDI,R14
CALL 0x00154550
MOV ECX,EDX
MOV EAX,R12D
CDQ
IDIV ECX
SHL EDX,0x8
OR EDX,R13D
MOV RAX,qword ptr [RSP]
MOV dword ptr [RAX + RBX*0x4],EDX
INC RBX
JMP 0x0017fde5
LAB_0017fe39:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LegacyGregoryHelper::FinalizeQuadOffsets(std::vector<unsigned
int, std::allocator<unsigned int>
>&)::QuadOffset::Assign(OpenSubdiv::v3_6_0::Vtr::internal::Level const&, int, unsigned int*) */
void OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LegacyGregoryHelper::FinalizeQuadOffsets(std::
vector<unsigned_int,std::allocator<unsigned_int>>&)::QuadOffset::Assign(OpenSubdiv::v3_6_0::Vtr
::internal::Level_const__int_unsigned_int__(Level *param_1,int param_2,long param_3)
{
uint uVar1;
long lVar2;
int extraout_EDX;
long lVar3;
int1 auVar4 [12];
int1 local_40 [12];
lVar2 = v3_6_0::Vtr::internal::Level::getFaceVertices(param_1,param_2);
for (lVar3 = 0; lVar3 != 4; lVar3 = lVar3 + 1) {
auVar4 = v3_6_0::Vtr::internal::Level::getVertexFaces(param_1,*(int *)(lVar2 + lVar3 * 4));
local_40 = auVar4;
uVar1 = v3_6_0::Vtr::ConstArray<int>::FindIndex((ConstArray<int> *)local_40,param_2);
v3_6_0::Vtr::internal::Level::getVertexEdges(param_1,*(int *)(lVar2 + lVar3 * 4));
*(uint *)(param_3 + lVar3 * 4) = (int)(uVar1 + 1) % extraout_EDX << 8 | uVar1;
}
return;
}
|
|
63,632
|
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LegacyGregoryHelper::FinalizeQuadOffsets(std::vector<unsigned int, std::allocator<unsigned int>>&)::QuadOffset::Assign(OpenSubdiv::v3_6_0::Vtr::internal::Level const&, int, unsigned int*)
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchTableFactory.cpp
|
static int Assign(Level const& level, Index faceIndex,
unsigned int offsets[]) {
ConstIndexArray fVerts = level.getFaceVertices(faceIndex);
for (int i = 0; i < 4; ++i) {
ConstIndexArray vFaces = level.getVertexFaces(fVerts[i]);
int faceInVFaces = vFaces.FindIndex(faceIndex);
// we have to use number of incident edges to modulo the local
// index as there could be 2 consecutive edges in the face
// belonging to the patch
int vOffset0 = faceInVFaces;
int vOffset1 = (faceInVFaces + 1) %
level.getVertexEdges(fVerts[i]).size();
offsets[i] = vOffset0 | (vOffset1 << 8);
}
return 4;
}
|
O3
|
cpp
|
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LegacyGregoryHelper::FinalizeQuadOffsets(std::vector<unsigned int, std::allocator<unsigned int>>&)::QuadOffset::Assign(OpenSubdiv::v3_6_0::Vtr::internal::Level const&, int, unsigned int*):
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rcx
leal 0x1(%rsi,%rsi), %eax
cltq
movq 0x18(%rdi), %rdx
movslq (%rdx,%rax,4), %r8
shlq $0x2, %r8
addq 0x30(%rdi), %r8
movq 0x108(%rdi), %r9
movq 0x120(%rdi), %r10
movq 0x150(%rdi), %rdi
xorl %r11d, %r11d
movslq (%r8,%r11,4), %rdx
leaq (%rdx,%rdx), %rax
movslq %eax, %r14
movslq (%r9,%r14,4), %rax
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
testq %rax, %rax
jle 0x6f8ac
movslq 0x4(%r9,%rdx,8), %rdx
leaq (%r10,%rdx,4), %r15
xorl %edx, %edx
cmpl %esi, (%r15,%rdx,4)
je 0x6f8aa
incq %rdx
cmpq %rdx, %rax
jne 0x6f89a
jmp 0x6f8ac
movl %edx, %ebx
leal 0x1(%rbx), %eax
cltd
idivl (%rdi,%r14,4)
shll $0x8, %edx
orl %ebx, %edx
movl %edx, (%rcx,%r11,4)
incq %r11
cmpq $0x4, %r11
jne 0x6f876
popq %rbx
popq %r14
popq %r15
retq
|
_ZZN10OpenSubdiv6v3_6_03Far17PatchTableBuilder19LegacyGregoryHelper19FinalizeQuadOffsetsERSt6vectorIjSaIjEEEN10QuadOffset6AssignERKNS0_3Vtr8internal5LevelEiPj:
push r15
push r14
push rbx
mov rcx, rdx
lea eax, [rsi+rsi+1]
cdqe
mov rdx, [rdi+18h]
movsxd r8, dword ptr [rdx+rax*4]
shl r8, 2
add r8, [rdi+30h]
mov r9, [rdi+108h]
mov r10, [rdi+120h]
mov rdi, [rdi+150h]
xor r11d, r11d
loc_6F876:
movsxd rdx, dword ptr [r8+r11*4]
lea rax, [rdx+rdx]
movsxd r14, eax
movsxd rax, dword ptr [r9+r14*4]
mov ebx, 0FFFFFFFFh
test rax, rax
jle short loc_6F8AC
movsxd rdx, dword ptr [r9+rdx*8+4]
lea r15, [r10+rdx*4]
xor edx, edx
loc_6F89A:
cmp [r15+rdx*4], esi
jz short loc_6F8AA
inc rdx
cmp rax, rdx
jnz short loc_6F89A
jmp short loc_6F8AC
loc_6F8AA:
mov ebx, edx
loc_6F8AC:
lea eax, [rbx+1]
cdq
idiv dword ptr [rdi+r14*4]
shl edx, 8
or edx, ebx
mov [rcx+r11*4], edx
inc r11
cmp r11, 4
jnz short loc_6F876
pop rbx
pop r14
pop r15
retn
|
long long OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LegacyGregoryHelper::FinalizeQuadOffsets(std::vector<unsigned int> &)::QuadOffset::Assign(
_QWORD *a1,
int a2,
long long a3)
{
long long v4; // r8
long long v5; // r9
long long v6; // r10
long long v7; // rdi
long long i; // r11
long long v9; // rdx
long long v10; // r14
long long v11; // rax
int v12; // ebx
long long v13; // r15
long long v14; // rdx
long long result; // rax
v4 = a1[6] + 4LL * *(int *)(a1[3] + 4LL * (2 * a2 + 1));
v5 = a1[33];
v6 = a1[36];
v7 = a1[42];
for ( i = 0LL; i != 4; ++i )
{
v9 = *(int *)(v4 + 4 * i);
v10 = 2 * (int)v9;
v11 = *(int *)(v5 + 4 * v10);
v12 = -1;
if ( v11 > 0 )
{
v13 = v6 + 4LL * *(int *)(v5 + 8 * v9 + 4);
v14 = 0LL;
while ( *(_DWORD *)(v13 + 4 * v14) != a2 )
{
if ( v11 == ++v14 )
goto LABEL_8;
}
v12 = v14;
}
LABEL_8:
result = (unsigned int)((v12 + 1) / *(_DWORD *)(v7 + 4 * v10));
*(_DWORD *)(a3 + 4 * i) = v12 | (((v12 + 1) % *(_DWORD *)(v7 + 4 * v10)) << 8);
}
return result;
}
|
Level_const&,int,unsigned_int*):
PUSH R15
PUSH R14
PUSH RBX
MOV RCX,RDX
LEA EAX,[RSI + RSI*0x1 + 0x1]
CDQE
MOV RDX,qword ptr [RDI + 0x18]
MOVSXD R8,dword ptr [RDX + RAX*0x4]
SHL R8,0x2
ADD R8,qword ptr [RDI + 0x30]
MOV R9,qword ptr [RDI + 0x108]
MOV R10,qword ptr [RDI + 0x120]
MOV RDI,qword ptr [RDI + 0x150]
XOR R11D,R11D
LAB_0016f876:
MOVSXD RDX,dword ptr [R8 + R11*0x4]
LEA RAX,[RDX + RDX*0x1]
MOVSXD R14,EAX
MOVSXD RAX,dword ptr [R9 + R14*0x4]
MOV EBX,0xffffffff
TEST RAX,RAX
JLE 0x0016f8ac
MOVSXD RDX,dword ptr [R9 + RDX*0x8 + 0x4]
LEA R15,[R10 + RDX*0x4]
XOR EDX,EDX
LAB_0016f89a:
CMP dword ptr [R15 + RDX*0x4],ESI
JZ 0x0016f8aa
INC RDX
CMP RAX,RDX
JNZ 0x0016f89a
JMP 0x0016f8ac
LAB_0016f8aa:
MOV EBX,EDX
LAB_0016f8ac:
LEA EAX,[RBX + 0x1]
CDQ
IDIV dword ptr [RDI + R14*0x4]
SHL EDX,0x8
OR EDX,EBX
MOV dword ptr [RCX + R11*0x4],EDX
INC R11
CMP R11,0x4
JNZ 0x0016f876
POP RBX
POP R14
POP R15
RET
|
/* OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LegacyGregoryHelper::FinalizeQuadOffsets(std::vector<unsigned
int, std::allocator<unsigned int>
>&)::QuadOffset::Assign(OpenSubdiv::v3_6_0::Vtr::internal::Level const&, int, unsigned int*) */
ulong OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LegacyGregoryHelper::FinalizeQuadOffsets(std::
vector<unsigned_int,std::allocator<unsigned_int>>&)::QuadOffset::Assign(OpenSubdiv::v3_6_0::
Vtr::internal::Level_const__int_unsigned_int__(long param_1,int param_2,long param_3)
{
int iVar1;
int iVar2;
long lVar3;
long lVar4;
long lVar5;
long lVar6;
long lVar7;
long lVar8;
uint uVar9;
long lVar10;
long lVar11;
iVar1 = *(int *)(*(long *)(param_1 + 0x18) + (long)(param_2 * 2 + 1) * 4);
lVar3 = *(long *)(param_1 + 0x30);
lVar4 = *(long *)(param_1 + 0x108);
lVar5 = *(long *)(param_1 + 0x120);
lVar6 = *(long *)(param_1 + 0x150);
lVar10 = 0;
do {
iVar2 = *(int *)((long)iVar1 * 4 + lVar3 + lVar10 * 4);
lVar11 = (long)(iVar2 * 2);
lVar7 = (long)*(int *)(lVar4 + lVar11 * 4);
uVar9 = 0xffffffff;
if (0 < lVar7) {
lVar8 = 0;
do {
if (*(int *)(lVar5 + (long)*(int *)(lVar4 + 4 + (long)iVar2 * 8) * 4 + lVar8 * 4) == param_2
) {
uVar9 = (uint)lVar8;
break;
}
lVar8 = lVar8 + 1;
} while (lVar7 != lVar8);
}
iVar2 = *(int *)(lVar6 + lVar11 * 4);
*(uint *)(param_3 + lVar10 * 4) = (int)(uVar9 + 1) % iVar2 << 8 | uVar9;
lVar10 = lVar10 + 1;
if (lVar10 == 4) {
return (long)(int)(uVar9 + 1) / (long)iVar2 & 0xffffffff;
}
} while( true );
}
|
|
63,633
|
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<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>>::json_sax_dom_callback_parser(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, std::function<bool (int, nlohmann::json_abi_v3_11_3::detail::parse_event_t, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__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>&)>, bool)
|
monkey531[P]llama/common/./json.hpp
|
json_sax_dom_callback_parser(BasicJsonType& r,
const parser_callback_t cb,
const bool allow_exceptions_ = true)
: root(r), callback(cb), allow_exceptions(allow_exceptions_)
{
keep_stack.push_back(true);
}
|
O0
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<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>>::json_sax_dom_callback_parser(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, std::function<bool (int, nlohmann::json_abi_v3_11_3::detail::parse_event_t, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__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>&)>, bool):
subq $0x88, %rsp
movq %rdx, 0x48(%rsp)
movb %cl, %al
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
andb $0x1, %al
movb %al, 0x6f(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x78(%rsp), %rcx
movq %rcx, (%rax)
movq %rax, %rdi
addq $0x8, %rdi
movq %rdi, 0x10(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movups %xmm0, 0x8(%rax)
movq $0x0, 0x18(%rax)
callq 0xb6020
movaps 0x20(%rsp), %xmm0
movq 0x40(%rsp), %rax
movq %rax, %rdi
addq $0x20, %rdi
movq %rdi, 0x18(%rsp)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movq $0x0, 0x40(%rax)
callq 0xb6030
movaps 0x20(%rsp), %xmm0
movq 0x40(%rsp), %rax
movq %rax, %rdi
addq $0x48, %rdi
movq %rdi, 0x38(%rsp)
movups %xmm0, 0x58(%rax)
movups %xmm0, 0x48(%rax)
movq $0x0, 0x68(%rax)
callq 0xb6030
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq $0x0, 0x70(%rdi)
movb $0x0, 0x78(%rdi)
subq $-0x80, %rdi
movq %rdi, 0x50(%rsp)
callq 0xae710
jmp 0xb150c
movq 0x40(%rsp), %rdi
movb 0x6f(%rsp), %al
andb $0x1, %al
movb %al, 0xa0(%rdi)
addq $0xa8, %rdi
movq %rdi, 0x8(%rsp)
movl $0x9, %esi
callq 0xb3dd0
jmp 0xb1535
movq 0x40(%rsp), %rdi
addq $0x20, %rdi
movl $0x1, %esi
callq 0xb6040
jmp 0xb154a
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xb1594
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xb158a
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
callq 0x6e0f0
movq 0x50(%rsp), %rdi
callq 0xae4b0
movq 0x38(%rsp), %rdi
callq 0xb6120
movq 0x18(%rsp), %rdi
callq 0xb6120
movq 0x10(%rsp), %rdi
callq 0xb6130
movq 0x60(%rsp), %rdi
callq 0x50940
nopl (%rax)
|
_ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEC2ERSF_St8functionIFbiNS1_13parse_event_tESH_EEb:
sub rsp, 88h
mov [rsp+88h+var_40], rdx
mov al, cl
mov [rsp+88h+var_8], rdi
mov [rsp+88h+var_10], rsi
mov [rsp+88h+var_18], rdx
and al, 1
mov [rsp+88h+var_19], al
mov rax, [rsp+88h+var_8]
mov [rsp+88h+var_48], rax
mov rcx, [rsp+88h+var_10]
mov [rax], rcx
mov rdi, rax
add rdi, 8
mov [rsp+88h+var_78], rdi
xorps xmm0, xmm0
movaps [rsp+88h+var_68], xmm0
movups xmmword ptr [rax+8], xmm0
mov qword ptr [rax+18h], 0
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EEC2Ev; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<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> *>>::vector(void)
movaps xmm0, [rsp+88h+var_68]
mov rax, [rsp+88h+var_48]
mov rdi, rax
add rdi, 20h ; ' '
mov [rsp+88h+var_70], rdi
movups xmmword ptr [rax+30h], xmm0
movups xmmword ptr [rax+20h], xmm0
mov qword ptr [rax+40h], 0
call _ZNSt6vectorIbSaIbEEC2Ev; std::vector<bool>::vector(void)
movaps xmm0, [rsp+88h+var_68]
mov rax, [rsp+88h+var_48]
mov rdi, rax
add rdi, 48h ; 'H'
mov [rsp+88h+var_50], rdi
movups xmmword ptr [rax+58h], xmm0
movups xmmword ptr [rax+48h], xmm0
mov qword ptr [rax+68h], 0
call _ZNSt6vectorIbSaIbEEC2Ev; std::vector<bool>::vector(void)
mov rdi, [rsp+88h+var_48]
mov rsi, [rsp+88h+var_40]
mov qword ptr [rdi+70h], 0
mov byte ptr [rdi+78h], 0
sub rdi, 0FFFFFFFFFFFFFF80h
mov [rsp+88h+var_38], rdi
call _ZNSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEEC2ERKSJ_; std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)>::function(std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)> const&)
jmp short $+2
loc_B150C:
mov rdi, [rsp+88h+var_48]
mov al, [rsp+88h+var_19]
and al, 1
mov [rdi+0A0h], al
add rdi, 0A8h
mov [rsp+88h+var_80], rdi
mov esi, 9
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ENS0_6detail7value_tE; 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(nlohmann::json_abi_v3_11_3::detail::value_t)
jmp short $+2
loc_B1535:
mov rdi, [rsp+88h+var_48]
add rdi, 20h ; ' '
mov esi, 1
call _ZNSt6vectorIbSaIbEE9push_backEb; std::vector<bool>::push_back(bool)
jmp short $+2
loc_B154A:
add rsp, 88h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_58], rcx
mov [rsp+arg_54], eax
jmp short loc_B1594
mov rcx, rax
mov eax, edx
mov [rsp+arg_58], rcx
mov [rsp+arg_54], eax
jmp short loc_B158A
mov rdi, [rsp+arg_0]
mov rcx, rax
mov eax, edx
mov [rsp+arg_58], rcx
mov [rsp+arg_54], eax
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; 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()
loc_B158A:
mov rdi, [rsp+arg_48]
call _ZNSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEED2Ev; std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)>::~function()
loc_B1594:
mov rdi, [rsp+arg_30]
call _ZNSt6vectorIbSaIbEED2Ev; std::vector<bool>::~vector()
mov rdi, [rsp+arg_10]
call _ZNSt6vectorIbSaIbEED2Ev; std::vector<bool>::~vector()
mov rdi, [rsp+arg_8]
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EED2Ev; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<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> *>>::~vector()
mov rdi, [rsp+arg_58]
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<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_sax_dom_callback_parser(
long long a1,
long long a2,
long long a3,
char a4)
{
char v6; // [rsp+6Fh] [rbp-19h]
v6 = a4 & 1;
*(_QWORD *)a1 = a2;
*(_OWORD *)(a1 + 8) = 0LL;
*(_QWORD *)(a1 + 24) = 0LL;
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<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> *>>::vector();
*(_OWORD *)(a1 + 48) = 0LL;
*(_OWORD *)(a1 + 32) = 0LL;
*(_QWORD *)(a1 + 64) = 0LL;
std::vector<bool>::vector();
*(_OWORD *)(a1 + 88) = 0LL;
*(_OWORD *)(a1 + 72) = 0LL;
*(_QWORD *)(a1 + 104) = 0LL;
std::vector<bool>::vector();
*(_QWORD *)(a1 + 112) = 0LL;
*(_BYTE *)(a1 + 120) = 0;
std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &)>::function(
(std::_Function_base *)(a1 + 128),
a3);
*(_BYTE *)(a1 + 160) = v6 & 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>::basic_json(
a1 + 168,
9LL);
return std::vector<bool>::push_back(a1 + 32, 1LL);
}
|
json_sax_dom_callback_parser:
SUB RSP,0x88
MOV qword ptr [RSP + 0x48],RDX
MOV AL,CL
MOV qword ptr [RSP + 0x80],RDI
MOV qword ptr [RSP + 0x78],RSI
MOV qword ptr [RSP + 0x70],RDX
AND AL,0x1
MOV byte ptr [RSP + 0x6f],AL
MOV RAX,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0x40],RAX
MOV RCX,qword ptr [RSP + 0x78]
MOV qword ptr [RAX],RCX
MOV RDI,RAX
ADD RDI,0x8
MOV qword ptr [RSP + 0x10],RDI
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOVUPS xmmword ptr [RAX + 0x8],XMM0
MOV qword ptr [RAX + 0x18],0x0
CALL 0x001b6020
MOVAPS XMM0,xmmword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x40]
MOV RDI,RAX
ADD RDI,0x20
MOV qword ptr [RSP + 0x18],RDI
MOVUPS xmmword ptr [RAX + 0x30],XMM0
MOVUPS xmmword ptr [RAX + 0x20],XMM0
MOV qword ptr [RAX + 0x40],0x0
CALL 0x001b6030
MOVAPS XMM0,xmmword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x40]
MOV RDI,RAX
ADD RDI,0x48
MOV qword ptr [RSP + 0x38],RDI
MOVUPS xmmword ptr [RAX + 0x58],XMM0
MOVUPS xmmword ptr [RAX + 0x48],XMM0
MOV qword ptr [RAX + 0x68],0x0
CALL 0x001b6030
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x48]
MOV qword ptr [RDI + 0x70],0x0
MOV byte ptr [RDI + 0x78],0x0
SUB RDI,-0x80
MOV qword ptr [RSP + 0x50],RDI
LAB_001b1505:
CALL 0x001ae710
JMP 0x001b150c
LAB_001b150c:
MOV RDI,qword ptr [RSP + 0x40]
MOV AL,byte ptr [RSP + 0x6f]
AND AL,0x1
MOV byte ptr [RDI + 0xa0],AL
ADD RDI,0xa8
MOV qword ptr [RSP + 0x8],RDI
LAB_001b1529:
MOV ESI,0x9
CALL 0x001b3dd0
JMP 0x001b1535
LAB_001b1535:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x20
LAB_001b153e:
MOV ESI,0x1
CALL 0x001b6040
LAB_001b1548:
JMP 0x001b154a
LAB_001b154a:
ADD RSP,0x88
RET
|
/* nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<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_sax_dom_callback_parser(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>&, std::function<bool (int, nlohmann::json_abi_v3_11_3::detail::parse_event_t,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__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>&)>, bool) */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<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_sax_dom_callback_parser
(json_sax_dom_callback_parser<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,int8 param_1,function *param_3,byte param_4)
{
*(int8 *)this = param_1;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::vector((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x40) = 0;
std::vector<bool,std::allocator<bool>>::vector((vector<bool,std::allocator<bool>> *)(this + 0x20))
;
*(int8 *)(this + 0x58) = 0;
*(int8 *)(this + 0x60) = 0;
*(int8 *)(this + 0x48) = 0;
*(int8 *)(this + 0x50) = 0;
*(int8 *)(this + 0x68) = 0;
std::vector<bool,std::allocator<bool>>::vector((vector<bool,std::allocator<bool>> *)(this + 0x48))
;
*(int8 *)(this + 0x70) = 0;
this[0x78] = (json_sax_dom_callback_parser<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>>
)0x0;
/* try { // try from 001b1505 to 001b1509 has its CatchHandler @ 001b1552 */
std::
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
::function((function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__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 + 0x80),param_3);
this[0xa0] = (json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
)(param_4 & 1);
/* try { // try from 001b1529 to 001b1532 has its CatchHandler @ 001b1562 */
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((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 + 0xa8),9);
/* try { // try from 001b153e to 001b1547 has its CatchHandler @ 001b1572 */
std::vector<bool,std::allocator<bool>>::push_back
((vector<bool,std::allocator<bool>> *)(this + 0x20),true);
return;
}
|
|
63,634
|
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::key() const
|
llama.cpp/common/json.hpp
|
const typename object_t::key_type& key() const
{
JSON_ASSERT(m_object != nullptr);
if (JSON_HEDLEY_LIKELY(m_object->is_object()))
{
return m_it.object_iterator->first;
}
JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators", m_object));
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::key() const:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0xc2ef1
movq %rdi, %r14
cmpb $0x1, (%rax)
jne 0xc2e93
movq 0x8(%r14), %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x20640
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x58295(%rip), %rsi # 0x11b145
leaq 0x582b7(%rip), %rdx # 0x11b16e
leaq 0x8(%rsp), %rdi
callq 0x28870
movq (%r14), %rcx
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0xcf, %esi
callq 0x8a32a
xorl %ebp, %ebp
leaq 0x9d11e(%rip), %rsi # 0x160000
leaq -0x4c8d9(%rip), %rdx # 0x76610
movq %rbx, %rdi
callq 0x20a40
leaq 0x569c0(%rip), %rdi # 0x1198b8
leaq 0x4f30e(%rip), %rdx # 0x11220d
leaq 0x5cd12(%rip), %rcx # 0x11fc18
movl $0x3519, %esi # imm = 0x3519
xorl %eax, %eax
callq 0x20e60
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xc2f2c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20180
testb %bpl, %bpl
jne 0xc2f36
jmp 0xc2f3e
movq %rax, %r14
movq %rbx, %rdi
callq 0x20ef0
movq %r14, %rdi
callq 0x20ae0
|
_ZNK8nlohmann16json_abi_v3_11_36detail9iter_implINS0_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_C2EF1
mov r14, rdi
cmp byte ptr [rax], 1
jnz short loc_C2E93
mov rax, [r14+8]
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_C2E93:
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_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_C2EF1:
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_C2F2C
mov rsi, [rsp+48h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C2F2C:
test bpl, bpl
jnz short loc_C2F36
jmp short loc_C2F3E
mov r14, rax
loc_C2F36:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_C2F3E:
mov rdi, r14
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::key(
_QWORD *a1)
{
void *v1; // rbx
char v2; // bp
void *v3; // r15
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
long long v6; // rax
long long v7; // r14
void *v8[2]; // [rsp+8h] [rbp-40h] BYREF
long long v9; // [rsp+18h] [rbp-30h] BYREF
if ( !*a1 )
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
13593LL,
"GGML_ASSERT(%s) failed",
"m_object != nullptr");
v7 = v6;
if ( v8[0] != v3 )
operator delete(v8[0], v9 + 1);
if ( v2 )
__cxa_free_exception(v1);
_Unwind_Resume(v7);
}
if ( *(_BYTE *)*a1 != 1 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v8[0] = &v9;
std::string::_M_construct<char const*>((long long)v8, "cannot use key() for non-object iterators", (long long)"");
ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
207,
v8);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::invalid_iterator,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return a1[1];
}
|
key:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x001c2ef1
MOV R14,RDI
CMP byte ptr [RAX],0x1
JNZ 0x001c2e93
MOV RAX,qword ptr [R14 + 0x8]
ADD RSP,0x28
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001c2e93:
MOV EDI,0x20
CALL 0x00120640
MOV RBX,RAX
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
LAB_001c2ea9:
LEA RSI,[0x21b145]
LEA RDX,[0x21b16e]
LEA RDI,[RSP + 0x8]
CALL 0x00128870
MOV RCX,qword ptr [R14]
MOV BPL,0x1
LAB_001c2ec7:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0xcf
CALL 0x0018a32a
XOR EBP,EBP
LEA RSI,[0x260000]
LEA RDX,[0x176610]
MOV RDI,RBX
CALL 0x00120a40
LAB_001c2ef1:
LEA RDI,[0x2198b8]
LEA RDX,[0x21220d]
LEA RCX,[0x21fc18]
MOV ESI,0x3519
XOR EAX,EAX
CALL 0x00120e60
|
/* 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> >::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>>
::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>>
*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 001c2ea9 to 001c2ec0 has its CatchHandler @ 001c2f33 */
std::__cxx11::string::_M_construct<char_const*>
(local_40,"cannot use key() for non-object iterators","");
/* try { // try from 001c2ec7 to 001c2ef0 has its CatchHandler @ 001c2f12 */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar1,0xcf,local_40,*(int8 *)this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&invalid_iterator::typeinfo,exception::~exception);
}
|
|
63,635
|
ma_insert_dynamic
|
eloqsql/libmariadb/libmariadb/ma_array.c
|
my_bool ma_insert_dynamic(DYNAMIC_ARRAY *array, void *element)
{
void *buffer;
if (array->elements == array->max_element)
{ /* Call only when necessary */
if (!(buffer=ma_alloc_dynamic(array)))
return TRUE;
}
else
{
buffer=array->buffer+(array->elements * array->size_of_element);
array->elements++;
}
memcpy(buffer,element,(size_t) array->size_of_element);
return FALSE;
}
|
O3
|
c
|
ma_insert_dynamic:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %ecx
cmpl 0xc(%rdi), %ecx
jne 0x32607
movq %r14, %rdi
callq 0x3262e
testq %rax, %rax
je 0x3262a
movq %rax, %rdi
movl 0x14(%r14), %eax
jmp 0x32619
movl 0x14(%r14), %eax
movl %eax, %edi
imull %ecx, %edi
addq (%r14), %rdi
incl %ecx
movl %ecx, 0x8(%r14)
movl %eax, %edx
movq %rbx, %rsi
callq 0x13390
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movb $0x1, %al
jmp 0x32625
|
ma_insert_dynamic:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rsi
mov r14, rdi
mov ecx, [rdi+8]
cmp ecx, [rdi+0Ch]
jnz short loc_32607
mov rdi, r14
call ma_alloc_dynamic
test rax, rax
jz short loc_3262A
mov rdi, rax
mov eax, [r14+14h]
jmp short loc_32619
loc_32607:
mov eax, [r14+14h]
mov edi, eax
imul edi, ecx
add rdi, [r14]
inc ecx
mov [r14+8], ecx
loc_32619:
mov edx, eax
mov rsi, rbx
call _memcpy
xor eax, eax
loc_32625:
pop rbx
pop r14
pop rbp
retn
loc_3262A:
mov al, 1
jmp short loc_32625
|
long long ma_insert_dynamic(long long a1, long long a2)
{
int v3; // ecx
long long v4; // rax
long long v5; // rdi
unsigned int v6; // eax
v3 = *(_DWORD *)(a1 + 8);
if ( v3 != *(_DWORD *)(a1 + 12) )
{
v6 = *(_DWORD *)(a1 + 20);
v5 = *(_QWORD *)a1 + v3 * v6;
*(_DWORD *)(a1 + 8) = v3 + 1;
goto LABEL_5;
}
v4 = ma_alloc_dynamic(a1);
if ( v4 )
{
v5 = v4;
v6 = *(_DWORD *)(a1 + 20);
LABEL_5:
memcpy(v5, a2, v6);
return 0LL;
}
return 1LL;
}
|
ma_insert_dynamic:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
MOV ECX,dword ptr [RDI + 0x8]
CMP ECX,dword ptr [RDI + 0xc]
JNZ 0x00132607
MOV RDI,R14
CALL 0x0013262e
TEST RAX,RAX
JZ 0x0013262a
MOV RDI,RAX
MOV EAX,dword ptr [R14 + 0x14]
JMP 0x00132619
LAB_00132607:
MOV EAX,dword ptr [R14 + 0x14]
MOV EDI,EAX
IMUL EDI,ECX
ADD RDI,qword ptr [R14]
INC ECX
MOV dword ptr [R14 + 0x8],ECX
LAB_00132619:
MOV EDX,EAX
MOV RSI,RBX
CALL 0x00113390
XOR EAX,EAX
LAB_00132625:
POP RBX
POP R14
POP RBP
RET
LAB_0013262a:
MOV AL,0x1
JMP 0x00132625
|
int8 ma_insert_dynamic(long *param_1,void *param_2)
{
int iVar1;
uint uVar2;
void *__dest;
iVar1 = (int)param_1[1];
if (iVar1 == *(int *)((long)param_1 + 0xc)) {
__dest = (void *)ma_alloc_dynamic(param_1);
if (__dest == (void *)0x0) {
return 1;
}
uVar2 = *(uint *)((long)param_1 + 0x14);
}
else {
uVar2 = *(uint *)((long)param_1 + 0x14);
__dest = (void *)((ulong)(uVar2 * iVar1) + *param_1);
*(int *)(param_1 + 1) = iVar1 + 1;
}
memcpy(__dest,param_2,(ulong)uVar2);
return 0;
}
|
|
63,636
|
lunasvg::SVGGraphicsElement::SVGGraphicsElement(lunasvg::Document*, lunasvg::ElementID)
|
dmazzella[P]pylunasvg/lunasvg/source/svgelement.cpp
|
SVGGraphicsElement::SVGGraphicsElement(Document* document, ElementID id)
: SVGElement(document, id)
, m_transform(PropertyID::Transform)
{
addProperty(m_transform);
}
|
O1
|
cpp
|
lunasvg::SVGGraphicsElement::SVGGraphicsElement(lunasvg::Document*, lunasvg::ElementID):
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
leaq 0x485a8(%rip), %rcx # 0x588b8
movq %rcx, (%rdi)
leaq 0x32e72(%rip), %rcx # 0x4318c
movups (%rcx), %xmm0
movups %xmm0, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movabsq $0x414000003f800000, %rcx # imm = 0x414000003F800000
movq %rcx, 0x38(%rdi)
movw $0x0, 0x40(%rdi)
movb $0x0, 0x42(%rdi)
movb %dl, 0x43(%rdi)
leaq 0x58(%rdi), %rcx
movups %xmm0, 0x48(%rdi)
movq %rcx, 0x60(%rdi)
movq %rcx, 0x58(%rdi)
movq %rax, 0x68(%rdi)
leaq 0x48c32(%rip), %rax # 0x58f90
movq %rax, (%rdi)
leaq 0x70(%rdi), %r14
movq %r14, %rdi
movl $0x46, %esi
callq 0x1f3bc
leaq 0x4acd7(%rip), %rax # 0x5b050
addq $0x10, %rax
movq %rax, 0x70(%rbx)
leaq 0x7c(%rbx), %rdi
callq 0xc8ec
movl $0x10, %edi
callq 0xa310
movq $0x0, (%rax)
movq %r14, 0x8(%rax)
movq 0x50(%rbx), %rcx
movq %rcx, (%rax)
movq %rax, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x103b4
movq %rax, %r14
movq %rbx, %rdi
callq 0xc5b2
movq %r14, %rdi
callq 0xa5c0
nop
|
_ZN7lunasvg18SVGGraphicsElementC2EPNS_8DocumentENS_9ElementIDE:
push r14; Alternative name is 'lunasvg::SVGGraphicsElement::SVGGraphicsElement(lunasvg::Document *, lunasvg::ElementID)'
push rbx
push rax
mov rbx, rdi
mov [rdi+8], rsi
xor eax, eax
mov [rdi+10h], rax
lea rcx, off_588B8
mov [rdi], rcx
lea rcx, _ZN7lunasvg4Rect7InvalidE; lunasvg::Rect::Invalid
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rdi+18h], xmm0
xorps xmm0, xmm0
movups xmmword ptr [rdi+28h], xmm0
mov rcx, 414000003F800000h
mov [rdi+38h], rcx
mov word ptr [rdi+40h], 0
mov byte ptr [rdi+42h], 0
mov [rdi+43h], dl
lea rcx, [rdi+58h]
movups xmmword ptr [rdi+48h], xmm0
mov [rdi+60h], rcx
mov [rdi+58h], rcx
mov [rdi+68h], rax
lea rax, off_58F90
mov [rdi], rax
lea r14, [rdi+70h]
mov rdi, r14
mov esi, 46h ; 'F'
call _ZN7lunasvg11SVGPropertyC2ENS_10PropertyIDE; lunasvg::SVGProperty::SVGProperty(lunasvg::PropertyID)
lea rax, _ZTVN7lunasvg12SVGTransformE; `vtable for'lunasvg::SVGTransform
add rax, 10h
mov [rbx+70h], rax
lea rdi, [rbx+7Ch]; this
call _ZN7lunasvg9TransformC2Ev; lunasvg::Transform::Transform(void)
mov edi, 10h; unsigned __int64
call __Znwm; operator new(ulong)
mov qword ptr [rax], 0
mov [rax+8], r14
mov rcx, [rbx+50h]
mov [rax], rcx
mov [rbx+50h], rax
add rsp, 8
pop rbx
pop r14
retn
jmp short $+2
loc_103B4:
mov r14, rax
mov rdi, rbx; this
call _ZN7lunasvg10SVGElementD2Ev; lunasvg::SVGElement::~SVGElement()
mov rdi, r14
call __Unwind_Resume
|
_QWORD * lunasvg::SVGGraphicsElement::SVGGraphicsElement(long long a1, long long a2, char a3)
{
_QWORD *result; // rax
*(_QWORD *)(a1 + 8) = a2;
*(_QWORD *)(a1 + 16) = 0LL;
*(_QWORD *)a1 = off_588B8;
*(_OWORD *)(a1 + 24) = lunasvg::Rect::Invalid;
*(_OWORD *)(a1 + 40) = 0LL;
*(_QWORD *)(a1 + 56) = 0x414000003F800000LL;
*(_WORD *)(a1 + 64) = 0;
*(_BYTE *)(a1 + 66) = 0;
*(_BYTE *)(a1 + 67) = a3;
*(_OWORD *)(a1 + 72) = 0LL;
*(_QWORD *)(a1 + 96) = a1 + 88;
*(_QWORD *)(a1 + 88) = a1 + 88;
*(_QWORD *)(a1 + 104) = 0LL;
*(_QWORD *)a1 = off_58F90;
lunasvg::SVGProperty::SVGProperty(a1 + 112, 70LL);
*(_QWORD *)(a1 + 112) = &`vtable for'lunasvg::SVGTransform + 2;
lunasvg::Transform::Transform((lunasvg::Transform *)(a1 + 124));
result = (_QWORD *)operator new(0x10uLL);
*result = 0LL;
result[1] = a1 + 112;
*result = *(_QWORD *)(a1 + 80);
*(_QWORD *)(a1 + 80) = result;
return result;
}
|
SVGGraphicsElement:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV qword ptr [RDI + 0x8],RSI
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],RAX
LEA RCX,[0x1588b8]
MOV qword ptr [RDI],RCX
LEA RCX,[0x14318c]
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RDI + 0x18],XMM0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x28],XMM0
MOV RCX,0x414000003f800000
MOV qword ptr [RDI + 0x38],RCX
MOV word ptr [RDI + 0x40],0x0
MOV byte ptr [RDI + 0x42],0x0
MOV byte ptr [RDI + 0x43],DL
LEA RCX,[RDI + 0x58]
MOVUPS xmmword ptr [RDI + 0x48],XMM0
MOV qword ptr [RDI + 0x60],RCX
MOV qword ptr [RDI + 0x58],RCX
MOV qword ptr [RDI + 0x68],RAX
LEA RAX,[0x158f90]
MOV qword ptr [RDI],RAX
LEA R14,[RDI + 0x70]
LAB_00110365:
MOV RDI,R14
MOV ESI,0x46
CALL 0x0011f3bc
LEA RAX,[0x15b050]
ADD RAX,0x10
MOV qword ptr [RBX + 0x70],RAX
LEA RDI,[RBX + 0x7c]
CALL 0x0010c8ec
LAB_0011038a:
MOV EDI,0x10
CALL 0x0010a310
LAB_00110394:
MOV qword ptr [RAX],0x0
MOV qword ptr [RAX + 0x8],R14
MOV RCX,qword ptr [RBX + 0x50]
MOV qword ptr [RAX],RCX
MOV qword ptr [RBX + 0x50],RAX
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* lunasvg::SVGGraphicsElement::SVGGraphicsElement(lunasvg::Document*, lunasvg::ElementID) */
void __thiscall
lunasvg::SVGGraphicsElement::SVGGraphicsElement
(SVGGraphicsElement *this,int8 param_1,SVGGraphicsElement param_3)
{
int8 uVar1;
int8 *puVar2;
*(int8 *)(this + 8) = param_1;
*(int8 *)(this + 0x10) = 0;
*(int ***)this = &PTR__SVGElement_001588b8;
uVar1 = Rect::Invalid._8_8_;
*(int8 *)(this + 0x18) = Rect::Invalid._0_8_;
*(int8 *)(this + 0x20) = uVar1;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0x414000003f800000;
*(int2 *)(this + 0x40) = 0;
this[0x42] = (SVGGraphicsElement)0x0;
this[0x43] = param_3;
*(int8 *)(this + 0x48) = 0;
*(int8 *)(this + 0x50) = 0;
*(SVGGraphicsElement **)(this + 0x60) = this + 0x58;
*(SVGGraphicsElement **)(this + 0x58) = this + 0x58;
*(int8 *)(this + 0x68) = 0;
*(int ***)this = &PTR__SVGGraphicsElement_00158f90;
/* try { // try from 00110365 to 00110389 has its CatchHandler @ 001103b4 */
SVGProperty::SVGProperty((SVGProperty *)(this + 0x70),0x46);
*(int ***)(this + 0x70) = &PTR__SVGProperty_0015b060;
Transform::Transform((Transform *)(this + 0x7c));
/* try { // try from 0011038a to 00110393 has its CatchHandler @ 001103b2 */
puVar2 = (int8 *)operator_new(0x10);
*puVar2 = 0;
puVar2[1] = (SVGProperty *)(this + 0x70);
*puVar2 = *(int8 *)(this + 0x50);
*(int8 **)(this + 0x50) = puVar2;
return;
}
|
|
63,637
|
testing::internal::NoExecDeathTest::NoExecDeathTest(char const*, testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>)
|
giladroyz[P]FindPeaks/build_O3/_deps/googletest-src/googletest/src/gtest-death-test.cc
|
NoExecDeathTest(const char* a_statement, Matcher<const std::string&> matcher)
: ForkingDeathTest(a_statement, std::move(matcher)) {}
|
O3
|
cpp
|
testing::internal::NoExecDeathTest::NoExecDeathTest(char const*, testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>):
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x8(%rdx), %rcx
leaq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rdx), %rcx
movq %rcx, 0x10(%rax)
movq $0x0, 0x8(%rdx)
leaq 0x26814(%rip), %rcx # 0x588b8
movq %rcx, (%rax)
movq %rax, %rdx
callq 0x104c8
leaq 0x8(%rsp), %rdi
callq 0x31d96
leaq 0x26268(%rip), %rax # 0x58328
movq %rax, (%rbx)
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x31d96
movq %rbx, %rdi
callq 0x8990
|
_ZN7testing8internal15NoExecDeathTestC2EPKcNS_7MatcherIRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEE:
push rbx
sub rsp, 20h
mov rbx, rdi
mov rcx, [rdx+8]
lea rax, [rsp+28h+var_20]
mov [rax+8], rcx
mov rcx, [rdx+10h]
mov [rax+10h], rcx
mov qword ptr [rdx+8], 0
lea rcx, off_588B8
mov [rax], rcx
mov rdx, rax
call _ZN7testing8internal16ForkingDeathTestC2EPKcNS_7MatcherIRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEE; testing::internal::ForkingDeathTest::ForkingDeathTest(char const*,testing::Matcher<std::string const&>)
lea rdi, [rsp+28h+var_20]
call _ZN7testing8internal11MatcherBaseIRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEED2Ev; testing::internal::MatcherBase<std::string const&>::~MatcherBase()
lea rax, off_58328
mov [rbx], rax
add rsp, 20h
pop rbx
retn
mov rbx, rax
lea rdi, [rsp+arg_0]
call _ZN7testing8internal11MatcherBaseIRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEED2Ev; testing::internal::MatcherBase<std::string const&>::~MatcherBase()
mov rdi, rbx
call __Unwind_Resume
|
void ( ** testing::internal::NoExecDeathTest::NoExecDeathTest(
_QWORD *a1,
long long a2,
long long a3))(testing::internal::DeathTestImpl *__hidden this)
{
void ( **result)(testing::internal::DeathTestImpl *__hidden); // rax
_QWORD v4[4]; // [rsp+8h] [rbp-20h] BYREF
v4[1] = *(_QWORD *)(a3 + 8);
v4[2] = *(_QWORD *)(a3 + 16);
*(_QWORD *)(a3 + 8) = 0LL;
v4[0] = &off_588B8;
testing::internal::ForkingDeathTest::ForkingDeathTest((long long)a1, a2, (long long)v4);
testing::internal::MatcherBase<std::string const&>::~MatcherBase((long long)v4);
result = off_58328;
*a1 = off_58328;
return result;
}
|
NoExecDeathTest:
PUSH RBX
SUB RSP,0x20
MOV RBX,RDI
MOV RCX,qword ptr [RDX + 0x8]
LEA RAX,[RSP + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RDX + 0x10]
MOV qword ptr [RAX + 0x10],RCX
MOV qword ptr [RDX + 0x8],0x0
LEA RCX,[0x1588b8]
MOV qword ptr [RAX],RCX
LAB_001320a7:
MOV RDX,RAX
CALL 0x001104c8
LAB_001320af:
LEA RDI,[RSP + 0x8]
CALL 0x00131d96
LEA RAX,[0x158328]
MOV qword ptr [RBX],RAX
ADD RSP,0x20
POP RBX
RET
|
/* testing::internal::NoExecDeathTest::NoExecDeathTest(char const*,
testing::Matcher<std::__cxx11::string const&>) */
void __thiscall
testing::internal::NoExecDeathTest::NoExecDeathTest
(NoExecDeathTest *this,int8 param_1,long param_3)
{
int **local_20;
int8 local_18;
int8 local_10;
local_18 = *(int8 *)(param_3 + 8);
local_10 = *(int8 *)(param_3 + 0x10);
*(int8 *)(param_3 + 8) = 0;
local_20 = &PTR__MatcherBase_001588b8;
/* try { // try from 001320a7 to 001320ae has its CatchHandler @ 001320c9 */
ForkingDeathTest::ForkingDeathTest((ForkingDeathTest *)this,param_1,&local_20);
MatcherBase<std::__cxx11::string_const&>::~MatcherBase
((MatcherBase<std::__cxx11::string_const&> *)&local_20);
*(int ***)this = &PTR__DeathTestImpl_00158328;
return;
}
|
|
63,638
|
psi_rwlock_rdlock
|
eloqsql/mysys/my_thr_init.c
|
ATTRIBUTE_COLD
int psi_rwlock_rdlock(mysql_rwlock_t *that, const char *file, uint line)
{
PSI_rwlock_locker_state state;
PSI_rwlock_locker *locker= PSI_RWLOCK_CALL(start_rwlock_rdwait)
(&state, that->m_psi, PSI_RWLOCK_READLOCK, file, line);
int result= rw_rdlock(&that->m_rwlock);
if (locker)
PSI_RWLOCK_CALL(end_rwlock_rdwait)(locker, result);
return result;
}
|
O0
|
c
|
psi_rwlock_rdlock:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x1b6c96(%rip), %rax # 0x2132d0
movq (%rax), %rax
movq 0x1a0(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x90(%rcx), %rsi
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %r8d
leaq -0x48(%rbp), %rdi
xorl %edx, %edx
callq *%rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5cc30
movl %eax, -0x54(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x5c690
leaq 0x1b6c53(%rip), %rax # 0x2132d0
movq (%rax), %rax
movq 0x1a8(%rax), %rax
movq -0x50(%rbp), %rdi
movl -0x54(%rbp), %esi
callq *%rax
movl -0x54(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
|
psi_rwlock_rdlock:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1A0h]
mov rcx, [rbp+var_8]
mov rsi, [rcx+90h]
mov rcx, [rbp+var_10]
mov r8d, [rbp+var_14]
lea rdi, [rbp+var_48]
xor edx, edx
call rax
mov [rbp+var_50], rax
mov rdi, [rbp+var_8]
call my_rw_rdlock
mov [rbp+var_54], eax
cmp [rbp+var_50], 0
jz short loc_5C690
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1A8h]
mov rdi, [rbp+var_50]
mov esi, [rbp+var_54]
call rax
loc_5C690:
mov eax, [rbp+var_54]
add rsp, 60h
pop rbp
retn
|
long long psi_rwlock_rdlock(long long a1, long long a2, unsigned int a3)
{
unsigned int v4; // [rsp+Ch] [rbp-54h]
long long v5; // [rsp+10h] [rbp-50h]
_BYTE v6[52]; // [rsp+18h] [rbp-48h] BYREF
unsigned int v7; // [rsp+4Ch] [rbp-14h]
long long v8; // [rsp+50h] [rbp-10h]
long long v9; // [rsp+58h] [rbp-8h]
v9 = a1;
v8 = a2;
v7 = a3;
v5 = ((long long ( *)(_BYTE *, _QWORD, _QWORD, long long, _QWORD))PSI_server[52])(
v6,
*(_QWORD *)(a1 + 144),
0LL,
a2,
a3);
v4 = my_rw_rdlock(v9);
if ( v5 )
((void ( *)(long long, _QWORD))PSI_server[53])(v5, v4);
return v4;
}
|
psi_rwlock_rdlock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
LEA RAX,[0x3132d0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1a0]
MOV RCX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RCX + 0x90]
MOV RCX,qword ptr [RBP + -0x10]
MOV R8D,dword ptr [RBP + -0x14]
LEA RDI,[RBP + -0x48]
XOR EDX,EDX
CALL RAX
MOV qword ptr [RBP + -0x50],RAX
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0015cc30
MOV dword ptr [RBP + -0x54],EAX
CMP qword ptr [RBP + -0x50],0x0
JZ 0x0015c690
LEA RAX,[0x3132d0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1a8]
MOV RDI,qword ptr [RBP + -0x50]
MOV ESI,dword ptr [RBP + -0x54]
CALL RAX
LAB_0015c690:
MOV EAX,dword ptr [RBP + -0x54]
ADD RSP,0x60
POP RBP
RET
|
int4 psi_rwlock_rdlock(long param_1,int8 param_2,int4 param_3)
{
int4 uVar1;
long lVar2;
int1 local_50 [52];
int4 local_1c;
int8 local_18;
long local_10;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
lVar2 = (**(code **)(PSI_server + 0x1a0))
(local_50,*(int8 *)(param_1 + 0x90),0,param_2,param_3);
uVar1 = my_rw_rdlock(local_10);
if (lVar2 != 0) {
(**(code **)(PSI_server + 0x1a8))(lVar2,uVar1);
}
return uVar1;
}
|
|
63,639
|
lex2str
|
eloqsql/strings/xml.c
|
static const char *lex2str(int lex)
{
switch(lex)
{
case MY_XML_EOF: return "END-OF-INPUT";
case MY_XML_STRING: return "STRING";
case MY_XML_IDENT: return "IDENT";
case MY_XML_CDATA: return "CDATA";
case MY_XML_EQ: return "'='";
case MY_XML_LT: return "'<'";
case MY_XML_GT: return "'>'";
case MY_XML_SLASH: return "'/'";
case MY_XML_COMMENT: return "COMMENT";
case MY_XML_TEXT: return "TEXT";
case MY_XML_QUESTION: return "'?'";
case MY_XML_EXCLAM: return "'!'";
}
return "unknown token";
}
|
O3
|
c
|
lex2str:
pushq %rbp
movq %rsp, %rbp
leal -0x3c(%rdi), %eax
cmpl $0x18, %eax
ja 0x59937
leaq 0x27d6db(%rip), %rcx # 0x2d7000
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4ef5(%rip), %rax # 0x5e82a
jmp 0x599ab
cmpl $0x21, %edi
je 0x599a4
cmpl $0x2f, %edi
jne 0x5994a
leaq 0x4eea(%rip), %rax # 0x5e832
jmp 0x599ab
leaq 0x4efa(%rip), %rax # 0x5e84b
jmp 0x599ab
leaq 0x4ec0(%rip), %rax # 0x5e81a
jmp 0x599ab
leaq 0x4eb0(%rip), %rax # 0x5e813
jmp 0x599ab
leaq 0x4ed7(%rip), %rax # 0x5e843
jmp 0x599ab
leaq 0x4eb1(%rip), %rax # 0x5e826
jmp 0x599ab
leaq 0x4eb0(%rip), %rax # 0x5e82e
jmp 0x599ab
leaq 0x4eaf(%rip), %rax # 0x5e836
jmp 0x599ab
leaq 0x4e5c(%rip), %rax # 0x5e7ec
jmp 0x599ab
leaq 0x4e87(%rip), %rax # 0x5e820
jmp 0x599ab
leaq 0x4e9c(%rip), %rax # 0x5e83e
jmp 0x599ab
leaq 0x4e9c(%rip), %rax # 0x5e847
popq %rbp
retq
|
lex2str:
push rbp
mov rbp, rsp
lea eax, [rdi-3Ch]; switch 25 cases
cmp eax, 18h
ja short def_5992C; jumptable 000000000005992C default case
lea rcx, jpt_5992C
movsxd rax, ds:(jpt_5992C - 2D7000h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_5992E:
lea rax, asc_5E82A; jumptable 000000000005992C case 60
jmp short loc_599AB
def_5992C:
cmp edi, 21h ; '!'; jumptable 000000000005992C default case
jz short loc_599A4
cmp edi, 2Fh ; '/'
jnz short loc_5994A; jumptable 000000000005992C cases 64-66,70-72,74-82
lea rax, asc_5E832; "'/'"
jmp short loc_599AB
loc_5994A:
lea rax, aUnknownToken; jumptable 000000000005992C cases 64-66,70-72,74-82
jmp short loc_599AB
loc_59953:
lea rax, aIdent; jumptable 000000000005992C case 73
jmp short loc_599AB
loc_5995C:
lea rax, aString; jumptable 000000000005992C case 83
jmp short loc_599AB
loc_59965:
lea rax, asc_5E843; jumptable 000000000005992C case 63
jmp short loc_599AB
loc_5996E:
lea rax, asc_5E826; jumptable 000000000005992C case 61
jmp short loc_599AB
loc_59977:
lea rax, asc_5E82E; jumptable 000000000005992C case 62
jmp short loc_599AB
loc_59980:
lea rax, aComment; jumptable 000000000005992C case 67
jmp short loc_599AB
loc_59989:
lea rax, aUnexpectedEndO+0Bh; jumptable 000000000005992C case 69
jmp short loc_599AB
loc_59992:
lea rax, aCdata; jumptable 000000000005992C case 68
jmp short loc_599AB
loc_5999B:
lea rax, aText; jumptable 000000000005992C case 84
jmp short loc_599AB
loc_599A4:
lea rax, asc_5E847; "'!'"
loc_599AB:
pop rbp
retn
|
char * lex2str(int a1)
{
char *result; // rax
switch ( a1 )
{
case '<':
result = "'<'";
break;
case '=':
result = "'='";
break;
case '>':
result = "'>'";
break;
case '?':
result = "'?'";
break;
case '@':
case 'A':
case 'B':
case 'F':
case 'G':
case 'H':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
goto LABEL_6;
case 'C':
result = "COMMENT";
break;
case 'D':
result = "CDATA";
break;
case 'E':
result = "END-OF-INPUT";
break;
case 'I':
result = "IDENT";
break;
case 'S':
result = "STRING";
break;
case 'T':
result = "TEXT";
break;
default:
if ( a1 == 33 )
{
result = "'!'";
}
else if ( a1 == 47 )
{
result = "'/'";
}
else
{
LABEL_6:
result = "unknown token";
}
break;
}
return result;
}
|
lex2str:
PUSH RBP
MOV RBP,RSP
LEA EAX,[RDI + -0x3c]
CMP EAX,0x18
JA 0x00159937
LEA RCX,[0x3d7000]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_3c:
LEA RAX,[0x15e82a]
JMP 0x001599ab
default:
CMP EDI,0x21
JZ 0x001599a4
CMP EDI,0x2f
JNZ 0x0015994a
LEA RAX,[0x15e832]
JMP 0x001599ab
caseD_40:
LEA RAX,[0x15e84b]
JMP 0x001599ab
caseD_49:
LEA RAX,[0x15e81a]
JMP 0x001599ab
caseD_53:
LEA RAX,[0x15e813]
JMP 0x001599ab
caseD_3f:
LEA RAX,[0x15e843]
JMP 0x001599ab
caseD_3d:
LEA RAX,[0x15e826]
JMP 0x001599ab
caseD_3e:
LEA RAX,[0x15e82e]
JMP 0x001599ab
caseD_43:
LEA RAX,[0x15e836]
JMP 0x001599ab
caseD_45:
LEA RAX,[0x15e7ec]
JMP 0x001599ab
caseD_44:
LEA RAX,[0x15e820]
JMP 0x001599ab
caseD_54:
LEA RAX,[0x15e83e]
JMP 0x001599ab
LAB_001599a4:
LEA RAX,[0x15e847]
LAB_001599ab:
POP RBP
RET
|
char * lex2str(int param_1)
{
char *pcVar1;
switch(param_1) {
case 0x3c:
pcVar1 = "\'<\'";
break;
case 0x3d:
pcVar1 = "\'=\'";
break;
case 0x3e:
pcVar1 = "\'>\'";
break;
case 0x3f:
pcVar1 = "\'?\'";
break;
case 0x43:
pcVar1 = "COMMENT";
break;
case 0x44:
pcVar1 = "CDATA";
break;
case 0x45:
pcVar1 = "END-OF-INPUT";
break;
case 0x49:
pcVar1 = "IDENT";
break;
case 0x53:
pcVar1 = "STRING";
break;
case 0x54:
pcVar1 = "TEXT";
break;
default:
if (param_1 == 0x21) {
return "\'!\'";
}
if (param_1 == 0x2f) {
return "\'/\'";
}
case 0x40:
case 0x41:
case 0x42:
case 0x46:
case 0x47:
case 0x48:
case 0x4a:
case 0x4b:
case 0x4c:
case 0x4d:
case 0x4e:
case 0x4f:
case 0x50:
case 0x51:
case 0x52:
pcVar1 = "unknown token";
}
return pcVar1;
}
|
|
63,640
|
void fmt::v10::detail::ignore_unused<bool, char [24]>(bool const&, char const (&) [24])
|
aimrt_mujoco_sim/_deps/fmt-src/include/fmt/core.h
|
constexpr FMT_INLINE auto is_constant_evaluated(
bool default_value = false) noexcept -> bool {
// Workaround for incompatibility between libstdc++ consteval-based
// std::is_constant_evaluated() implementation and clang-14.
// https://github.com/fmtlib/fmt/issues/3247
#if FMT_CPLUSPLUS >= 202002L && defined(_GLIBCXX_RELEASE) && \
_GLIBCXX_RELEASE >= 12 && \
(FMT_CLANG_VERSION >= 1400 && FMT_CLANG_VERSION < 1500)
ignore_unused(default_value);
return __builtin_is_constant_evaluated();
#elif defined(__cpp_lib_is_constant_evaluated)
ignore_unused(default_value);
return std::is_constant_evaluated();
#else
return default_value;
#endif
}
|
O0
|
c
|
void fmt::v10::detail::ignore_unused<bool, char [24]>(bool const&, char const (&) [24]):
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
retq
nopl (%rax,%rax)
|
_ZN3fmt3v106detail13ignore_unusedIJbA24_cEEEvDpRKT_:
mov [rsp+var_8], rdi
mov [rsp+var_10], rsi
retn
|
void fmt::v10::detail::ignore_unused<bool,char [24]>()
{
;
}
|
ignore_unused<bool,char[24]>:
MOV qword ptr [RSP + -0x8],RDI
MOV qword ptr [RSP + -0x10],RSI
RET
|
/* void fmt::v10::detail::ignore_unused<bool, char [24]>(bool const&, char const (&) [24]) */
void fmt::v10::detail::ignore_unused<bool,char[24]>(bool *param_1,char *param_2)
{
return;
}
|
|
63,641
|
my_once_free
|
eloqsql/mysys/my_once.c
|
void my_once_free(void)
{
reg1 USED_MEM *next,*old;
DBUG_ENTER("my_once_free");
for (next=my_once_root_block ; next ; )
{
old=next; next= next->next ;
free((uchar*) old);
}
my_once_root_block=0;
DBUG_VOID_RETURN;
}
|
O0
|
c
|
my_once_free:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x360151(%rip), %rax # 0x390bd0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x30aab
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x24370
jmp 0x30a86
leaq 0x36011e(%rip), %rax # 0x390bd0
movq $0x0, (%rax)
jmp 0x30abb
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
|
my_once_free:
push rbp
mov rbp, rsp
sub rsp, 10h
lea rax, my_once_root_block
mov rax, [rax]
mov [rbp+var_8], rax
loc_30A86:
cmp [rbp+var_8], 0
jz short loc_30AAB
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_8], rax
mov rdi, [rbp+var_10]
call _free
jmp short loc_30A86
loc_30AAB:
lea rax, my_once_root_block
mov qword ptr [rax], 0
jmp short $+2
loc_30ABB:
add rsp, 10h
pop rbp
retn
|
_QWORD *my_once_free()
{
_QWORD *result; // rax
_QWORD *v1; // [rsp+0h] [rbp-10h]
_QWORD *v2; // [rsp+8h] [rbp-8h]
v2 = (_QWORD *)my_once_root_block;
while ( v2 )
{
v1 = v2;
v2 = (_QWORD *)*v2;
free(v1);
}
result = &my_once_root_block;
my_once_root_block = 0LL;
return result;
}
|
my_once_free:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
LEA RAX,[0x490bd0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x8],RAX
LAB_00130a86:
CMP qword ptr [RBP + -0x8],0x0
JZ 0x00130aab
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x8],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00124370
JMP 0x00130a86
LAB_00130aab:
LEA RAX,[0x490bd0]
MOV qword ptr [RAX],0x0
JMP 0x00130abb
LAB_00130abb:
ADD RSP,0x10
POP RBP
RET
|
void my_once_free(void)
{
int8 *puVar1;
int8 local_10;
local_10 = my_once_root_block;
while (local_10 != (int8 *)0x0) {
puVar1 = (int8 *)*local_10;
free(local_10);
local_10 = puVar1;
}
my_once_root_block = (int8 *)0x0;
return;
}
|
|
63,642
|
my_once_free
|
eloqsql/mysys/my_once.c
|
void my_once_free(void)
{
reg1 USED_MEM *next,*old;
DBUG_ENTER("my_once_free");
for (next=my_once_root_block ; next ; )
{
old=next; next= next->next ;
free((uchar*) old);
}
my_once_root_block=0;
DBUG_VOID_RETURN;
}
|
O3
|
c
|
my_once_free:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x341f26(%rip), %rbx # 0x36dff0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2c0e2
movq (%rdi), %r14
callq 0x243d0
movq %r14, %rdi
testq %r14, %r14
jne 0x2c0d2
movq $0x0, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
|
my_once_free:
push rbp
mov rbp, rsp
push r14
push rbx
lea rbx, my_once_root_block
mov rdi, [rbx]
test rdi, rdi
jz short loc_2C0E2
loc_2C0D2:
mov r14, [rdi]
call _free
mov rdi, r14
test r14, r14
jnz short loc_2C0D2
loc_2C0E2:
mov qword ptr [rbx], 0
pop rbx
pop r14
pop rbp
retn
|
long long my_once_free(long long a1, long long a2)
{
_QWORD *v2; // rdi
_QWORD *v3; // r14
long long result; // rax
v2 = (_QWORD *)my_once_root_block;
if ( my_once_root_block )
{
do
{
v3 = (_QWORD *)*v2;
result = free(v2, a2);
v2 = v3;
}
while ( v3 );
}
my_once_root_block = 0LL;
return result;
}
|
my_once_free:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
LEA RBX,[0x46dff0]
MOV RDI,qword ptr [RBX]
TEST RDI,RDI
JZ 0x0012c0e2
LAB_0012c0d2:
MOV R14,qword ptr [RDI]
CALL 0x001243d0
MOV RDI,R14
TEST R14,R14
JNZ 0x0012c0d2
LAB_0012c0e2:
MOV qword ptr [RBX],0x0
POP RBX
POP R14
POP RBP
RET
|
void my_once_free(void)
{
long *plVar1;
long *__ptr;
__ptr = my_once_root_block;
if (my_once_root_block != (long *)0x0) {
do {
plVar1 = (long *)*__ptr;
free(__ptr);
__ptr = plVar1;
} while (plVar1 != (long *)0x0);
}
my_once_root_block = (long *)0x0;
return;
}
|
|
63,643
|
token_type_to_string
|
tsotchke[P]eshkol/src/frontend/lexer/lexer.c
|
const char* token_type_to_string(TokenType type) {
switch (type) {
case TOKEN_EOF: return "EOF";
case TOKEN_LPAREN: return "(";
case TOKEN_RPAREN: return ")";
case TOKEN_LBRACKET: return "[";
case TOKEN_RBRACKET: return "]";
case TOKEN_QUOTE: return "'";
case TOKEN_BACKQUOTE: return "`";
case TOKEN_COMMA: return ",";
case TOKEN_COMMA_AT: return ",@";
case TOKEN_DOT: return ".";
case TOKEN_COLON: return ":";
case TOKEN_IDENTIFIER: return "IDENTIFIER";
case TOKEN_BOOLEAN: return "BOOLEAN";
case TOKEN_NUMBER: return "NUMBER";
case TOKEN_CHARACTER: return "CHARACTER";
case TOKEN_STRING: return "STRING";
case TOKEN_VECTOR_START: return "#(";
case TOKEN_COMMENT: return "COMMENT";
case TOKEN_ERROR: return "ERROR";
default: return "UNKNOWN";
}
}
|
O2
|
c
|
token_type_to_string:
cmpl $0x12, %edi
ja 0x428b
movl %edi, %eax
leaq 0x13f4d(%rip), %rcx # 0x181d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0x140c3(%rip), %rax # 0x18355
retq
|
token_type_to_string:
cmp edi, 12h
ja short loc_428B
mov eax, edi
lea rcx, unk_181D0
movsxd rax, dword ptr [rcx+rax*4]
add rax, rcx
retn
loc_428B:
lea rax, aUnknown_0; "UNKNOWN"
retn
|
const char * token_type_to_string(unsigned int a1)
{
if ( a1 > 0x12 )
return "UNKNOWN";
else
return (char *)dword_181D0 + dword_181D0[a1];
}
|
token_type_to_string:
CMP EDI,0x12
JA 0x0010428b
MOV EAX,EDI
LEA RCX,[0x1181d0]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
RET
LAB_0010428b:
LEA RAX,[0x118355]
RET
|
char * token_type_to_string(uint param_1)
{
if (param_1 < 0x13) {
return &DAT_001181d0 + *(int *)(&DAT_001181d0 + (ulong)param_1 * 4);
}
return "UNKNOWN";
}
|
|
63,644
|
token_type_to_string
|
tsotchke[P]eshkol/src/frontend/lexer/lexer.c
|
const char* token_type_to_string(TokenType type) {
switch (type) {
case TOKEN_EOF: return "EOF";
case TOKEN_LPAREN: return "(";
case TOKEN_RPAREN: return ")";
case TOKEN_LBRACKET: return "[";
case TOKEN_RBRACKET: return "]";
case TOKEN_QUOTE: return "'";
case TOKEN_BACKQUOTE: return "`";
case TOKEN_COMMA: return ",";
case TOKEN_COMMA_AT: return ",@";
case TOKEN_DOT: return ".";
case TOKEN_COLON: return ":";
case TOKEN_IDENTIFIER: return "IDENTIFIER";
case TOKEN_BOOLEAN: return "BOOLEAN";
case TOKEN_NUMBER: return "NUMBER";
case TOKEN_CHARACTER: return "CHARACTER";
case TOKEN_STRING: return "STRING";
case TOKEN_VECTOR_START: return "#(";
case TOKEN_COMMENT: return "COMMENT";
case TOKEN_ERROR: return "ERROR";
default: return "UNKNOWN";
}
}
|
O3
|
c
|
token_type_to_string:
cmpl $0x12, %edi
ja 0x4791
movl %edi, %eax
leaq 0x15a47(%rip), %rcx # 0x1a1d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0x15bbd(%rip), %rax # 0x1a355
retq
|
token_type_to_string:
cmp edi, 12h
ja short loc_4791
mov eax, edi
lea rcx, unk_1A1D0
movsxd rax, dword ptr [rcx+rax*4]
add rax, rcx
retn
loc_4791:
lea rax, aUnknown_0; "UNKNOWN"
retn
|
const char * token_type_to_string(unsigned int a1)
{
if ( a1 > 0x12 )
return "UNKNOWN";
else
return (char *)dword_1A1D0 + dword_1A1D0[a1];
}
|
token_type_to_string:
CMP EDI,0x12
JA 0x00104791
MOV EAX,EDI
LEA RCX,[0x11a1d0]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
RET
LAB_00104791:
LEA RAX,[0x11a355]
RET
|
char * token_type_to_string(uint param_1)
{
if (param_1 < 0x13) {
return &DAT_0011a1d0 + *(int *)(&DAT_0011a1d0 + (ulong)param_1 * 4);
}
return "UNKNOWN";
}
|
|
63,645
|
ggml_vec_dot_q3_K_q8_K
|
ngxson[P]ggml-easy/ggml/src/ggml-cpu/ggml-cpu-quants.c
|
void ggml_vec_dot_q3_K_q8_K(int n, float * GGML_RESTRICT s, size_t bs, const void * GGML_RESTRICT vx, size_t bx, const void * GGML_RESTRICT vy, size_t by, int nrc) {
assert(n % QK_K == 0);
assert(nrc == 1);
UNUSED(nrc);
UNUSED(bx);
UNUSED(by);
UNUSED(bs);
const uint32_t kmask1 = 0x03030303;
const uint32_t kmask2 = 0x0f0f0f0f;
const block_q3_K * GGML_RESTRICT x = vx;
const block_q8_K * GGML_RESTRICT y = vy;
const int nb = n / QK_K;
#if defined(__ARM_FEATURE_SVE)
uint32_t aux[3];
uint32_t utmp[4];
const int8_t m32 = 32;
const int vector_length = svcntb()*8;
const svuint8_t m3b_sv = svdup_n_u8(0x3);
const svint32_t vzero_sv = svdup_n_s32(0);
const svuint8_t m0_sv = svdup_n_u8(1);
const svuint8_t m1_sv = svlsl_n_u8_x(svptrue_b8(), m0_sv, 1);
const svuint8_t m2_sv = svlsl_n_u8_x(svptrue_b8(), m0_sv, 2);
const svuint8_t m3_sv = svlsl_n_u8_x(svptrue_b8(), m0_sv, 3);
float sum = 0;
for (int i = 0; i < nb; ++i) {
const float d = y[i].d * GGML_FP16_TO_FP32(x[i].d);
const uint8_t * GGML_RESTRICT q3_sv = x[i].qs;
const uint8_t * GGML_RESTRICT qh_sv = x[i].hmask;
const int8_t * GGML_RESTRICT q8_sv = y[i].qs;
// Set up scales
memcpy(aux, x[i].scales, 12);
utmp[3] = ((aux[1] >> 4) & kmask2) | (((aux[2] >> 6) & kmask1) << 4);
utmp[2] = ((aux[0] >> 4) & kmask2) | (((aux[2] >> 4) & kmask1) << 4);
utmp[1] = (aux[1] & kmask2) | (((aux[2] >> 2) & kmask1) << 4);
utmp[0] = (aux[0] & kmask2) | (((aux[2] >> 0) & kmask1) << 4);
int8_t * scale = (int8_t *)utmp;
for (int j = 0; j < 16; ++j) scale[j] -= m32;
switch (vector_length) {
case 128:
{
svuint8_t qhbits_sv_1 = svld1_u8(svptrue_b8(), qh_sv);
svuint8_t qhbits_sv_2 = svld1_u8(svptrue_b8(), qh_sv+16);
svuint8_t q3h_sv;
svint32_t sumi1_1 = svdup_n_s32(0);
svint8_t q3bytes_sv;
for (int j = 0; j < QK_K/128; ++j) {
const svuint8_t q3bits_sv = svld1_u8(svptrue_b8(), q3_sv); q3_sv += 16;
const svuint8_t q3bits_sv_1 = svld1_u8(svptrue_b8(), q3_sv); q3_sv += 16;
svint8_t q8bytes_1_sv_1 = svld1_s8(svptrue_b8(), q8_sv); q8_sv += 16;
svint8_t q8bytes_1_sv_2 = svld1_s8(svptrue_b8(), q8_sv); q8_sv += 16;
q3h_sv = svlsl_n_u8_x(svptrue_b8(), svbic_u8_x(svptrue_b8(), m0_sv, qhbits_sv_1), 2);
q3bytes_sv = svsub_s8_x(svptrue_b8(), svreinterpret_s8_u8(svand_u8_m(svptrue_b8(), q3bits_sv, m3b_sv)), svreinterpret_s8_u8(q3h_sv));
sumi1_1 = svmla_s32_m(svptrue_b32(), sumi1_1, svdot_s32(vzero_sv, q3bytes_sv, q8bytes_1_sv_1), svdup_n_s32((int32_t)scale[0]));
q3h_sv = svlsl_n_u8_x(svptrue_b8(), svbic_u8_x(svptrue_b8(), m0_sv, qhbits_sv_2), 2);
q3bytes_sv = svsub_s8_x(svptrue_b8(), svreinterpret_s8_u8(svand_u8_m(svptrue_b8(), q3bits_sv_1, m3b_sv)), svreinterpret_s8_u8(q3h_sv));
sumi1_1 = svmla_s32_m(svptrue_b32(), sumi1_1, svdot_s32(vzero_sv, q3bytes_sv, q8bytes_1_sv_2), svdup_n_s32((int32_t)scale[1]));
q8bytes_1_sv_1 = svld1_s8(svptrue_b8(), q8_sv); q8_sv += 16;
q8bytes_1_sv_2 = svld1_s8(svptrue_b8(), q8_sv); q8_sv += 16;
q3h_sv = svlsl_n_u8_x(svptrue_b8(), svbic_u8_x(svptrue_b8(), m1_sv, qhbits_sv_1), 1);
q3bytes_sv = svsub_s8_x(svptrue_b8(), svreinterpret_s8_u8(svand_u8_m(svptrue_b8(), svlsr_n_u8_x(svptrue_b8(), q3bits_sv, 2), m3b_sv)), svreinterpret_s8_u8(q3h_sv));
sumi1_1 = svmla_s32_m(svptrue_b32(), sumi1_1, svdot_s32(vzero_sv, q3bytes_sv, q8bytes_1_sv_1), svdup_n_s32((int32_t)scale[2]));
q3h_sv = svlsl_n_u8_x(svptrue_b8(), svbic_u8_x(svptrue_b8(), m1_sv, qhbits_sv_2), 1);
q3bytes_sv = svsub_s8_x(svptrue_b8(), svreinterpret_s8_u8(svand_u8_m(svptrue_b8(), svlsr_n_u8_x(svptrue_b8(), q3bits_sv_1, 2), m3b_sv)), svreinterpret_s8_u8(q3h_sv));
sumi1_1 = svmla_s32_m(svptrue_b32(), sumi1_1, svdot_s32(vzero_sv, q3bytes_sv, q8bytes_1_sv_2), svdup_n_s32((int32_t)scale[3]));
scale += 4;
q8bytes_1_sv_1 = svld1_s8(svptrue_b8(), q8_sv); q8_sv += 16;
q8bytes_1_sv_2 = svld1_s8(svptrue_b8(), q8_sv); q8_sv += 16;
q3h_sv = svbic_u8_x(svptrue_b8(), m2_sv, qhbits_sv_1);
q3bytes_sv = svsub_s8_x(svptrue_b8(), svreinterpret_s8_u8(svand_u8_m(svptrue_b8(), svlsr_n_u8_x(svptrue_b8(), q3bits_sv, 4), m3b_sv)), svreinterpret_s8_u8(q3h_sv));
sumi1_1 = svmla_s32_m(svptrue_b32(), sumi1_1, svdot_s32(vzero_sv, q3bytes_sv, q8bytes_1_sv_1), svdup_n_s32((int32_t)scale[0]));
q3h_sv = svbic_u8_x(svptrue_b8(), m2_sv, qhbits_sv_2);
q3bytes_sv = svsub_s8_x(svptrue_b8(), svreinterpret_s8_u8(svand_u8_m(svptrue_b8(), svlsr_n_u8_x(svptrue_b8(), q3bits_sv_1, 4), m3b_sv)), svreinterpret_s8_u8(q3h_sv));
sumi1_1 = svmla_s32_m(svptrue_b32(), sumi1_1, svdot_s32(vzero_sv, q3bytes_sv, q8bytes_1_sv_2), svdup_n_s32((int32_t)scale[1]));
q8bytes_1_sv_1 = svld1_s8(svptrue_b8(), q8_sv); q8_sv += 16;
q8bytes_1_sv_2 = svld1_s8(svptrue_b8(), q8_sv); q8_sv += 16;
q3h_sv = svlsr_n_u8_x(svptrue_b8(), svbic_u8_x(svptrue_b8(), m3_sv, qhbits_sv_1), 1);
q3bytes_sv = svsub_s8_x(svptrue_b8(), svreinterpret_s8_u8(svand_u8_m(svptrue_b8(), svlsr_n_u8_x(svptrue_b8(), q3bits_sv, 6), m3b_sv)), svreinterpret_s8_u8(q3h_sv));
sumi1_1 = svmla_s32_m(svptrue_b32(), sumi1_1, svdot_s32(vzero_sv, q3bytes_sv, q8bytes_1_sv_1), svdup_n_s32((int32_t)scale[2]));
q3h_sv = svlsr_n_u8_x(svptrue_b8(), svbic_u8_x(svptrue_b8(), m3_sv, qhbits_sv_2), 1);
q3bytes_sv = svsub_s8_x(svptrue_b8(), svreinterpret_s8_u8(svand_u8_m(svptrue_b8(), svlsr_n_u8_x(svptrue_b8(), q3bits_sv_1, 6), m3b_sv)), svreinterpret_s8_u8(q3h_sv));
sumi1_1 = svmla_s32_m(svptrue_b32(), sumi1_1, svdot_s32(vzero_sv, q3bytes_sv, q8bytes_1_sv_2), svdup_n_s32((int32_t)scale[3]));
if (j == 0) {
qhbits_sv_1 = svlsr_n_u8_x(svptrue_b8(), qhbits_sv_1, 4);
qhbits_sv_2 = svlsr_n_u8_x(svptrue_b8(), qhbits_sv_2, 4);
}
scale += 4;
}
sum += d * (svaddv_s32(svptrue_b32(), sumi1_1));
} break;
case 256:
case 512:
{
svuint8_t qhbits_sv = svld1_u8(svptrue_pat_b8(SV_VL32), qh_sv);
svuint8_t q3h_sv;
svint32_t sumi1_1 = svdup_n_s32(0);
svint8_t q3bytes_sv;
for (int j = 0; j < QK_K/128; ++j) {
const svuint8_t q3bits_sv = svld1_u8(svptrue_pat_b8(SV_VL32), q3_sv); q3_sv += 32;
svint8_t q8bytes_1_sv_1 = svld1_s8(svptrue_pat_b8(SV_VL32), q8_sv); q8_sv += 32;
svint8_t q8bytes_1_sv_2 = svld1_s8(svptrue_pat_b8(SV_VL32), q8_sv); q8_sv += 32;
q3h_sv = svlsl_n_u8_x(svptrue_pat_b8(SV_VL32), svbic_u8_x(svptrue_pat_b8(SV_VL32), m0_sv, qhbits_sv), 2);
q3bytes_sv = svsub_s8_x(svptrue_pat_b8(SV_VL32), svreinterpret_s8_u8(svand_u8_m(svptrue_pat_b8(SV_VL32), q3bits_sv, m3b_sv)), svreinterpret_s8_u8(q3h_sv));
svint32_t scale_1 = svsel_s32(svptrue_pat_b32(SV_VL4), svdup_n_s32((int32_t)scale[0]), svdup_n_s32((int32_t)scale[1]));
sumi1_1 = svmla_s32_m(svptrue_pat_b32(SV_VL8), sumi1_1, svdot_s32(vzero_sv, q3bytes_sv, q8bytes_1_sv_1), scale_1);
q3h_sv = svlsl_n_u8_x(svptrue_pat_b8(SV_VL32), svbic_u8_x(svptrue_pat_b8(SV_VL32), m1_sv, qhbits_sv), 1);
q3bytes_sv = svsub_s8_x(svptrue_pat_b8(SV_VL32), svreinterpret_s8_u8(svand_u8_m(svptrue_pat_b8(SV_VL32), svlsr_n_u8_x(svptrue_pat_b8(SV_VL32), q3bits_sv, 2), m3b_sv)), svreinterpret_s8_u8(q3h_sv));
scale_1 = svsel_s32(svptrue_pat_b32(SV_VL4), svdup_n_s32((int32_t)scale[2]), svdup_n_s32((int32_t)scale[3]));
sumi1_1 = svmla_s32_m(svptrue_pat_b32(SV_VL8), sumi1_1, svdot_s32(vzero_sv, q3bytes_sv, q8bytes_1_sv_2), scale_1);
scale += 4;
q8bytes_1_sv_1 = svld1_s8(svptrue_pat_b8(SV_VL32), q8_sv); q8_sv += 32;
q8bytes_1_sv_2 = svld1_s8(svptrue_pat_b8(SV_VL32), q8_sv); q8_sv += 32;
q3h_sv = svbic_u8_x(svptrue_pat_b8(SV_VL32), m2_sv, qhbits_sv);
q3bytes_sv = svsub_s8_x(svptrue_pat_b8(SV_VL32), svreinterpret_s8_u8(svand_u8_m(svptrue_pat_b8(SV_VL32), svlsr_n_u8_x(svptrue_pat_b8(SV_VL32), q3bits_sv, 4), m3b_sv)), svreinterpret_s8_u8(q3h_sv));
scale_1 = svsel_s32(svptrue_pat_b32(SV_VL4), svdup_n_s32((int32_t)scale[0]), svdup_n_s32((int32_t)scale[1]));
sumi1_1 = svmla_s32_m(svptrue_pat_b32(SV_VL8), sumi1_1, svdot_s32(vzero_sv, q3bytes_sv, q8bytes_1_sv_1), scale_1);
q3h_sv = svlsr_n_u8_x(svptrue_pat_b8(SV_VL32), svbic_u8_x(svptrue_pat_b8(SV_VL32), m3_sv, qhbits_sv), 1);
q3bytes_sv = svsub_s8_x(svptrue_pat_b8(SV_VL32), svreinterpret_s8_u8(svand_u8_m(svptrue_pat_b8(SV_VL32), svlsr_n_u8_x(svptrue_pat_b8(SV_VL32), q3bits_sv, 6), m3b_sv)), svreinterpret_s8_u8(q3h_sv));
scale_1 = svsel_s32(svptrue_pat_b32(SV_VL4), svdup_n_s32((int32_t)scale[2]), svdup_n_s32((int32_t)scale[3]));
sumi1_1 = svmla_s32_m(svptrue_pat_b32(SV_VL8), sumi1_1, svdot_s32(vzero_sv, q3bytes_sv, q8bytes_1_sv_2), scale_1);
if (j == 0) {
qhbits_sv = svlsr_n_u8_x(svptrue_pat_b8(SV_VL32), qhbits_sv, 4);
}
scale += 4;
}
sum += d * (svaddv_s32(svptrue_pat_b32(SV_VL8), sumi1_1));
} break;
default:
assert(false && "Unsupported vector length");
break;
}
}
*s = sum;
#elif __ARM_NEON
uint32_t aux[3];
uint32_t utmp[4];
const uint8x16_t m3b = vdupq_n_u8(0x3);
const int32x4_t vzero = vdupq_n_s32(0);
const uint8x16_t m0 = vdupq_n_u8(1);
const uint8x16_t m1 = vshlq_n_u8(m0, 1);
const uint8x16_t m2 = vshlq_n_u8(m0, 2);
const uint8x16_t m3 = vshlq_n_u8(m0, 3);
const int8_t m32 = 32;
ggml_int8x16x4_t q3bytes;
float sum = 0;
for (int i = 0; i < nb; ++i) {
const float d = y[i].d * GGML_FP16_TO_FP32(x[i].d);
const uint8_t * GGML_RESTRICT q3 = x[i].qs;
const uint8_t * GGML_RESTRICT qh = x[i].hmask;
const int8_t * GGML_RESTRICT q8 = y[i].qs;
ggml_uint8x16x2_t qhbits = ggml_vld1q_u8_x2(qh);
ggml_uint8x16x4_t q3h;
int32_t isum = 0;
// Set up scales
memcpy(aux, x[i].scales, 12);
utmp[3] = ((aux[1] >> 4) & kmask2) | (((aux[2] >> 6) & kmask1) << 4);
utmp[2] = ((aux[0] >> 4) & kmask2) | (((aux[2] >> 4) & kmask1) << 4);
utmp[1] = (aux[1] & kmask2) | (((aux[2] >> 2) & kmask1) << 4);
utmp[0] = (aux[0] & kmask2) | (((aux[2] >> 0) & kmask1) << 4);
int8_t * scale = (int8_t *)utmp;
for (int j = 0; j < 16; ++j) scale[j] -= m32;
for (int j = 0; j < QK_K/128; ++j) {
const ggml_uint8x16x2_t q3bits = ggml_vld1q_u8_x2(q3); q3 += 32;
const ggml_int8x16x4_t q8bytes_1 = ggml_vld1q_s8_x4(q8); q8 += 64;
const ggml_int8x16x4_t q8bytes_2 = ggml_vld1q_s8_x4(q8); q8 += 64;
q3h.val[0] = vshlq_n_u8(vbicq_u8(m0, qhbits.val[0]), 2);
q3h.val[1] = vshlq_n_u8(vbicq_u8(m0, qhbits.val[1]), 2);
q3h.val[2] = vshlq_n_u8(vbicq_u8(m1, qhbits.val[0]), 1);
q3h.val[3] = vshlq_n_u8(vbicq_u8(m1, qhbits.val[1]), 1);
q3bytes.val[0] = vsubq_s8(vreinterpretq_s8_u8(vandq_u8(q3bits.val[0], m3b)), vreinterpretq_s8_u8(q3h.val[0]));
q3bytes.val[1] = vsubq_s8(vreinterpretq_s8_u8(vandq_u8(q3bits.val[1], m3b)), vreinterpretq_s8_u8(q3h.val[1]));
q3bytes.val[2] = vsubq_s8(vreinterpretq_s8_u8(vandq_u8(vshrq_n_u8(q3bits.val[0], 2), m3b)), vreinterpretq_s8_u8(q3h.val[2]));
q3bytes.val[3] = vsubq_s8(vreinterpretq_s8_u8(vandq_u8(vshrq_n_u8(q3bits.val[1], 2), m3b)), vreinterpretq_s8_u8(q3h.val[3]));
isum += vaddvq_s32(ggml_vdotq_s32(vzero, q3bytes.val[0], q8bytes_1.val[0])) * scale[0];
isum += vaddvq_s32(ggml_vdotq_s32(vzero, q3bytes.val[1], q8bytes_1.val[1])) * scale[1];
isum += vaddvq_s32(ggml_vdotq_s32(vzero, q3bytes.val[2], q8bytes_1.val[2])) * scale[2];
isum += vaddvq_s32(ggml_vdotq_s32(vzero, q3bytes.val[3], q8bytes_1.val[3])) * scale[3];
scale += 4;
q3h.val[0] = vbicq_u8(m2, qhbits.val[0]);
q3h.val[1] = vbicq_u8(m2, qhbits.val[1]);
q3h.val[2] = vshrq_n_u8(vbicq_u8(m3, qhbits.val[0]), 1);
q3h.val[3] = vshrq_n_u8(vbicq_u8(m3, qhbits.val[1]), 1);
q3bytes.val[0] = vsubq_s8(vreinterpretq_s8_u8(vandq_u8(vshrq_n_u8(q3bits.val[0], 4), m3b)), vreinterpretq_s8_u8(q3h.val[0]));
q3bytes.val[1] = vsubq_s8(vreinterpretq_s8_u8(vandq_u8(vshrq_n_u8(q3bits.val[1], 4), m3b)), vreinterpretq_s8_u8(q3h.val[1]));
q3bytes.val[2] = vsubq_s8(vreinterpretq_s8_u8(vandq_u8(vshrq_n_u8(q3bits.val[0], 6), m3b)), vreinterpretq_s8_u8(q3h.val[2]));
q3bytes.val[3] = vsubq_s8(vreinterpretq_s8_u8(vandq_u8(vshrq_n_u8(q3bits.val[1], 6), m3b)), vreinterpretq_s8_u8(q3h.val[3]));
isum += vaddvq_s32(ggml_vdotq_s32(vzero, q3bytes.val[0], q8bytes_2.val[0])) * scale[0];
isum += vaddvq_s32(ggml_vdotq_s32(vzero, q3bytes.val[1], q8bytes_2.val[1])) * scale[1];
isum += vaddvq_s32(ggml_vdotq_s32(vzero, q3bytes.val[2], q8bytes_2.val[2])) * scale[2];
isum += vaddvq_s32(ggml_vdotq_s32(vzero, q3bytes.val[3], q8bytes_2.val[3])) * scale[3];
scale += 4;
if (j == 0) {
qhbits.val[0] = vshrq_n_u8(qhbits.val[0], 4);
qhbits.val[1] = vshrq_n_u8(qhbits.val[1], 4);
}
}
sum += d * isum;
}
*s = sum;
#elif defined __AVX2__
const __m256i m3 = _mm256_set1_epi8(3);
const __m256i mone = _mm256_set1_epi8(1);
const __m128i m32 = _mm_set1_epi8(32);
__m256 acc = _mm256_setzero_ps();
uint32_t aux[3];
for (int i = 0; i < nb; ++i) {
const float d = y[i].d * GGML_FP16_TO_FP32(x[i].d);
const uint8_t * GGML_RESTRICT q3 = x[i].qs;
const int8_t * GGML_RESTRICT q8 = y[i].qs;
// Set up scales
memcpy(aux, x[i].scales, 12);
__m128i scales128 = _mm_set_epi32(
((aux[1] >> 4) & kmask2) | (((aux[2] >> 6) & kmask1) << 4),
((aux[0] >> 4) & kmask2) | (((aux[2] >> 4) & kmask1) << 4),
(aux[1] & kmask2) | (((aux[2] >> 2) & kmask1) << 4),
(aux[0] & kmask2) | (((aux[2] >> 0) & kmask1) << 4));
scales128 = _mm_sub_epi8(scales128, m32);
const __m256i all_scales = _mm256_cvtepi8_epi16(scales128);
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)};
// high bit
const __m256i hbits = _mm256_loadu_si256((const __m256i*)x[i].hmask);
// integer accumulator
__m256i sumi = _mm256_setzero_si256();
int bit = 0;
int is = 0;
for (int j = 0; j < QK_K/128; ++j) {
// load low 2 bits
const __m256i q3bits = _mm256_loadu_si256((const __m256i*)q3); q3 += 32;
// prepare low and high bits
const __m256i q3l_0 = _mm256_and_si256(q3bits, m3);
const __m256i q3h_0 = _mm256_slli_epi16(_mm256_srli_epi16(_mm256_andnot_si256(hbits, _mm256_slli_epi16(mone, bit)), bit), 2);
++bit;
const __m256i q3l_1 = _mm256_and_si256(_mm256_srli_epi16(q3bits, 2), m3);
const __m256i q3h_1 = _mm256_slli_epi16(_mm256_srli_epi16(_mm256_andnot_si256(hbits, _mm256_slli_epi16(mone, bit)), bit), 2);
++bit;
const __m256i q3l_2 = _mm256_and_si256(_mm256_srli_epi16(q3bits, 4), m3);
const __m256i q3h_2 = _mm256_slli_epi16(_mm256_srli_epi16(_mm256_andnot_si256(hbits, _mm256_slli_epi16(mone, bit)), bit), 2);
++bit;
const __m256i q3l_3 = _mm256_and_si256(_mm256_srli_epi16(q3bits, 6), m3);
const __m256i q3h_3 = _mm256_slli_epi16(_mm256_srli_epi16(_mm256_andnot_si256(hbits, _mm256_slli_epi16(mone, bit)), bit), 2);
++bit;
// load Q8 quants
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;
// Dot product: we multiply the 2 low bits and 1 high bit part separately, so we can use _mm256_maddubs_epi16,
// and then subtract. The high bit part has the 2 already subtracted (and so, it is zero if the high bit was not set,
// and 2 if the high bit was set)
__m256i q8s_0 = _mm256_maddubs_epi16(q3h_0, q8_0);
__m256i q8s_1 = _mm256_maddubs_epi16(q3h_1, q8_1);
__m256i q8s_2 = _mm256_maddubs_epi16(q3h_2, q8_2);
__m256i q8s_3 = _mm256_maddubs_epi16(q3h_3, q8_3);
__m256i p16_0 = _mm256_maddubs_epi16(q3l_0, q8_0);
__m256i p16_1 = _mm256_maddubs_epi16(q3l_1, q8_1);
__m256i p16_2 = _mm256_maddubs_epi16(q3l_2, q8_2);
__m256i p16_3 = _mm256_maddubs_epi16(q3l_3, q8_3);
p16_0 = _mm256_sub_epi16(p16_0, q8s_0);
p16_1 = _mm256_sub_epi16(p16_1, q8s_1);
p16_2 = _mm256_sub_epi16(p16_2, q8s_2);
p16_3 = _mm256_sub_epi16(p16_3, q8s_3);
// multiply with scales
p16_0 = _mm256_madd_epi16(_mm256_shuffle_epi8(scales[j], get_scale_shuffle_q3k(is + 0)), p16_0);
p16_1 = _mm256_madd_epi16(_mm256_shuffle_epi8(scales[j], get_scale_shuffle_q3k(is + 1)), p16_1);
p16_2 = _mm256_madd_epi16(_mm256_shuffle_epi8(scales[j], get_scale_shuffle_q3k(is + 2)), p16_2);
p16_3 = _mm256_madd_epi16(_mm256_shuffle_epi8(scales[j], get_scale_shuffle_q3k(is + 3)), p16_3);
// accumulate
p16_0 = _mm256_add_epi32(p16_0, p16_1);
p16_2 = _mm256_add_epi32(p16_2, p16_3);
sumi = _mm256_add_epi32(sumi, _mm256_add_epi32(p16_0, p16_2));
}
// multiply with block scale and accumulate
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(3);
const __m128i mone = _mm_set1_epi8(1);
const __m128i m32 = _mm_set1_epi8(32);
const __m128i m2 = _mm_set1_epi8(2);
__m256 acc = _mm256_setzero_ps();
const uint32_t *aux;
for (int i = 0; i < nb; ++i) {
const float d = y[i].d * GGML_FP16_TO_FP32(x[i].d);
const uint8_t * GGML_RESTRICT q3 = x[i].qs;
const int8_t * GGML_RESTRICT q8 = y[i].qs;
// Set up scales
aux = (const uint32_t *)x[i].scales;
__m128i scales128 = _mm_set_epi32(
((aux[1] >> 4) & kmask2) | (((aux[2] >> 6) & kmask1) << 4),
((aux[0] >> 4) & kmask2) | (((aux[2] >> 4) & kmask1) << 4),
(aux[1] & kmask2) | (((aux[2] >> 2) & kmask1) << 4),
(aux[0] & kmask2) | (((aux[2] >> 0) & kmask1) << 4));
scales128 = _mm_sub_epi8(scales128, m32);
const __m128i scales_0 = _mm_cvtepi8_epi16(scales128);
const __m128i scales_1 = _mm_cvtepi8_epi16(_mm_unpackhi_epi64(scales128, scales128));
const __m128i scales[2] = { scales_0, scales_1 };
// high bit *128*2 from block_q3_K.hmask[QK_K/8]
const __m128i hbits_0 = _mm_loadu_si128((const __m128i*)&x[i].hmask[0]);
const __m128i hbits_1 = _mm_loadu_si128((const __m128i*)&x[i].hmask[16]);
// integer accumulator
__m128i sumi_0 = _mm_setzero_si128();
__m128i sumi_1 = _mm_setzero_si128();
for (int j = 0; j < QK_K/128; ++j) {
// load low 2 bits *64*2 from block_q3_K.qs[QK_K/4]
const __m128i q3bits_0 = _mm_loadu_si128((const __m128i*)q3); q3 += 16;
const __m128i q3bits_1 = _mm_loadu_si128((const __m128i*)q3); q3 += 16;
// prepare low and high bits
const int bit = j << 2;
const __m128i q3l_0 = _mm_and_si128(q3bits_0, m3);
const __m128i q3l_1 = _mm_and_si128(q3bits_1, m3);
const __m128i q3h_0 = _mm_slli_epi16(_mm_srli_epi16(_mm_andnot_si128(hbits_0, _mm_slli_epi16(mone, bit)), bit), 2);
const __m128i q3h_1 = _mm_slli_epi16(_mm_srli_epi16(_mm_andnot_si128(hbits_1, _mm_slli_epi16(mone, bit)), bit), 2);
const __m128i q3l_2 = _mm_and_si128(_mm_srli_epi16(q3bits_0, 2), m3);
const __m128i q3l_3 = _mm_and_si128(_mm_srli_epi16(q3bits_1, 2), m3);
const __m128i q3h_2 = _mm_slli_epi16(_mm_srli_epi16(_mm_andnot_si128(hbits_0, _mm_slli_epi16(mone, bit+1)), bit+1), 2);
const __m128i q3h_3 = _mm_slli_epi16(_mm_srli_epi16(_mm_andnot_si128(hbits_1, _mm_slli_epi16(mone, bit+1)), bit+1), 2);
const __m128i q3l_4 = _mm_and_si128(_mm_srli_epi16(q3bits_0, 4), m3);
const __m128i q3l_5 = _mm_and_si128(_mm_srli_epi16(q3bits_1, 4), m3);
const __m128i q3h_4 = _mm_slli_epi16(_mm_srli_epi16(_mm_andnot_si128(hbits_0, _mm_slli_epi16(mone, bit+2)), bit+2), 2);
const __m128i q3h_5 = _mm_slli_epi16(_mm_srli_epi16(_mm_andnot_si128(hbits_1, _mm_slli_epi16(mone, bit+2)), bit+2), 2);
const __m128i q3l_6 = _mm_and_si128(_mm_srli_epi16(q3bits_0, 6), m3);
const __m128i q3l_7 = _mm_and_si128(_mm_srli_epi16(q3bits_1, 6), m3);
const __m128i q3h_6 = _mm_slli_epi16(_mm_srli_epi16(_mm_andnot_si128(hbits_0, _mm_slli_epi16(mone, bit+3)), bit+3), 2);
const __m128i q3h_7 = _mm_slli_epi16(_mm_srli_epi16(_mm_andnot_si128(hbits_1, _mm_slli_epi16(mone, bit+3)), bit+3), 2);
// load Q8 quants 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;
// Dot product: we multiply the 2 low bits and 1 high bit part separately, so we can use _mm256_maddubs_epi16,
// and then subtract. The high bit part has the 2 already subtracted (and so, it is zero if the high bit was not set,
// and 2 if the high bit was set)
__m128i q8s_0 = _mm_maddubs_epi16(q3h_0, q8_0);
__m128i q8s_1 = _mm_maddubs_epi16(q3h_1, q8_1);
__m128i q8s_2 = _mm_maddubs_epi16(q3h_2, q8_2);
__m128i q8s_3 = _mm_maddubs_epi16(q3h_3, q8_3);
__m128i q8s_4 = _mm_maddubs_epi16(q3h_4, q8_4);
__m128i q8s_5 = _mm_maddubs_epi16(q3h_5, q8_5);
__m128i q8s_6 = _mm_maddubs_epi16(q3h_6, q8_6);
__m128i q8s_7 = _mm_maddubs_epi16(q3h_7, q8_7);
__m128i p16_0 = _mm_maddubs_epi16(q3l_0, q8_0);
__m128i p16_1 = _mm_maddubs_epi16(q3l_1, q8_1);
__m128i p16_2 = _mm_maddubs_epi16(q3l_2, q8_2);
__m128i p16_3 = _mm_maddubs_epi16(q3l_3, q8_3);
__m128i p16_4 = _mm_maddubs_epi16(q3l_4, q8_4);
__m128i p16_5 = _mm_maddubs_epi16(q3l_5, q8_5);
__m128i p16_6 = _mm_maddubs_epi16(q3l_6, q8_6);
__m128i p16_7 = _mm_maddubs_epi16(q3l_7, q8_7);
p16_0 = _mm_sub_epi16(p16_0, q8s_0);
p16_1 = _mm_sub_epi16(p16_1, q8s_1);
p16_2 = _mm_sub_epi16(p16_2, q8s_2);
p16_3 = _mm_sub_epi16(p16_3, q8s_3);
p16_4 = _mm_sub_epi16(p16_4, q8s_4);
p16_5 = _mm_sub_epi16(p16_5, q8s_5);
p16_6 = _mm_sub_epi16(p16_6, q8s_6);
p16_7 = _mm_sub_epi16(p16_7, q8s_7);
// multiply with scales
__m128i shuffle = _mm_set1_epi16(0x0100);
p16_0 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p16_0);
shuffle = _mm_add_epi16(shuffle, m2);
p16_1 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p16_1);
shuffle = _mm_add_epi16(shuffle, m2);
p16_2 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p16_2);
shuffle = _mm_add_epi16(shuffle, m2);
p16_3 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p16_3);
shuffle = _mm_add_epi16(shuffle, m2);
p16_4 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p16_4);
shuffle = _mm_add_epi16(shuffle, m2);
p16_5 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p16_5);
shuffle = _mm_add_epi16(shuffle, m2);
p16_6 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p16_6);
shuffle = _mm_add_epi16(shuffle, m2);
p16_7 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p16_7);
// accumulate
p16_0 = _mm_add_epi32(p16_0, p16_1);
p16_2 = _mm_add_epi32(p16_2, p16_3);
p16_4 = _mm_add_epi32(p16_4, p16_5);
p16_6 = _mm_add_epi32(p16_6, p16_7);
sumi_0 = _mm_add_epi32(sumi_0, _mm_add_epi32(p16_0, p16_2));
sumi_1 = _mm_add_epi32(sumi_1, _mm_add_epi32(p16_4, p16_6));
}
// multiply with block scale and accumulate
__m256i sumi = MM256_SET_M128I(sumi_1, sumi_0);
acc = _mm256_add_ps(_mm256_mul_ps(_mm256_broadcast_ss(&d), _mm256_cvtepi32_ps(sumi)), acc);
}
*s = hsum_float_8(acc);
#elif defined __wasm_simd128__
int8_t aux8[QK_K];
float sums[8] = {0};
uint32_t auxs[4];
float sumf = 0;
for (int i = 0; i < nb; ++i) {
const uint8_t * GGML_RESTRICT q3 = x[i].qs;
const uint8_t * GGML_RESTRICT hm = x[i].hmask;
const int8_t * GGML_RESTRICT q8 = y[i].qs;
// Process blocks with SIMD
int8_t * a = aux8;
uint8_t m = 1;
for (int j = 0; j < QK_K; j += 128) {
for (int shift = 0; shift <= 6; shift += 2) {
v128_t v_m = wasm_i8x16_splat(m);
for (int l = 0; l < 32; l += 16) {
v128_t v_q3 = wasm_v128_load(q3 + l);
v128_t v_shift = wasm_i8x16_shr(v_q3, shift);
v128_t v_low2 = wasm_v128_and(v_shift, wasm_i8x16_splat(0x03));
v128_t v_hm = wasm_v128_load(hm + l);
v128_t v_mask = wasm_v128_and(v_hm, v_m);
v_mask = wasm_i8x16_ne(v_mask, wasm_i8x16_splat(0));
v_low2 = wasm_i8x16_sub(v_low2, wasm_v128_and(wasm_i8x16_splat(4), wasm_v128_not(v_mask)));
wasm_v128_store(a + l, v_low2);
}
a += 32;
m <<= 1;
}
q3 += 32;
}
// Extract scales
memcpy(auxs, x[i].scales, 12);
uint32_t tmp = auxs[2];
auxs[2] = ((auxs[0] >> 4) & kmask2) | (((tmp >> 4) & kmask1) << 4);
auxs[3] = ((auxs[1] >> 4) & kmask2) | (((tmp >> 6) & kmask1) << 4);
auxs[0] = (auxs[0] & kmask2) | (((tmp >> 0) & kmask1) << 4);
auxs[1] = (auxs[1] & kmask2) | (((tmp >> 2) & kmask1) << 4);
const int8_t * scales = (const int8_t *)auxs;
// SIMD dot product with register accumulators
v128_t v_acc0 = wasm_i32x4_splat(0);
v128_t v_acc1 = wasm_i32x4_splat(0);
a = aux8;
for (int j = 0; j < QK_K/16; ++j) {
const v128_t v_scale = wasm_i16x8_splat(scales[j] - 32);
// Process 16 elements per iteration
for (int k = 0; k < 2; ++k) {
const v128_t v_q8 = wasm_i16x8_load8x8(q8);
const v128_t v_a = wasm_i16x8_load8x8(a);
v128_t v_prod = wasm_i16x8_mul(v_q8, v_a);
v_prod = wasm_i16x8_mul(v_prod, v_scale);
v_acc0 = wasm_i32x4_add(v_acc0, wasm_i32x4_extend_low_i16x8(v_prod));
v_acc1 = wasm_i32x4_add(v_acc1, wasm_i32x4_extend_high_i16x8(v_prod));
q8 += 8;
a += 8;
}
}
// Accumulate results
const float d = GGML_FP16_TO_FP32(x[i].d) * y[i].d;
const v128_t v_d = wasm_f32x4_splat(d);
v128_t v_sum = wasm_f32x4_add(
wasm_f32x4_mul(wasm_f32x4_convert_i32x4(v_acc0), v_d),
wasm_f32x4_mul(wasm_f32x4_convert_i32x4(v_acc1), v_d)
);
// Accumulate into sums vector
wasm_v128_store(sums, wasm_f32x4_add(wasm_v128_load(sums), v_sum));
}
// Horizontal sum
v128_t v_sum = wasm_f32x4_add(wasm_v128_load(sums), wasm_v128_load(sums + 4));
sumf = wasm_f32x4_extract_lane(v_sum, 0) +
wasm_f32x4_extract_lane(v_sum, 1) +
wasm_f32x4_extract_lane(v_sum, 2) +
wasm_f32x4_extract_lane(v_sum, 3);
*s = sumf;
#elif defined __riscv_v_intrinsic
uint32_t aux[3];
uint32_t utmp[4];
const int vector_length = __riscv_vlenb() * 8;
float sumf = 0;
switch (vector_length) {
case 256:
for (int i = 0; i < nb; ++i) {
const uint8_t * GGML_RESTRICT q3 = x[i].qs;
const uint8_t * GGML_RESTRICT qh = x[i].hmask;
const int8_t * GGML_RESTRICT q8 = y[i].qs;
memcpy(aux, x[i].scales, 12);
utmp[3] = ((aux[1] >> 4) & kmask2) | (((aux[2] >> 6) & kmask1) << 4);
utmp[2] = ((aux[0] >> 4) & kmask2) | (((aux[2] >> 4) & kmask1) << 4);
utmp[1] = (aux[1] & kmask2) | (((aux[2] >> 2) & kmask1) << 4);
utmp[0] = (aux[0] & kmask2) | (((aux[2] >> 0) & kmask1) << 4);
int8_t * scale = (int8_t *)utmp;
for (int j = 0; j < 16; ++j) scale[j] -= 32;
size_t vl = 32;
uint8_t m = 1;
vint32m1_t vzero = __riscv_vmv_v_x_i32m1(0, 1);
vuint8m1_t vqh = __riscv_vle8_v_u8m1(qh, vl);
int sum_t = 0;
for (int j = 0; j < QK_K; j += 128) {
vl = 32;
// load Q3
vuint8m1_t q3_x = __riscv_vle8_v_u8m1(q3, vl);
vint8m1_t q3_0 = __riscv_vreinterpret_v_u8m1_i8m1(__riscv_vand_vx_u8m1(q3_x, 0x03, vl));
vint8m1_t q3_1 = __riscv_vreinterpret_v_u8m1_i8m1(__riscv_vand_vx_u8m1(__riscv_vsrl_vx_u8m1(q3_x, 0x2, vl), 0x03 , vl));
vint8m1_t q3_2 = __riscv_vreinterpret_v_u8m1_i8m1(__riscv_vand_vx_u8m1(__riscv_vsrl_vx_u8m1(q3_x, 0x4, vl), 0x03 , vl));
vint8m1_t q3_3 = __riscv_vreinterpret_v_u8m1_i8m1(__riscv_vand_vx_u8m1(__riscv_vsrl_vx_u8m1(q3_x, 0x6, vl), 0x03 , vl));
// compute mask for subtraction
vuint8m1_t qh_m0 = __riscv_vand_vx_u8m1(vqh, m, vl);
vbool8_t vmask_0 = __riscv_vmseq_vx_u8m1_b8(qh_m0, 0, vl);
vint8m1_t q3_m0 = __riscv_vsub_vx_i8m1_mu(vmask_0, q3_0, q3_0, 0x4, vl);
m <<= 1;
vuint8m1_t qh_m1 = __riscv_vand_vx_u8m1(vqh, m, vl);
vbool8_t vmask_1 = __riscv_vmseq_vx_u8m1_b8(qh_m1, 0, vl);
vint8m1_t q3_m1 = __riscv_vsub_vx_i8m1_mu(vmask_1, q3_1, q3_1, 0x4, vl);
m <<= 1;
vuint8m1_t qh_m2 = __riscv_vand_vx_u8m1(vqh, m, vl);
vbool8_t vmask_2 = __riscv_vmseq_vx_u8m1_b8(qh_m2, 0, vl);
vint8m1_t q3_m2 = __riscv_vsub_vx_i8m1_mu(vmask_2, q3_2, q3_2, 0x4, vl);
m <<= 1;
vuint8m1_t qh_m3 = __riscv_vand_vx_u8m1(vqh, m, vl);
vbool8_t vmask_3 = __riscv_vmseq_vx_u8m1_b8(qh_m3, 0, vl);
vint8m1_t q3_m3 = __riscv_vsub_vx_i8m1_mu(vmask_3, q3_3, q3_3, 0x4, vl);
m <<= 1;
// load Q8 and take product with Q3
vint16m2_t a0 = __riscv_vwmul_vv_i16m2(q3_m0, __riscv_vle8_v_i8m1(q8, vl), vl);
vint16m2_t a1 = __riscv_vwmul_vv_i16m2(q3_m1, __riscv_vle8_v_i8m1(q8+32, vl), vl);
vint16m2_t a2 = __riscv_vwmul_vv_i16m2(q3_m2, __riscv_vle8_v_i8m1(q8+64, vl), vl);
vint16m2_t a3 = __riscv_vwmul_vv_i16m2(q3_m3, __riscv_vle8_v_i8m1(q8+96, vl), vl);
vl = 16;
// retrieve lane to multiply with scale
vint32m2_t aux0_0 = __riscv_vwmul_vx_i32m2(__riscv_vget_v_i16m2_i16m1(a0, 0), (scale[0]), vl);
vint32m2_t aux0_1 = __riscv_vwmul_vx_i32m2(__riscv_vget_v_i16m2_i16m1(a0, 1), (scale[1]), vl);
vint32m2_t aux1_0 = __riscv_vwmul_vx_i32m2(__riscv_vget_v_i16m2_i16m1(a1, 0), (scale[2]), vl);
vint32m2_t aux1_1 = __riscv_vwmul_vx_i32m2(__riscv_vget_v_i16m2_i16m1(a1, 1), (scale[3]), vl);
vint32m2_t aux2_0 = __riscv_vwmul_vx_i32m2(__riscv_vget_v_i16m2_i16m1(a2, 0), (scale[4]), vl);
vint32m2_t aux2_1 = __riscv_vwmul_vx_i32m2(__riscv_vget_v_i16m2_i16m1(a2, 1), (scale[5]), vl);
vint32m2_t aux3_0 = __riscv_vwmul_vx_i32m2(__riscv_vget_v_i16m2_i16m1(a3, 0), (scale[6]), vl);
vint32m2_t aux3_1 = __riscv_vwmul_vx_i32m2(__riscv_vget_v_i16m2_i16m1(a3, 1), (scale[7]), vl);
vint32m1_t isum0 = __riscv_vredsum_vs_i32m2_i32m1(__riscv_vadd_vv_i32m2(aux0_0, aux0_1, vl), vzero, vl);
vint32m1_t isum1 = __riscv_vredsum_vs_i32m2_i32m1(__riscv_vadd_vv_i32m2(aux1_0, aux1_1, vl), isum0, vl);
vint32m1_t isum2 = __riscv_vredsum_vs_i32m2_i32m1(__riscv_vadd_vv_i32m2(aux2_0, aux2_1, vl), isum1, vl);
vint32m1_t isum3 = __riscv_vredsum_vs_i32m2_i32m1(__riscv_vadd_vv_i32m2(aux3_0, aux3_1, vl), isum2, vl);
sum_t += __riscv_vmv_x_s_i32m1_i32(isum3);
q3 += 32; q8 += 128; scale += 8;
}
const float d = GGML_FP16_TO_FP32(x[i].d) * y[i].d;
sumf += d*sum_t;
}
break;
case 128:
for (int i = 0; i < nb; ++i) {
const uint8_t * restrict q3 = x[i].qs;
const uint8_t * restrict qh = x[i].hmask;
const int8_t * restrict q8 = y[i].qs;
int8_t * scale = (int8_t *)utmp;
int tmp;
__asm__ __volatile__(
"vsetivli zero, 12, e8, m1\n\t"
"vle8.v v0, (%[s6b])\n\t"
"vmv1r.v v2, v0\n\t"
"vsetivli zero, 2, e64, m1\n\t"
"vmv.v.x v9, %[sh]\n\t"\
"vslidedown.vi v1, v0, 1\n\t"
"vslide1up.vx v8, v9, zero\n\t" // {0, 0, 4, 4}
"vslideup.vi v0, v2, 1\n\t" // {aux[0], aux[1], aux[0], aux[1]}
"vsetivli zero, 4, e32, m1\n\t"
"vid.v v9\n\t"
"vmv.x.s %[tmp], v1\n\t"
"vsll.vi v9, v9, 1\n\t" // {0, 2, 4, 6}
"vmv.v.x v1, %[tmp]\n\t" // {aux[2], aux[2], aux[2], aux[2]}
"vsrl.vv v4, v1, v9\n\t"
"vsrl.vv v2, v0, v8\n\t"
"vand.vx v5, v4, %[kmask1]\n\t"
"vand.vx v3, v2, %[kmask2]\n\t"
"vsll.vi v6, v5, 4\n\t"
"vor.vv v7, v6, v3\n\t"
"vsetivli zero, 16, e8, m1\n\t"
"vsub.vx v0, v7, %[c]\n\t"
"vse8.v v0, (%[scale])"
: [tmp] "=&r" (tmp)
: [sh] "r" (0x0000000400000004), [s6b] "r" (x[i].scales), [c] "r" (32)
, [scale] "r" (scale), [kmask1] "r" (kmask1), [kmask2] "r" (kmask2)
: "memory"
, "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7"
, "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15"
, "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23"
, "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31"
);
uint8_t m = 1;
int isum = 0;
for (int j = 0; j < QK_K; j += 128) {
__asm__ __volatile__(
"vsetvli zero, %[vl32], e8, m2, ta, mu\n\t"
"vle8.v v8, (%[q3])\n\t"
"vsrl.vi v10, v8, 2\n\t"
"vsrl.vi v12, v8, 4\n\t"
"vsrl.vi v14, v8, 6\n\t"
"vand.vi v8, v8, 3\n\t"
"vand.vi v10, v10, 3\n\t"
"vand.vi v12, v12, 3\n\t"
"vle8.v v2, (%[qh])\n\t"
"vand.vx v4, v2, %[m]\n\t"
"slli %[m], %[m], 1\n\t"
"vmseq.vx v0, v4, zero\n\t"
"vadd.vi v8, v8, -4, v0.t\n\t"
"vand.vx v4, v2, %[m]\n\t"
"slli %[m], %[m], 1\n\t"
"vmseq.vx v0, v4, zero\n\t"
"vadd.vi v10, v10, -4, v0.t\n\t"
"vand.vx v4, v2, %[m]\n\t"
"slli %[m], %[m], 1\n\t"
"vmseq.vx v0, v4, zero\n\t"
"vadd.vi v12, v12, -4, v0.t\n\t"
"vand.vx v4, v2, %[m]\n\t"
"slli %[m], %[m], 1\n\t"
"vmseq.vx v0, v4, zero\n\t"
"vadd.vi v14, v14, -4, v0.t\n\t"
"vsetvli zero, %[vl128], e8, m8\n\t"
"vle8.v v0, (%[q8])\n\t"
"vsetvli zero, %[vl64], e8, m4\n\t"
"vwmul.vv v16, v0, v8\n\t"
"vwmul.vv v24, v4, v12\n\t"
"vsetivli zero, 16, e16, m2\n\t"
"vmv.v.x v0, zero\n\t"
"vwredsum.vs v10, v16, v0\n\t"
"vwredsum.vs v9, v18, v0\n\t"
"vwredsum.vs v8, v20, v0\n\t"
"vwredsum.vs v7, v22, v0\n\t"
"vwredsum.vs v11, v24, v0\n\t"
"vwredsum.vs v12, v26, v0\n\t"
"vwredsum.vs v13, v28, v0\n\t"
"vwredsum.vs v14, v30, v0\n\t"
"vsetivli zero, 4, e32, m1\n\t"
"vslideup.vi v10, v9, 1\n\t"
"vslideup.vi v8, v7, 1\n\t"
"vslideup.vi v11, v12, 1\n\t"
"vslideup.vi v13, v14, 1\n\t"
"vslideup.vi v10, v8, 2\n\t"
"vslideup.vi v11, v13, 2\n\t"
"vsetivli zero, 8, e32, m2\n\t"\
"vle8.v v15, (%[scale])\n\t"
"vsext.vf4 v12, v15\n\t"
"vmul.vv v10, v10, v12\n\t"
"vredsum.vs v0, v10, v0\n\t"
"vmv.x.s %[tmp], v0\n\t"
"add %[isum], %[isum], %[tmp]"
: [tmp] "=&r" (tmp), [m] "+&r" (m), [isum] "+&r" (isum)
: [vl128] "r" (128), [vl64] "r" (64), [vl32] "r" (32)
, [q3] "r" (q3), [qh] "r" (qh), [scale] "r" (scale), [q8] "r" (q8)
: "memory"
, "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7"
, "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15"
, "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23"
, "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31"
);
q3 += 32; q8 += 128; scale += 8;
}
const float d = GGML_FP16_TO_FP32(x[i].d) * y[i].d;
sumf += d * isum;
}
break;
default:
assert(false && "Unsupported vector length");
break;
}
*s = sumf;
#elif defined(__POWER9_VECTOR__)
const vector signed char lowMask = vec_splats((signed char)0x3);
const vector signed char lowMask1 = vec_splats((int8_t)0xf);
const vector signed char lowMask2 = vec_splats((int8_t)0x30);
const vector int v0 = vec_splats((int32_t)0);
const vector signed char v1 = vec_splats((signed char)0x1);
const vector unsigned char v2 = vec_splats((unsigned char)0x2);
const vector unsigned char v3 = vec_splats((unsigned char)0x3);
const vector unsigned char v4 = vec_splats((unsigned char)0x4);
const vector unsigned char v6 = vec_splats((unsigned char)0x6);
const vector signed char off = vec_splats((signed char)0x20);
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);
UNUSED(kmask1);
UNUSED(kmask2);
vector signed char u0 = (vector signed char)vec_xl_len(x[i].scales, 8);
vector signed char u1 = vec_and(u0, lowMask1);
vector signed char u2 = (vector signed char)vec_xl_len(x[i].scales + 8, 4);
vector signed char u3 = (vector signed char)vec_mergeh((vector signed int)u2, (vector signed int)vec_sr(u2, v2));
vector signed char u30 = vec_sl(vec_and(u3, lowMask), v4);
vector signed char u31 = vec_and(u3, lowMask2);
u1 = vec_or(u1, u30);
u2 = vec_or(vec_sr(u0, v4), u31);
vector signed char vscales = (vector signed char)vec_mergeh((vector signed long long)u1, (vector signed long long)u2);
vector signed char qxhs0 = (vector signed char)vec_xl( 0, x[i].hmask);
vector signed char qxhs1 = (vector signed char)vec_xl(16, x[i].hmask);
vscales = vec_sub(vscales, off);
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 * GGML_RESTRICT q3 = x[i].qs;
const int8_t * GGML_RESTRICT q8 = y[i].qs;
for (int j = 0; j < QK_K/128; ++j) {
__builtin_prefetch(q3, 0, 1);
__builtin_prefetch(q8, 0, 1);
vector signed char qxs0 = (vector signed char)vec_xl( 0, q3);
vector signed char qxs1 = (vector signed char)vec_xl(16, q3);
q3 += 32;
//the low 2 bits
vector signed char qxs00 = vec_and(qxs0, lowMask);
vector signed char qxs01 = vec_and(vec_sr(qxs0, v2), lowMask);
vector signed char qxs02 = vec_and(vec_sr(qxs0, v4), lowMask);
vector signed char qxs03 = vec_and(vec_sr(qxs0, v6), lowMask);
vector signed char qxs10 = vec_and(qxs1, lowMask);
vector signed char qxs11 = vec_and(vec_sr(qxs1, v2), lowMask);
vector signed char qxs12 = vec_and(vec_sr(qxs1, v4), lowMask);
vector signed char qxs13 = vec_and(vec_sr(qxs1, v6), lowMask);
//the 3rd bit
vector signed char qxh00 = vec_sl(vec_andc(v1, qxhs0), v2);
vector signed char qxh01 = vec_sl(vec_andc(v1, vec_sr(qxhs0, (vector unsigned char)v1)), v2);
vector signed char qxh02 = vec_sl(vec_andc(v1, vec_sr(qxhs0, v2)), v2);
vector signed char qxh03 = vec_sl(vec_andc(v1, vec_sr(qxhs0, v3)), v2);
vector signed char qxh10 = vec_sl(vec_andc(v1, qxhs1), v2);
vector signed char qxh11 = vec_sl(vec_andc(v1, vec_sr(qxhs1, (vector unsigned char)v1)), v2);
vector signed char qxh12 = vec_sl(vec_andc(v1, vec_sr(qxhs1, v2)), v2);
vector signed char qxh13 = vec_sl(vec_andc(v1, vec_sr(qxhs1, v3)), v2);
qxhs0 = vec_sr(qxhs0, v4);
qxhs1 = vec_sr(qxhs1, v4);
vector signed char q3x00 = vec_sub(qxs00, qxh00);
vector signed char q3x01 = vec_sub(qxs01, qxh01);
vector signed char q3x02 = vec_sub(qxs02, qxh02);
vector signed char q3x03 = vec_sub(qxs03, qxh03);
vector signed char q3x10 = vec_sub(qxs10, qxh10);
vector signed char q3x11 = vec_sub(qxs11, qxh11);
vector signed char q3x12 = vec_sub(qxs12, qxh12);
vector signed char q3x13 = vec_sub(qxs13, qxh13);
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 short vscales_h = vec_unpackh(vscales);
vector signed short vs0 = vec_splat(vscales_h, 0);
vector signed short vs1 = vec_splat(vscales_h, 1);
vector signed short vs2 = vec_splat(vscales_h, 2);
vector signed short vs3 = vec_splat(vscales_h, 3);
vector signed short vs4 = vec_splat(vscales_h, 4);
vector signed short vs5 = vec_splat(vscales_h, 5);
vector signed short vs6 = vec_splat(vscales_h, 6);
vector signed short vs7 = vec_splat(vscales_h, 7);
vscales = vec_sld(vscales, vscales, 8);
vector signed short qv00 = vec_add(vec_mule(q3x00, q8y00), vec_mulo(q3x00, q8y00));
vector signed short qv01 = vec_add(vec_mule(q3x01, q8y01), vec_mulo(q3x01, q8y01));
vector signed short qv02 = vec_add(vec_mule(q3x02, q8y02), vec_mulo(q3x02, q8y02));
vector signed short qv03 = vec_add(vec_mule(q3x03, q8y03), vec_mulo(q3x03, q8y03));
vector signed short qv10 = vec_add(vec_mule(q3x10, q8y10), vec_mulo(q3x10, q8y10));
vector signed short qv11 = vec_add(vec_mule(q3x11, q8y11), vec_mulo(q3x11, q8y11));
vector signed short qv12 = vec_add(vec_mule(q3x12, q8y12), vec_mulo(q3x12, q8y12));
vector signed short qv13 = vec_add(vec_mule(q3x13, q8y13), vec_mulo(q3x13, q8y13));
vsumi0 = vec_msum(qv00, vs0, vsumi0);
vsumi1 = vec_msum(qv01, vs2, vsumi1);
vsumi2 = vec_msum(qv02, vs4, vsumi2);
vsumi3 = vec_msum(qv03, vs6, vsumi3);
vsumi4 = vec_msum(qv10, vs1, vsumi4);
vsumi5 = vec_msum(qv11, vs3, vsumi5);
vsumi6 = vec_msum(qv12, vs5, vsumi6);
vsumi7 = vec_msum(qv13, 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 __m128i m32 = __lsx_vreplgr2vr_b(32);
__m256 acc = (__m256)__lasx_xvldi(0);
uint32_t aux[3];
for (int i = 0; i < nb; ++i) {
const float d = y[i].d * GGML_FP16_TO_FP32(x[i].d);
const uint8_t * GGML_RESTRICT q3 = x[i].qs;
const int8_t * GGML_RESTRICT q8 = y[i].qs;
// Set up scales
memcpy(aux, x[i].scales, 12);
__m128i scales128 = lsx_set_w(
((aux[1] >> 4) & kmask2) | (((aux[2] >> 6) & kmask1) << 4),
((aux[0] >> 4) & kmask2) | (((aux[2] >> 4) & kmask1) << 4),
(aux[1] & kmask2) | (((aux[2] >> 2) & kmask1) << 4),
(aux[0] & kmask2) | (((aux[2] >> 0) & kmask1) << 4));
scales128 = __lsx_vsub_b(scales128, m32);
const v16i8 shuffle_mask = {0, 2, 4, 6, 8, 10, 12, 14, 1, 3, 5, 7, 9, 11, 13, 15};
const __m256i scales_shuffled = lasx_ext8_16(__lsx_vshuf_b(scales128, scales128, (__m128i)shuffle_mask));
// high bit
const __m256i hbits = __lasx_xvld((const __m256i*)x[i].hmask, 0);
// integer accumulator
__m256i sumi = __lasx_xvldi(0);
for (int j = 0; j < QK_K/128; ++j) {
// load low 2 bits
const __m256i q3bits = __lasx_xvld((const __m256i*)q3, 0); q3 += 32;
// prepare low and high bits
const __m256i q3l_0 = __lasx_xvandi_b(q3bits, 3);
const __m256i q3l_1 = __lasx_xvandi_b(__lasx_xvsrli_b(q3bits, 2), 3);
const __m256i q3l_2 = __lasx_xvandi_b(__lasx_xvsrli_b(q3bits, 4), 3);
const __m256i q3l_3 = __lasx_xvsrli_b(q3bits, 6);
const __m256i q3h_0 = __lasx_xvslli_b(__lasx_xvseqi_b(lasx_xvandi_b_bit(hbits, 4 * j + 0), 0), 2);
const __m256i q3h_1 = __lasx_xvslli_b(__lasx_xvseqi_b(lasx_xvandi_b_bit(hbits, 4 * j + 1), 0), 2);
const __m256i q3h_2 = __lasx_xvslli_b(__lasx_xvseqi_b(lasx_xvandi_b_bit(hbits, 4 * j + 2), 0), 2);
const __m256i q3h_3 = __lasx_xvslli_b(__lasx_xvseqi_b(lasx_xvandi_b_bit(hbits, 4 * j + 3), 0), 2);
const __m256i q3_0 = __lasx_xvor_v(q3h_0, q3l_0);
const __m256i q3_1 = __lasx_xvor_v(q3h_1, q3l_1);
const __m256i q3_2 = __lasx_xvor_v(q3h_2, q3l_2);
const __m256i q3_3 = __lasx_xvor_v(q3h_3, q3l_3);
// load Q8 quants
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;
__m256i p16_0 = lasx_madd_h_b(q8_0, q3_0);
__m256i p16_1 = lasx_madd_h_b(q8_1, q3_1);
__m256i p16_2 = lasx_madd_h_b(q8_2, q3_2);
__m256i p16_3 = lasx_madd_h_b(q8_3, q3_3);
// multiply with scales
p16_0 = lasx_madd_h(lasx_xvrepl128vei_h(scales_shuffled, 4 * j + 0), p16_0);
p16_1 = lasx_madd_h(lasx_xvrepl128vei_h(scales_shuffled, 4 * j + 1), p16_1);
p16_2 = lasx_madd_h(lasx_xvrepl128vei_h(scales_shuffled, 4 * j + 2), p16_2);
p16_3 = lasx_madd_h(lasx_xvrepl128vei_h(scales_shuffled, 4 * j + 3), p16_3);
// accumulate
p16_0 = __lasx_xvadd_w(p16_0, p16_1);
p16_2 = __lasx_xvadd_w(p16_2, p16_3);
sumi = __lasx_xvadd_w(sumi, __lasx_xvadd_w(p16_0, p16_2));
}
// multiply with block scale and accumulate
acc = __lasx_xvfmadd_s(__lasx_xvreplfr2vr_s(d), __lasx_xvffint_s_w(sumi), acc);
}
*s = hsum_float_8(acc);
#else
// scalar version
// This function is written like this so the compiler can manage to vectorize most of it
// Using -Ofast, GCC and clang manage to produce code that is within a factor of 2 or so from the
// manually vectorized version above. Every other version I tried would run at least 4 times slower.
// The ideal situation would be if we could just write the code once, and the compiler would
// automatically produce the best possible set of machine instructions, instead of us having to manually
// write vectorized versions for AVX, ARM_NEON, etc.
int8_t aux8[QK_K];
int16_t aux16[8];
float sums [8];
int32_t aux32[8];
memset(sums, 0, 8*sizeof(float));
uint32_t auxs[4];
const int8_t * scales = (const int8_t*)auxs;
float sumf = 0;
for (int i = 0; i < nb; ++i) {
const uint8_t * GGML_RESTRICT q3 = x[i].qs;
const uint8_t * GGML_RESTRICT hm = x[i].hmask;
const int8_t * GGML_RESTRICT q8 = y[i].qs;
memset(aux32, 0, 8*sizeof(int32_t));
int8_t * GGML_RESTRICT a = aux8;
uint8_t m = 1;
for (int j = 0; j < QK_K; j += 128) {
for (int l = 0; l < 32; ++l) a[l] = q3[l] & 3;
for (int l = 0; l < 32; ++l) a[l] -= (hm[l] & m ? 0 : 4);
a += 32; m <<= 1;
for (int l = 0; l < 32; ++l) a[l] = (q3[l] >> 2) & 3;
for (int l = 0; l < 32; ++l) a[l] -= (hm[l] & m ? 0 : 4);
a += 32; m <<= 1;
for (int l = 0; l < 32; ++l) a[l] = (q3[l] >> 4) & 3;
for (int l = 0; l < 32; ++l) a[l] -= (hm[l] & m ? 0 : 4);
a += 32; m <<= 1;
for (int l = 0; l < 32; ++l) a[l] = (q3[l] >> 6) & 3;
for (int l = 0; l < 32; ++l) a[l] -= (hm[l] & m ? 0 : 4);
a += 32; m <<= 1;
q3 += 32;
}
a = aux8;
memcpy(auxs, x[i].scales, 12);
uint32_t tmp = auxs[2];
auxs[2] = ((auxs[0] >> 4) & kmask2) | (((tmp >> 4) & kmask1) << 4);
auxs[3] = ((auxs[1] >> 4) & kmask2) | (((tmp >> 6) & kmask1) << 4);
auxs[0] = (auxs[0] & kmask2) | (((tmp >> 0) & kmask1) << 4);
auxs[1] = (auxs[1] & kmask2) | (((tmp >> 2) & kmask1) << 4);
for (int j = 0; j < QK_K/16; ++j) {
for (int l = 0; l < 8; ++l) aux16[l] = q8[l] * a[l];
for (int l = 0; l < 8; ++l) aux32[l] += (scales[j] - 32) * aux16[l];
q8 += 8; a += 8;
for (int l = 0; l < 8; ++l) aux16[l] = q8[l] * a[l];
for (int l = 0; l < 8; ++l) aux32[l] += (scales[j] - 32) * aux16[l];
q8 += 8; a += 8;
}
const float d = GGML_FP16_TO_FP32(x[i].d) * y[i].d;
for (int l = 0; l < 8; ++l) sums[l] += d * aux32[l];
}
for (int l = 0; l < 8; ++l) sumf += sums[l];
*s = sumf;
#endif
}
|
O1
|
c
|
ggml_vec_dot_q3_K_q8_K:
vxorps %xmm13, %xmm13, %xmm13
cmpl $0x100, %edi # imm = 0x100
jl 0x1ea3c
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
andq $-0x20, %rsp
subq $0x40, %rsp
shrl $0x8, %edi
leaq 0x20(%rcx), %rax
vxorps %xmm5, %xmm5, %xmm5
xorl %edx, %edx
vpmovsxbq 0x2c121(%rip), %xmm18 # 0x4a8a9
vpbroadcastq 0x2c0af(%rip), %xmm1 # 0x4a840
vmovdqa64 0x34ad5(%rip), %xmm19 # 0x53270
movq 0x3d7be(%rip), %r8 # 0x5bf60
vmovdqa 0x34ad6(%rip), %xmm3 # 0x53280
vpbroadcastb 0x2c0f1(%rip), %xmm4 # 0x4a8a4
vpcmpeqd %ymm6, %ymm6, %ymm6
vpbroadcastw 0x2c0e6(%rip), %ymm7 # 0x4a8a6
vpbroadcastb 0x2c0df(%rip), %ymm8 # 0x4a8a8
vmovdqa 0x2be2f(%rip), %ymm9 # 0x4a600
vmovdqa 0x2be47(%rip), %ymm10 # 0x4a620
vmovdqa 0x2be5f(%rip), %ymm11 # 0x4a640
vmovdqa 0x2be77(%rip), %ymm12 # 0x4a660
imulq $0x124, %rdx, %r10 # imm = 0x124
addq %r9, %r10
addq $0x4, %r10
vmovss -0x4(%r10), %xmm13
imulq $0x6e, %rdx, %r11
movzwl 0x6c(%rcx,%r11), %ebx
vmovss (%r8,%rbx,4), %xmm14
movl 0x60(%rcx,%r11), %ebx
movq 0x64(%rcx,%r11), %r14
vmovq %r14, %xmm15
shrl $0x4, %r14d
vmovd %ebx, %xmm16
vpsrlq $0x20, %xmm15, %xmm17
vpermt2d %xmm16, %xmm18, %xmm15
vpinsrd $0x3, %r14d, %xmm15, %xmm15
vpinsrd $0x1, %ebx, %xmm17, %xmm16
vpshufd $0x10, %xmm16, %xmm16 # xmm16 = xmm16[0,0,1,0]
vpsllvd %xmm1, %xmm16, %xmm0
vpsrlvd %xmm1, %xmm16, %xmm2
vpblendd $0xc, %xmm2, %xmm0, %xmm0 # xmm0 = xmm0[0,1],xmm2[2,3]
vpandd %xmm19, %xmm0, %xmm0
vpternlogd $0xf8, %xmm3, %xmm15, %xmm0
vpaddb %xmm4, %xmm0, %xmm0
vpmovsxbw %xmm0, %ymm0
vpermq $0x44, %ymm0, %ymm2 # ymm2 = ymm0[0,1,0,1]
vmovdqa %ymm2, (%rsp)
vpermq $0xee, %ymm0, %ymm0 # ymm0 = ymm0[2,3,2,3]
vmovdqa %ymm0, 0x20(%rsp)
vpxor (%rcx,%r11), %ymm6, %ymm15
xorl %r11d, %r11d
vpxord %xmm16, %xmm16, %xmm16
vmovdqu (%rax,%r11,8), %ymm0
vmovd %r11d, %xmm2
vpsllw %xmm2, %ymm7, %ymm17
vpandq %ymm15, %ymm17, %ymm17
vpsrlw %xmm2, %ymm17, %ymm2
vpsllw $0x2, %ymm2, %ymm2
vpsrlw $0x2, %ymm0, %ymm17
leal 0x1(%r11), %ebx
vmovd %ebx, %xmm20
vpsllw %xmm20, %ymm7, %ymm21
vpandq %ymm15, %ymm21, %ymm21
vpsrlw %xmm20, %ymm21, %ymm20
vpsllw $0x2, %ymm20, %ymm20
vpsrlw $0x4, %ymm0, %ymm21
leal 0x2(%r11), %ebx
vmovd %ebx, %xmm22
vpsllw %xmm22, %ymm7, %ymm23
vpandq %ymm15, %ymm23, %ymm23
vpsrlw %xmm22, %ymm23, %ymm22
vpsllw $0x2, %ymm22, %ymm22
vpsrlw $0x6, %ymm0, %ymm23
leal 0x3(%r11), %ebx
vmovd %ebx, %xmm24
vpsllw %xmm24, %ymm7, %ymm25
vpandq %ymm15, %ymm25, %ymm25
vpsrlw %xmm24, %ymm25, %ymm24
vmovdqu64 (%r10), %ymm25
vmovdqu64 0x20(%r10), %ymm26
vmovdqu64 0x40(%r10), %ymm27
vpsllw $0x2, %ymm24, %ymm24
vmovdqu64 0x60(%r10), %ymm28
vpmaddubsw %ymm25, %ymm2, %ymm2
vpmaddubsw %ymm26, %ymm20, %ymm20
vpmaddubsw %ymm27, %ymm22, %ymm22
vpmaddubsw %ymm28, %ymm24, %ymm24
vpand %ymm0, %ymm8, %ymm0
vpmaddubsw %ymm25, %ymm0, %ymm0
vpsubw %ymm2, %ymm0, %ymm0
vpandq %ymm8, %ymm17, %ymm2
vpmaddubsw %ymm26, %ymm2, %ymm2
vpsubw %ymm20, %ymm2, %ymm2
vpandq %ymm8, %ymm21, %ymm17
vpmaddubsw %ymm27, %ymm17, %ymm17
vpsubw %ymm22, %ymm17, %ymm17
vpandq %ymm8, %ymm23, %ymm20
vpmaddubsw %ymm28, %ymm20, %ymm20
vpsubw %ymm24, %ymm20, %ymm20
vmovdqa64 (%rsp,%r11,8), %ymm21
vpshufb %ymm9, %ymm21, %ymm22
vpmaddwd %ymm0, %ymm22, %ymm0
vpaddd %ymm16, %ymm0, %ymm0
vpshufb %ymm10, %ymm21, %ymm16
vpmaddwd %ymm2, %ymm16, %ymm2
vpshufb %ymm11, %ymm21, %ymm16
vpmaddwd %ymm17, %ymm16, %ymm16
vpaddd %ymm16, %ymm2, %ymm2
vpaddd %ymm2, %ymm0, %ymm0
vpshufb %ymm12, %ymm21, %ymm2
vpmaddwd %ymm20, %ymm2, %ymm2
vpaddd %ymm2, %ymm0, %ymm16
addq $0x4, %r11
subq $-0x80, %r10
cmpq $0x4, %r11
je 0x1e895
vmulss %xmm14, %xmm13, %xmm0
vbroadcastss %xmm0, %ymm0
vcvtdq2ps %ymm16, %ymm13
vfmadd213ps %ymm5, %ymm0, %ymm13 # ymm13 = (ymm0 * ymm13) + ymm5
incq %rdx
addq $0x6e, %rax
vmovaps %ymm13, %ymm5
cmpq %rdi, %rdx
jne 0x1e7e9
leaq -0x10(%rbp), %rsp
popq %rbx
popq %r14
popq %rbp
vextractf128 $0x1, %ymm13, %xmm0
vaddps %xmm0, %xmm13, %xmm0
vshufpd $0x1, %xmm0, %xmm0, %xmm1 # xmm1 = xmm0[1,0]
vaddps %xmm1, %xmm0, %xmm0
vhaddps %xmm0, %xmm0, %xmm0
vmovss %xmm0, (%rsi)
vzeroupper
retq
|
ggml_vec_dot_q3_K_q8_K:
vxorps xmm13, xmm13, xmm13
cmp edi, 100h
jl loc_1EA3C
push rbp
mov rbp, rsp
push r14
push rbx
and rsp, 0FFFFFFFFFFFFFFE0h
sub rsp, 40h
shr edi, 8
lea rax, [rcx+20h]
vxorps xmm5, xmm5, xmm5
xor edx, edx
vpmovsxbq xmm18, cs:word_4A8A9
vpbroadcastq xmm1, cs:qword_4A840
vmovdqa64 xmm19, cs:xmmword_53270
mov r8, cs:ggml_table_f32_f16_ptr
vmovdqa xmm3, cs:xmmword_53280
vpbroadcastb xmm4, cs:byte_4A8A4
vpcmpeqd ymm6, ymm6, ymm6
vpbroadcastw ymm7, cs:word_4A8A6
vpbroadcastb ymm8, cs:byte_4A8A8
vmovdqa ymm9, cs:ymmword_4A600
vmovdqa ymm10, cs:ymmword_4A620
vmovdqa ymm11, cs:ymmword_4A640
vmovdqa ymm12, cs:ymmword_4A660
loc_1E7E9:
imul r10, rdx, 124h
add r10, r9
add r10, 4
vmovss xmm13, dword ptr [r10-4]
imul r11, rdx, 6Eh ; 'n'
movzx ebx, word ptr [rcx+r11+6Ch]
vmovss xmm14, dword ptr [r8+rbx*4]
mov ebx, [rcx+r11+60h]
mov r14, [rcx+r11+64h]
vmovq xmm15, r14
shr r14d, 4
vmovd xmm16, ebx
vpsrlq xmm17, xmm15, 20h ; ' '
vpermt2d xmm15, xmm18, xmm16
vpinsrd xmm15, xmm15, r14d, 3
vpinsrd xmm16, xmm17, ebx, 1
vpshufd xmm16, xmm16, 10h
vpsllvd xmm0, xmm16, xmm1
vpsrlvd xmm2, xmm16, xmm1
vpblendd xmm0, xmm0, xmm2, 0Ch
vpandd xmm0, xmm0, xmm19
vpternlogd xmm0, xmm15, xmm3, 0F8h
vpaddb xmm0, xmm0, xmm4
vpmovsxbw ymm0, xmm0
vpermq ymm2, ymm0, 44h ; 'D'
vmovdqa [rsp+58h+var_58], ymm2
vpermq ymm0, ymm0, 0EEh
vmovdqa [rsp+58h+var_38], ymm0
vpxor ymm15, ymm6, ymmword ptr [rcx+r11]
xor r11d, r11d
vpxord xmm16, xmm16, xmm16
loc_1E895:
vmovdqu ymm0, ymmword ptr [rax+r11*8]
vmovd xmm2, r11d
vpsllw ymm17, ymm7, xmm2
vpandq ymm17, ymm17, ymm15
vpsrlw ymm2, ymm17, xmm2
vpsllw ymm2, ymm2, 2
vpsrlw ymm17, ymm0, 2
lea ebx, [r11+1]
vmovd xmm20, ebx
vpsllw ymm21, ymm7, xmm20
vpandq ymm21, ymm21, ymm15
vpsrlw ymm20, ymm21, xmm20
vpsllw ymm20, ymm20, 2
vpsrlw ymm21, ymm0, 4
lea ebx, [r11+2]
vmovd xmm22, ebx
vpsllw ymm23, ymm7, xmm22
vpandq ymm23, ymm23, ymm15
vpsrlw ymm22, ymm23, xmm22
vpsllw ymm22, ymm22, 2
vpsrlw ymm23, ymm0, 6
lea ebx, [r11+3]
vmovd xmm24, ebx
vpsllw ymm25, ymm7, xmm24
vpandq ymm25, ymm25, ymm15
vpsrlw ymm24, ymm25, xmm24
vmovdqu64 ymm25, ymmword ptr [r10]
vmovdqu64 ymm26, ymmword ptr [r10+20h]
vmovdqu64 ymm27, ymmword ptr [r10+40h]
vpsllw ymm24, ymm24, 2
vmovdqu64 ymm28, ymmword ptr [r10+60h]
vpmaddubsw ymm2, ymm2, ymm25
vpmaddubsw ymm20, ymm20, ymm26
vpmaddubsw ymm22, ymm22, ymm27
vpmaddubsw ymm24, ymm24, ymm28
vpand ymm0, ymm8, ymm0
vpmaddubsw ymm0, ymm0, ymm25
vpsubw ymm0, ymm0, ymm2
vpandq ymm2, ymm17, ymm8
vpmaddubsw ymm2, ymm2, ymm26
vpsubw ymm2, ymm2, ymm20
vpandq ymm17, ymm21, ymm8
vpmaddubsw ymm17, ymm17, ymm27
vpsubw ymm17, ymm17, ymm22
vpandq ymm20, ymm23, ymm8
vpmaddubsw ymm20, ymm20, ymm28
vpsubw ymm20, ymm20, ymm24
vmovdqa64 ymm21, [rsp+r11*8+58h+var_58]
vpshufb ymm22, ymm21, ymm9
vpmaddwd ymm0, ymm22, ymm0
vpaddd ymm0, ymm0, ymm16
vpshufb ymm16, ymm21, ymm10
vpmaddwd ymm2, ymm16, ymm2
vpshufb ymm16, ymm21, ymm11
vpmaddwd ymm16, ymm16, ymm17
vpaddd ymm2, ymm2, ymm16
vpaddd ymm0, ymm0, ymm2
vpshufb ymm2, ymm21, ymm12
vpmaddwd ymm2, ymm2, ymm20
vpaddd ymm16, ymm0, ymm2
add r11, 4
sub r10, 0FFFFFFFFFFFFFF80h
cmp r11, 4
jz loc_1E895
vmulss xmm0, xmm13, xmm14
vbroadcastss ymm0, xmm0
vcvtdq2ps ymm13, ymm16
vfmadd213ps ymm13, ymm0, ymm5
inc rdx
add rax, 6Eh ; 'n'
vmovaps ymm5, ymm13
cmp rdx, rdi
jnz loc_1E7E9
lea rsp, [rbp-10h]
pop rbx
pop r14
pop rbp
loc_1EA3C:
vextractf128 xmm0, ymm13, 1
vaddps xmm0, xmm13, xmm0
vshufpd xmm1, xmm0, xmm0, 1
vaddps xmm0, xmm0, xmm1
vhaddps xmm0, xmm0, xmm0
vmovss dword ptr [rsi], xmm0
vzeroupper
retn
|
void ggml_vec_dot_q3_K_q8_K(
int a1,
long long _RSI,
double a3,
double a4,
double a5,
double a6,
double a7,
__m128 _XMM5,
long long a9,
long long a10,
long long a11,
long long a12)
{
long long v16; // rdi
long long v19; // rdx
__asm { vxorps xmm13, xmm13, xmm13 }
if ( a1 >= 256 )
{
v16 = (unsigned int)a1 >> 8;
_RAX = a10 + 32;
__asm { vxorps xmm5, xmm5, xmm5 }
v19 = 0LL;
__asm
{
vpmovsxbq xmm18, cs:word_4A8A9
vpbroadcastq xmm1, cs:qword_4A840
vmovdqa64 xmm19, cs:xmmword_53270
}
_R8 = &ggml_table_f32_f16;
__asm
{
vmovdqa xmm3, cs:xmmword_53280
vpbroadcastb xmm4, cs:byte_4A8A4
vpcmpeqd ymm6, ymm6, ymm6
vpbroadcastw ymm7, cs:word_4A8A6
vpbroadcastb ymm8, cs:byte_4A8A8
vmovdqa ymm9, cs:ymmword_4A600
vmovdqa ymm10, cs:ymmword_4A620
vmovdqa ymm11, cs:ymmword_4A640
vmovdqa ymm12, cs:ymmword_4A660
}
do
{
_R10 = a12 + 292 * v19 + 4;
__asm { vmovss xmm13, dword ptr [r10-4] }
_RBX = *(unsigned __int16 *)(a10 + 110 * v19 + 108);
__asm { vmovss xmm14, dword ptr [r8+rbx*4] }
LODWORD(_RBX) = *(_DWORD *)(a10 + 110 * v19 + 96);
_R14 = *(_QWORD *)(a10 + 110 * v19 + 100);
__asm
{
vmovq xmm15, r14
vmovd xmm16, ebx
vpsrlq xmm17, xmm15, 20h ; ' '
vpermt2d xmm15, xmm18, xmm16
vpinsrd xmm15, xmm15, r14d, 3
vpinsrd xmm16, xmm17, ebx, 1
vpshufd xmm16, xmm16, 10h
vpsllvd xmm0, xmm16, xmm1
vpsrlvd xmm2, xmm16, xmm1
vpblendd xmm0, xmm0, xmm2, 0Ch
vpandd xmm0, xmm0, xmm19
vpternlogd xmm0, xmm15, xmm3, 0F8h
vpaddb xmm0, xmm0, xmm4
vpmovsxbw ymm0, xmm0
vpermq ymm2, ymm0, 44h ; 'D'
vmovdqa [rsp+58h+var_58], ymm2
vpermq ymm0, ymm0, 0EEh
vmovdqa [rsp+58h+var_38], ymm0
vpxor ymm15, ymm6, ymmword ptr [rcx+r11]
}
_R11 = 0LL;
__asm { vpxord xmm16, xmm16, xmm16 }
do
{
__asm
{
vmovdqu ymm0, ymmword ptr [rax+r11*8]
vmovd xmm2, r11d
vpsllw ymm17, ymm7, xmm2
vpandq ymm17, ymm17, ymm15
vpsrlw ymm2, ymm17, xmm2
vpsllw ymm2, ymm2, 2
vpsrlw ymm17, ymm0, 2
}
_EBX = _R11 + 1;
__asm
{
vmovd xmm20, ebx
vpsllw ymm21, ymm7, xmm20
vpandq ymm21, ymm21, ymm15
vpsrlw ymm20, ymm21, xmm20
vpsllw ymm20, ymm20, 2
vpsrlw ymm21, ymm0, 4
}
_EBX = _R11 + 2;
__asm
{
vmovd xmm22, ebx
vpsllw ymm23, ymm7, xmm22
vpandq ymm23, ymm23, ymm15
vpsrlw ymm22, ymm23, xmm22
vpsllw ymm22, ymm22, 2
vpsrlw ymm23, ymm0, 6
}
_EBX = _R11 + 3;
__asm
{
vmovd xmm24, ebx
vpsllw ymm25, ymm7, xmm24
vpandq ymm25, ymm25, ymm15
vpsrlw ymm24, ymm25, xmm24
vmovdqu64 ymm25, ymmword ptr [r10]
vmovdqu64 ymm26, ymmword ptr [r10+20h]
vmovdqu64 ymm27, ymmword ptr [r10+40h]
vpsllw ymm24, ymm24, 2
vmovdqu64 ymm28, ymmword ptr [r10+60h]
vpmaddubsw ymm2, ymm2, ymm25
vpmaddubsw ymm20, ymm20, ymm26
vpmaddubsw ymm22, ymm22, ymm27
vpmaddubsw ymm24, ymm24, ymm28
vpand ymm0, ymm8, ymm0
vpmaddubsw ymm0, ymm0, ymm25
vpsubw ymm0, ymm0, ymm2
vpandq ymm2, ymm17, ymm8
vpmaddubsw ymm2, ymm2, ymm26
vpsubw ymm2, ymm2, ymm20
vpandq ymm17, ymm21, ymm8
vpmaddubsw ymm17, ymm17, ymm27
vpsubw ymm17, ymm17, ymm22
vpandq ymm20, ymm23, ymm8
vpmaddubsw ymm20, ymm20, ymm28
vpsubw ymm20, ymm20, ymm24
vmovdqa64 ymm21, [rsp+r11*8+58h+var_58]
vpshufb ymm22, ymm21, ymm9
vpmaddwd ymm0, ymm22, ymm0
vpaddd ymm0, ymm0, ymm16
vpshufb ymm16, ymm21, ymm10
vpmaddwd ymm2, ymm16, ymm2
vpshufb ymm16, ymm21, ymm11
vpmaddwd ymm16, ymm16, ymm17
vpaddd ymm2, ymm2, ymm16
vpaddd ymm0, ymm0, ymm2
vpshufb ymm2, ymm21, ymm12
vpmaddwd ymm2, ymm2, ymm20
vpaddd ymm16, ymm0, ymm2
}
_R11 += 4LL;
_R10 += 128LL;
}
while ( _R11 == 4 );
__asm
{
vmulss xmm0, xmm13, xmm14
vbroadcastss ymm0, xmm0
vcvtdq2ps ymm13, ymm16
vfmadd213ps ymm13, ymm0, ymm5
}
++v19;
_RAX += 110LL;
__asm { vmovaps ymm5, ymm13 }
}
while ( v19 != v16 );
}
__asm
{
vextractf128 xmm0, ymm13, 1
vaddps xmm0, xmm13, xmm0
vshufpd xmm1, xmm0, xmm0, 1
vaddps xmm0, xmm0, xmm1
vhaddps xmm0, xmm0, xmm0
vmovss dword ptr [rsi], xmm0
vzeroupper
}
}
|
ggml_vec_dot_q3_K_q8_K:
VXORPS XMM13,XMM13,XMM13
CMP EDI,0x100
JL 0x0011ea3c
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
AND RSP,-0x20
SUB RSP,0x40
SHR EDI,0x8
LEA RAX,[RCX + 0x20]
VXORPS XMM5,XMM5,XMM5
XOR EDX,EDX
VPMOVSXBQ XMM2,word ptr [0x0014a8a9]
VPBROADCASTQ XMM1,qword ptr [0x0014a840]
VMOVDQA64 XMM3,xmmword ptr [0x00153270]
MOV R8,qword ptr [0x0015bf60]
VMOVDQA XMM3,xmmword ptr [0x00153280]
VPBROADCASTB XMM4,byte ptr [0x0014a8a4]
VPCMPEQD YMM6,YMM6,YMM6
VPBROADCASTW YMM7,word ptr [0x0014a8a6]
VPBROADCASTB YMM8,byte ptr [0x0014a8a8]
VMOVDQA YMM9,ymmword ptr [0x0014a600]
VMOVDQA YMM10,ymmword ptr [0x0014a620]
VMOVDQA YMM11,ymmword ptr [0x0014a640]
VMOVDQA YMM12,ymmword ptr [0x0014a660]
IMUL R10,RDX,0x124
ADD R10,R9
ADD R10,0x4
VMOVSS XMM13,dword ptr [R10 + -0x4]
IMUL R11,RDX,0x6e
MOVZX EBX,word ptr [RCX + R11*0x1 + 0x6c]
VMOVSS XMM14,dword ptr [R8 + RBX*0x4]
MOV EBX,dword ptr [RCX + R11*0x1 + 0x60]
MOV R14,qword ptr [RCX + R11*0x1 + 0x64]
VMOVQ XMM15,R14
SHR R14D,0x4
VMOVD XMM0,EBX
VPSRLQ XMM1,XMM15,0x20
LAB_0011ea3c:
VEXTRACTF128 XMM0,YMM13,0x1
VADDPS XMM0,XMM13,XMM0
VSHUFPD XMM1,XMM0,XMM0,0x1
VADDPS XMM0,XMM0,XMM1
VHADDPS XMM0,XMM0,XMM0
VMOVSS dword ptr [RSI],XMM0
VZEROUPPER
RET
|
/* WARNING: Control flow encountered bad instruction data */
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void ggml_vec_dot_q3_K_q8_K(int param_1,int4 *param_2,int8 param_3,long param_4)
{
int1 auVar1 [16];
int1 in_ZMM6 [64];
int1 auVar2 [16];
if (param_1 < 0x100) {
auVar2 = vshufpd_avx(ZEXT816(0),ZEXT816(0),1);
auVar1._0_4_ = auVar2._0_4_ + 0.0;
auVar1._4_4_ = auVar2._4_4_ + 0.0;
auVar1._8_4_ = auVar2._8_4_ + 0.0;
auVar1._12_4_ = auVar2._12_4_ + 0.0;
auVar2 = vhaddps_avx(auVar1,auVar1);
*param_2 = auVar2._0_4_;
return;
}
vpmovsxbq_avx512vl(ZEXT216(DAT_0014a8a9));
vmovdqa64_avx512vl(_DAT_00153270);
vpcmpeqd_avx2(in_ZMM6._0_32_,in_ZMM6._0_32_);
auVar2._8_8_ = 0;
auVar2._0_8_ = *(ulong *)(param_4 + 100);
vpsrlq_avx512vl(auVar2,0x20);
/* WARNING: Bad instruction - Truncating control flow here */
halt_baddata();
}
|
|
63,646
|
ggml_vec_dot_q3_K_q8_K
|
ngxson[P]ggml-easy/ggml/src/ggml-cpu/ggml-cpu-quants.c
|
void ggml_vec_dot_q3_K_q8_K(int n, float * GGML_RESTRICT s, size_t bs, const void * GGML_RESTRICT vx, size_t bx, const void * GGML_RESTRICT vy, size_t by, int nrc) {
assert(n % QK_K == 0);
assert(nrc == 1);
UNUSED(nrc);
UNUSED(bx);
UNUSED(by);
UNUSED(bs);
const uint32_t kmask1 = 0x03030303;
const uint32_t kmask2 = 0x0f0f0f0f;
const block_q3_K * GGML_RESTRICT x = vx;
const block_q8_K * GGML_RESTRICT y = vy;
const int nb = n / QK_K;
#if defined(__ARM_FEATURE_SVE)
uint32_t aux[3];
uint32_t utmp[4];
const int8_t m32 = 32;
const int vector_length = svcntb()*8;
const svuint8_t m3b_sv = svdup_n_u8(0x3);
const svint32_t vzero_sv = svdup_n_s32(0);
const svuint8_t m0_sv = svdup_n_u8(1);
const svuint8_t m1_sv = svlsl_n_u8_x(svptrue_b8(), m0_sv, 1);
const svuint8_t m2_sv = svlsl_n_u8_x(svptrue_b8(), m0_sv, 2);
const svuint8_t m3_sv = svlsl_n_u8_x(svptrue_b8(), m0_sv, 3);
float sum = 0;
for (int i = 0; i < nb; ++i) {
const float d = y[i].d * GGML_FP16_TO_FP32(x[i].d);
const uint8_t * GGML_RESTRICT q3_sv = x[i].qs;
const uint8_t * GGML_RESTRICT qh_sv = x[i].hmask;
const int8_t * GGML_RESTRICT q8_sv = y[i].qs;
// Set up scales
memcpy(aux, x[i].scales, 12);
utmp[3] = ((aux[1] >> 4) & kmask2) | (((aux[2] >> 6) & kmask1) << 4);
utmp[2] = ((aux[0] >> 4) & kmask2) | (((aux[2] >> 4) & kmask1) << 4);
utmp[1] = (aux[1] & kmask2) | (((aux[2] >> 2) & kmask1) << 4);
utmp[0] = (aux[0] & kmask2) | (((aux[2] >> 0) & kmask1) << 4);
int8_t * scale = (int8_t *)utmp;
for (int j = 0; j < 16; ++j) scale[j] -= m32;
switch (vector_length) {
case 128:
{
svuint8_t qhbits_sv_1 = svld1_u8(svptrue_b8(), qh_sv);
svuint8_t qhbits_sv_2 = svld1_u8(svptrue_b8(), qh_sv+16);
svuint8_t q3h_sv;
svint32_t sumi1_1 = svdup_n_s32(0);
svint8_t q3bytes_sv;
for (int j = 0; j < QK_K/128; ++j) {
const svuint8_t q3bits_sv = svld1_u8(svptrue_b8(), q3_sv); q3_sv += 16;
const svuint8_t q3bits_sv_1 = svld1_u8(svptrue_b8(), q3_sv); q3_sv += 16;
svint8_t q8bytes_1_sv_1 = svld1_s8(svptrue_b8(), q8_sv); q8_sv += 16;
svint8_t q8bytes_1_sv_2 = svld1_s8(svptrue_b8(), q8_sv); q8_sv += 16;
q3h_sv = svlsl_n_u8_x(svptrue_b8(), svbic_u8_x(svptrue_b8(), m0_sv, qhbits_sv_1), 2);
q3bytes_sv = svsub_s8_x(svptrue_b8(), svreinterpret_s8_u8(svand_u8_m(svptrue_b8(), q3bits_sv, m3b_sv)), svreinterpret_s8_u8(q3h_sv));
sumi1_1 = svmla_s32_m(svptrue_b32(), sumi1_1, svdot_s32(vzero_sv, q3bytes_sv, q8bytes_1_sv_1), svdup_n_s32((int32_t)scale[0]));
q3h_sv = svlsl_n_u8_x(svptrue_b8(), svbic_u8_x(svptrue_b8(), m0_sv, qhbits_sv_2), 2);
q3bytes_sv = svsub_s8_x(svptrue_b8(), svreinterpret_s8_u8(svand_u8_m(svptrue_b8(), q3bits_sv_1, m3b_sv)), svreinterpret_s8_u8(q3h_sv));
sumi1_1 = svmla_s32_m(svptrue_b32(), sumi1_1, svdot_s32(vzero_sv, q3bytes_sv, q8bytes_1_sv_2), svdup_n_s32((int32_t)scale[1]));
q8bytes_1_sv_1 = svld1_s8(svptrue_b8(), q8_sv); q8_sv += 16;
q8bytes_1_sv_2 = svld1_s8(svptrue_b8(), q8_sv); q8_sv += 16;
q3h_sv = svlsl_n_u8_x(svptrue_b8(), svbic_u8_x(svptrue_b8(), m1_sv, qhbits_sv_1), 1);
q3bytes_sv = svsub_s8_x(svptrue_b8(), svreinterpret_s8_u8(svand_u8_m(svptrue_b8(), svlsr_n_u8_x(svptrue_b8(), q3bits_sv, 2), m3b_sv)), svreinterpret_s8_u8(q3h_sv));
sumi1_1 = svmla_s32_m(svptrue_b32(), sumi1_1, svdot_s32(vzero_sv, q3bytes_sv, q8bytes_1_sv_1), svdup_n_s32((int32_t)scale[2]));
q3h_sv = svlsl_n_u8_x(svptrue_b8(), svbic_u8_x(svptrue_b8(), m1_sv, qhbits_sv_2), 1);
q3bytes_sv = svsub_s8_x(svptrue_b8(), svreinterpret_s8_u8(svand_u8_m(svptrue_b8(), svlsr_n_u8_x(svptrue_b8(), q3bits_sv_1, 2), m3b_sv)), svreinterpret_s8_u8(q3h_sv));
sumi1_1 = svmla_s32_m(svptrue_b32(), sumi1_1, svdot_s32(vzero_sv, q3bytes_sv, q8bytes_1_sv_2), svdup_n_s32((int32_t)scale[3]));
scale += 4;
q8bytes_1_sv_1 = svld1_s8(svptrue_b8(), q8_sv); q8_sv += 16;
q8bytes_1_sv_2 = svld1_s8(svptrue_b8(), q8_sv); q8_sv += 16;
q3h_sv = svbic_u8_x(svptrue_b8(), m2_sv, qhbits_sv_1);
q3bytes_sv = svsub_s8_x(svptrue_b8(), svreinterpret_s8_u8(svand_u8_m(svptrue_b8(), svlsr_n_u8_x(svptrue_b8(), q3bits_sv, 4), m3b_sv)), svreinterpret_s8_u8(q3h_sv));
sumi1_1 = svmla_s32_m(svptrue_b32(), sumi1_1, svdot_s32(vzero_sv, q3bytes_sv, q8bytes_1_sv_1), svdup_n_s32((int32_t)scale[0]));
q3h_sv = svbic_u8_x(svptrue_b8(), m2_sv, qhbits_sv_2);
q3bytes_sv = svsub_s8_x(svptrue_b8(), svreinterpret_s8_u8(svand_u8_m(svptrue_b8(), svlsr_n_u8_x(svptrue_b8(), q3bits_sv_1, 4), m3b_sv)), svreinterpret_s8_u8(q3h_sv));
sumi1_1 = svmla_s32_m(svptrue_b32(), sumi1_1, svdot_s32(vzero_sv, q3bytes_sv, q8bytes_1_sv_2), svdup_n_s32((int32_t)scale[1]));
q8bytes_1_sv_1 = svld1_s8(svptrue_b8(), q8_sv); q8_sv += 16;
q8bytes_1_sv_2 = svld1_s8(svptrue_b8(), q8_sv); q8_sv += 16;
q3h_sv = svlsr_n_u8_x(svptrue_b8(), svbic_u8_x(svptrue_b8(), m3_sv, qhbits_sv_1), 1);
q3bytes_sv = svsub_s8_x(svptrue_b8(), svreinterpret_s8_u8(svand_u8_m(svptrue_b8(), svlsr_n_u8_x(svptrue_b8(), q3bits_sv, 6), m3b_sv)), svreinterpret_s8_u8(q3h_sv));
sumi1_1 = svmla_s32_m(svptrue_b32(), sumi1_1, svdot_s32(vzero_sv, q3bytes_sv, q8bytes_1_sv_1), svdup_n_s32((int32_t)scale[2]));
q3h_sv = svlsr_n_u8_x(svptrue_b8(), svbic_u8_x(svptrue_b8(), m3_sv, qhbits_sv_2), 1);
q3bytes_sv = svsub_s8_x(svptrue_b8(), svreinterpret_s8_u8(svand_u8_m(svptrue_b8(), svlsr_n_u8_x(svptrue_b8(), q3bits_sv_1, 6), m3b_sv)), svreinterpret_s8_u8(q3h_sv));
sumi1_1 = svmla_s32_m(svptrue_b32(), sumi1_1, svdot_s32(vzero_sv, q3bytes_sv, q8bytes_1_sv_2), svdup_n_s32((int32_t)scale[3]));
if (j == 0) {
qhbits_sv_1 = svlsr_n_u8_x(svptrue_b8(), qhbits_sv_1, 4);
qhbits_sv_2 = svlsr_n_u8_x(svptrue_b8(), qhbits_sv_2, 4);
}
scale += 4;
}
sum += d * (svaddv_s32(svptrue_b32(), sumi1_1));
} break;
case 256:
case 512:
{
svuint8_t qhbits_sv = svld1_u8(svptrue_pat_b8(SV_VL32), qh_sv);
svuint8_t q3h_sv;
svint32_t sumi1_1 = svdup_n_s32(0);
svint8_t q3bytes_sv;
for (int j = 0; j < QK_K/128; ++j) {
const svuint8_t q3bits_sv = svld1_u8(svptrue_pat_b8(SV_VL32), q3_sv); q3_sv += 32;
svint8_t q8bytes_1_sv_1 = svld1_s8(svptrue_pat_b8(SV_VL32), q8_sv); q8_sv += 32;
svint8_t q8bytes_1_sv_2 = svld1_s8(svptrue_pat_b8(SV_VL32), q8_sv); q8_sv += 32;
q3h_sv = svlsl_n_u8_x(svptrue_pat_b8(SV_VL32), svbic_u8_x(svptrue_pat_b8(SV_VL32), m0_sv, qhbits_sv), 2);
q3bytes_sv = svsub_s8_x(svptrue_pat_b8(SV_VL32), svreinterpret_s8_u8(svand_u8_m(svptrue_pat_b8(SV_VL32), q3bits_sv, m3b_sv)), svreinterpret_s8_u8(q3h_sv));
svint32_t scale_1 = svsel_s32(svptrue_pat_b32(SV_VL4), svdup_n_s32((int32_t)scale[0]), svdup_n_s32((int32_t)scale[1]));
sumi1_1 = svmla_s32_m(svptrue_pat_b32(SV_VL8), sumi1_1, svdot_s32(vzero_sv, q3bytes_sv, q8bytes_1_sv_1), scale_1);
q3h_sv = svlsl_n_u8_x(svptrue_pat_b8(SV_VL32), svbic_u8_x(svptrue_pat_b8(SV_VL32), m1_sv, qhbits_sv), 1);
q3bytes_sv = svsub_s8_x(svptrue_pat_b8(SV_VL32), svreinterpret_s8_u8(svand_u8_m(svptrue_pat_b8(SV_VL32), svlsr_n_u8_x(svptrue_pat_b8(SV_VL32), q3bits_sv, 2), m3b_sv)), svreinterpret_s8_u8(q3h_sv));
scale_1 = svsel_s32(svptrue_pat_b32(SV_VL4), svdup_n_s32((int32_t)scale[2]), svdup_n_s32((int32_t)scale[3]));
sumi1_1 = svmla_s32_m(svptrue_pat_b32(SV_VL8), sumi1_1, svdot_s32(vzero_sv, q3bytes_sv, q8bytes_1_sv_2), scale_1);
scale += 4;
q8bytes_1_sv_1 = svld1_s8(svptrue_pat_b8(SV_VL32), q8_sv); q8_sv += 32;
q8bytes_1_sv_2 = svld1_s8(svptrue_pat_b8(SV_VL32), q8_sv); q8_sv += 32;
q3h_sv = svbic_u8_x(svptrue_pat_b8(SV_VL32), m2_sv, qhbits_sv);
q3bytes_sv = svsub_s8_x(svptrue_pat_b8(SV_VL32), svreinterpret_s8_u8(svand_u8_m(svptrue_pat_b8(SV_VL32), svlsr_n_u8_x(svptrue_pat_b8(SV_VL32), q3bits_sv, 4), m3b_sv)), svreinterpret_s8_u8(q3h_sv));
scale_1 = svsel_s32(svptrue_pat_b32(SV_VL4), svdup_n_s32((int32_t)scale[0]), svdup_n_s32((int32_t)scale[1]));
sumi1_1 = svmla_s32_m(svptrue_pat_b32(SV_VL8), sumi1_1, svdot_s32(vzero_sv, q3bytes_sv, q8bytes_1_sv_1), scale_1);
q3h_sv = svlsr_n_u8_x(svptrue_pat_b8(SV_VL32), svbic_u8_x(svptrue_pat_b8(SV_VL32), m3_sv, qhbits_sv), 1);
q3bytes_sv = svsub_s8_x(svptrue_pat_b8(SV_VL32), svreinterpret_s8_u8(svand_u8_m(svptrue_pat_b8(SV_VL32), svlsr_n_u8_x(svptrue_pat_b8(SV_VL32), q3bits_sv, 6), m3b_sv)), svreinterpret_s8_u8(q3h_sv));
scale_1 = svsel_s32(svptrue_pat_b32(SV_VL4), svdup_n_s32((int32_t)scale[2]), svdup_n_s32((int32_t)scale[3]));
sumi1_1 = svmla_s32_m(svptrue_pat_b32(SV_VL8), sumi1_1, svdot_s32(vzero_sv, q3bytes_sv, q8bytes_1_sv_2), scale_1);
if (j == 0) {
qhbits_sv = svlsr_n_u8_x(svptrue_pat_b8(SV_VL32), qhbits_sv, 4);
}
scale += 4;
}
sum += d * (svaddv_s32(svptrue_pat_b32(SV_VL8), sumi1_1));
} break;
default:
assert(false && "Unsupported vector length");
break;
}
}
*s = sum;
#elif __ARM_NEON
uint32_t aux[3];
uint32_t utmp[4];
const uint8x16_t m3b = vdupq_n_u8(0x3);
const int32x4_t vzero = vdupq_n_s32(0);
const uint8x16_t m0 = vdupq_n_u8(1);
const uint8x16_t m1 = vshlq_n_u8(m0, 1);
const uint8x16_t m2 = vshlq_n_u8(m0, 2);
const uint8x16_t m3 = vshlq_n_u8(m0, 3);
const int8_t m32 = 32;
ggml_int8x16x4_t q3bytes;
float sum = 0;
for (int i = 0; i < nb; ++i) {
const float d = y[i].d * GGML_FP16_TO_FP32(x[i].d);
const uint8_t * GGML_RESTRICT q3 = x[i].qs;
const uint8_t * GGML_RESTRICT qh = x[i].hmask;
const int8_t * GGML_RESTRICT q8 = y[i].qs;
ggml_uint8x16x2_t qhbits = ggml_vld1q_u8_x2(qh);
ggml_uint8x16x4_t q3h;
int32_t isum = 0;
// Set up scales
memcpy(aux, x[i].scales, 12);
utmp[3] = ((aux[1] >> 4) & kmask2) | (((aux[2] >> 6) & kmask1) << 4);
utmp[2] = ((aux[0] >> 4) & kmask2) | (((aux[2] >> 4) & kmask1) << 4);
utmp[1] = (aux[1] & kmask2) | (((aux[2] >> 2) & kmask1) << 4);
utmp[0] = (aux[0] & kmask2) | (((aux[2] >> 0) & kmask1) << 4);
int8_t * scale = (int8_t *)utmp;
for (int j = 0; j < 16; ++j) scale[j] -= m32;
for (int j = 0; j < QK_K/128; ++j) {
const ggml_uint8x16x2_t q3bits = ggml_vld1q_u8_x2(q3); q3 += 32;
const ggml_int8x16x4_t q8bytes_1 = ggml_vld1q_s8_x4(q8); q8 += 64;
const ggml_int8x16x4_t q8bytes_2 = ggml_vld1q_s8_x4(q8); q8 += 64;
q3h.val[0] = vshlq_n_u8(vbicq_u8(m0, qhbits.val[0]), 2);
q3h.val[1] = vshlq_n_u8(vbicq_u8(m0, qhbits.val[1]), 2);
q3h.val[2] = vshlq_n_u8(vbicq_u8(m1, qhbits.val[0]), 1);
q3h.val[3] = vshlq_n_u8(vbicq_u8(m1, qhbits.val[1]), 1);
q3bytes.val[0] = vsubq_s8(vreinterpretq_s8_u8(vandq_u8(q3bits.val[0], m3b)), vreinterpretq_s8_u8(q3h.val[0]));
q3bytes.val[1] = vsubq_s8(vreinterpretq_s8_u8(vandq_u8(q3bits.val[1], m3b)), vreinterpretq_s8_u8(q3h.val[1]));
q3bytes.val[2] = vsubq_s8(vreinterpretq_s8_u8(vandq_u8(vshrq_n_u8(q3bits.val[0], 2), m3b)), vreinterpretq_s8_u8(q3h.val[2]));
q3bytes.val[3] = vsubq_s8(vreinterpretq_s8_u8(vandq_u8(vshrq_n_u8(q3bits.val[1], 2), m3b)), vreinterpretq_s8_u8(q3h.val[3]));
isum += vaddvq_s32(ggml_vdotq_s32(vzero, q3bytes.val[0], q8bytes_1.val[0])) * scale[0];
isum += vaddvq_s32(ggml_vdotq_s32(vzero, q3bytes.val[1], q8bytes_1.val[1])) * scale[1];
isum += vaddvq_s32(ggml_vdotq_s32(vzero, q3bytes.val[2], q8bytes_1.val[2])) * scale[2];
isum += vaddvq_s32(ggml_vdotq_s32(vzero, q3bytes.val[3], q8bytes_1.val[3])) * scale[3];
scale += 4;
q3h.val[0] = vbicq_u8(m2, qhbits.val[0]);
q3h.val[1] = vbicq_u8(m2, qhbits.val[1]);
q3h.val[2] = vshrq_n_u8(vbicq_u8(m3, qhbits.val[0]), 1);
q3h.val[3] = vshrq_n_u8(vbicq_u8(m3, qhbits.val[1]), 1);
q3bytes.val[0] = vsubq_s8(vreinterpretq_s8_u8(vandq_u8(vshrq_n_u8(q3bits.val[0], 4), m3b)), vreinterpretq_s8_u8(q3h.val[0]));
q3bytes.val[1] = vsubq_s8(vreinterpretq_s8_u8(vandq_u8(vshrq_n_u8(q3bits.val[1], 4), m3b)), vreinterpretq_s8_u8(q3h.val[1]));
q3bytes.val[2] = vsubq_s8(vreinterpretq_s8_u8(vandq_u8(vshrq_n_u8(q3bits.val[0], 6), m3b)), vreinterpretq_s8_u8(q3h.val[2]));
q3bytes.val[3] = vsubq_s8(vreinterpretq_s8_u8(vandq_u8(vshrq_n_u8(q3bits.val[1], 6), m3b)), vreinterpretq_s8_u8(q3h.val[3]));
isum += vaddvq_s32(ggml_vdotq_s32(vzero, q3bytes.val[0], q8bytes_2.val[0])) * scale[0];
isum += vaddvq_s32(ggml_vdotq_s32(vzero, q3bytes.val[1], q8bytes_2.val[1])) * scale[1];
isum += vaddvq_s32(ggml_vdotq_s32(vzero, q3bytes.val[2], q8bytes_2.val[2])) * scale[2];
isum += vaddvq_s32(ggml_vdotq_s32(vzero, q3bytes.val[3], q8bytes_2.val[3])) * scale[3];
scale += 4;
if (j == 0) {
qhbits.val[0] = vshrq_n_u8(qhbits.val[0], 4);
qhbits.val[1] = vshrq_n_u8(qhbits.val[1], 4);
}
}
sum += d * isum;
}
*s = sum;
#elif defined __AVX2__
const __m256i m3 = _mm256_set1_epi8(3);
const __m256i mone = _mm256_set1_epi8(1);
const __m128i m32 = _mm_set1_epi8(32);
__m256 acc = _mm256_setzero_ps();
uint32_t aux[3];
for (int i = 0; i < nb; ++i) {
const float d = y[i].d * GGML_FP16_TO_FP32(x[i].d);
const uint8_t * GGML_RESTRICT q3 = x[i].qs;
const int8_t * GGML_RESTRICT q8 = y[i].qs;
// Set up scales
memcpy(aux, x[i].scales, 12);
__m128i scales128 = _mm_set_epi32(
((aux[1] >> 4) & kmask2) | (((aux[2] >> 6) & kmask1) << 4),
((aux[0] >> 4) & kmask2) | (((aux[2] >> 4) & kmask1) << 4),
(aux[1] & kmask2) | (((aux[2] >> 2) & kmask1) << 4),
(aux[0] & kmask2) | (((aux[2] >> 0) & kmask1) << 4));
scales128 = _mm_sub_epi8(scales128, m32);
const __m256i all_scales = _mm256_cvtepi8_epi16(scales128);
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)};
// high bit
const __m256i hbits = _mm256_loadu_si256((const __m256i*)x[i].hmask);
// integer accumulator
__m256i sumi = _mm256_setzero_si256();
int bit = 0;
int is = 0;
for (int j = 0; j < QK_K/128; ++j) {
// load low 2 bits
const __m256i q3bits = _mm256_loadu_si256((const __m256i*)q3); q3 += 32;
// prepare low and high bits
const __m256i q3l_0 = _mm256_and_si256(q3bits, m3);
const __m256i q3h_0 = _mm256_slli_epi16(_mm256_srli_epi16(_mm256_andnot_si256(hbits, _mm256_slli_epi16(mone, bit)), bit), 2);
++bit;
const __m256i q3l_1 = _mm256_and_si256(_mm256_srli_epi16(q3bits, 2), m3);
const __m256i q3h_1 = _mm256_slli_epi16(_mm256_srli_epi16(_mm256_andnot_si256(hbits, _mm256_slli_epi16(mone, bit)), bit), 2);
++bit;
const __m256i q3l_2 = _mm256_and_si256(_mm256_srli_epi16(q3bits, 4), m3);
const __m256i q3h_2 = _mm256_slli_epi16(_mm256_srli_epi16(_mm256_andnot_si256(hbits, _mm256_slli_epi16(mone, bit)), bit), 2);
++bit;
const __m256i q3l_3 = _mm256_and_si256(_mm256_srli_epi16(q3bits, 6), m3);
const __m256i q3h_3 = _mm256_slli_epi16(_mm256_srli_epi16(_mm256_andnot_si256(hbits, _mm256_slli_epi16(mone, bit)), bit), 2);
++bit;
// load Q8 quants
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;
// Dot product: we multiply the 2 low bits and 1 high bit part separately, so we can use _mm256_maddubs_epi16,
// and then subtract. The high bit part has the 2 already subtracted (and so, it is zero if the high bit was not set,
// and 2 if the high bit was set)
__m256i q8s_0 = _mm256_maddubs_epi16(q3h_0, q8_0);
__m256i q8s_1 = _mm256_maddubs_epi16(q3h_1, q8_1);
__m256i q8s_2 = _mm256_maddubs_epi16(q3h_2, q8_2);
__m256i q8s_3 = _mm256_maddubs_epi16(q3h_3, q8_3);
__m256i p16_0 = _mm256_maddubs_epi16(q3l_0, q8_0);
__m256i p16_1 = _mm256_maddubs_epi16(q3l_1, q8_1);
__m256i p16_2 = _mm256_maddubs_epi16(q3l_2, q8_2);
__m256i p16_3 = _mm256_maddubs_epi16(q3l_3, q8_3);
p16_0 = _mm256_sub_epi16(p16_0, q8s_0);
p16_1 = _mm256_sub_epi16(p16_1, q8s_1);
p16_2 = _mm256_sub_epi16(p16_2, q8s_2);
p16_3 = _mm256_sub_epi16(p16_3, q8s_3);
// multiply with scales
p16_0 = _mm256_madd_epi16(_mm256_shuffle_epi8(scales[j], get_scale_shuffle_q3k(is + 0)), p16_0);
p16_1 = _mm256_madd_epi16(_mm256_shuffle_epi8(scales[j], get_scale_shuffle_q3k(is + 1)), p16_1);
p16_2 = _mm256_madd_epi16(_mm256_shuffle_epi8(scales[j], get_scale_shuffle_q3k(is + 2)), p16_2);
p16_3 = _mm256_madd_epi16(_mm256_shuffle_epi8(scales[j], get_scale_shuffle_q3k(is + 3)), p16_3);
// accumulate
p16_0 = _mm256_add_epi32(p16_0, p16_1);
p16_2 = _mm256_add_epi32(p16_2, p16_3);
sumi = _mm256_add_epi32(sumi, _mm256_add_epi32(p16_0, p16_2));
}
// multiply with block scale and accumulate
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(3);
const __m128i mone = _mm_set1_epi8(1);
const __m128i m32 = _mm_set1_epi8(32);
const __m128i m2 = _mm_set1_epi8(2);
__m256 acc = _mm256_setzero_ps();
const uint32_t *aux;
for (int i = 0; i < nb; ++i) {
const float d = y[i].d * GGML_FP16_TO_FP32(x[i].d);
const uint8_t * GGML_RESTRICT q3 = x[i].qs;
const int8_t * GGML_RESTRICT q8 = y[i].qs;
// Set up scales
aux = (const uint32_t *)x[i].scales;
__m128i scales128 = _mm_set_epi32(
((aux[1] >> 4) & kmask2) | (((aux[2] >> 6) & kmask1) << 4),
((aux[0] >> 4) & kmask2) | (((aux[2] >> 4) & kmask1) << 4),
(aux[1] & kmask2) | (((aux[2] >> 2) & kmask1) << 4),
(aux[0] & kmask2) | (((aux[2] >> 0) & kmask1) << 4));
scales128 = _mm_sub_epi8(scales128, m32);
const __m128i scales_0 = _mm_cvtepi8_epi16(scales128);
const __m128i scales_1 = _mm_cvtepi8_epi16(_mm_unpackhi_epi64(scales128, scales128));
const __m128i scales[2] = { scales_0, scales_1 };
// high bit *128*2 from block_q3_K.hmask[QK_K/8]
const __m128i hbits_0 = _mm_loadu_si128((const __m128i*)&x[i].hmask[0]);
const __m128i hbits_1 = _mm_loadu_si128((const __m128i*)&x[i].hmask[16]);
// integer accumulator
__m128i sumi_0 = _mm_setzero_si128();
__m128i sumi_1 = _mm_setzero_si128();
for (int j = 0; j < QK_K/128; ++j) {
// load low 2 bits *64*2 from block_q3_K.qs[QK_K/4]
const __m128i q3bits_0 = _mm_loadu_si128((const __m128i*)q3); q3 += 16;
const __m128i q3bits_1 = _mm_loadu_si128((const __m128i*)q3); q3 += 16;
// prepare low and high bits
const int bit = j << 2;
const __m128i q3l_0 = _mm_and_si128(q3bits_0, m3);
const __m128i q3l_1 = _mm_and_si128(q3bits_1, m3);
const __m128i q3h_0 = _mm_slli_epi16(_mm_srli_epi16(_mm_andnot_si128(hbits_0, _mm_slli_epi16(mone, bit)), bit), 2);
const __m128i q3h_1 = _mm_slli_epi16(_mm_srli_epi16(_mm_andnot_si128(hbits_1, _mm_slli_epi16(mone, bit)), bit), 2);
const __m128i q3l_2 = _mm_and_si128(_mm_srli_epi16(q3bits_0, 2), m3);
const __m128i q3l_3 = _mm_and_si128(_mm_srli_epi16(q3bits_1, 2), m3);
const __m128i q3h_2 = _mm_slli_epi16(_mm_srli_epi16(_mm_andnot_si128(hbits_0, _mm_slli_epi16(mone, bit+1)), bit+1), 2);
const __m128i q3h_3 = _mm_slli_epi16(_mm_srli_epi16(_mm_andnot_si128(hbits_1, _mm_slli_epi16(mone, bit+1)), bit+1), 2);
const __m128i q3l_4 = _mm_and_si128(_mm_srli_epi16(q3bits_0, 4), m3);
const __m128i q3l_5 = _mm_and_si128(_mm_srli_epi16(q3bits_1, 4), m3);
const __m128i q3h_4 = _mm_slli_epi16(_mm_srli_epi16(_mm_andnot_si128(hbits_0, _mm_slli_epi16(mone, bit+2)), bit+2), 2);
const __m128i q3h_5 = _mm_slli_epi16(_mm_srli_epi16(_mm_andnot_si128(hbits_1, _mm_slli_epi16(mone, bit+2)), bit+2), 2);
const __m128i q3l_6 = _mm_and_si128(_mm_srli_epi16(q3bits_0, 6), m3);
const __m128i q3l_7 = _mm_and_si128(_mm_srli_epi16(q3bits_1, 6), m3);
const __m128i q3h_6 = _mm_slli_epi16(_mm_srli_epi16(_mm_andnot_si128(hbits_0, _mm_slli_epi16(mone, bit+3)), bit+3), 2);
const __m128i q3h_7 = _mm_slli_epi16(_mm_srli_epi16(_mm_andnot_si128(hbits_1, _mm_slli_epi16(mone, bit+3)), bit+3), 2);
// load Q8 quants 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;
// Dot product: we multiply the 2 low bits and 1 high bit part separately, so we can use _mm256_maddubs_epi16,
// and then subtract. The high bit part has the 2 already subtracted (and so, it is zero if the high bit was not set,
// and 2 if the high bit was set)
__m128i q8s_0 = _mm_maddubs_epi16(q3h_0, q8_0);
__m128i q8s_1 = _mm_maddubs_epi16(q3h_1, q8_1);
__m128i q8s_2 = _mm_maddubs_epi16(q3h_2, q8_2);
__m128i q8s_3 = _mm_maddubs_epi16(q3h_3, q8_3);
__m128i q8s_4 = _mm_maddubs_epi16(q3h_4, q8_4);
__m128i q8s_5 = _mm_maddubs_epi16(q3h_5, q8_5);
__m128i q8s_6 = _mm_maddubs_epi16(q3h_6, q8_6);
__m128i q8s_7 = _mm_maddubs_epi16(q3h_7, q8_7);
__m128i p16_0 = _mm_maddubs_epi16(q3l_0, q8_0);
__m128i p16_1 = _mm_maddubs_epi16(q3l_1, q8_1);
__m128i p16_2 = _mm_maddubs_epi16(q3l_2, q8_2);
__m128i p16_3 = _mm_maddubs_epi16(q3l_3, q8_3);
__m128i p16_4 = _mm_maddubs_epi16(q3l_4, q8_4);
__m128i p16_5 = _mm_maddubs_epi16(q3l_5, q8_5);
__m128i p16_6 = _mm_maddubs_epi16(q3l_6, q8_6);
__m128i p16_7 = _mm_maddubs_epi16(q3l_7, q8_7);
p16_0 = _mm_sub_epi16(p16_0, q8s_0);
p16_1 = _mm_sub_epi16(p16_1, q8s_1);
p16_2 = _mm_sub_epi16(p16_2, q8s_2);
p16_3 = _mm_sub_epi16(p16_3, q8s_3);
p16_4 = _mm_sub_epi16(p16_4, q8s_4);
p16_5 = _mm_sub_epi16(p16_5, q8s_5);
p16_6 = _mm_sub_epi16(p16_6, q8s_6);
p16_7 = _mm_sub_epi16(p16_7, q8s_7);
// multiply with scales
__m128i shuffle = _mm_set1_epi16(0x0100);
p16_0 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p16_0);
shuffle = _mm_add_epi16(shuffle, m2);
p16_1 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p16_1);
shuffle = _mm_add_epi16(shuffle, m2);
p16_2 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p16_2);
shuffle = _mm_add_epi16(shuffle, m2);
p16_3 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p16_3);
shuffle = _mm_add_epi16(shuffle, m2);
p16_4 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p16_4);
shuffle = _mm_add_epi16(shuffle, m2);
p16_5 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p16_5);
shuffle = _mm_add_epi16(shuffle, m2);
p16_6 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p16_6);
shuffle = _mm_add_epi16(shuffle, m2);
p16_7 = _mm_madd_epi16(_mm_shuffle_epi8(scales[j], shuffle), p16_7);
// accumulate
p16_0 = _mm_add_epi32(p16_0, p16_1);
p16_2 = _mm_add_epi32(p16_2, p16_3);
p16_4 = _mm_add_epi32(p16_4, p16_5);
p16_6 = _mm_add_epi32(p16_6, p16_7);
sumi_0 = _mm_add_epi32(sumi_0, _mm_add_epi32(p16_0, p16_2));
sumi_1 = _mm_add_epi32(sumi_1, _mm_add_epi32(p16_4, p16_6));
}
// multiply with block scale and accumulate
__m256i sumi = MM256_SET_M128I(sumi_1, sumi_0);
acc = _mm256_add_ps(_mm256_mul_ps(_mm256_broadcast_ss(&d), _mm256_cvtepi32_ps(sumi)), acc);
}
*s = hsum_float_8(acc);
#elif defined __wasm_simd128__
int8_t aux8[QK_K];
float sums[8] = {0};
uint32_t auxs[4];
float sumf = 0;
for (int i = 0; i < nb; ++i) {
const uint8_t * GGML_RESTRICT q3 = x[i].qs;
const uint8_t * GGML_RESTRICT hm = x[i].hmask;
const int8_t * GGML_RESTRICT q8 = y[i].qs;
// Process blocks with SIMD
int8_t * a = aux8;
uint8_t m = 1;
for (int j = 0; j < QK_K; j += 128) {
for (int shift = 0; shift <= 6; shift += 2) {
v128_t v_m = wasm_i8x16_splat(m);
for (int l = 0; l < 32; l += 16) {
v128_t v_q3 = wasm_v128_load(q3 + l);
v128_t v_shift = wasm_i8x16_shr(v_q3, shift);
v128_t v_low2 = wasm_v128_and(v_shift, wasm_i8x16_splat(0x03));
v128_t v_hm = wasm_v128_load(hm + l);
v128_t v_mask = wasm_v128_and(v_hm, v_m);
v_mask = wasm_i8x16_ne(v_mask, wasm_i8x16_splat(0));
v_low2 = wasm_i8x16_sub(v_low2, wasm_v128_and(wasm_i8x16_splat(4), wasm_v128_not(v_mask)));
wasm_v128_store(a + l, v_low2);
}
a += 32;
m <<= 1;
}
q3 += 32;
}
// Extract scales
memcpy(auxs, x[i].scales, 12);
uint32_t tmp = auxs[2];
auxs[2] = ((auxs[0] >> 4) & kmask2) | (((tmp >> 4) & kmask1) << 4);
auxs[3] = ((auxs[1] >> 4) & kmask2) | (((tmp >> 6) & kmask1) << 4);
auxs[0] = (auxs[0] & kmask2) | (((tmp >> 0) & kmask1) << 4);
auxs[1] = (auxs[1] & kmask2) | (((tmp >> 2) & kmask1) << 4);
const int8_t * scales = (const int8_t *)auxs;
// SIMD dot product with register accumulators
v128_t v_acc0 = wasm_i32x4_splat(0);
v128_t v_acc1 = wasm_i32x4_splat(0);
a = aux8;
for (int j = 0; j < QK_K/16; ++j) {
const v128_t v_scale = wasm_i16x8_splat(scales[j] - 32);
// Process 16 elements per iteration
for (int k = 0; k < 2; ++k) {
const v128_t v_q8 = wasm_i16x8_load8x8(q8);
const v128_t v_a = wasm_i16x8_load8x8(a);
v128_t v_prod = wasm_i16x8_mul(v_q8, v_a);
v_prod = wasm_i16x8_mul(v_prod, v_scale);
v_acc0 = wasm_i32x4_add(v_acc0, wasm_i32x4_extend_low_i16x8(v_prod));
v_acc1 = wasm_i32x4_add(v_acc1, wasm_i32x4_extend_high_i16x8(v_prod));
q8 += 8;
a += 8;
}
}
// Accumulate results
const float d = GGML_FP16_TO_FP32(x[i].d) * y[i].d;
const v128_t v_d = wasm_f32x4_splat(d);
v128_t v_sum = wasm_f32x4_add(
wasm_f32x4_mul(wasm_f32x4_convert_i32x4(v_acc0), v_d),
wasm_f32x4_mul(wasm_f32x4_convert_i32x4(v_acc1), v_d)
);
// Accumulate into sums vector
wasm_v128_store(sums, wasm_f32x4_add(wasm_v128_load(sums), v_sum));
}
// Horizontal sum
v128_t v_sum = wasm_f32x4_add(wasm_v128_load(sums), wasm_v128_load(sums + 4));
sumf = wasm_f32x4_extract_lane(v_sum, 0) +
wasm_f32x4_extract_lane(v_sum, 1) +
wasm_f32x4_extract_lane(v_sum, 2) +
wasm_f32x4_extract_lane(v_sum, 3);
*s = sumf;
#elif defined __riscv_v_intrinsic
uint32_t aux[3];
uint32_t utmp[4];
const int vector_length = __riscv_vlenb() * 8;
float sumf = 0;
switch (vector_length) {
case 256:
for (int i = 0; i < nb; ++i) {
const uint8_t * GGML_RESTRICT q3 = x[i].qs;
const uint8_t * GGML_RESTRICT qh = x[i].hmask;
const int8_t * GGML_RESTRICT q8 = y[i].qs;
memcpy(aux, x[i].scales, 12);
utmp[3] = ((aux[1] >> 4) & kmask2) | (((aux[2] >> 6) & kmask1) << 4);
utmp[2] = ((aux[0] >> 4) & kmask2) | (((aux[2] >> 4) & kmask1) << 4);
utmp[1] = (aux[1] & kmask2) | (((aux[2] >> 2) & kmask1) << 4);
utmp[0] = (aux[0] & kmask2) | (((aux[2] >> 0) & kmask1) << 4);
int8_t * scale = (int8_t *)utmp;
for (int j = 0; j < 16; ++j) scale[j] -= 32;
size_t vl = 32;
uint8_t m = 1;
vint32m1_t vzero = __riscv_vmv_v_x_i32m1(0, 1);
vuint8m1_t vqh = __riscv_vle8_v_u8m1(qh, vl);
int sum_t = 0;
for (int j = 0; j < QK_K; j += 128) {
vl = 32;
// load Q3
vuint8m1_t q3_x = __riscv_vle8_v_u8m1(q3, vl);
vint8m1_t q3_0 = __riscv_vreinterpret_v_u8m1_i8m1(__riscv_vand_vx_u8m1(q3_x, 0x03, vl));
vint8m1_t q3_1 = __riscv_vreinterpret_v_u8m1_i8m1(__riscv_vand_vx_u8m1(__riscv_vsrl_vx_u8m1(q3_x, 0x2, vl), 0x03 , vl));
vint8m1_t q3_2 = __riscv_vreinterpret_v_u8m1_i8m1(__riscv_vand_vx_u8m1(__riscv_vsrl_vx_u8m1(q3_x, 0x4, vl), 0x03 , vl));
vint8m1_t q3_3 = __riscv_vreinterpret_v_u8m1_i8m1(__riscv_vand_vx_u8m1(__riscv_vsrl_vx_u8m1(q3_x, 0x6, vl), 0x03 , vl));
// compute mask for subtraction
vuint8m1_t qh_m0 = __riscv_vand_vx_u8m1(vqh, m, vl);
vbool8_t vmask_0 = __riscv_vmseq_vx_u8m1_b8(qh_m0, 0, vl);
vint8m1_t q3_m0 = __riscv_vsub_vx_i8m1_mu(vmask_0, q3_0, q3_0, 0x4, vl);
m <<= 1;
vuint8m1_t qh_m1 = __riscv_vand_vx_u8m1(vqh, m, vl);
vbool8_t vmask_1 = __riscv_vmseq_vx_u8m1_b8(qh_m1, 0, vl);
vint8m1_t q3_m1 = __riscv_vsub_vx_i8m1_mu(vmask_1, q3_1, q3_1, 0x4, vl);
m <<= 1;
vuint8m1_t qh_m2 = __riscv_vand_vx_u8m1(vqh, m, vl);
vbool8_t vmask_2 = __riscv_vmseq_vx_u8m1_b8(qh_m2, 0, vl);
vint8m1_t q3_m2 = __riscv_vsub_vx_i8m1_mu(vmask_2, q3_2, q3_2, 0x4, vl);
m <<= 1;
vuint8m1_t qh_m3 = __riscv_vand_vx_u8m1(vqh, m, vl);
vbool8_t vmask_3 = __riscv_vmseq_vx_u8m1_b8(qh_m3, 0, vl);
vint8m1_t q3_m3 = __riscv_vsub_vx_i8m1_mu(vmask_3, q3_3, q3_3, 0x4, vl);
m <<= 1;
// load Q8 and take product with Q3
vint16m2_t a0 = __riscv_vwmul_vv_i16m2(q3_m0, __riscv_vle8_v_i8m1(q8, vl), vl);
vint16m2_t a1 = __riscv_vwmul_vv_i16m2(q3_m1, __riscv_vle8_v_i8m1(q8+32, vl), vl);
vint16m2_t a2 = __riscv_vwmul_vv_i16m2(q3_m2, __riscv_vle8_v_i8m1(q8+64, vl), vl);
vint16m2_t a3 = __riscv_vwmul_vv_i16m2(q3_m3, __riscv_vle8_v_i8m1(q8+96, vl), vl);
vl = 16;
// retrieve lane to multiply with scale
vint32m2_t aux0_0 = __riscv_vwmul_vx_i32m2(__riscv_vget_v_i16m2_i16m1(a0, 0), (scale[0]), vl);
vint32m2_t aux0_1 = __riscv_vwmul_vx_i32m2(__riscv_vget_v_i16m2_i16m1(a0, 1), (scale[1]), vl);
vint32m2_t aux1_0 = __riscv_vwmul_vx_i32m2(__riscv_vget_v_i16m2_i16m1(a1, 0), (scale[2]), vl);
vint32m2_t aux1_1 = __riscv_vwmul_vx_i32m2(__riscv_vget_v_i16m2_i16m1(a1, 1), (scale[3]), vl);
vint32m2_t aux2_0 = __riscv_vwmul_vx_i32m2(__riscv_vget_v_i16m2_i16m1(a2, 0), (scale[4]), vl);
vint32m2_t aux2_1 = __riscv_vwmul_vx_i32m2(__riscv_vget_v_i16m2_i16m1(a2, 1), (scale[5]), vl);
vint32m2_t aux3_0 = __riscv_vwmul_vx_i32m2(__riscv_vget_v_i16m2_i16m1(a3, 0), (scale[6]), vl);
vint32m2_t aux3_1 = __riscv_vwmul_vx_i32m2(__riscv_vget_v_i16m2_i16m1(a3, 1), (scale[7]), vl);
vint32m1_t isum0 = __riscv_vredsum_vs_i32m2_i32m1(__riscv_vadd_vv_i32m2(aux0_0, aux0_1, vl), vzero, vl);
vint32m1_t isum1 = __riscv_vredsum_vs_i32m2_i32m1(__riscv_vadd_vv_i32m2(aux1_0, aux1_1, vl), isum0, vl);
vint32m1_t isum2 = __riscv_vredsum_vs_i32m2_i32m1(__riscv_vadd_vv_i32m2(aux2_0, aux2_1, vl), isum1, vl);
vint32m1_t isum3 = __riscv_vredsum_vs_i32m2_i32m1(__riscv_vadd_vv_i32m2(aux3_0, aux3_1, vl), isum2, vl);
sum_t += __riscv_vmv_x_s_i32m1_i32(isum3);
q3 += 32; q8 += 128; scale += 8;
}
const float d = GGML_FP16_TO_FP32(x[i].d) * y[i].d;
sumf += d*sum_t;
}
break;
case 128:
for (int i = 0; i < nb; ++i) {
const uint8_t * restrict q3 = x[i].qs;
const uint8_t * restrict qh = x[i].hmask;
const int8_t * restrict q8 = y[i].qs;
int8_t * scale = (int8_t *)utmp;
int tmp;
__asm__ __volatile__(
"vsetivli zero, 12, e8, m1\n\t"
"vle8.v v0, (%[s6b])\n\t"
"vmv1r.v v2, v0\n\t"
"vsetivli zero, 2, e64, m1\n\t"
"vmv.v.x v9, %[sh]\n\t"\
"vslidedown.vi v1, v0, 1\n\t"
"vslide1up.vx v8, v9, zero\n\t" // {0, 0, 4, 4}
"vslideup.vi v0, v2, 1\n\t" // {aux[0], aux[1], aux[0], aux[1]}
"vsetivli zero, 4, e32, m1\n\t"
"vid.v v9\n\t"
"vmv.x.s %[tmp], v1\n\t"
"vsll.vi v9, v9, 1\n\t" // {0, 2, 4, 6}
"vmv.v.x v1, %[tmp]\n\t" // {aux[2], aux[2], aux[2], aux[2]}
"vsrl.vv v4, v1, v9\n\t"
"vsrl.vv v2, v0, v8\n\t"
"vand.vx v5, v4, %[kmask1]\n\t"
"vand.vx v3, v2, %[kmask2]\n\t"
"vsll.vi v6, v5, 4\n\t"
"vor.vv v7, v6, v3\n\t"
"vsetivli zero, 16, e8, m1\n\t"
"vsub.vx v0, v7, %[c]\n\t"
"vse8.v v0, (%[scale])"
: [tmp] "=&r" (tmp)
: [sh] "r" (0x0000000400000004), [s6b] "r" (x[i].scales), [c] "r" (32)
, [scale] "r" (scale), [kmask1] "r" (kmask1), [kmask2] "r" (kmask2)
: "memory"
, "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7"
, "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15"
, "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23"
, "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31"
);
uint8_t m = 1;
int isum = 0;
for (int j = 0; j < QK_K; j += 128) {
__asm__ __volatile__(
"vsetvli zero, %[vl32], e8, m2, ta, mu\n\t"
"vle8.v v8, (%[q3])\n\t"
"vsrl.vi v10, v8, 2\n\t"
"vsrl.vi v12, v8, 4\n\t"
"vsrl.vi v14, v8, 6\n\t"
"vand.vi v8, v8, 3\n\t"
"vand.vi v10, v10, 3\n\t"
"vand.vi v12, v12, 3\n\t"
"vle8.v v2, (%[qh])\n\t"
"vand.vx v4, v2, %[m]\n\t"
"slli %[m], %[m], 1\n\t"
"vmseq.vx v0, v4, zero\n\t"
"vadd.vi v8, v8, -4, v0.t\n\t"
"vand.vx v4, v2, %[m]\n\t"
"slli %[m], %[m], 1\n\t"
"vmseq.vx v0, v4, zero\n\t"
"vadd.vi v10, v10, -4, v0.t\n\t"
"vand.vx v4, v2, %[m]\n\t"
"slli %[m], %[m], 1\n\t"
"vmseq.vx v0, v4, zero\n\t"
"vadd.vi v12, v12, -4, v0.t\n\t"
"vand.vx v4, v2, %[m]\n\t"
"slli %[m], %[m], 1\n\t"
"vmseq.vx v0, v4, zero\n\t"
"vadd.vi v14, v14, -4, v0.t\n\t"
"vsetvli zero, %[vl128], e8, m8\n\t"
"vle8.v v0, (%[q8])\n\t"
"vsetvli zero, %[vl64], e8, m4\n\t"
"vwmul.vv v16, v0, v8\n\t"
"vwmul.vv v24, v4, v12\n\t"
"vsetivli zero, 16, e16, m2\n\t"
"vmv.v.x v0, zero\n\t"
"vwredsum.vs v10, v16, v0\n\t"
"vwredsum.vs v9, v18, v0\n\t"
"vwredsum.vs v8, v20, v0\n\t"
"vwredsum.vs v7, v22, v0\n\t"
"vwredsum.vs v11, v24, v0\n\t"
"vwredsum.vs v12, v26, v0\n\t"
"vwredsum.vs v13, v28, v0\n\t"
"vwredsum.vs v14, v30, v0\n\t"
"vsetivli zero, 4, e32, m1\n\t"
"vslideup.vi v10, v9, 1\n\t"
"vslideup.vi v8, v7, 1\n\t"
"vslideup.vi v11, v12, 1\n\t"
"vslideup.vi v13, v14, 1\n\t"
"vslideup.vi v10, v8, 2\n\t"
"vslideup.vi v11, v13, 2\n\t"
"vsetivli zero, 8, e32, m2\n\t"\
"vle8.v v15, (%[scale])\n\t"
"vsext.vf4 v12, v15\n\t"
"vmul.vv v10, v10, v12\n\t"
"vredsum.vs v0, v10, v0\n\t"
"vmv.x.s %[tmp], v0\n\t"
"add %[isum], %[isum], %[tmp]"
: [tmp] "=&r" (tmp), [m] "+&r" (m), [isum] "+&r" (isum)
: [vl128] "r" (128), [vl64] "r" (64), [vl32] "r" (32)
, [q3] "r" (q3), [qh] "r" (qh), [scale] "r" (scale), [q8] "r" (q8)
: "memory"
, "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7"
, "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15"
, "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23"
, "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31"
);
q3 += 32; q8 += 128; scale += 8;
}
const float d = GGML_FP16_TO_FP32(x[i].d) * y[i].d;
sumf += d * isum;
}
break;
default:
assert(false && "Unsupported vector length");
break;
}
*s = sumf;
#elif defined(__POWER9_VECTOR__)
const vector signed char lowMask = vec_splats((signed char)0x3);
const vector signed char lowMask1 = vec_splats((int8_t)0xf);
const vector signed char lowMask2 = vec_splats((int8_t)0x30);
const vector int v0 = vec_splats((int32_t)0);
const vector signed char v1 = vec_splats((signed char)0x1);
const vector unsigned char v2 = vec_splats((unsigned char)0x2);
const vector unsigned char v3 = vec_splats((unsigned char)0x3);
const vector unsigned char v4 = vec_splats((unsigned char)0x4);
const vector unsigned char v6 = vec_splats((unsigned char)0x6);
const vector signed char off = vec_splats((signed char)0x20);
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);
UNUSED(kmask1);
UNUSED(kmask2);
vector signed char u0 = (vector signed char)vec_xl_len(x[i].scales, 8);
vector signed char u1 = vec_and(u0, lowMask1);
vector signed char u2 = (vector signed char)vec_xl_len(x[i].scales + 8, 4);
vector signed char u3 = (vector signed char)vec_mergeh((vector signed int)u2, (vector signed int)vec_sr(u2, v2));
vector signed char u30 = vec_sl(vec_and(u3, lowMask), v4);
vector signed char u31 = vec_and(u3, lowMask2);
u1 = vec_or(u1, u30);
u2 = vec_or(vec_sr(u0, v4), u31);
vector signed char vscales = (vector signed char)vec_mergeh((vector signed long long)u1, (vector signed long long)u2);
vector signed char qxhs0 = (vector signed char)vec_xl( 0, x[i].hmask);
vector signed char qxhs1 = (vector signed char)vec_xl(16, x[i].hmask);
vscales = vec_sub(vscales, off);
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 * GGML_RESTRICT q3 = x[i].qs;
const int8_t * GGML_RESTRICT q8 = y[i].qs;
for (int j = 0; j < QK_K/128; ++j) {
__builtin_prefetch(q3, 0, 1);
__builtin_prefetch(q8, 0, 1);
vector signed char qxs0 = (vector signed char)vec_xl( 0, q3);
vector signed char qxs1 = (vector signed char)vec_xl(16, q3);
q3 += 32;
//the low 2 bits
vector signed char qxs00 = vec_and(qxs0, lowMask);
vector signed char qxs01 = vec_and(vec_sr(qxs0, v2), lowMask);
vector signed char qxs02 = vec_and(vec_sr(qxs0, v4), lowMask);
vector signed char qxs03 = vec_and(vec_sr(qxs0, v6), lowMask);
vector signed char qxs10 = vec_and(qxs1, lowMask);
vector signed char qxs11 = vec_and(vec_sr(qxs1, v2), lowMask);
vector signed char qxs12 = vec_and(vec_sr(qxs1, v4), lowMask);
vector signed char qxs13 = vec_and(vec_sr(qxs1, v6), lowMask);
//the 3rd bit
vector signed char qxh00 = vec_sl(vec_andc(v1, qxhs0), v2);
vector signed char qxh01 = vec_sl(vec_andc(v1, vec_sr(qxhs0, (vector unsigned char)v1)), v2);
vector signed char qxh02 = vec_sl(vec_andc(v1, vec_sr(qxhs0, v2)), v2);
vector signed char qxh03 = vec_sl(vec_andc(v1, vec_sr(qxhs0, v3)), v2);
vector signed char qxh10 = vec_sl(vec_andc(v1, qxhs1), v2);
vector signed char qxh11 = vec_sl(vec_andc(v1, vec_sr(qxhs1, (vector unsigned char)v1)), v2);
vector signed char qxh12 = vec_sl(vec_andc(v1, vec_sr(qxhs1, v2)), v2);
vector signed char qxh13 = vec_sl(vec_andc(v1, vec_sr(qxhs1, v3)), v2);
qxhs0 = vec_sr(qxhs0, v4);
qxhs1 = vec_sr(qxhs1, v4);
vector signed char q3x00 = vec_sub(qxs00, qxh00);
vector signed char q3x01 = vec_sub(qxs01, qxh01);
vector signed char q3x02 = vec_sub(qxs02, qxh02);
vector signed char q3x03 = vec_sub(qxs03, qxh03);
vector signed char q3x10 = vec_sub(qxs10, qxh10);
vector signed char q3x11 = vec_sub(qxs11, qxh11);
vector signed char q3x12 = vec_sub(qxs12, qxh12);
vector signed char q3x13 = vec_sub(qxs13, qxh13);
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 short vscales_h = vec_unpackh(vscales);
vector signed short vs0 = vec_splat(vscales_h, 0);
vector signed short vs1 = vec_splat(vscales_h, 1);
vector signed short vs2 = vec_splat(vscales_h, 2);
vector signed short vs3 = vec_splat(vscales_h, 3);
vector signed short vs4 = vec_splat(vscales_h, 4);
vector signed short vs5 = vec_splat(vscales_h, 5);
vector signed short vs6 = vec_splat(vscales_h, 6);
vector signed short vs7 = vec_splat(vscales_h, 7);
vscales = vec_sld(vscales, vscales, 8);
vector signed short qv00 = vec_add(vec_mule(q3x00, q8y00), vec_mulo(q3x00, q8y00));
vector signed short qv01 = vec_add(vec_mule(q3x01, q8y01), vec_mulo(q3x01, q8y01));
vector signed short qv02 = vec_add(vec_mule(q3x02, q8y02), vec_mulo(q3x02, q8y02));
vector signed short qv03 = vec_add(vec_mule(q3x03, q8y03), vec_mulo(q3x03, q8y03));
vector signed short qv10 = vec_add(vec_mule(q3x10, q8y10), vec_mulo(q3x10, q8y10));
vector signed short qv11 = vec_add(vec_mule(q3x11, q8y11), vec_mulo(q3x11, q8y11));
vector signed short qv12 = vec_add(vec_mule(q3x12, q8y12), vec_mulo(q3x12, q8y12));
vector signed short qv13 = vec_add(vec_mule(q3x13, q8y13), vec_mulo(q3x13, q8y13));
vsumi0 = vec_msum(qv00, vs0, vsumi0);
vsumi1 = vec_msum(qv01, vs2, vsumi1);
vsumi2 = vec_msum(qv02, vs4, vsumi2);
vsumi3 = vec_msum(qv03, vs6, vsumi3);
vsumi4 = vec_msum(qv10, vs1, vsumi4);
vsumi5 = vec_msum(qv11, vs3, vsumi5);
vsumi6 = vec_msum(qv12, vs5, vsumi6);
vsumi7 = vec_msum(qv13, 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 __m128i m32 = __lsx_vreplgr2vr_b(32);
__m256 acc = (__m256)__lasx_xvldi(0);
uint32_t aux[3];
for (int i = 0; i < nb; ++i) {
const float d = y[i].d * GGML_FP16_TO_FP32(x[i].d);
const uint8_t * GGML_RESTRICT q3 = x[i].qs;
const int8_t * GGML_RESTRICT q8 = y[i].qs;
// Set up scales
memcpy(aux, x[i].scales, 12);
__m128i scales128 = lsx_set_w(
((aux[1] >> 4) & kmask2) | (((aux[2] >> 6) & kmask1) << 4),
((aux[0] >> 4) & kmask2) | (((aux[2] >> 4) & kmask1) << 4),
(aux[1] & kmask2) | (((aux[2] >> 2) & kmask1) << 4),
(aux[0] & kmask2) | (((aux[2] >> 0) & kmask1) << 4));
scales128 = __lsx_vsub_b(scales128, m32);
const v16i8 shuffle_mask = {0, 2, 4, 6, 8, 10, 12, 14, 1, 3, 5, 7, 9, 11, 13, 15};
const __m256i scales_shuffled = lasx_ext8_16(__lsx_vshuf_b(scales128, scales128, (__m128i)shuffle_mask));
// high bit
const __m256i hbits = __lasx_xvld((const __m256i*)x[i].hmask, 0);
// integer accumulator
__m256i sumi = __lasx_xvldi(0);
for (int j = 0; j < QK_K/128; ++j) {
// load low 2 bits
const __m256i q3bits = __lasx_xvld((const __m256i*)q3, 0); q3 += 32;
// prepare low and high bits
const __m256i q3l_0 = __lasx_xvandi_b(q3bits, 3);
const __m256i q3l_1 = __lasx_xvandi_b(__lasx_xvsrli_b(q3bits, 2), 3);
const __m256i q3l_2 = __lasx_xvandi_b(__lasx_xvsrli_b(q3bits, 4), 3);
const __m256i q3l_3 = __lasx_xvsrli_b(q3bits, 6);
const __m256i q3h_0 = __lasx_xvslli_b(__lasx_xvseqi_b(lasx_xvandi_b_bit(hbits, 4 * j + 0), 0), 2);
const __m256i q3h_1 = __lasx_xvslli_b(__lasx_xvseqi_b(lasx_xvandi_b_bit(hbits, 4 * j + 1), 0), 2);
const __m256i q3h_2 = __lasx_xvslli_b(__lasx_xvseqi_b(lasx_xvandi_b_bit(hbits, 4 * j + 2), 0), 2);
const __m256i q3h_3 = __lasx_xvslli_b(__lasx_xvseqi_b(lasx_xvandi_b_bit(hbits, 4 * j + 3), 0), 2);
const __m256i q3_0 = __lasx_xvor_v(q3h_0, q3l_0);
const __m256i q3_1 = __lasx_xvor_v(q3h_1, q3l_1);
const __m256i q3_2 = __lasx_xvor_v(q3h_2, q3l_2);
const __m256i q3_3 = __lasx_xvor_v(q3h_3, q3l_3);
// load Q8 quants
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;
__m256i p16_0 = lasx_madd_h_b(q8_0, q3_0);
__m256i p16_1 = lasx_madd_h_b(q8_1, q3_1);
__m256i p16_2 = lasx_madd_h_b(q8_2, q3_2);
__m256i p16_3 = lasx_madd_h_b(q8_3, q3_3);
// multiply with scales
p16_0 = lasx_madd_h(lasx_xvrepl128vei_h(scales_shuffled, 4 * j + 0), p16_0);
p16_1 = lasx_madd_h(lasx_xvrepl128vei_h(scales_shuffled, 4 * j + 1), p16_1);
p16_2 = lasx_madd_h(lasx_xvrepl128vei_h(scales_shuffled, 4 * j + 2), p16_2);
p16_3 = lasx_madd_h(lasx_xvrepl128vei_h(scales_shuffled, 4 * j + 3), p16_3);
// accumulate
p16_0 = __lasx_xvadd_w(p16_0, p16_1);
p16_2 = __lasx_xvadd_w(p16_2, p16_3);
sumi = __lasx_xvadd_w(sumi, __lasx_xvadd_w(p16_0, p16_2));
}
// multiply with block scale and accumulate
acc = __lasx_xvfmadd_s(__lasx_xvreplfr2vr_s(d), __lasx_xvffint_s_w(sumi), acc);
}
*s = hsum_float_8(acc);
#else
// scalar version
// This function is written like this so the compiler can manage to vectorize most of it
// Using -Ofast, GCC and clang manage to produce code that is within a factor of 2 or so from the
// manually vectorized version above. Every other version I tried would run at least 4 times slower.
// The ideal situation would be if we could just write the code once, and the compiler would
// automatically produce the best possible set of machine instructions, instead of us having to manually
// write vectorized versions for AVX, ARM_NEON, etc.
int8_t aux8[QK_K];
int16_t aux16[8];
float sums [8];
int32_t aux32[8];
memset(sums, 0, 8*sizeof(float));
uint32_t auxs[4];
const int8_t * scales = (const int8_t*)auxs;
float sumf = 0;
for (int i = 0; i < nb; ++i) {
const uint8_t * GGML_RESTRICT q3 = x[i].qs;
const uint8_t * GGML_RESTRICT hm = x[i].hmask;
const int8_t * GGML_RESTRICT q8 = y[i].qs;
memset(aux32, 0, 8*sizeof(int32_t));
int8_t * GGML_RESTRICT a = aux8;
uint8_t m = 1;
for (int j = 0; j < QK_K; j += 128) {
for (int l = 0; l < 32; ++l) a[l] = q3[l] & 3;
for (int l = 0; l < 32; ++l) a[l] -= (hm[l] & m ? 0 : 4);
a += 32; m <<= 1;
for (int l = 0; l < 32; ++l) a[l] = (q3[l] >> 2) & 3;
for (int l = 0; l < 32; ++l) a[l] -= (hm[l] & m ? 0 : 4);
a += 32; m <<= 1;
for (int l = 0; l < 32; ++l) a[l] = (q3[l] >> 4) & 3;
for (int l = 0; l < 32; ++l) a[l] -= (hm[l] & m ? 0 : 4);
a += 32; m <<= 1;
for (int l = 0; l < 32; ++l) a[l] = (q3[l] >> 6) & 3;
for (int l = 0; l < 32; ++l) a[l] -= (hm[l] & m ? 0 : 4);
a += 32; m <<= 1;
q3 += 32;
}
a = aux8;
memcpy(auxs, x[i].scales, 12);
uint32_t tmp = auxs[2];
auxs[2] = ((auxs[0] >> 4) & kmask2) | (((tmp >> 4) & kmask1) << 4);
auxs[3] = ((auxs[1] >> 4) & kmask2) | (((tmp >> 6) & kmask1) << 4);
auxs[0] = (auxs[0] & kmask2) | (((tmp >> 0) & kmask1) << 4);
auxs[1] = (auxs[1] & kmask2) | (((tmp >> 2) & kmask1) << 4);
for (int j = 0; j < QK_K/16; ++j) {
for (int l = 0; l < 8; ++l) aux16[l] = q8[l] * a[l];
for (int l = 0; l < 8; ++l) aux32[l] += (scales[j] - 32) * aux16[l];
q8 += 8; a += 8;
for (int l = 0; l < 8; ++l) aux16[l] = q8[l] * a[l];
for (int l = 0; l < 8; ++l) aux32[l] += (scales[j] - 32) * aux16[l];
q8 += 8; a += 8;
}
const float d = GGML_FP16_TO_FP32(x[i].d) * y[i].d;
for (int l = 0; l < 8; ++l) sums[l] += d * aux32[l];
}
for (int l = 0; l < 8; ++l) sumf += sums[l];
*s = sumf;
#endif
}
|
O2
|
c
|
ggml_vec_dot_q3_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 0x20(%rcx), %rdx
vxorps %xmm0, %xmm0, %xmm0
xorl %edi, %edi
vpmovsxbq 0x28119(%rip), %xmm18 # 0x45741
vpbroadcastq 0x280b7(%rip), %xmm2 # 0x456e8
vmovdqa64 0x30ac5(%rip), %xmm19 # 0x4e100
movq 0x3991e(%rip), %r8 # 0x56f60
vmovdqa 0x30ac6(%rip), %xmm4 # 0x4e110
vpbroadcastb 0x280e9(%rip), %xmm5 # 0x4573c
vpcmpeqd %ymm6, %ymm6, %ymm6
vpbroadcastw 0x280de(%rip), %ymm7 # 0x4573e
vpbroadcastb 0x280d7(%rip), %ymm8 # 0x45740
vmovdqa 0x27e2f(%rip), %ymm9 # 0x454a0
vmovdqa 0x27e47(%rip), %ymm10 # 0x454c0
vmovdqa 0x27e5f(%rip), %ymm11 # 0x454e0
vmovdqa 0x27e77(%rip), %ymm12 # 0x45500
cmpq %rax, %rdi
je 0x1d8d7
imulq $0x124, %rdi, %r10 # imm = 0x124
addq %r9, %r10
addq $0x4, %r10
vmovss -0x4(%r10), %xmm13
imulq $0x6e, %rdi, %r11
movzwl 0x6c(%rcx,%r11), %ebx
vmovss (%r8,%rbx,4), %xmm14
movl 0x60(%rcx,%r11), %ebx
movq 0x64(%rcx,%r11), %r14
vmovq %r14, %xmm15
shrl $0x4, %r14d
vmovd %ebx, %xmm16
vpsrlq $0x20, %xmm15, %xmm17
vpermt2d %xmm16, %xmm18, %xmm15
vpinsrd $0x3, %r14d, %xmm15, %xmm15
vpinsrd $0x1, %ebx, %xmm17, %xmm16
vpshufd $0x10, %xmm16, %xmm16 # xmm16 = xmm16[0,0,1,0]
vpsllvd %xmm2, %xmm16, %xmm1
vpsrlvd %xmm2, %xmm16, %xmm3
vpblendd $0xc, %xmm3, %xmm1, %xmm1 # xmm1 = xmm1[0,1],xmm3[2,3]
vpandd %xmm19, %xmm1, %xmm1
vpternlogd $0xf8, %xmm4, %xmm15, %xmm1
vpaddb %xmm5, %xmm1, %xmm1
vpmovsxbw %xmm1, %ymm1
vpermq $0x44, %ymm1, %ymm3 # ymm3 = ymm1[0,1,0,1]
vmovdqa %ymm3, (%rsp)
vpermq $0xee, %ymm1, %ymm1 # ymm1 = ymm1[2,3,2,3]
vmovdqa %ymm1, 0x20(%rsp)
vpxorq (%rcx,%r11), %ymm6, %ymm16
vpxor %xmm15, %xmm15, %xmm15
xorl %r11d, %r11d
cmpq $0x8, %r11
je 0x1d8b7
vmovdqu (%rdx,%r11,8), %ymm1
vmovd %r11d, %xmm3
vpsllw %xmm3, %ymm7, %ymm17
vpandq %ymm16, %ymm17, %ymm17
vpsrlw %xmm3, %ymm17, %ymm3
vpsllw $0x2, %ymm3, %ymm3
leal 0x1(%r11), %ebx
vmovd %ebx, %xmm17
vpsllw %xmm17, %ymm7, %ymm20
vpandq %ymm16, %ymm20, %ymm20
vpsrlw %xmm17, %ymm20, %ymm17
vpsrlw $0x2, %ymm1, %ymm20
vpsllw $0x2, %ymm17, %ymm17
leal 0x2(%r11), %ebx
vmovd %ebx, %xmm21
vpsllw %xmm21, %ymm7, %ymm22
vpsrlw $0x4, %ymm1, %ymm23
vpandq %ymm16, %ymm22, %ymm22
vpsrlw %xmm21, %ymm22, %ymm21
vpsllw $0x2, %ymm21, %ymm21
leal 0x3(%r11), %ebx
vmovd %ebx, %xmm22
vpsllw %xmm22, %ymm7, %ymm24
vpandq %ymm16, %ymm24, %ymm24
vpsrlw %xmm22, %ymm24, %ymm22
vpsrlw $0x6, %ymm1, %ymm24
vpsllw $0x2, %ymm22, %ymm22
vmovdqu64 (%r10), %ymm25
vmovdqu64 0x20(%r10), %ymm26
vmovdqu64 0x40(%r10), %ymm27
vmovdqu64 0x60(%r10), %ymm28
vpmaddubsw %ymm25, %ymm3, %ymm3
vpmaddubsw %ymm26, %ymm17, %ymm17
vpmaddubsw %ymm27, %ymm21, %ymm21
vpmaddubsw %ymm28, %ymm22, %ymm22
vpand %ymm1, %ymm8, %ymm1
vpmaddubsw %ymm25, %ymm1, %ymm1
vpsubw %ymm3, %ymm1, %ymm1
vpandq %ymm8, %ymm20, %ymm3
vpmaddubsw %ymm26, %ymm3, %ymm3
vpsubw %ymm17, %ymm3, %ymm3
vpandq %ymm8, %ymm23, %ymm17
vpmaddubsw %ymm27, %ymm17, %ymm17
vpsubw %ymm21, %ymm17, %ymm17
vpandq %ymm8, %ymm24, %ymm20
vpmaddubsw %ymm28, %ymm20, %ymm20
vpsubw %ymm22, %ymm20, %ymm20
vmovdqa64 (%rsp,%r11,8), %ymm21
vpshufb %ymm9, %ymm21, %ymm22
vpmaddwd %ymm1, %ymm22, %ymm1
vpshufb %ymm10, %ymm21, %ymm22
vpmaddwd %ymm3, %ymm22, %ymm3
vpshufb %ymm11, %ymm21, %ymm22
vpmaddwd %ymm17, %ymm22, %ymm17
vpaddd %ymm17, %ymm3, %ymm3
vpshufb %ymm12, %ymm21, %ymm17
vpmaddwd %ymm20, %ymm17, %ymm17
vpaddd %ymm1, %ymm15, %ymm1
vpaddd %ymm3, %ymm1, %ymm1
vpaddd %ymm17, %ymm1, %ymm15
addq $0x4, %r11
subq $-0x80, %r10
jmp 0x1d73e
vmulss %xmm14, %xmm13, %xmm1
vbroadcastss %xmm1, %ymm1
vcvtdq2ps %ymm15, %ymm3
vfmadd231ps %ymm3, %ymm1, %ymm0 # ymm0 = (ymm1 * ymm3) + ymm0
incq %rdi
addq $0x6e, %rdx
jmp 0x1d689
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_q3_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, [rcx+20h]
vxorps xmm0, xmm0, xmm0
xor edi, edi
vpmovsxbq xmm18, cs:word_45741
vpbroadcastq xmm2, cs:qword_456E8
vmovdqa64 xmm19, cs:xmmword_4E100
mov r8, cs:ggml_table_f32_f16_ptr
vmovdqa xmm4, cs:xmmword_4E110
vpbroadcastb xmm5, cs:byte_4573C
vpcmpeqd ymm6, ymm6, ymm6
vpbroadcastw ymm7, cs:word_4573E
vpbroadcastb ymm8, cs:byte_45740
vmovdqa ymm9, cs:ymmword_454A0
vmovdqa ymm10, cs:ymmword_454C0
vmovdqa ymm11, cs:ymmword_454E0
vmovdqa ymm12, cs:ymmword_45500
loc_1D689:
cmp rdi, rax
jz loc_1D8D7
imul r10, rdi, 124h
add r10, r9
add r10, 4
vmovss xmm13, dword ptr [r10-4]
imul r11, rdi, 6Eh ; 'n'
movzx ebx, word ptr [rcx+r11+6Ch]
vmovss xmm14, dword ptr [r8+rbx*4]
mov ebx, [rcx+r11+60h]
mov r14, [rcx+r11+64h]
vmovq xmm15, r14
shr r14d, 4
vmovd xmm16, ebx
vpsrlq xmm17, xmm15, 20h ; ' '
vpermt2d xmm15, xmm18, xmm16
vpinsrd xmm15, xmm15, r14d, 3
vpinsrd xmm16, xmm17, ebx, 1
vpshufd xmm16, xmm16, 10h
vpsllvd xmm1, xmm16, xmm2
vpsrlvd xmm3, xmm16, xmm2
vpblendd xmm1, xmm1, xmm3, 0Ch
vpandd xmm1, xmm1, xmm19
vpternlogd xmm1, xmm15, xmm4, 0F8h
vpaddb xmm1, xmm1, xmm5
vpmovsxbw ymm1, xmm1
vpermq ymm3, ymm1, 44h ; 'D'
vmovdqa [rsp+50h+var_50], ymm3
vpermq ymm1, ymm1, 0EEh
vmovdqa [rsp+50h+var_30], ymm1
vpxorq ymm16, ymm6, ymmword ptr [rcx+r11]
vpxor xmm15, xmm15, xmm15
xor r11d, r11d
loc_1D73E:
cmp r11, 8
jz loc_1D8B7
vmovdqu ymm1, ymmword ptr [rdx+r11*8]
vmovd xmm3, r11d
vpsllw ymm17, ymm7, xmm3
vpandq ymm17, ymm17, ymm16
vpsrlw ymm3, ymm17, xmm3
vpsllw ymm3, ymm3, 2
lea ebx, [r11+1]
vmovd xmm17, ebx
vpsllw ymm20, ymm7, xmm17
vpandq ymm20, ymm20, ymm16
vpsrlw ymm17, ymm20, xmm17
vpsrlw ymm20, ymm1, 2
vpsllw ymm17, ymm17, 2
lea ebx, [r11+2]
vmovd xmm21, ebx
vpsllw ymm22, ymm7, xmm21
vpsrlw ymm23, ymm1, 4
vpandq ymm22, ymm22, ymm16
vpsrlw ymm21, ymm22, xmm21
vpsllw ymm21, ymm21, 2
lea ebx, [r11+3]
vmovd xmm22, ebx
vpsllw ymm24, ymm7, xmm22
vpandq ymm24, ymm24, ymm16
vpsrlw ymm22, ymm24, xmm22
vpsrlw ymm24, ymm1, 6
vpsllw ymm22, ymm22, 2
vmovdqu64 ymm25, ymmword ptr [r10]
vmovdqu64 ymm26, ymmword ptr [r10+20h]
vmovdqu64 ymm27, ymmword ptr [r10+40h]
vmovdqu64 ymm28, ymmword ptr [r10+60h]
vpmaddubsw ymm3, ymm3, ymm25
vpmaddubsw ymm17, ymm17, ymm26
vpmaddubsw ymm21, ymm21, ymm27
vpmaddubsw ymm22, ymm22, ymm28
vpand ymm1, ymm8, ymm1
vpmaddubsw ymm1, ymm1, ymm25
vpsubw ymm1, ymm1, ymm3
vpandq ymm3, ymm20, ymm8
vpmaddubsw ymm3, ymm3, ymm26
vpsubw ymm3, ymm3, ymm17
vpandq ymm17, ymm23, ymm8
vpmaddubsw ymm17, ymm17, ymm27
vpsubw ymm17, ymm17, ymm21
vpandq ymm20, ymm24, ymm8
vpmaddubsw ymm20, ymm20, ymm28
vpsubw ymm20, ymm20, ymm22
vmovdqa64 ymm21, [rsp+r11*8+50h+var_50]
vpshufb ymm22, ymm21, ymm9
vpmaddwd ymm1, ymm22, ymm1
vpshufb ymm22, ymm21, ymm10
vpmaddwd ymm3, ymm22, ymm3
vpshufb ymm22, ymm21, ymm11
vpmaddwd ymm17, ymm22, ymm17
vpaddd ymm3, ymm3, ymm17
vpshufb ymm17, ymm21, ymm12
vpmaddwd ymm17, ymm17, ymm20
vpaddd ymm1, ymm15, ymm1
vpaddd ymm1, ymm1, ymm3
vpaddd ymm15, ymm1, ymm17
add r11, 4
sub r10, 0FFFFFFFFFFFFFF80h
jmp loc_1D73E
loc_1D8B7:
vmulss xmm1, xmm13, xmm14
vbroadcastss ymm1, xmm1
vcvtdq2ps ymm3, ymm15
vfmadd231ps ymm0, ymm1, ymm3
inc rdi
add rdx, 6Eh ; 'n'
jmp loc_1D689
loc_1D8D7:
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_q3_K_q8_K(
int a1,
long long _RSI,
__m128 _XMM0,
long long a4,
long long a5,
long long a6,
long long a7)
{
long long result; // rax
long long v13; // rdi
result = (a1 / 256) & (unsigned int)~((a1 / 256) >> 31);
_RDX = a5 + 32;
__asm { vxorps xmm0, xmm0, xmm0 }
v13 = 0LL;
__asm
{
vpmovsxbq xmm18, cs:word_45741
vpbroadcastq xmm2, cs:qword_456E8
vmovdqa64 xmm19, cs:xmmword_4E100
}
_R8 = &ggml_table_f32_f16;
__asm
{
vmovdqa xmm4, cs:xmmword_4E110
vpbroadcastb xmm5, cs:byte_4573C
vpcmpeqd ymm6, ymm6, ymm6
vpbroadcastw ymm7, cs:word_4573E
vpbroadcastb ymm8, cs:byte_45740
vmovdqa ymm9, cs:ymmword_454A0
vmovdqa ymm10, cs:ymmword_454C0
vmovdqa ymm11, cs:ymmword_454E0
vmovdqa ymm12, cs:ymmword_45500
}
while ( v13 != result )
{
_R10 = a7 + 292 * v13 + 4;
__asm { vmovss xmm13, dword ptr [r10-4] }
_RBX = *(unsigned __int16 *)(a5 + 110 * v13 + 108);
__asm { vmovss xmm14, dword ptr [r8+rbx*4] }
LODWORD(_RBX) = *(_DWORD *)(a5 + 110 * v13 + 96);
_R14 = *(_QWORD *)(a5 + 110 * v13 + 100);
__asm
{
vmovq xmm15, r14
vmovd xmm16, ebx
vpsrlq xmm17, xmm15, 20h ; ' '
vpermt2d xmm15, xmm18, xmm16
vpinsrd xmm15, xmm15, r14d, 3
vpinsrd xmm16, xmm17, ebx, 1
vpshufd xmm16, xmm16, 10h
vpsllvd xmm1, xmm16, xmm2
vpsrlvd xmm3, xmm16, xmm2
vpblendd xmm1, xmm1, xmm3, 0Ch
vpandd xmm1, xmm1, xmm19
vpternlogd xmm1, xmm15, xmm4, 0F8h
vpaddb xmm1, xmm1, xmm5
vpmovsxbw ymm1, xmm1
vpermq ymm3, ymm1, 44h ; 'D'
vmovdqa [rsp+50h+var_50], ymm3
vpermq ymm1, ymm1, 0EEh
vmovdqa [rsp+50h+var_30], ymm1
vpxorq ymm16, ymm6, ymmword ptr [rcx+r11]
vpxor xmm15, xmm15, xmm15
}
for ( _R11 = 0LL; _R11 != 8; _R11 += 4LL )
{
__asm
{
vmovdqu ymm1, ymmword ptr [rdx+r11*8]
vmovd xmm3, r11d
vpsllw ymm17, ymm7, xmm3
vpandq ymm17, ymm17, ymm16
vpsrlw ymm3, ymm17, xmm3
vpsllw ymm3, ymm3, 2
}
_EBX = _R11 + 1;
__asm
{
vmovd xmm17, ebx
vpsllw ymm20, ymm7, xmm17
vpandq ymm20, ymm20, ymm16
vpsrlw ymm17, ymm20, xmm17
vpsrlw ymm20, ymm1, 2
vpsllw ymm17, ymm17, 2
}
_EBX = _R11 + 2;
__asm
{
vmovd xmm21, ebx
vpsllw ymm22, ymm7, xmm21
vpsrlw ymm23, ymm1, 4
vpandq ymm22, ymm22, ymm16
vpsrlw ymm21, ymm22, xmm21
vpsllw ymm21, ymm21, 2
}
_EBX = _R11 + 3;
__asm
{
vmovd xmm22, ebx
vpsllw ymm24, ymm7, xmm22
vpandq ymm24, ymm24, ymm16
vpsrlw ymm22, ymm24, xmm22
vpsrlw ymm24, ymm1, 6
vpsllw ymm22, ymm22, 2
vmovdqu64 ymm25, ymmword ptr [r10]
vmovdqu64 ymm26, ymmword ptr [r10+20h]
vmovdqu64 ymm27, ymmword ptr [r10+40h]
vmovdqu64 ymm28, ymmword ptr [r10+60h]
vpmaddubsw ymm3, ymm3, ymm25
vpmaddubsw ymm17, ymm17, ymm26
vpmaddubsw ymm21, ymm21, ymm27
vpmaddubsw ymm22, ymm22, ymm28
vpand ymm1, ymm8, ymm1
vpmaddubsw ymm1, ymm1, ymm25
vpsubw ymm1, ymm1, ymm3
vpandq ymm3, ymm20, ymm8
vpmaddubsw ymm3, ymm3, ymm26
vpsubw ymm3, ymm3, ymm17
vpandq ymm17, ymm23, ymm8
vpmaddubsw ymm17, ymm17, ymm27
vpsubw ymm17, ymm17, ymm21
vpandq ymm20, ymm24, ymm8
vpmaddubsw ymm20, ymm20, ymm28
vpsubw ymm20, ymm20, ymm22
vmovdqa64 ymm21, [rsp+r11*8+50h+var_50]
vpshufb ymm22, ymm21, ymm9
vpmaddwd ymm1, ymm22, ymm1
vpshufb ymm22, ymm21, ymm10
vpmaddwd ymm3, ymm22, ymm3
vpshufb ymm22, ymm21, ymm11
vpmaddwd ymm17, ymm22, ymm17
vpaddd ymm3, ymm3, ymm17
vpshufb ymm17, ymm21, ymm12
vpmaddwd ymm17, ymm17, ymm20
vpaddd ymm1, ymm15, ymm1
vpaddd ymm1, ymm1, ymm3
vpaddd ymm15, ymm1, ymm17
}
_R10 += 128LL;
}
__asm
{
vmulss xmm1, xmm13, xmm14
vbroadcastss ymm1, xmm1
vcvtdq2ps ymm3, ymm15
vfmadd231ps ymm0, ymm1, ymm3
}
++v13;
_RDX += 110LL;
}
__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_q3_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,[RCX + 0x20]
VXORPS XMM0,XMM0,XMM0
XOR EDI,EDI
VPMOVSXBQ XMM2,word ptr [0x00145741]
VPBROADCASTQ XMM2,qword ptr [0x001456e8]
VMOVDQA64 XMM3,xmmword ptr [0x0014e100]
MOV R8,qword ptr [0x00156f60]
VMOVDQA XMM4,xmmword ptr [0x0014e110]
VPBROADCASTB XMM5,byte ptr [0x0014573c]
VPCMPEQD YMM6,YMM6,YMM6
VPBROADCASTW YMM7,word ptr [0x0014573e]
VPBROADCASTB YMM8,byte ptr [0x00145740]
VMOVDQA YMM9,ymmword ptr [0x001454a0]
VMOVDQA YMM10,ymmword ptr [0x001454c0]
VMOVDQA YMM11,ymmword ptr [0x001454e0]
VMOVDQA YMM12,ymmword ptr [0x00145500]
CMP RDI,RAX
JZ 0x0011d8d7
IMUL R10,RDI,0x124
ADD R10,R9
ADD R10,0x4
VMOVSS XMM13,dword ptr [R10 + -0x4]
IMUL R11,RDI,0x6e
MOVZX EBX,word ptr [RCX + R11*0x1 + 0x6c]
VMOVSS XMM14,dword ptr [R8 + RBX*0x4]
MOV EBX,dword ptr [RCX + R11*0x1 + 0x60]
MOV R14,qword ptr [RCX + R11*0x1 + 0x64]
VMOVQ XMM15,R14
SHR R14D,0x4
VMOVD XMM0,EBX
VPSRLQ XMM1,XMM15,0x20
LAB_0011d8d7:
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: Control flow encountered bad instruction data */
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void ggml_vec_dot_q3_K_q8_K(int param_1,int4 *param_2,int8 param_3,long param_4)
{
int1 auVar1 [16];
int1 in_ZMM6 [64];
int1 auVar2 [16];
vpmovsxbq_avx512vl(ZEXT216(DAT_00145741));
vmovdqa64_avx512vl(_DAT_0014e100);
vpcmpeqd_avx2(in_ZMM6._0_32_,in_ZMM6._0_32_);
if ((~(param_1 / 0x100 >> 0x1f) & param_1 / 0x100) == 0) {
auVar2 = vshufpd_avx(ZEXT816(0),ZEXT816(0),1);
auVar1._0_4_ = auVar2._0_4_ + 0.0;
auVar1._4_4_ = auVar2._4_4_ + 0.0;
auVar1._8_4_ = auVar2._8_4_ + 0.0;
auVar1._12_4_ = auVar2._12_4_ + 0.0;
auVar2 = vhaddps_avx(auVar1,auVar1);
*param_2 = auVar2._0_4_;
return;
}
auVar2._8_8_ = 0;
auVar2._0_8_ = *(ulong *)(param_4 + 100);
vpsrlq_avx512vl(auVar2,0x20);
/* WARNING: Bad instruction - Truncating control flow here */
halt_baddata();
}
|
|
63,647
|
pagecache_set_write_on_delete_by_link
|
eloqsql/storage/maria/ma_pagecache.c
|
void pagecache_set_write_on_delete_by_link(PAGECACHE_BLOCK_LINK *block)
{
DBUG_ENTER("pagecache_set_write_on_delete_by_link");
DBUG_PRINT("enter", ("fd: %d block %p %d -> TRUE",
block->hash_link->file.file,
block, (int) block->status & PCBLOCK_DEL_WRITE));
DBUG_ASSERT(block->pins); /* should be pinned */
DBUG_ASSERT(block->wlocks); /* should be write locked */
block->status|= PCBLOCK_DEL_WRITE;
DBUG_VOID_RETURN;
}
|
O0
|
c
|
pagecache_set_write_on_delete_by_link:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
jmp 0xb5bca
jmp 0xb5bcc
jmp 0xb5bce
jmp 0xb5bd0
jmp 0xb5bd2
movq -0x8(%rbp), %rax
movzwl 0x74(%rax), %ecx
orl $0x80, %ecx
movw %cx, 0x74(%rax)
jmp 0xb5be6
popq %rbp
retq
nopl (%rax,%rax)
|
pagecache_set_write_on_delete_by_link:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
jmp short $+2
loc_B5BCA:
jmp short $+2
loc_B5BCC:
jmp short $+2
loc_B5BCE:
jmp short $+2
loc_B5BD0:
jmp short $+2
loc_B5BD2:
mov rax, [rbp+var_8]
movzx ecx, word ptr [rax+74h]
or ecx, 80h
mov [rax+74h], cx
jmp short $+2
loc_B5BE6:
pop rbp
retn
|
long long pagecache_set_write_on_delete_by_link(long long a1)
{
long long result; // rax
result = a1;
*(_WORD *)(a1 + 116) |= 0x80u;
return result;
}
|
pagecache_set_write_on_delete_by_link:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
JMP 0x001b5bca
LAB_001b5bca:
JMP 0x001b5bcc
LAB_001b5bcc:
JMP 0x001b5bce
LAB_001b5bce:
JMP 0x001b5bd0
LAB_001b5bd0:
JMP 0x001b5bd2
LAB_001b5bd2:
MOV RAX,qword ptr [RBP + -0x8]
MOVZX ECX,word ptr [RAX + 0x74]
OR ECX,0x80
MOV word ptr [RAX + 0x74],CX
JMP 0x001b5be6
LAB_001b5be6:
POP RBP
RET
|
void pagecache_set_write_on_delete_by_link(long param_1)
{
*(ushort *)(param_1 + 0x74) = *(ushort *)(param_1 + 0x74) | 0x80;
return;
}
|
|
63,648
|
vemit_tap
|
eloqsql/unittest/mytap/tap.c
|
static void
vemit_tap(int pass, char const *fmt, va_list ap)
{
fprintf(tapout, "%sok %d%s",
pass ? "" : "not ",
++g_test.last,
(fmt && *fmt) ? " - " : "");
if (fmt && *fmt)
vfprintf(tapout, fmt, ap);
fflush(tapout);
}
|
O0
|
c
|
vemit_tap:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x1a90f6(%rip), %rax # 0x1cdfc0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x4(%rbp), %edx
leaq 0x5436e(%rip), %rax # 0x79249
leaq 0x57db2(%rip), %rcx # 0x7cc94
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x28(%rbp)
movl 0x3608f9(%rip), %eax # 0x3857ec
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl %eax, 0x3608ed(%rip) # 0x3857ec
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x19(%rbp)
je 0x24f1b
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movl -0x20(%rbp), %ecx
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rdi
movb -0x19(%rbp), %sil
leaq 0x57d63(%rip), %r8 # 0x7cc94
leaq 0x54316(%rip), %rax # 0x7924e
testb $0x1, %sil
cmovneq %rax, %r8
leaq 0x542f8(%rip), %rsi # 0x7923f
movb $0x0, %al
callq 0x243f0
cmpq $0x0, -0x10(%rbp)
je 0x24f78
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x24f78
movq 0x1a9058(%rip), %rax # 0x1cdfc0
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x243c0
movq 0x1a9041(%rip), %rax # 0x1cdfc0
movq (%rax), %rdi
callq 0x24310
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
|
vemit_tap:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, cs:stdout_ptr
mov rax, [rax]
mov [rbp+var_30], rax
mov edx, [rbp+var_4]
lea rax, aNot; "not "
lea rcx, asc_7CC90+4; ""
cmp edx, 0
cmovnz rax, rcx
mov [rbp+var_28], rax
mov eax, cs:dword_3857EC
add eax, 1
mov [rbp+var_20], eax
mov cs:dword_3857EC, eax
xor eax, eax
cmp [rbp+var_10], 0
mov [rbp+var_19], al
jz short loc_24F1B
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 0
setnz al
mov [rbp+var_19], al
loc_24F1B:
mov ecx, [rbp+var_20]
mov rdx, [rbp+var_28]
mov rdi, [rbp+var_30]
mov sil, [rbp+var_19]
lea r8, asc_7CC90+4; ""
lea rax, asc_7924E; " - "
test sil, 1
cmovnz r8, rax
lea rsi, aSokDS; "%sok %d%s"
mov al, 0
call _fprintf
cmp [rbp+var_10], 0
jz short loc_24F78
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 0
jz short loc_24F78
mov rax, cs:stdout_ptr
mov rdi, [rax]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
call _vfprintf
loc_24F78:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
add rsp, 30h
pop rbp
retn
|
long long vemit_tap(int a1, _BYTE *a2, long long a3)
{
const char *v3; // rax
const char *v4; // r8
int v6; // [rsp+10h] [rbp-20h]
bool v7; // [rsp+17h] [rbp-19h]
v3 = "not ";
if ( a1 )
v3 = "";
v6 = ++dword_3857EC;
v7 = 0;
if ( a2 )
v7 = *a2 != 0;
v4 = "";
if ( v7 )
v4 = " - ";
fprintf(stdout, "%sok %d%s", v3, v6, v4);
if ( a2 && *a2 )
vfprintf(stdout, a2, a3);
return fflush(stdout);
}
|
vemit_tap:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [0x002cdfc0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x30],RAX
MOV EDX,dword ptr [RBP + -0x4]
LEA RAX,[0x179249]
LEA RCX,[0x17cc94]
CMP EDX,0x0
CMOVNZ RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
MOV EAX,dword ptr [0x004857ec]
ADD EAX,0x1
MOV dword ptr [RBP + -0x20],EAX
MOV dword ptr [0x004857ec],EAX
XOR EAX,EAX
CMP qword ptr [RBP + -0x10],0x0
MOV byte ptr [RBP + -0x19],AL
JZ 0x00124f1b
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x19],AL
LAB_00124f1b:
MOV ECX,dword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RBP + -0x30]
MOV SIL,byte ptr [RBP + -0x19]
LEA R8,[0x17cc94]
LEA RAX,[0x17924e]
TEST SIL,0x1
CMOVNZ R8,RAX
LEA RSI,[0x17923f]
MOV AL,0x0
CALL 0x001243f0
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00124f78
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JZ 0x00124f78
MOV RAX,qword ptr [0x002cdfc0]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x001243c0
LAB_00124f78:
MOV RAX,qword ptr [0x002cdfc0]
MOV RDI,qword ptr [RAX]
CALL 0x00124310
ADD RSP,0x30
POP RBP
RET
|
void vemit_tap(int param_1,char *param_2,__gnuc_va_list param_3)
{
int *puVar1;
int *puVar2;
bool bVar3;
puVar1 = &DAT_00179249;
if (param_1 != 0) {
puVar1 = &DAT_0017cc94;
}
DAT_004857ec = DAT_004857ec + 1;
bVar3 = false;
if (param_2 != (char *)0x0) {
bVar3 = *param_2 != '\0';
}
puVar2 = &DAT_0017cc94;
if (bVar3) {
puVar2 = &DAT_0017924e;
}
fprintf(*(FILE **)PTR_stdout_002cdfc0,"%sok %d%s",puVar1,(ulong)DAT_004857ec,puVar2);
if ((param_2 != (char *)0x0) && (*param_2 != '\0')) {
vfprintf(*(FILE **)PTR_stdout_002cdfc0,param_2,param_3);
}
fflush(*(FILE **)PTR_stdout_002cdfc0);
return;
}
|
|
63,649
|
inline_mysql_file_close
|
eloqsql/include/mysql/psi/mysql_file.h
|
static inline int
inline_mysql_file_close(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, myf flags)
{
int result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, file, PSI_FILE_CLOSE);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_close_wait)(locker, src_file, src_line);
result= my_close(file, flags);
PSI_FILE_CALL(end_file_close_wait)(locker, result);
return result;
}
#endif
result= my_close(file, flags);
return result;
}
|
O0
|
c
|
inline_mysql_file_close:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq 0x208d88(%rip), %rax # 0x2c1158
movq (%rax), %rax
movq 0x158(%rax), %rax
movl -0x18(%rbp), %esi
leaq -0x78(%rbp), %rdi
movl $0x4, %edx
callq *%rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xb845b
leaq 0x208d45(%rip), %rax # 0x2c1158
movq (%rax), %rax
movq 0x220(%rax), %rax
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq *%rax
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0xf5880
movl %eax, -0x24(%rbp)
leaq 0x208d18(%rip), %rax # 0x2c1158
movq (%rax), %rax
movq 0x228(%rax), %rax
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
callq *%rax
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb8470
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0xf5880
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
|
inline_mysql_file_close_6:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_20], rcx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+158h]
mov esi, [rbp+var_18]
lea rdi, [rbp+var_78]
mov edx, 4
call rax
mov [rbp+var_30], rax
cmp [rbp+var_30], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_B845B
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+220h]
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_10]
mov edx, [rbp+var_14]
call rax
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
call my_close
mov [rbp+var_24], eax
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+228h]
mov rdi, [rbp+var_30]
mov esi, [rbp+var_24]
call rax
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
jmp short loc_B8470
loc_B845B:
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
call my_close
mov [rbp+var_24], eax
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
loc_B8470:
mov eax, [rbp+var_4]
add rsp, 80h
pop rbp
retn
|
long long inline_mysql_file_close_6(long long a1, unsigned int a2, unsigned int a3, long long a4)
{
_BYTE v5[72]; // [rsp+8h] [rbp-78h] BYREF
long long v6; // [rsp+50h] [rbp-30h]
unsigned int v7; // [rsp+5Ch] [rbp-24h]
long long v8; // [rsp+60h] [rbp-20h]
unsigned int v9; // [rsp+68h] [rbp-18h]
unsigned int v10; // [rsp+6Ch] [rbp-14h]
long long v11; // [rsp+70h] [rbp-10h]
v11 = a1;
v10 = a2;
v9 = a3;
v8 = a4;
v6 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v5, a3, 4LL);
if ( v6 )
{
((void ( *)(long long, long long, _QWORD))PSI_server[68])(v6, v11, v10);
v7 = my_close(v9, v8);
((void ( *)(long long, _QWORD))PSI_server[69])(v6, v7);
}
else
{
return (unsigned int)my_close(v9, v8);
}
return v7;
}
|
inline_mysql_file_close:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV qword ptr [RBP + -0x20],RCX
LEA RAX,[0x3c1158]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x158]
MOV ESI,dword ptr [RBP + -0x18]
LEA RDI,[RBP + -0x78]
MOV EDX,0x4
CALL RAX
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x30],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001b845b
LEA RAX,[0x3c1158]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x220]
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x14]
CALL RAX
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x001f5880
MOV dword ptr [RBP + -0x24],EAX
LEA RAX,[0x3c1158]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x228]
MOV RDI,qword ptr [RBP + -0x30]
MOV ESI,dword ptr [RBP + -0x24]
CALL RAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001b8470
LAB_001b845b:
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x001f5880
MOV dword ptr [RBP + -0x24],EAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
LAB_001b8470:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x80
POP RBP
RET
|
int4
inline_mysql_file_close(int8 param_1,int4 param_2,int4 param_3,int8 param_4)
{
int1 local_80 [72];
long local_38;
int4 local_2c;
int8 local_28;
int4 local_20;
int4 local_1c;
int8 local_18;
int4 local_c;
local_28 = param_4;
local_20 = param_3;
local_1c = param_2;
local_18 = param_1;
local_38 = (**(code **)(PSI_server + 0x158))(local_80,param_3,4);
if (local_38 == 0) {
local_c = my_close(local_20,local_28);
}
else {
(**(code **)(PSI_server + 0x220))(local_38,local_18,local_1c);
local_2c = my_close(local_20,local_28);
(**(code **)(PSI_server + 0x228))(local_38,local_2c);
local_c = local_2c;
}
return local_c;
}
|
|
63,650
|
coro::shared_scoped_lock<coro::thread_pool>::unlock()
|
AlayaLite/build_O3/_deps/libcoro-src/include/coro/shared_mutex.hpp
|
auto unlock() -> void
{
if (m_shared_mutex != nullptr)
{
if (m_exclusive)
{
m_shared_mutex->unlock();
}
else
{
m_shared_mutex->unlock_shared();
}
m_shared_mutex = nullptr;
}
}
|
O3
|
cpp
|
coro::shared_scoped_lock<coro::thread_pool>::unlock():
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x34071
cmpb $0x1, 0x8(%rbx)
jne 0x34065
callq 0x33c54
jmp 0x3406a
callq 0x34074
movq $0x0, (%rbx)
popq %rbx
retq
nop
|
_ZN4coro18shared_scoped_lockINS_11thread_poolEE6unlockEv:
push rbx
mov rbx, rdi
mov rdi, [rdi]
test rdi, rdi
jz short loc_34071
cmp byte ptr [rbx+8], 1
jnz short loc_34065
call _ZN4coro12shared_mutexINS_11thread_poolEE6unlockEv; coro::shared_mutex<coro::thread_pool>::unlock(void)
jmp short loc_3406A
loc_34065:
call _ZN4coro12shared_mutexINS_11thread_poolEE13unlock_sharedEv; coro::shared_mutex<coro::thread_pool>::unlock_shared(void)
loc_3406A:
mov qword ptr [rbx], 0
loc_34071:
pop rbx
retn
|
long long coro::shared_scoped_lock<coro::thread_pool>::unlock(
long long a1,
int a2,
int a3,
int a4,
int a5,
int a6)
{
long long v7; // rdi
long long result; // rax
v7 = *(_QWORD *)a1;
if ( v7 )
{
if ( *(_BYTE *)(a1 + 8) == 1 )
result = coro::shared_mutex<coro::thread_pool>::unlock(v7);
else
result = coro::shared_mutex<coro::thread_pool>::unlock_shared(v7, a2, a3, a4, a5, a6);
*(_QWORD *)a1 = 0LL;
}
return result;
}
|
unlock:
PUSH RBX
MOV RBX,RDI
MOV RDI,qword ptr [RDI]
TEST RDI,RDI
JZ 0x00134071
CMP byte ptr [RBX + 0x8],0x1
JNZ 0x00134065
CALL 0x00133c54
JMP 0x0013406a
LAB_00134065:
CALL 0x00134074
LAB_0013406a:
MOV qword ptr [RBX],0x0
LAB_00134071:
POP RBX
RET
|
/* coro::shared_scoped_lock<coro::thread_pool>::unlock() */
void __thiscall
coro::shared_scoped_lock<coro::thread_pool>::unlock(shared_scoped_lock<coro::thread_pool> *this)
{
shared_mutex<coro::thread_pool> *this_00;
this_00 = *(shared_mutex<coro::thread_pool> **)this;
if (this_00 != (shared_mutex<coro::thread_pool> *)0x0) {
if (this[8] == (shared_scoped_lock<coro::thread_pool>)0x1) {
shared_mutex<coro::thread_pool>::unlock(this_00);
}
else {
shared_mutex<coro::thread_pool>::unlock_shared(this_00);
}
*(int8 *)this = 0;
}
return;
}
|
|
63,651
|
testing::internal::BriefUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int)
|
AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest.cc
|
void BriefUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
int /*iteration*/) {
ColoredPrintf(GTestColor::kGreen, "[==========] ");
printf("%s from %s ran.",
FormatTestCount(unit_test.test_to_run_count()).c_str(),
FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
if (GTEST_FLAG_GET(print_time)) {
printf(" (%s ms total)",
internal::StreamableToString(unit_test.elapsed_time()).c_str());
}
printf("\n");
ColoredPrintf(GTestColor::kGreen, "[ PASSED ] ");
printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str());
const int skipped_test_count = unit_test.skipped_test_count();
if (skipped_test_count > 0) {
ColoredPrintf(GTestColor::kGreen, "[ SKIPPED ] ");
printf("%s.\n", FormatTestCount(skipped_test_count).c_str());
}
int num_disabled = unit_test.reportable_disabled_test_count();
if (num_disabled && !GTEST_FLAG_GET(also_run_disabled_tests)) {
if (unit_test.Passed()) {
printf("\n"); // Add a spacer if no FAILURE banner is displayed.
}
ColoredPrintf(GTestColor::kYellow, " YOU HAVE %d DISABLED %s\n\n",
num_disabled, num_disabled == 1 ? "TEST" : "TESTS");
}
// Ensure that Google Test output is printed before, e.g., heapchecker output.
fflush(stdout);
}
|
O0
|
cpp
|
testing::internal::BriefUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int):
subq $0x118, %rsp # imm = 0x118
movq %rdi, 0x110(%rsp)
movq %rsi, 0x108(%rsp)
movl %edx, 0x104(%rsp)
leaq 0x4af97(%rip), %rsi # 0x11d7bc
xorl %eax, %eax
movl $0x2, %edi
callq 0xd0b10
movq 0x108(%rsp), %rdi
callq 0xd1540
movl %eax, %esi
leaq 0xe0(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0xd1500
movq 0x28(%rsp), %rdi
callq 0x1f1e0
movq %rax, 0x30(%rsp)
movq 0x108(%rsp), %rdi
callq 0xd15a0
movl %eax, 0x38(%rsp)
jmp 0xd2874
movl 0x38(%rsp), %esi
leaq 0xc0(%rsp), %rdi
callq 0xd1560
jmp 0xd2887
leaq 0xc0(%rsp), %rdi
callq 0x1f1e0
movq 0x30(%rsp), %rsi
movq %rax, %rdx
leaq 0x4b094(%rip), %rdi # 0x11d937
xorl %eax, %eax
callq 0x16060
jmp 0xd28ac
leaq 0xc0(%rsp), %rdi
callq 0x1dfd0
leaq 0xe0(%rsp), %rdi
callq 0x1dfd0
leaq 0xb33fc(%rip), %rax # 0x185cc9
testb $0x1, (%rax)
je 0xd29a0
movq 0x108(%rsp), %rdi
callq 0xd2630
movq %rax, 0x88(%rsp)
leaq 0x90(%rsp), %rdi
movq %rdi, 0x20(%rsp)
leaq 0x88(%rsp), %rsi
callq 0xf1880
movq 0x20(%rsp), %rdi
callq 0x1f1e0
movq %rax, %rsi
leaq 0x4b02e(%rip), %rdi # 0x11d947
xorl %eax, %eax
callq 0x16060
jmp 0xd2922
leaq 0x90(%rsp), %rdi
callq 0x1dfd0
jmp 0xd29a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0xd2968
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x1dfd0
leaq 0xe0(%rsp), %rdi
callq 0x1dfd0
jmp 0xd2b4f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x1dfd0
jmp 0xd2b4f
leaq 0x4aeec(%rip), %rdi # 0x11d893
xorl %eax, %eax
movb %al, 0x1f(%rsp)
callq 0x16060
movb 0x1f(%rsp), %al
leaq 0x4af99(%rip), %rsi # 0x11d956
movl $0x2, %edi
callq 0xd0b10
movq 0x108(%rsp), %rdi
callq 0xd2650
movl %eax, %esi
leaq 0x68(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xd1500
movq 0x10(%rsp), %rdi
callq 0x1f1e0
movq %rax, %rsi
movb 0x1f(%rsp), %al
leaq 0x4ad85(%rip), %rdi # 0x11d782
callq 0x16060
jmp 0xd2a04
leaq 0x68(%rsp), %rdi
callq 0x1dfd0
movq 0x108(%rsp), %rdi
callq 0xd2270
movl %eax, 0x64(%rsp)
cmpl $0x0, 0x64(%rsp)
jle 0xd2ac3
leaq 0x4ae23(%rip), %rsi # 0x11d854
xorl %eax, %eax
movb %al, 0xf(%rsp)
movl $0x2, %edi
callq 0xd0b10
movl 0x64(%rsp), %esi
leaq 0x40(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xd1500
movq (%rsp), %rdi
callq 0x1f1e0
movq %rax, %rsi
movb 0xf(%rsp), %al
leaq 0x4ad18(%rip), %rdi # 0x11d782
callq 0x16060
jmp 0xd2a71
leaq 0x40(%rsp), %rdi
callq 0x1dfd0
jmp 0xd2ac3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x1dfd0
jmp 0xd2b4f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x1dfd0
jmp 0xd2b4f
movq 0x108(%rsp), %rdi
callq 0xd2690
movl %eax, 0x3c(%rsp)
cmpl $0x0, 0x3c(%rsp)
je 0xd2b38
leaq 0xb3179(%rip), %rax # 0x185c5b
testb $0x1, (%rax)
jne 0xd2b38
movq 0x108(%rsp), %rdi
callq 0xd2670
testb $0x1, %al
jne 0xd2afa
jmp 0xd2b08
leaq 0x4ad92(%rip), %rdi # 0x11d893
movb $0x0, %al
callq 0x16060
movl 0x3c(%rsp), %edx
movl 0x3c(%rsp), %esi
leaq 0x4adcf(%rip), %rcx # 0x11d8e6
leaq 0x4adc3(%rip), %rax # 0x11d8e1
cmpl $0x1, %esi
cmoveq %rax, %rcx
movl $0x3, %edi
leaq 0x4ae33(%rip), %rsi # 0x11d964
movb $0x0, %al
callq 0xd0b10
movq 0xb23c1(%rip), %rax # 0x184f00
movq (%rax), %rdi
callq 0x16850
addq $0x118, %rsp # imm = 0x118
retq
movq 0xb8(%rsp), %rdi
callq 0x16cf0
nopl (%rax)
|
_ZN7testing8internal26BriefUnitTestResultPrinter18OnTestIterationEndERKNS_8UnitTestEi:
sub rsp, 118h
mov [rsp+118h+var_8], rdi
mov [rsp+118h+var_10], rsi
mov [rsp+118h+var_14], edx
lea rsi, asc_11D7BC; "[==========] "
xor eax, eax
mov edi, 2
call _ZN7testing8internalL13ColoredPrintfENS0_12_GLOBAL__N_110GTestColorEPKcz; testing::internal::ColoredPrintf(testing::internal::`anonymous namespace'::GTestColor,char const*,...)
mov rdi, [rsp+118h+var_10]; this
call _ZNK7testing8UnitTest17test_to_run_countEv; testing::UnitTest::test_to_run_count(void)
mov esi, eax
lea rdi, [rsp+118h+var_38]
mov [rsp+118h+var_F0], rdi
call _ZN7testingL15FormatTestCountB5cxx11Ei; testing::FormatTestCount(int)
mov rdi, [rsp+118h+var_F0]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov [rsp+118h+var_E8], rax
mov rdi, [rsp+118h+var_10]; this
call _ZNK7testing8UnitTest23test_suite_to_run_countEv; testing::UnitTest::test_suite_to_run_count(void)
mov [rsp+118h+var_E0], eax
jmp short $+2
loc_D2874:
mov esi, [rsp+118h+var_E0]
lea rdi, [rsp+118h+var_58]
call _ZN7testingL20FormatTestSuiteCountB5cxx11Ei; testing::FormatTestSuiteCount(int)
jmp short $+2
loc_D2887:
lea rdi, [rsp+118h+var_58]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rsi, [rsp+118h+var_E8]
mov rdx, rax
lea rdi, aSFromSRan; "%s from %s ran."
xor eax, eax
call _printf
jmp short $+2
loc_D28AC:
lea rdi, [rsp+118h+var_58]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+118h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rax, _ZN7testing22FLAGS_gtest_print_timeE; testing::FLAGS_gtest_print_time
test byte ptr [rax], 1
jz loc_D29A0
mov rdi, [rsp+118h+var_10]; this
call _ZNK7testing8UnitTest12elapsed_timeEv; testing::UnitTest::elapsed_time(void)
mov [rsp+118h+var_90], rax
lea rdi, [rsp+118h+var_88]
mov [rsp+118h+var_F8], rdi
lea rsi, [rsp+118h+var_90]
call _ZN7testing8internal18StreamableToStringIlEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKT_; testing::internal::StreamableToString<long>(long const&)
mov rdi, [rsp+118h+var_F8]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rsi, rax
lea rdi, aSMsTotal; " (%s ms total)"
xor eax, eax
call _printf
jmp short $+2
loc_D2922:
lea rdi, [rsp+118h+var_88]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_D29A0
mov rcx, rax
mov eax, edx
mov [rsp+arg_B0], rcx
mov [rsp+arg_AC], eax
jmp short loc_D2968
mov rcx, rax
mov eax, edx
mov [rsp+arg_B0], rcx
mov [rsp+arg_AC], eax
lea rdi, [rsp+arg_B8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_D2968:
lea rdi, [rsp+arg_D8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp loc_D2B4F
mov rcx, rax
mov eax, edx
mov [rsp+arg_B0], rcx
mov [rsp+arg_AC], eax
lea rdi, [rsp+arg_88]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp loc_D2B4F
loc_D29A0:
lea rdi, aSFromSSMsTotal+19h; "\n"
xor eax, eax
mov [rsp+118h+var_F9], al
call _printf
mov al, [rsp+118h+var_F9]
lea rsi, aPassed; "[ PASSED ] "
mov edi, 2
call _ZN7testing8internalL13ColoredPrintfENS0_12_GLOBAL__N_110GTestColorEPKcz; testing::internal::ColoredPrintf(testing::internal::`anonymous namespace'::GTestColor,char const*,...)
mov rdi, [rsp+118h+var_10]; this
call _ZNK7testing8UnitTest21successful_test_countEv; testing::UnitTest::successful_test_count(void)
mov esi, eax
lea rdi, [rsp+118h+var_B0]
mov [rsp+118h+var_108], rdi
call _ZN7testingL15FormatTestCountB5cxx11Ei; testing::FormatTestCount(int)
mov rdi, [rsp+118h+var_108]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rsi, rax
mov al, [rsp+118h+var_F9]
lea rdi, aNoteThisIsTest+1Fh; "%s.\n"
call _printf
jmp short $+2
loc_D2A04:
lea rdi, [rsp+118h+var_B0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, [rsp+118h+var_10]; this
call _ZNK7testing8UnitTest18skipped_test_countEv; testing::UnitTest::skipped_test_count(void)
mov [rsp+118h+var_B4], eax
cmp [rsp+118h+var_B4], 0
jle loc_D2AC3
lea rsi, aSkipped_0; "[ SKIPPED ] "
xor eax, eax
mov [rsp+118h+var_109], al
mov edi, 2
call _ZN7testing8internalL13ColoredPrintfENS0_12_GLOBAL__N_110GTestColorEPKcz; testing::internal::ColoredPrintf(testing::internal::`anonymous namespace'::GTestColor,char const*,...)
mov esi, [rsp+118h+var_B4]
lea rdi, [rsp+118h+var_D8]
mov [rsp+118h+var_118], rdi
call _ZN7testingL15FormatTestCountB5cxx11Ei; testing::FormatTestCount(int)
mov rdi, [rsp+118h+var_118]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rsi, rax
mov al, [rsp+118h+var_109]
lea rdi, aNoteThisIsTest+1Fh; "%s.\n"
call _printf
jmp short $+2
loc_D2A71:
lea rdi, [rsp+118h+var_D8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_D2AC3
mov rcx, rax
mov eax, edx
mov [rsp+arg_B0], rcx
mov [rsp+arg_AC], eax
lea rdi, [rsp+arg_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp loc_D2B4F
mov rcx, rax
mov eax, edx
mov [rsp+arg_B0], rcx
mov [rsp+arg_AC], eax
lea rdi, [rsp+arg_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp loc_D2B4F
loc_D2AC3:
mov rdi, [rsp+118h+var_10]; this
call _ZNK7testing8UnitTest30reportable_disabled_test_countEv; testing::UnitTest::reportable_disabled_test_count(void)
mov [rsp+118h+var_DC], eax
cmp [rsp+118h+var_DC], 0
jz short loc_D2B38
lea rax, _ZN7testing35FLAGS_gtest_also_run_disabled_testsE; testing::FLAGS_gtest_also_run_disabled_tests
test byte ptr [rax], 1
jnz short loc_D2B38
mov rdi, [rsp+118h+var_10]; this
call _ZNK7testing8UnitTest6PassedEv; testing::UnitTest::Passed(void)
test al, 1
jnz short loc_D2AFA
jmp short loc_D2B08
loc_D2AFA:
lea rdi, aSFromSSMsTotal+19h; "\n"
mov al, 0
call _printf
loc_D2B08:
mov edx, [rsp+118h+var_DC]
mov esi, [rsp+118h+var_DC]
lea rcx, aTests; "TESTS"
lea rax, aTest_0; "TEST"
cmp esi, 1
cmovz rcx, rax
mov edi, 3
lea rsi, aYouHaveDDisabl; " YOU HAVE %d DISABLED %s\n\n"
mov al, 0
call _ZN7testing8internalL13ColoredPrintfENS0_12_GLOBAL__N_110GTestColorEPKcz; testing::internal::ColoredPrintf(testing::internal::`anonymous namespace'::GTestColor,char const*,...)
loc_D2B38:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
add rsp, 118h
retn
loc_D2B4F:
mov rdi, [rsp+arg_B0]
call __Unwind_Resume
|
long long testing::internal::BriefUnitTestResultPrinter::OnTestIterationEnd(
testing::internal::BriefUnitTestResultPrinter *this,
const testing::UnitTest *a2,
int a3)
{
unsigned int v3; // eax
const char *v4; // rax
int v5; // edx
int v6; // ecx
int v7; // r8d
int v8; // r9d
const char *v9; // rax
unsigned int v10; // eax
const char *v11; // rax
const char *v12; // rax
const char *v13; // rcx
int v15; // [rsp+0h] [rbp-118h]
int v16; // [rsp+8h] [rbp-110h]
const char *v17; // [rsp+30h] [rbp-E8h]
unsigned int v18; // [rsp+38h] [rbp-E0h]
int v19; // [rsp+3Ch] [rbp-DCh]
_BYTE v20[36]; // [rsp+40h] [rbp-D8h] BYREF
int v21; // [rsp+64h] [rbp-B4h]
_BYTE v22[32]; // [rsp+68h] [rbp-B0h] BYREF
long long v23; // [rsp+88h] [rbp-90h] BYREF
_BYTE v24[48]; // [rsp+90h] [rbp-88h] BYREF
_BYTE v25[32]; // [rsp+C0h] [rbp-58h] BYREF
_BYTE v26[36]; // [rsp+E0h] [rbp-38h] BYREF
int v27; // [rsp+104h] [rbp-14h]
testing::UnitTest *v28; // [rsp+108h] [rbp-10h]
testing::internal::BriefUnitTestResultPrinter *v29; // [rsp+110h] [rbp-8h]
v29 = this;
v28 = a2;
v27 = a3;
testing::internal::ColoredPrintf(2u, (long long)"[==========] ");
v3 = testing::UnitTest::test_to_run_count(a2);
testing::FormatTestCount[abi:cxx11](v26, v3);
v17 = (const char *)std::string::c_str((long long)v26);
v18 = testing::UnitTest::test_suite_to_run_count(v28);
testing::FormatTestSuiteCount[abi:cxx11](v25, v18);
v4 = (const char *)std::string::c_str((long long)v25);
printf("%s from %s ran.", v17, v4);
std::string::~string(v25);
std::string::~string(v26);
if ( (testing::FLAGS_gtest_print_time & 1) != 0 )
{
v23 = testing::UnitTest::elapsed_time(v28);
testing::internal::StreamableToString<long>((unsigned int)v24, (unsigned int)&v23, v5, v6, v7, v8, v15, v16);
v9 = (const char *)std::string::c_str((long long)v24);
printf(" (%s ms total)", v9);
std::string::~string(v24);
}
printf("\n");
testing::internal::ColoredPrintf(2u, (long long)"[ PASSED ] ");
v10 = testing::UnitTest::successful_test_count(v28, (long long)"[ PASSED ] ");
testing::FormatTestCount[abi:cxx11](v22, v10);
v11 = (const char *)std::string::c_str((long long)v22);
printf("%s.\n", v11);
std::string::~string(v22);
v21 = testing::UnitTest::skipped_test_count(v28);
if ( v21 > 0 )
{
testing::internal::ColoredPrintf(2u, (long long)"[ SKIPPED ] ");
testing::FormatTestCount[abi:cxx11](v20, (unsigned int)v21);
v12 = (const char *)std::string::c_str((long long)v20);
printf("%s.\n", v12);
std::string::~string(v20);
}
v19 = testing::UnitTest::reportable_disabled_test_count(v28);
if ( v19 && (testing::FLAGS_gtest_also_run_disabled_tests & 1) == 0 )
{
if ( (testing::UnitTest::Passed(v28) & 1) != 0 )
printf("\n");
v13 = "TESTS";
if ( v19 == 1 )
v13 = "TEST";
testing::internal::ColoredPrintf(3u, (long long)" YOU HAVE %d DISABLED %s\n\n", v19, v13);
}
return fflush(stdout);
}
|
OnTestIterationEnd:
SUB RSP,0x118
MOV qword ptr [RSP + 0x110],RDI
MOV qword ptr [RSP + 0x108],RSI
MOV dword ptr [RSP + 0x104],EDX
LEA RSI,[0x21d7bc]
XOR EAX,EAX
MOV EDI,0x2
CALL 0x001d0b10
MOV RDI,qword ptr [RSP + 0x108]
CALL 0x001d1540
MOV ESI,EAX
LEA RDI,[RSP + 0xe0]
MOV qword ptr [RSP + 0x28],RDI
CALL 0x001d1500
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x0011f1e0
MOV qword ptr [RSP + 0x30],RAX
MOV RDI,qword ptr [RSP + 0x108]
LAB_001d2869:
CALL 0x001d15a0
MOV dword ptr [RSP + 0x38],EAX
JMP 0x001d2874
LAB_001d2874:
MOV ESI,dword ptr [RSP + 0x38]
LEA RDI,[RSP + 0xc0]
CALL 0x001d1560
JMP 0x001d2887
LAB_001d2887:
LEA RDI,[RSP + 0xc0]
CALL 0x0011f1e0
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,RAX
LAB_001d289c:
LEA RDI,[0x21d937]
XOR EAX,EAX
CALL 0x00116060
LAB_001d28aa:
JMP 0x001d28ac
LAB_001d28ac:
LEA RDI,[RSP + 0xc0]
CALL 0x0011dfd0
LEA RDI,[RSP + 0xe0]
CALL 0x0011dfd0
LEA RAX,[0x285cc9]
TEST byte ptr [RAX],0x1
JZ 0x001d29a0
MOV RDI,qword ptr [RSP + 0x108]
CALL 0x001d2630
MOV qword ptr [RSP + 0x88],RAX
LEA RDI,[RSP + 0x90]
MOV qword ptr [RSP + 0x20],RDI
LEA RSI,[RSP + 0x88]
CALL 0x001f1880
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x0011f1e0
MOV RSI,RAX
LAB_001d2912:
LEA RDI,[0x21d947]
XOR EAX,EAX
CALL 0x00116060
LAB_001d2920:
JMP 0x001d2922
LAB_001d2922:
LEA RDI,[RSP + 0x90]
CALL 0x0011dfd0
JMP 0x001d29a0
LAB_001d29a0:
LEA RDI,[0x21d893]
XOR EAX,EAX
MOV byte ptr [RSP + 0x1f],AL
CALL 0x00116060
MOV AL,byte ptr [RSP + 0x1f]
LEA RSI,[0x21d956]
MOV EDI,0x2
CALL 0x001d0b10
MOV RDI,qword ptr [RSP + 0x108]
CALL 0x001d2650
MOV ESI,EAX
LEA RDI,[RSP + 0x68]
MOV qword ptr [RSP + 0x10],RDI
CALL 0x001d1500
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x0011f1e0
MOV RSI,RAX
MOV AL,byte ptr [RSP + 0x1f]
LAB_001d29f6:
LEA RDI,[0x21d782]
CALL 0x00116060
LAB_001d2a02:
JMP 0x001d2a04
LAB_001d2a04:
LEA RDI,[RSP + 0x68]
CALL 0x0011dfd0
MOV RDI,qword ptr [RSP + 0x108]
CALL 0x001d2270
MOV dword ptr [RSP + 0x64],EAX
CMP dword ptr [RSP + 0x64],0x0
JLE 0x001d2ac3
LEA RSI,[0x21d854]
XOR EAX,EAX
MOV byte ptr [RSP + 0xf],AL
MOV EDI,0x2
CALL 0x001d0b10
MOV ESI,dword ptr [RSP + 0x64]
LEA RDI,[RSP + 0x40]
MOV qword ptr [RSP],RDI
CALL 0x001d1500
MOV RDI,qword ptr [RSP]
CALL 0x0011f1e0
MOV RSI,RAX
MOV AL,byte ptr [RSP + 0xf]
LAB_001d2a63:
LEA RDI,[0x21d782]
CALL 0x00116060
LAB_001d2a6f:
JMP 0x001d2a71
LAB_001d2a71:
LEA RDI,[RSP + 0x40]
CALL 0x0011dfd0
JMP 0x001d2ac3
LAB_001d2ac3:
MOV RDI,qword ptr [RSP + 0x108]
CALL 0x001d2690
MOV dword ptr [RSP + 0x3c],EAX
CMP dword ptr [RSP + 0x3c],0x0
JZ 0x001d2b38
LEA RAX,[0x285c5b]
TEST byte ptr [RAX],0x1
JNZ 0x001d2b38
MOV RDI,qword ptr [RSP + 0x108]
CALL 0x001d2670
TEST AL,0x1
JNZ 0x001d2afa
JMP 0x001d2b08
LAB_001d2afa:
LEA RDI,[0x21d893]
MOV AL,0x0
CALL 0x00116060
LAB_001d2b08:
MOV EDX,dword ptr [RSP + 0x3c]
MOV ESI,dword ptr [RSP + 0x3c]
LEA RCX,[0x21d8e6]
LEA RAX,[0x21d8e1]
CMP ESI,0x1
CMOVZ RCX,RAX
MOV EDI,0x3
LEA RSI,[0x21d964]
MOV AL,0x0
CALL 0x001d0b10
LAB_001d2b38:
MOV RAX,qword ptr [0x00284f00]
MOV RDI,qword ptr [RAX]
CALL 0x00116850
ADD RSP,0x118
RET
|
/* testing::internal::BriefUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int)
*/
void __thiscall
testing::internal::BriefUnitTestResultPrinter::OnTestIterationEnd
(BriefUnitTestResultPrinter *this,UnitTest *param_1,int param_2)
{
int iVar1;
int8 uVar2;
int8 uVar3;
ulong uVar4;
char *pcVar5;
testing local_d8 [36];
int local_b4;
testing local_b0 [32];
long local_90;
internal local_88 [48];
testing local_58 [32];
testing local_38 [36];
int local_14;
UnitTest *local_10;
BriefUnitTestResultPrinter *local_8;
local_14 = param_2;
local_10 = param_1;
local_8 = this;
ColoredPrintf(2,"[==========] ");
iVar1 = UnitTest::test_to_run_count(local_10);
FormatTestCount_abi_cxx11_(local_38,iVar1);
uVar2 = std::__cxx11::string::c_str((string *)local_38);
/* try { // try from 001d2869 to 001d2884 has its CatchHandler @ 001d2931 */
iVar1 = UnitTest::test_suite_to_run_count(local_10);
FormatTestSuiteCount_abi_cxx11_(local_58,iVar1);
uVar3 = std::__cxx11::string::c_str((string *)local_58);
/* try { // try from 001d289c to 001d28a9 has its CatchHandler @ 001d2947 */
printf("%s from %s ran.",uVar2,uVar3);
std::__cxx11::string::~string((string *)local_58);
std::__cxx11::string::~string((string *)local_38);
if ((FLAGS_gtest_print_time & 1) != 0) {
local_90 = UnitTest::elapsed_time(local_10);
StreamableToString<long>(local_88,&local_90);
uVar2 = std::__cxx11::string::c_str((string *)local_88);
/* try { // try from 001d2912 to 001d291f has its CatchHandler @ 001d297a */
printf(" (%s ms total)",uVar2);
std::__cxx11::string::~string((string *)local_88);
}
printf("\n");
ColoredPrintf(2,"[ PASSED ] ");
iVar1 = UnitTest::successful_test_count(local_10);
FormatTestCount_abi_cxx11_(local_b0,iVar1);
uVar2 = std::__cxx11::string::c_str((string *)local_b0);
/* try { // try from 001d29f6 to 001d2a01 has its CatchHandler @ 001d2a7d */
printf("%s.\n",uVar2);
std::__cxx11::string::~string((string *)local_b0);
local_b4 = UnitTest::skipped_test_count(local_10);
if (0 < local_b4) {
ColoredPrintf(2,"[ SKIPPED ] ");
FormatTestCount_abi_cxx11_(local_d8,local_b4);
uVar2 = std::__cxx11::string::c_str((string *)local_d8);
/* try { // try from 001d2a63 to 001d2a6e has its CatchHandler @ 001d2aa0 */
printf("%s.\n",uVar2);
std::__cxx11::string::~string((string *)local_d8);
}
iVar1 = UnitTest::reportable_disabled_test_count(local_10);
if ((iVar1 != 0) && ((FLAGS_gtest_also_run_disabled_tests & 1) == 0)) {
uVar4 = UnitTest::Passed(local_10);
if ((uVar4 & 1) != 0) {
printf("\n");
}
pcVar5 = "TESTS";
if (iVar1 == 1) {
pcVar5 = "TEST";
}
ColoredPrintf(3," YOU HAVE %d DISABLED %s\n\n",iVar1,pcVar5);
}
fflush(*(FILE **)PTR_stdout_00284f00);
return;
}
|
|
63,652
|
YAML::convert<aimrt::runtime::core::rpc::LocalRpcBackend::Options>::decode(YAML::Node const&, aimrt::runtime::core::rpc::LocalRpcBackend::Options&)
|
aimrt_mujoco_sim/_deps/aimrt-src/src/runtime/core/rpc/local_rpc_backend.cc
|
static bool decode(const Node& node, Options& rhs) {
if (node["timeout_executor"])
rhs.timeout_executor = node["timeout_executor"].as<std::string>();
return true;
}
|
O0
|
cpp
|
YAML::convert<aimrt::runtime::core::rpc::LocalRpcBackend::Options>::decode(YAML::Node const&, aimrt::runtime::core::rpc::LocalRpcBackend::Options&):
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq 0xd0(%rsp), %rsi
leaq 0x2ebbc3(%rip), %rdx # 0x5e8649
leaq 0x88(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1e4840
movq 0x8(%rsp), %rdi
callq 0x1ddda0
movb %al, 0x17(%rsp)
jmp 0x2fcaa8
leaq 0x88(%rsp), %rdi
callq 0x1e3e90
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x2fcac2
jmp 0x2fcb54
movq 0xd0(%rsp), %rsi
leaq 0x2ebb78(%rip), %rdx # 0x5e8649
leaq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x1e4840
movq (%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x1e3de0
jmp 0x2fcaef
movq 0xc8(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x1972d0
leaq 0x58(%rsp), %rdi
callq 0x1a7610
leaq 0x18(%rsp), %rdi
callq 0x1e3e90
jmp 0x2fcb54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x1e3e90
jmp 0x2fcb60
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x1e3e90
jmp 0x2fcb60
movb $0x1, %al
andb $0x1, %al
addq $0xd8, %rsp
retq
movq 0x80(%rsp), %rdi
callq 0x198ce0
nopl (%rax)
|
_ZN4YAML7convertIN5aimrt7runtime4core3rpc15LocalRpcBackend7OptionsEE6decodeERKNS_4NodeERS6_:
sub rsp, 0D8h
mov [rsp+0D8h+var_8], rdi
mov [rsp+0D8h+var_10], rsi
mov rsi, [rsp+0D8h+var_8]
lea rdx, aTimeoutExecuto_0; "timeout_executor"
lea rdi, [rsp+0D8h+var_50]
mov [rsp+0D8h+var_D0], rdi
call _ZNK4YAML4NodeixIA17_cEEKS0_RKT_; YAML::Node::operator[]<char [17]>(char [17] const&)
mov rdi, [rsp+0D8h+var_D0]
call _ZNK4YAML4NodecvbEv; YAML::Node::operator bool(void)
mov [rsp+0D8h+var_C1], al
jmp short $+2
loc_2FCAA8:
lea rdi, [rsp+0D8h+var_50]; this
call _ZN4YAML4NodeD2Ev; YAML::Node::~Node()
mov al, [rsp+0D8h+var_C1]
test al, 1
jnz short loc_2FCAC2
jmp loc_2FCB54
loc_2FCAC2:
mov rsi, [rsp+0D8h+var_8]
lea rdx, aTimeoutExecuto_0; "timeout_executor"
lea rdi, [rsp+0D8h+var_C0]
mov [rsp+0D8h+var_D8], rdi
call _ZNK4YAML4NodeixIA17_cEEKS0_RKT_; YAML::Node::operator[]<char [17]>(char [17] const&)
mov rsi, [rsp+0D8h+var_D8]
lea rdi, [rsp+0D8h+var_80]
call _ZNK4YAML4Node2asINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v; YAML::Node::as<std::string>(void)
jmp short $+2
loc_2FCAEF:
mov rdi, [rsp+0D8h+var_10]
lea rsi, [rsp+0D8h+var_80]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
lea rdi, [rsp+0D8h+var_80]; void *
call j__ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+0D8h+var_C0]; this
call _ZN4YAML4NodeD2Ev; YAML::Node::~Node()
jmp short loc_2FCB54
mov rcx, rax
mov eax, edx
mov [rsp+arg_78], rcx
mov [rsp+arg_74], eax
lea rdi, [rsp+arg_80]; this
call _ZN4YAML4NodeD2Ev; YAML::Node::~Node()
jmp short loc_2FCB60
mov rcx, rax
mov eax, edx
mov [rsp+arg_78], rcx
mov [rsp+arg_74], eax
lea rdi, [rsp+arg_10]; this
call _ZN4YAML4NodeD2Ev; YAML::Node::~Node()
jmp short loc_2FCB60
loc_2FCB54:
mov al, 1
and al, 1
add rsp, 0D8h
retn
loc_2FCB60:
mov rdi, [rsp+arg_78]
call __Unwind_Resume
|
char YAML::convert<aimrt::runtime::core::rpc::LocalRpcBackend::Options>::decode(YAML::Node *a1, long long a2)
{
char v3; // [rsp+17h] [rbp-C1h]
_BYTE v4[64]; // [rsp+18h] [rbp-C0h] BYREF
_BYTE v5[48]; // [rsp+58h] [rbp-80h] BYREF
_BYTE v6[64]; // [rsp+88h] [rbp-50h] BYREF
long long v7; // [rsp+C8h] [rbp-10h]
YAML::Node *v8; // [rsp+D0h] [rbp-8h]
v8 = a1;
v7 = a2;
YAML::Node::operator[]<char [17]>((long long)v6, a1, (long long)"timeout_executor");
v3 = YAML::Node::operator bool((YAML::Node *)v6);
YAML::Node::~Node((YAML::Node *)v6);
if ( (v3 & 1) != 0 )
{
YAML::Node::operator[]<char [17]>((long long)v4, v8, (long long)"timeout_executor");
YAML::Node::as<std::string>((long long)v5, v4);
std::string::operator=(v7, v5);
std::string::~string(v5);
YAML::Node::~Node((YAML::Node *)v4);
}
return 1;
}
|
get<1ul,aimrt::plugins::time_manipulator_plugin::TimeManipulatorServiceImpl*,std::default_delete<aimrt::plugins::time_manipulator_plugin::TimeManipulatorServiceImpl>>:
PUSH RAX
MOV qword ptr [RSP],RDI
MOV RDI,qword ptr [RSP]
CALL 0x002fca70
POP RCX
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* std::tuple_element<1ul,
std::tuple<aimrt::plugins::time_manipulator_plugin::TimeManipulatorServiceImpl*,
std::default_delete<aimrt::plugins::time_manipulator_plugin::TimeManipulatorServiceImpl> >
>::type& std::get<1ul, aimrt::plugins::time_manipulator_plugin::TimeManipulatorServiceImpl*,
std::default_delete<aimrt::plugins::time_manipulator_plugin::TimeManipulatorServiceImpl>
>(std::tuple<aimrt::plugins::time_manipulator_plugin::TimeManipulatorServiceImpl*,
std::default_delete<aimrt::plugins::time_manipulator_plugin::TimeManipulatorServiceImpl> >&) */
type * std::
get<1ul,aimrt::plugins::time_manipulator_plugin::TimeManipulatorServiceImpl*,std::default_delete<aimrt::plugins::time_manipulator_plugin::TimeManipulatorServiceImpl>>
(tuple *param_1)
{
default_delete *pdVar1;
pdVar1 = __get_helper<1ul,std::default_delete<aimrt::plugins::time_manipulator_plugin::TimeManipulatorServiceImpl>>
((_Tuple_impl *)param_1);
return (type *)pdVar1;
}
|
|
63,653
|
pfs_drop_table_share_v1
|
eloqsql/storage/perfschema/pfs.cc
|
void
pfs_drop_table_share_v1(my_bool temporary,
const char *schema_name, int schema_name_length,
const char *table_name, int table_name_length)
{
/* Ignore temporary tables. */
if (temporary)
return;
PFS_thread *pfs_thread= my_thread_get_THR_PFS();
if (unlikely(pfs_thread == NULL))
return;
/* TODO: temporary tables */
drop_table_share(pfs_thread, temporary, schema_name, schema_name_length,
table_name, table_name_length);
}
|
O0
|
cpp
|
pfs_drop_table_share_v1:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
cmpb $0x0, -0x1(%rbp)
je 0x48e65
jmp 0x48ea7
callq 0x48dd0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x48e82
jmp 0x48ea7
movq -0x30(%rbp), %rdi
cmpb $0x0, -0x1(%rbp)
setne %al
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %r8
movl -0x24(%rbp), %r9d
movzbl %al, %esi
andl $0x1, %esi
callq 0x301f0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
|
pfs_drop_table_share_v1:
push rbp
mov rbp, rsp
sub rsp, 30h
mov al, dil
mov [rbp+var_1], al
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_20], rcx
mov [rbp+var_24], r8d
cmp [rbp+var_1], 0
jz short loc_48E65
jmp short loc_48EA7
loc_48E65:
call _ZL21my_thread_get_THR_PFSv; my_thread_get_THR_PFS(void)
mov [rbp+var_30], rax
cmp [rbp+var_30], 0
setz al
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_48E82
jmp short loc_48EA7
loc_48E82:
mov rdi, [rbp+var_30]; PFS_thread *
cmp [rbp+var_1], 0
setnz al
mov rdx, [rbp+var_10]; char *
mov ecx, [rbp+var_14]; unsigned int
mov r8, [rbp+var_20]; char *
mov r9d, [rbp+var_24]; unsigned int
movzx esi, al
and esi, 1; bool
call _Z16drop_table_shareP10PFS_threadbPKcjS2_j; drop_table_share(PFS_thread *,bool,char const*,uint,char const*,uint)
loc_48EA7:
add rsp, 30h
pop rbp
retn
|
char pfs_drop_table_share_v1(char a1, const char *a2, unsigned int a3, const char *a4, unsigned int a5)
{
char result; // al
PFS_thread *THR_PFS; // [rsp+0h] [rbp-30h]
result = a1;
if ( !a1 )
{
THR_PFS = (PFS_thread *)my_thread_get_THR_PFS();
result = THR_PFS == 0LL;
if ( THR_PFS )
return drop_table_share(THR_PFS, 0, a2, a3, a4, a5);
}
return result;
}
|
pfs_drop_table_share_v1:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV AL,DIL
MOV byte ptr [RBP + -0x1],AL
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV dword ptr [RBP + -0x24],R8D
CMP byte ptr [RBP + -0x1],0x0
JZ 0x00148e65
JMP 0x00148ea7
LAB_00148e65:
CALL 0x00148dd0
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x30],0x0
SETZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x00148e82
JMP 0x00148ea7
LAB_00148e82:
MOV RDI,qword ptr [RBP + -0x30]
CMP byte ptr [RBP + -0x1],0x0
SETNZ AL
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x14]
MOV R8,qword ptr [RBP + -0x20]
MOV R9D,dword ptr [RBP + -0x24]
MOVZX ESI,AL
AND ESI,0x1
CALL 0x001301f0
LAB_00148ea7:
ADD RSP,0x30
POP RBP
RET
|
void pfs_drop_table_share_v1(char param_1,char *param_2,uint param_3,char *param_4,uint param_5)
{
PFS_thread *pPVar1;
if ((param_1 == '\0') &&
(pPVar1 = (PFS_thread *)my_thread_get_THR_PFS(), pPVar1 != (PFS_thread *)0x0)) {
drop_table_share(pPVar1,false,param_2,param_3,param_4,param_5);
}
return;
}
|
|
63,654
|
js_object_isPrototypeOf
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_object_isPrototypeOf(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue obj, v1;
JSValue v;
int res;
v = argv[0];
if (!JS_IsObject(v))
return JS_FALSE;
obj = JS_ToObject(ctx, this_val);
if (JS_IsException(obj))
return JS_EXCEPTION;
v1 = js_dup(v);
for(;;) {
v1 = JS_GetPrototypeFree(ctx, v1);
if (JS_IsException(v1))
goto exception;
if (JS_IsNull(v1)) {
res = FALSE;
break;
}
if (JS_VALUE_GET_OBJ(obj) == JS_VALUE_GET_OBJ(v1)) {
res = TRUE;
break;
}
/* avoid infinite loop (possible with proxies) */
if (js_poll_interrupts(ctx))
goto exception;
}
JS_FreeValue(ctx, v1);
JS_FreeValue(ctx, obj);
return js_bool(res);
exception:
JS_FreeValue(ctx, v1);
JS_FreeValue(ctx, obj);
return JS_EXCEPTION;
}
|
O1
|
c
|
js_object_isPrototypeOf:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x8(%r8), %r15
movl $0x1, %ecx
cmpl $-0x1, %r15d
jne 0x714d4
movq %rdi, %r14
movq (%r8), %xmm0
movq %xmm0, 0x18(%rsp)
callq 0x26ddd
movq %rax, 0x20(%rsp)
movl $0x6, %ecx
cmpl $0x6, %edx
jne 0x714ec
xorl %r15d, %r15d
movq %r15, %rax
movq %rcx, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %xmm0
movq %xmm0, (%rsp)
movq (%rsp), %rax
incl (%rax)
movq %xmm0, (%rsp)
movq %xmm0, %r12
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x2289f
movq %rax, %r13
movq %rdx, %rbp
movq 0x18(%r14), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1d8c6
movq %r13, (%rsp)
movl %ebp, %eax
cmpq $0x6, %rax
jne 0x71572
movq %rbp, %r15
movq 0x18(%r14), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x1d8c6
movq 0x18(%r14), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x1d8c6
xorl %r15d, %r15d
movl $0x6, %ecx
jmp 0x714d7
movq 0x20(%rsp), %rbx
cmpq $0x2, %rax
je 0x715e6
cmpq (%rsp), %rbx
je 0x715e6
movl 0x1d8(%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x1d8(%r14)
cmpl $0x1, %eax
jle 0x715d5
movq (%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x2289f
movq %rax, %r13
movq %rdx, %r15
movq 0x18(%r14), %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x1d8c6
movq %r13, (%rsp)
movl %r15d, %eax
movq %r15, %rbp
cmpq $0x6, %rax
jne 0x71577
jmp 0x71543
movq %r14, %rdi
callq 0x3d4e2
testl %eax, %eax
je 0x71599
jmp 0x71540
xorl %r15d, %r15d
cmpq $0x2, %rax
setne %r15b
movq 0x18(%r14), %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x1d8c6
movq 0x18(%r14), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x1d8c6
movl $0x1, %ecx
jmp 0x714d7
|
js_object_isPrototypeOf:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r15, [r8+8]
mov ecx, 1
cmp r15d, 0FFFFFFFFh
jnz short loc_714D4
mov r14, rdi
movq xmm0, qword ptr [r8]
movq [rsp+58h+var_40], xmm0
call JS_ToObject
mov [rsp+58h+var_38], rax
mov ecx, 6
cmp edx, 6
jnz short loc_714EC
loc_714D4:
xor r15d, r15d
loc_714D7:
mov rax, r15
mov rdx, rcx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_714EC:
mov [rsp+58h+var_50], rax
mov [rsp+58h+var_48], rdx
movq xmm0, [rsp+58h+var_40]
movq [rsp+58h+var_58], xmm0
mov rax, [rsp+58h+var_58]
inc dword ptr [rax]
movq [rsp+58h+var_58], xmm0
movq r12, xmm0
mov rdi, r14
mov rsi, r12
mov rdx, r15
call JS_GetPrototype
mov r13, rax
mov rbp, rdx
mov rdi, [r14+18h]
mov rsi, r12
mov rdx, r15
call JS_FreeValueRT
mov [rsp+58h+var_58], r13
mov eax, ebp
cmp rax, 6
jnz short loc_71572
loc_71540:
mov r15, rbp
loc_71543:
mov rdi, [r14+18h]
mov rsi, r13
mov rdx, r15
call JS_FreeValueRT
mov rdi, [r14+18h]
mov rsi, [rsp+58h+var_50]
mov rdx, [rsp+58h+var_48]
call JS_FreeValueRT
xor r15d, r15d
mov ecx, 6
jmp loc_714D7
loc_71572:
mov rbx, [rsp+58h+var_38]
loc_71577:
cmp rax, 2
jz short loc_715E6
cmp rbx, [rsp+58h+var_58]
jz short loc_715E6
mov eax, [r14+1D8h]
lea ecx, [rax-1]
mov [r14+1D8h], ecx
cmp eax, 1
jle short loc_715D5
loc_71599:
mov r12, [rsp+58h+var_58]
mov rdi, r14
mov rsi, r12
mov rdx, rbp
call JS_GetPrototype
mov r13, rax
mov r15, rdx
mov rdi, [r14+18h]
mov rsi, r12
mov rdx, rbp
call JS_FreeValueRT
mov [rsp+58h+var_58], r13
mov eax, r15d
mov rbp, r15
cmp rax, 6
jnz short loc_71577
jmp loc_71543
loc_715D5:
mov rdi, r14
call __js_poll_interrupts
test eax, eax
jz short loc_71599
jmp loc_71540
loc_715E6:
xor r15d, r15d
cmp rax, 2
setnz r15b
mov rdi, [r14+18h]
mov rsi, r13
mov rdx, rbp
call JS_FreeValueRT
mov rdi, [r14+18h]
mov rsi, [rsp+58h+var_50]
mov rdx, [rsp+58h+var_48]
call JS_FreeValueRT
mov ecx, 1
jmp loc_714D7
|
_BOOL8 js_object_isPrototypeOf(
long long a1,
long long a2,
long long a3,
double a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
long long a12,
const __m128i *a13,
long long a14)
{
long long v14; // r15
__m128 v15; // xmm0
_DWORD *v16; // rax
long long v17; // rdx
_BOOL8 v18; // r15
__m128 v20; // xmm0
_DWORD *Prototype; // r13
long long v22; // rdx
long long v23; // rbp
double v24; // xmm4_8
double v25; // xmm5_8
long long v26; // rax
long long v27; // r15
long long v28; // rbx
int v29; // eax
long long v30; // rdx
_DWORD *v31; // [rsp+0h] [rbp-58h]
_DWORD *v32; // [rsp+8h] [rbp-50h]
long long v33; // [rsp+10h] [rbp-48h]
__m128i v34; // [rsp+18h] [rbp-40h] BYREF
v14 = a13->m128i_i64[1];
if ( (_DWORD)v14 != -1 )
return 0LL;
v15 = (__m128)_mm_loadl_epi64(a13);
v34.m128i_i64[0] = v15.m128_u64[0];
v16 = JS_ToObject(a1, a2, a3, 1LL, (long long)a13, a14, v15, a5, a6, a7, a8, a9, a10, a11);
v34.m128i_i64[1] = (long long)v16;
if ( (_DWORD)v17 == 6 )
return 0LL;
v32 = v16;
v33 = v17;
v20 = (__m128)_mm_loadl_epi64(&v34);
++*(_DWORD *)v20.m128_u64[0];
Prototype = (_DWORD *)JS_GetPrototype(a1, v20.m128_i64[0], v14);
v23 = v22;
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v20.m128_u64[0], v14);
v31 = Prototype;
v26 = (unsigned int)v23;
if ( (unsigned int)v23 == 6LL )
{
LABEL_6:
v27 = v23;
LABEL_7:
JS_FreeValueRT(*(_QWORD *)(a1 + 24), Prototype, v27);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v32, v33);
return 0LL;
}
else
{
v28 = v34.m128i_i64[1];
while ( v26 != 2 && (_DWORD *)v28 != v31 )
{
v29 = *(_DWORD *)(a1 + 472);
*(_DWORD *)(a1 + 472) = v29 - 1;
if ( v29 <= 1 && (unsigned int)_js_poll_interrupts(a1, v20, a5, a6, a7, v24, v25, a10, a11) )
goto LABEL_6;
Prototype = (_DWORD *)JS_GetPrototype(a1, (long long)v31, v23);
v27 = v30;
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v31, v23);
v31 = Prototype;
v26 = (unsigned int)v27;
v23 = v27;
if ( (unsigned int)v27 == 6LL )
goto LABEL_7;
}
v18 = v26 != 2;
JS_FreeValueRT(*(_QWORD *)(a1 + 24), Prototype, v23);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v32, v33);
}
return v18;
}
|
js_object_isPrototypeOf:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R15,qword ptr [R8 + 0x8]
MOV ECX,0x1
CMP R15D,-0x1
JNZ 0x001714d4
MOV R14,RDI
MOVQ XMM0,qword ptr [R8]
MOVQ qword ptr [RSP + 0x18],XMM0
CALL 0x00126ddd
MOV qword ptr [RSP + 0x20],RAX
MOV ECX,0x6
CMP EDX,0x6
JNZ 0x001714ec
LAB_001714d4:
XOR R15D,R15D
LAB_001714d7:
MOV RAX,R15
MOV RDX,RCX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001714ec:
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RDX
MOVQ XMM0,qword ptr [RSP + 0x18]
MOVQ qword ptr [RSP],XMM0
MOV RAX,qword ptr [RSP]
INC dword ptr [RAX]
MOVQ qword ptr [RSP],XMM0
MOVQ R12,XMM0
MOV RDI,R14
MOV RSI,R12
MOV RDX,R15
CALL 0x0012289f
MOV R13,RAX
MOV RBP,RDX
MOV RDI,qword ptr [R14 + 0x18]
MOV RSI,R12
MOV RDX,R15
CALL 0x0011d8c6
MOV qword ptr [RSP],R13
MOV EAX,EBP
CMP RAX,0x6
JNZ 0x00171572
LAB_00171540:
MOV R15,RBP
LAB_00171543:
MOV RDI,qword ptr [R14 + 0x18]
MOV RSI,R13
MOV RDX,R15
CALL 0x0011d8c6
MOV RDI,qword ptr [R14 + 0x18]
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
CALL 0x0011d8c6
XOR R15D,R15D
MOV ECX,0x6
JMP 0x001714d7
LAB_00171572:
MOV RBX,qword ptr [RSP + 0x20]
LAB_00171577:
CMP RAX,0x2
JZ 0x001715e6
CMP RBX,qword ptr [RSP]
JZ 0x001715e6
MOV EAX,dword ptr [R14 + 0x1d8]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R14 + 0x1d8],ECX
CMP EAX,0x1
JLE 0x001715d5
LAB_00171599:
MOV R12,qword ptr [RSP]
MOV RDI,R14
MOV RSI,R12
MOV RDX,RBP
CALL 0x0012289f
MOV R13,RAX
MOV R15,RDX
MOV RDI,qword ptr [R14 + 0x18]
MOV RSI,R12
MOV RDX,RBP
CALL 0x0011d8c6
MOV qword ptr [RSP],R13
MOV EAX,R15D
MOV RBP,R15
CMP RAX,0x6
JNZ 0x00171577
JMP 0x00171543
LAB_001715d5:
MOV RDI,R14
CALL 0x0013d4e2
TEST EAX,EAX
JZ 0x00171599
JMP 0x00171540
LAB_001715e6:
XOR R15D,R15D
CMP RAX,0x2
SETNZ R15B
MOV RDI,qword ptr [R14 + 0x18]
MOV RSI,R13
MOV RDX,RBP
CALL 0x0011d8c6
MOV RDI,qword ptr [R14 + 0x18]
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
CALL 0x0011d8c6
MOV ECX,0x1
JMP 0x001714d7
|
bool js_object_isPrototypeOf(long param_1)
{
int *piVar1;
int iVar2;
long lVar3;
ulong uVar4;
int8 uVar5;
int8 *in_R8;
long lVar6;
int1 auVar7 [16];
int1 auVar8 [16];
uVar5 = in_R8[1];
if ((int)uVar5 == -1) {
piVar1 = (int *)*in_R8;
auVar7 = JS_ToObject();
lVar3 = auVar7._0_8_;
if (auVar7._8_4_ != 6) {
*piVar1 = *piVar1 + 1;
auVar8 = JS_GetPrototype(param_1,piVar1,uVar5);
uVar4 = auVar8._8_8_;
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),piVar1,uVar5);
while( true ) {
uVar4 = uVar4 & 0xffffffff;
lVar6 = auVar8._0_8_;
uVar5 = auVar8._8_8_;
if (uVar4 == 6) break;
if ((uVar4 == 2) || (lVar3 == lVar6)) {
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),lVar6,uVar5);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),lVar3,auVar7._8_8_);
return uVar4 != 2;
}
iVar2 = *(int *)(param_1 + 0x1d8);
*(int *)(param_1 + 0x1d8) = iVar2 + -1;
if ((iVar2 < 2) && (iVar2 = __js_poll_interrupts(param_1), iVar2 != 0)) break;
auVar8 = JS_GetPrototype(param_1,lVar6,uVar5);
uVar4 = auVar8._8_8_;
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),lVar6,uVar5);
}
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),lVar6,uVar5);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),lVar3,auVar7._8_8_);
return false;
}
}
return false;
}
|
|
63,655
|
ma_pvio_start_ssl
|
eloqsql/libmariadb/libmariadb/ma_pvio.c
|
my_bool ma_pvio_start_ssl(MARIADB_PVIO *pvio)
{
if (!pvio || !pvio->mysql)
return 1;
CLEAR_CLIENT_ERROR(pvio->mysql);
if (!(pvio->ctls= ma_pvio_tls_init(pvio->mysql)))
{
return 1;
}
if (ma_pvio_tls_connect(pvio->ctls))
{
free(pvio->ctls);
pvio->ctls= NULL;
return 1;
}
/* default behaviour:
1. peer certificate verification
2. verify CN (requires option ssl_verify_check)
3. verrify finger print
*/
if ((pvio->mysql->client_flag & CLIENT_SSL_VERIFY_SERVER_CERT) &&
ma_pvio_tls_verify_server_cert(pvio->ctls))
return 1;
if (pvio->mysql->options.extension &&
((pvio->mysql->options.extension->tls_fp && pvio->mysql->options.extension->tls_fp[0]) ||
(pvio->mysql->options.extension->tls_fp_list && pvio->mysql->options.extension->tls_fp_list[0])))
{
if (ma_pvio_tls_check_fp(pvio->ctls,
pvio->mysql->options.extension->tls_fp,
pvio->mysql->options.extension->tls_fp_list))
return 1;
}
return 0;
}
|
O0
|
c
|
ma_pvio_start_ssl:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7ec8e
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x7ec97
movb $0x1, -0x1(%rbp)
jmp 0x7ee59
jmp 0x7ec99
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movl $0x0, 0x90(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
addq $0x297, %rdi # imm = 0x297
leaq 0x96616(%rip), %rsi # 0x1152d7
callq 0x3b4c0
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movb $0x0, 0x97(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
cmpq $0x0, 0x2a0(%rax)
je 0x7ecfd
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x2a0(%rax), %rax
movl $0x0, 0x4(%rax)
jmp 0x7ecff
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x7ef30
movq -0x10(%rbp), %rcx
movq %rax, 0x38(%rcx)
cmpq $0x0, %rax
jne 0x7ed23
movb $0x1, -0x1(%rbp)
jmp 0x7ee59
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x7efe0
cmpb $0x0, %al
je 0x7ed56
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x3b220
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x7ee59
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x368(%rax), %rax
andq $0x40000000, %rax # imm = 0x40000000
cmpq $0x0, %rax
je 0x7ed8c
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x7f090
cmpl $0x0, %eax
je 0x7ed8c
movb $0x1, -0x1(%rbp)
jmp 0x7ee59
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
cmpq $0x0, 0x480(%rax)
je 0x7ee55
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x480(%rax), %rax
cmpq $0x0, 0x90(%rax)
je 0x7edd9
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x480(%rax), %rax
movq 0x90(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x7ee10
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x480(%rax), %rax
cmpq $0x0, 0x98(%rax)
je 0x7ee55
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x480(%rax), %rax
movq 0x98(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x7ee55
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x480(%rax), %rax
movq 0x90(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x480(%rax), %rax
movq 0x98(%rax), %rdx
callq 0x7f160
cmpb $0x0, %al
je 0x7ee53
movb $0x1, -0x1(%rbp)
jmp 0x7ee59
jmp 0x7ee55
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
ma_pvio_start_ssl:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_10], rdi
cmp [rbp+var_10], 0
jz short loc_7EC8E
mov rax, [rbp+var_10]
cmp qword ptr [rax+40h], 0
jnz short loc_7EC97
loc_7EC8E:
mov [rbp+var_1], 1
jmp loc_7EE59
loc_7EC97:
jmp short $+2
loc_7EC99:
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov dword ptr [rax+90h], 0
mov rax, [rbp+var_10]
mov rdi, [rax+40h]
add rdi, 297h
lea rsi, a00000; "00000"
call _strcpy
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov byte ptr [rax+97h], 0
mov rax, [rbp+var_10]
mov rax, [rax+40h]
cmp qword ptr [rax+2A0h], 0
jz short loc_7ECFD
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rax, [rax+2A0h]
mov dword ptr [rax+4], 0
loc_7ECFD:
jmp short $+2
loc_7ECFF:
mov rax, [rbp+var_10]
mov rdi, [rax+40h]
call ma_pvio_tls_init
mov rcx, [rbp+var_10]
mov [rcx+38h], rax
cmp rax, 0
jnz short loc_7ED23
mov [rbp+var_1], 1
jmp loc_7EE59
loc_7ED23:
mov rax, [rbp+var_10]
mov rdi, [rax+38h]
call ma_pvio_tls_connect
cmp al, 0
jz short loc_7ED56
mov rax, [rbp+var_10]
mov rdi, [rax+38h]
call _free
mov rax, [rbp+var_10]
mov qword ptr [rax+38h], 0
mov [rbp+var_1], 1
jmp loc_7EE59
loc_7ED56:
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rax, [rax+368h]
and rax, 40000000h
cmp rax, 0
jz short loc_7ED8C
mov rax, [rbp+var_10]
mov rdi, [rax+38h]
call ma_pvio_tls_verify_server_cert
cmp eax, 0
jz short loc_7ED8C
mov [rbp+var_1], 1
jmp loc_7EE59
loc_7ED8C:
mov rax, [rbp+var_10]
mov rax, [rax+40h]
cmp qword ptr [rax+480h], 0
jz loc_7EE55
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rax, [rax+480h]
cmp qword ptr [rax+90h], 0
jz short loc_7EDD9
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rax, [rax+480h]
mov rax, [rax+90h]
movsx eax, byte ptr [rax]
cmp eax, 0
jnz short loc_7EE10
loc_7EDD9:
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rax, [rax+480h]
cmp qword ptr [rax+98h], 0
jz short loc_7EE55
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rax, [rax+480h]
mov rax, [rax+98h]
movsx eax, byte ptr [rax]
cmp eax, 0
jz short loc_7EE55
loc_7EE10:
mov rax, [rbp+var_10]
mov rdi, [rax+38h]
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rax, [rax+480h]
mov rsi, [rax+90h]
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rax, [rax+480h]
mov rdx, [rax+98h]
call ma_pvio_tls_check_fp
cmp al, 0
jz short loc_7EE53
mov [rbp+var_1], 1
jmp short loc_7EE59
loc_7EE53:
jmp short $+2
loc_7EE55:
mov [rbp+var_1], 0
loc_7EE59:
mov al, [rbp+var_1]
add rsp, 10h
pop rbp
retn
|
bool ma_pvio_start_ssl(long long a1)
{
long long v1; // rax
if ( !a1 || !*(_QWORD *)(a1 + 64) )
return 1;
*(_DWORD *)(*(_QWORD *)(a1 + 64) + 144LL) = 0;
strcpy(*(_QWORD *)(a1 + 64) + 663LL, "00000");
*(_BYTE *)(*(_QWORD *)(a1 + 64) + 151LL) = 0;
if ( *(_QWORD *)(*(_QWORD *)(a1 + 64) + 672LL) )
*(_DWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 64) + 672LL) + 4LL) = 0;
v1 = ma_pvio_tls_init(*(_QWORD *)(a1 + 64));
*(_QWORD *)(a1 + 56) = v1;
if ( !v1 )
return 1;
if ( !(unsigned __int8)ma_pvio_tls_connect(*(_QWORD *)(a1 + 56)) )
return (*(_QWORD *)(*(_QWORD *)(a1 + 64) + 872LL) & 0x40000000LL) != 0
&& (unsigned int)ma_pvio_tls_verify_server_cert(*(_QWORD *)(a1 + 56))
|| *(_QWORD *)(*(_QWORD *)(a1 + 64) + 1152LL)
&& (*(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 64) + 1152LL) + 144LL)
&& **(_BYTE **)(*(_QWORD *)(*(_QWORD *)(a1 + 64) + 1152LL) + 144LL)
|| *(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 64) + 1152LL) + 152LL)
&& **(_BYTE **)(*(_QWORD *)(*(_QWORD *)(a1 + 64) + 1152LL) + 152LL))
&& (unsigned __int8)ma_pvio_tls_check_fp(
*(_QWORD *)(a1 + 56),
*(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 64) + 1152LL) + 144LL),
*(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 64) + 1152LL) + 152LL));
free(*(_QWORD *)(a1 + 56));
*(_QWORD *)(a1 + 56) = 0LL;
return 1;
}
|
ma_pvio_start_ssl:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x10],RDI
CMP qword ptr [RBP + -0x10],0x0
JZ 0x0017ec8e
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x40],0x0
JNZ 0x0017ec97
LAB_0017ec8e:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0017ee59
LAB_0017ec97:
JMP 0x0017ec99
LAB_0017ec99:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV dword ptr [RAX + 0x90],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x40]
ADD RDI,0x297
LEA RSI,[0x2152d7]
CALL 0x0013b4c0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV byte ptr [RAX + 0x97],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
CMP qword ptr [RAX + 0x2a0],0x0
JZ 0x0017ecfd
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RAX,qword ptr [RAX + 0x2a0]
MOV dword ptr [RAX + 0x4],0x0
LAB_0017ecfd:
JMP 0x0017ecff
LAB_0017ecff:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x40]
CALL 0x0017ef30
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x38],RAX
CMP RAX,0x0
JNZ 0x0017ed23
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0017ee59
LAB_0017ed23:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x38]
CALL 0x0017efe0
CMP AL,0x0
JZ 0x0017ed56
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x38]
CALL 0x0013b220
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x38],0x0
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0017ee59
LAB_0017ed56:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RAX,qword ptr [RAX + 0x368]
AND RAX,0x40000000
CMP RAX,0x0
JZ 0x0017ed8c
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x38]
CALL 0x0017f090
CMP EAX,0x0
JZ 0x0017ed8c
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0017ee59
LAB_0017ed8c:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
CMP qword ptr [RAX + 0x480],0x0
JZ 0x0017ee55
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RAX,qword ptr [RAX + 0x480]
CMP qword ptr [RAX + 0x90],0x0
JZ 0x0017edd9
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x90]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JNZ 0x0017ee10
LAB_0017edd9:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RAX,qword ptr [RAX + 0x480]
CMP qword ptr [RAX + 0x98],0x0
JZ 0x0017ee55
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x98]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JZ 0x0017ee55
LAB_0017ee10:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RAX,qword ptr [RAX + 0x480]
MOV RSI,qword ptr [RAX + 0x90]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RAX,qword ptr [RAX + 0x480]
MOV RDX,qword ptr [RAX + 0x98]
CALL 0x0017f160
CMP AL,0x0
JZ 0x0017ee53
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0017ee59
LAB_0017ee53:
JMP 0x0017ee55
LAB_0017ee55:
MOV byte ptr [RBP + -0x1],0x0
LAB_0017ee59:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x10
POP RBP
RET
|
int1 ma_pvio_start_ssl(long param_1)
{
char cVar1;
int iVar2;
long lVar3;
int1 local_9;
if ((param_1 == 0) || (*(long *)(param_1 + 0x40) == 0)) {
local_9 = 1;
}
else {
*(int4 *)(*(long *)(param_1 + 0x40) + 0x90) = 0;
strcpy((char *)(*(long *)(param_1 + 0x40) + 0x297),"00000");
*(int1 *)(*(long *)(param_1 + 0x40) + 0x97) = 0;
if (*(long *)(*(long *)(param_1 + 0x40) + 0x2a0) != 0) {
*(int4 *)(*(long *)(*(long *)(param_1 + 0x40) + 0x2a0) + 4) = 0;
}
lVar3 = ma_pvio_tls_init(*(int8 *)(param_1 + 0x40));
*(long *)(param_1 + 0x38) = lVar3;
if (lVar3 == 0) {
local_9 = 1;
}
else {
cVar1 = ma_pvio_tls_connect(*(int8 *)(param_1 + 0x38));
if (cVar1 == '\0') {
if (((*(ulong *)(*(long *)(param_1 + 0x40) + 0x368) & 0x40000000) == 0) ||
(iVar2 = ma_pvio_tls_verify_server_cert(*(int8 *)(param_1 + 0x38)), iVar2 == 0)) {
if (((*(long *)(*(long *)(param_1 + 0x40) + 0x480) == 0) ||
(((*(long *)(*(long *)(*(long *)(param_1 + 0x40) + 0x480) + 0x90) == 0 ||
(**(char **)(*(long *)(*(long *)(param_1 + 0x40) + 0x480) + 0x90) == '\0')) &&
((*(long *)(*(long *)(*(long *)(param_1 + 0x40) + 0x480) + 0x98) == 0 ||
(**(char **)(*(long *)(*(long *)(param_1 + 0x40) + 0x480) + 0x98) == '\0')))))) ||
(cVar1 = ma_pvio_tls_check_fp
(*(int8 *)(param_1 + 0x38),
*(int8 *)
(*(long *)(*(long *)(param_1 + 0x40) + 0x480) + 0x90),
*(int8 *)
(*(long *)(*(long *)(param_1 + 0x40) + 0x480) + 0x98)),
cVar1 == '\0')) {
local_9 = 0;
}
else {
local_9 = 1;
}
}
else {
local_9 = 1;
}
}
else {
free(*(void **)(param_1 + 0x38));
*(int8 *)(param_1 + 0x38) = 0;
local_9 = 1;
}
}
}
return local_9;
}
|
|
63,656
|
ma_pvio_start_ssl
|
eloqsql/libmariadb/libmariadb/ma_pvio.c
|
my_bool ma_pvio_start_ssl(MARIADB_PVIO *pvio)
{
if (!pvio || !pvio->mysql)
return 1;
CLEAR_CLIENT_ERROR(pvio->mysql);
if (!(pvio->ctls= ma_pvio_tls_init(pvio->mysql)))
{
return 1;
}
if (ma_pvio_tls_connect(pvio->ctls))
{
free(pvio->ctls);
pvio->ctls= NULL;
return 1;
}
/* default behaviour:
1. peer certificate verification
2. verify CN (requires option ssl_verify_check)
3. verrify finger print
*/
if ((pvio->mysql->client_flag & CLIENT_SSL_VERIFY_SERVER_CERT) &&
ma_pvio_tls_verify_server_cert(pvio->ctls))
return 1;
if (pvio->mysql->options.extension &&
((pvio->mysql->options.extension->tls_fp && pvio->mysql->options.extension->tls_fp[0]) ||
(pvio->mysql->options.extension->tls_fp_list && pvio->mysql->options.extension->tls_fp_list[0])))
{
if (ma_pvio_tls_check_fp(pvio->ctls,
pvio->mysql->options.extension->tls_fp,
pvio->mysql->options.extension->tls_fp_list))
return 1;
}
return 0;
}
|
O3
|
c
|
ma_pvio_start_ssl:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movb $0x1, %bl
testq %rdi, %rdi
je 0x619a4
movq %rdi, %r14
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0x619a4
movl $0x0, 0x90(%rax)
movq 0x40(%r14), %rax
movw $0x30, 0x29b(%rax)
movl $0x30303030, 0x297(%rax) # imm = 0x30303030
movq 0x40(%r14), %rax
movb $0x0, 0x97(%rax)
movq 0x40(%r14), %rdi
movq 0x2a0(%rdi), %rax
testq %rax, %rax
je 0x6190f
movl $0x0, 0x4(%rax)
movq 0x40(%r14), %rdi
callq 0x61a20
movq %rax, 0x38(%r14)
testq %rax, %rax
je 0x619a4
movq %rax, %rdi
callq 0x61a88
testb %al, %al
je 0x61940
movq 0x38(%r14), %rdi
callq 0x3a210
movq $0x0, 0x38(%r14)
jmp 0x619a4
movq 0x40(%r14), %rax
testb $0x40, 0x36b(%rax)
je 0x6195e
movq 0x38(%r14), %rdi
callq 0x61acc
testl %eax, %eax
jne 0x619a4
movq 0x40(%r14), %rax
movq 0x480(%rax), %rax
testq %rax, %rax
je 0x619a2
movq 0x90(%rax), %rsi
testq %rsi, %rsi
je 0x61984
cmpb $0x0, (%rsi)
je 0x61984
movq 0x98(%rax), %rdx
jmp 0x61995
movq 0x98(%rax), %rdx
testq %rdx, %rdx
je 0x619a2
cmpb $0x0, (%rdx)
je 0x619a2
movq 0x38(%r14), %rdi
callq 0x61b1c
testb %al, %al
jne 0x619a4
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
|
ma_pvio_start_ssl:
push rbp
mov rbp, rsp
push r14
push rbx
mov bl, 1
test rdi, rdi
jz loc_619A4
mov r14, rdi
mov rax, [rdi+40h]
test rax, rax
jz loc_619A4
mov dword ptr [rax+90h], 0
mov rax, [r14+40h]
mov word ptr [rax+29Bh], 30h ; '0'
mov dword ptr [rax+297h], 30303030h
mov rax, [r14+40h]
mov byte ptr [rax+97h], 0
mov rdi, [r14+40h]
mov rax, [rdi+2A0h]
test rax, rax
jz short loc_6190F
mov dword ptr [rax+4], 0
mov rdi, [r14+40h]
loc_6190F:
call ma_pvio_tls_init
mov [r14+38h], rax
test rax, rax
jz loc_619A4
mov rdi, rax
call ma_pvio_tls_connect
test al, al
jz short loc_61940
mov rdi, [r14+38h]
call _free
mov qword ptr [r14+38h], 0
jmp short loc_619A4
loc_61940:
mov rax, [r14+40h]
test byte ptr [rax+36Bh], 40h
jz short loc_6195E
mov rdi, [r14+38h]
call ma_pvio_tls_verify_server_cert
test eax, eax
jnz short loc_619A4
mov rax, [r14+40h]
loc_6195E:
mov rax, [rax+480h]
test rax, rax
jz short loc_619A2
mov rsi, [rax+90h]
test rsi, rsi
jz short loc_61984
cmp byte ptr [rsi], 0
jz short loc_61984
mov rdx, [rax+98h]
jmp short loc_61995
loc_61984:
mov rdx, [rax+98h]
test rdx, rdx
jz short loc_619A2
cmp byte ptr [rdx], 0
jz short loc_619A2
loc_61995:
mov rdi, [r14+38h]
call ma_pvio_tls_check_fp
test al, al
jnz short loc_619A4
loc_619A2:
xor ebx, ebx
loc_619A4:
mov eax, ebx
pop rbx
pop r14
pop rbp
retn
|
long long ma_pvio_start_ssl(long long a1)
{
unsigned int v1; // ebx
long long v3; // rax
long long v4; // rdi
long long v5; // rax
long long v6; // rax
long long v7; // rax
long long v8; // rax
_BYTE *v9; // rsi
_BYTE *v10; // rdx
LOBYTE(v1) = 1;
if ( a1 )
{
v3 = *(_QWORD *)(a1 + 64);
if ( v3 )
{
*(_DWORD *)(v3 + 144) = 0;
strcpy((char *)(*(_QWORD *)(a1 + 64) + 663LL), "00000");
*(_BYTE *)(*(_QWORD *)(a1 + 64) + 151LL) = 0;
v4 = *(_QWORD *)(a1 + 64);
v5 = *(_QWORD *)(v4 + 672);
if ( v5 )
{
*(_DWORD *)(v5 + 4) = 0;
v4 = *(_QWORD *)(a1 + 64);
}
v6 = ma_pvio_tls_init(v4);
*(_QWORD *)(a1 + 56) = v6;
if ( v6 )
{
if ( (unsigned __int8)ma_pvio_tls_connect(v6) )
{
free(*(_QWORD *)(a1 + 56));
*(_QWORD *)(a1 + 56) = 0LL;
return v1;
}
v7 = *(_QWORD *)(a1 + 64);
if ( (*(_BYTE *)(v7 + 875) & 0x40) != 0 )
{
if ( (unsigned int)ma_pvio_tls_verify_server_cert(*(_QWORD *)(a1 + 56)) )
return v1;
v7 = *(_QWORD *)(a1 + 64);
}
v8 = *(_QWORD *)(v7 + 1152);
if ( v8 )
{
v9 = *(_BYTE **)(v8 + 144);
if ( v9 && *v9 )
{
v10 = *(_BYTE **)(v8 + 152);
}
else
{
v10 = *(_BYTE **)(v8 + 152);
if ( !v10 || !*v10 )
return 0;
}
if ( (unsigned __int8)ma_pvio_tls_check_fp(*(_QWORD *)(a1 + 56), v9, v10) )
return v1;
}
return 0;
}
}
}
return v1;
}
|
ma_pvio_start_ssl:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV BL,0x1
TEST RDI,RDI
JZ 0x001619a4
MOV R14,RDI
MOV RAX,qword ptr [RDI + 0x40]
TEST RAX,RAX
JZ 0x001619a4
MOV dword ptr [RAX + 0x90],0x0
MOV RAX,qword ptr [R14 + 0x40]
MOV word ptr [RAX + 0x29b],0x30
MOV dword ptr [RAX + 0x297],0x30303030
MOV RAX,qword ptr [R14 + 0x40]
MOV byte ptr [RAX + 0x97],0x0
MOV RDI,qword ptr [R14 + 0x40]
MOV RAX,qword ptr [RDI + 0x2a0]
TEST RAX,RAX
JZ 0x0016190f
MOV dword ptr [RAX + 0x4],0x0
MOV RDI,qword ptr [R14 + 0x40]
LAB_0016190f:
CALL 0x00161a20
MOV qword ptr [R14 + 0x38],RAX
TEST RAX,RAX
JZ 0x001619a4
MOV RDI,RAX
CALL 0x00161a88
TEST AL,AL
JZ 0x00161940
MOV RDI,qword ptr [R14 + 0x38]
CALL 0x0013a210
MOV qword ptr [R14 + 0x38],0x0
JMP 0x001619a4
LAB_00161940:
MOV RAX,qword ptr [R14 + 0x40]
TEST byte ptr [RAX + 0x36b],0x40
JZ 0x0016195e
MOV RDI,qword ptr [R14 + 0x38]
CALL 0x00161acc
TEST EAX,EAX
JNZ 0x001619a4
MOV RAX,qword ptr [R14 + 0x40]
LAB_0016195e:
MOV RAX,qword ptr [RAX + 0x480]
TEST RAX,RAX
JZ 0x001619a2
MOV RSI,qword ptr [RAX + 0x90]
TEST RSI,RSI
JZ 0x00161984
CMP byte ptr [RSI],0x0
JZ 0x00161984
MOV RDX,qword ptr [RAX + 0x98]
JMP 0x00161995
LAB_00161984:
MOV RDX,qword ptr [RAX + 0x98]
TEST RDX,RDX
JZ 0x001619a2
CMP byte ptr [RDX],0x0
JZ 0x001619a2
LAB_00161995:
MOV RDI,qword ptr [R14 + 0x38]
CALL 0x00161b1c
TEST AL,AL
JNZ 0x001619a4
LAB_001619a2:
XOR EBX,EBX
LAB_001619a4:
MOV EAX,EBX
POP RBX
POP R14
POP RBP
RET
|
ulong ma_pvio_start_ssl(long param_1)
{
char *pcVar1;
char cVar2;
int iVar3;
long lVar4;
char *pcVar5;
int8 unaff_RBX;
ulong uVar6;
uVar6 = CONCAT71((int7)((ulong)unaff_RBX >> 8),1);
if ((param_1 == 0) || (*(long *)(param_1 + 0x40) == 0)) goto LAB_001619a4;
*(int4 *)(*(long *)(param_1 + 0x40) + 0x90) = 0;
lVar4 = *(long *)(param_1 + 0x40);
*(int2 *)(lVar4 + 0x29b) = 0x30;
*(int4 *)(lVar4 + 0x297) = 0x30303030;
*(int1 *)(*(long *)(param_1 + 0x40) + 0x97) = 0;
lVar4 = *(long *)(param_1 + 0x40);
if (*(long *)(lVar4 + 0x2a0) != 0) {
*(int4 *)(*(long *)(lVar4 + 0x2a0) + 4) = 0;
lVar4 = *(long *)(param_1 + 0x40);
}
lVar4 = ma_pvio_tls_init(lVar4);
*(long *)(param_1 + 0x38) = lVar4;
if (lVar4 == 0) goto LAB_001619a4;
cVar2 = ma_pvio_tls_connect(lVar4);
if (cVar2 != '\0') {
free(*(void **)(param_1 + 0x38));
*(int8 *)(param_1 + 0x38) = 0;
goto LAB_001619a4;
}
lVar4 = *(long *)(param_1 + 0x40);
if ((*(byte *)(lVar4 + 0x36b) & 0x40) != 0) {
iVar3 = ma_pvio_tls_verify_server_cert(*(int8 *)(param_1 + 0x38));
if (iVar3 != 0) goto LAB_001619a4;
lVar4 = *(long *)(param_1 + 0x40);
}
lVar4 = *(long *)(lVar4 + 0x480);
if (lVar4 != 0) {
pcVar1 = *(char **)(lVar4 + 0x90);
if ((pcVar1 == (char *)0x0) || (*pcVar1 == '\0')) {
pcVar5 = *(char **)(lVar4 + 0x98);
if ((pcVar5 == (char *)0x0) || (*pcVar5 == '\0')) goto LAB_001619a2;
}
else {
pcVar5 = *(char **)(lVar4 + 0x98);
}
cVar2 = ma_pvio_tls_check_fp(*(int8 *)(param_1 + 0x38),pcVar1,pcVar5);
if (cVar2 != '\0') goto LAB_001619a4;
}
LAB_001619a2:
uVar6 = 0;
LAB_001619a4:
return uVar6 & 0xffffffff;
}
|
|
63,657
|
minja::CallExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const
|
monkey531[P]llama/common/minja.hpp
|
Value do_evaluate(const std::shared_ptr<Context> & context) const override {
if (!object) throw std::runtime_error("CallExpr.object is null");
auto obj = object->evaluate(context);
if (!obj.is_callable()) {
throw std::runtime_error("Object is not callable: " + obj.dump(2));
}
auto vargs = args.evaluate(context);
return obj.call(context, vargs);
}
|
O0
|
cpp
|
minja::CallExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const:
subq $0x118, %rsp # imm = 0x118
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x110(%rsp)
movq %rsi, 0x108(%rsp)
movq %rdx, 0x100(%rsp)
movq 0x108(%rsp), %rdi
movq %rdi, 0x20(%rsp)
addq $0x20, %rdi
callq 0x788b0
testb $0x1, %al
jne 0xdf3d4
movl $0x10, %edi
callq 0x4f580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0xda17b(%rip), %rsi # 0x1b950d
callq 0x4f380
jmp 0xdf399
movq 0x8(%rsp), %rdi
movq 0x156c03(%rip), %rsi # 0x235fa8
movq 0x156bbc(%rip), %rdx # 0x235f68
callq 0x4f940
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf8(%rsp)
movl %eax, 0xf4(%rsp)
callq 0x4fc70
jmp 0xdf59d
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
callq 0x9f320
movq %rax, %rsi
movq 0x100(%rsp), %rdx
leaq 0xa0(%rsp), %rdi
callq 0x9f330
leaq 0xa0(%rsp), %rdi
callq 0xd9e30
testb $0x1, %al
jne 0xdf4fa
movb $0x1, 0x5f(%rsp)
movl $0x10, %edi
callq 0x4f580
movq %rax, (%rsp)
leaq 0x60(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
movl $0x2, %edx
xorl %ecx, %ecx
callq 0x9fe90
jmp 0xdf43d
leaq 0xda364(%rip), %rsi # 0x1b97a8
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rdx
callq 0x62680
jmp 0xdf458
movq (%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x4f3d0
jmp 0xdf46b
movq (%rsp), %rdi
movb $0x0, 0x5f(%rsp)
movq 0x156b2d(%rip), %rsi # 0x235fa8
movq 0x156ae6(%rip), %rdx # 0x235f68
callq 0x4f940
jmp 0xdf5aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf8(%rsp)
movl %eax, 0xf4(%rsp)
jmp 0xdf4e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf8(%rsp)
movl %eax, 0xf4(%rsp)
jmp 0xdf4d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf8(%rsp)
movl %eax, 0xf4(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x50100
leaq 0x60(%rsp), %rdi
callq 0x50100
testb $0x1, 0x5f(%rsp)
jne 0xdf4ec
jmp 0xdf4f5
movq (%rsp), %rdi
callq 0x4fc70
jmp 0xdf590
movq 0x20(%rsp), %rsi
addq $0x30, %rsi
movq 0x100(%rsp), %rdx
leaq 0x28(%rsp), %rdi
callq 0xd7eb0
jmp 0xdf517
movq 0x10(%rsp), %rdi
movq 0x100(%rsp), %rdx
leaq 0xa0(%rsp), %rsi
leaq 0x28(%rsp), %rcx
callq 0xd9e50
jmp 0xdf538
leaq 0x28(%rsp), %rdi
callq 0xda020
leaq 0xa0(%rsp), %rdi
callq 0x9f7d0
movq 0x18(%rsp), %rax
addq $0x118, %rsp # imm = 0x118
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf8(%rsp)
movl %eax, 0xf4(%rsp)
jmp 0xdf590
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf8(%rsp)
movl %eax, 0xf4(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xda020
leaq 0xa0(%rsp), %rdi
callq 0x9f7d0
movq 0xf8(%rsp), %rdi
callq 0x4f990
nopw (%rax,%rax)
|
_ZNK5minja8CallExpr11do_evaluateERKSt10shared_ptrINS_7ContextEE:
sub rsp, 118h
mov qword ptr [rsp+118h+var_108], rdi; int
mov rax, rdi
mov qword ptr [rsp+118h+var_100], rax; int
mov qword ptr [rsp+118h+var_8], rdi; int
mov [rsp+118h+var_10], rsi; int
mov qword ptr [rsp+118h+var_18], rdx; int
mov rdi, [rsp+118h+var_10]
mov [rsp+118h+var_F8], rdi; __int16
add rdi, 20h ; ' '
call _ZNKSt12__shared_ptrIN5minja10ExpressionELN9__gnu_cxx12_Lock_policyE2EEcvbEv; std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator bool(void)
test al, 1
jnz short loc_DF3D4
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+118h+var_110], rax
lea rsi, aMethodcallexpr+6; char *
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_DF399:
mov rdi, [rsp+118h+var_110]; void *
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
mov rdi, [rsp+118h+var_110]; void *
mov rcx, rax
mov eax, edx
mov [rsp+118h+var_20], rcx
mov [rsp+118h+var_24], eax
call ___cxa_free_exception
jmp loc_DF59D
loc_DF3D4:
mov rdi, [rsp+118h+var_F8]
add rdi, 20h ; ' '
call _ZNKSt19__shared_ptr_accessIN5minja10ExpressionELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<minja::Expression,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rsi, rax
mov rdx, qword ptr [rsp+118h+var_18]
lea rdi, [rsp+118h+var_78]
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
lea rdi, [rsp+118h+var_78]; this
call _ZNK5minja5Value11is_callableEv; minja::Value::is_callable(void)
test al, 1
jnz loc_DF4FA
mov [rsp+118h+var_B9], 1
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov [rsp+118h+var_118], rax
lea rdi, [rsp+118h+var_B8]
lea rsi, [rsp+118h+var_78]
mov edx, 2
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
jmp short $+2
loc_DF43D:
lea rsi, aObjectIsNotCal; "Object is not callable: "
lea rdi, [rsp+118h+var_98]
lea rdx, [rsp+118h+var_B8]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
jmp short $+2
loc_DF458:
mov rdi, [rsp+118h+var_118]
lea rsi, [rsp+118h+var_98]
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
jmp short $+2
loc_DF46B:
mov rdi, [rsp+118h+var_118]; void *
mov [rsp+118h+var_B9], 0
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp loc_DF5AA
mov rcx, rax
mov eax, edx
mov [rsp+118h+var_20], rcx
mov [rsp+118h+var_24], eax
jmp short loc_DF4E3
mov rcx, rax
mov eax, edx
mov [rsp+118h+var_20], rcx
mov [rsp+118h+var_24], eax
jmp short loc_DF4D9
mov rcx, rax
mov eax, edx
mov [rsp+118h+var_20], rcx
mov [rsp+118h+var_24], eax
lea rdi, [rsp+118h+var_98]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_DF4D9:
lea rdi, [rsp+118h+var_B8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_DF4E3:
test [rsp+118h+var_B9], 1
jnz short loc_DF4EC
jmp short loc_DF4F5
loc_DF4EC:
mov rdi, [rsp+118h+var_118]; void *
call ___cxa_free_exception
loc_DF4F5:
jmp loc_DF590
loc_DF4FA:
mov rsi, [rsp+118h+var_F8]
add rsi, 30h ; '0'; int
mov rdx, qword ptr [rsp+118h+var_18]; int
lea rdi, [rsp+118h+var_F0]; int
call _ZNK5minja19ArgumentsExpression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::ArgumentsExpression::evaluate(std::shared_ptr<minja::Context> const&)
jmp short $+2
loc_DF517:
mov rdi, qword ptr [rsp+118h+var_108]; int
mov rdx, qword ptr [rsp+118h+var_18]; int
lea rsi, [rsp+118h+var_78]; int
lea rcx, [rsp+118h+var_F0]; int
call _ZNK5minja5Value4callERKSt10shared_ptrINS_7ContextEERNS_14ArgumentsValueE; minja::Value::call(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)
jmp short $+2
loc_DF538:
lea rdi, [rsp+118h+var_F0]; this
call _ZN5minja14ArgumentsValueD2Ev; minja::ArgumentsValue::~ArgumentsValue()
lea rdi, [rsp+118h+var_78]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rax, qword ptr [rsp+118h+var_100]
add rsp, 118h
retn
mov rcx, rax
mov eax, edx
mov [rsp+118h+var_20], rcx
mov [rsp+118h+var_24], eax
jmp short loc_DF590
mov rcx, rax
mov eax, edx
mov [rsp+118h+var_20], rcx
mov [rsp+118h+var_24], eax
lea rdi, [rsp+118h+var_F0]; this
call _ZN5minja14ArgumentsValueD2Ev; minja::ArgumentsValue::~ArgumentsValue()
loc_DF590:
lea rdi, [rsp+118h+var_78]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_DF59D:
mov rdi, [rsp+118h+var_20]
call __Unwind_Resume
loc_DF5AA:
nop word ptr [rax+rax+00h]
|
long long minja::CallExpr::do_evaluate(long long a1, _QWORD *a2, long long a3)
{
void (***v3)(void); // rax
void *v5; // [rsp+0h] [rbp-118h]
std::runtime_error *exception; // [rsp+8h] [rbp-110h]
int v7[13]; // [rsp+28h] [rbp-F0h] BYREF
char v8; // [rsp+5Fh] [rbp-B9h]
_BYTE v9[32]; // [rsp+60h] [rbp-B8h] BYREF
_BYTE v10[32]; // [rsp+80h] [rbp-98h] BYREF
int v11[21]; // [rsp+A0h] [rbp-78h] BYREF
int v12[2]; // [rsp+100h] [rbp-18h]
void *v13; // [rsp+108h] [rbp-10h]
int v14[2]; // [rsp+110h] [rbp-8h]
*(_QWORD *)v14 = a1;
v13 = a2;
*(_QWORD *)v12 = a3;
if ( !std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator bool(a2 + 4) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "CallExpr.object is null");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v3 = (void (***)(void))std::__shared_ptr_access<minja::Expression,(__gnu_cxx::_Lock_policy)2,false,false>::operator->((long long)(a2 + 4));
minja::Expression::evaluate((long long)v11, v3);
if ( !minja::Value::is_callable((minja::Value *)v11) )
{
v5 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v9, (long long)v11, 2u, 0);
std::operator+<char>((long long)v10, (long long)"Object is not callable: ", (long long)v9);
std::runtime_error::runtime_error(v5, v10);
v8 = 0;
__cxa_throw(
v5,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::ArgumentsExpression::evaluate((minja::ArgumentsValue *)v7, (long long)(a2 + 6), *(long long *)v12);
minja::Value::call(a1, (long long)v11, *(long long *)v12, (long long)v7);
minja::ArgumentsValue::~ArgumentsValue((minja::ArgumentsValue *)v7);
minja::Value::~Value((minja::Value *)v11);
return a1;
}
|
do_evaluate:
SUB RSP,0x118
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x110],RDI
MOV qword ptr [RSP + 0x108],RSI
MOV qword ptr [RSP + 0x100],RDX
MOV RDI,qword ptr [RSP + 0x108]
MOV qword ptr [RSP + 0x20],RDI
ADD RDI,0x20
CALL 0x001788b0
TEST AL,0x1
JNZ 0x001df3d4
MOV EDI,0x10
CALL 0x0014f580
MOV RDI,RAX
MOV RAX,RDI
MOV qword ptr [RSP + 0x8],RAX
LAB_001df38b:
LEA RSI,[0x2b950d]
CALL 0x0014f380
LAB_001df397:
JMP 0x001df399
LAB_001df399:
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [0x00335fa8]
MOV RDX,qword ptr [0x00335f68]
CALL 0x0014f940
LAB_001df3d4:
MOV RDI,qword ptr [RSP + 0x20]
ADD RDI,0x20
CALL 0x0019f320
MOV RSI,RAX
MOV RDX,qword ptr [RSP + 0x100]
LEA RDI,[RSP + 0xa0]
CALL 0x0019f330
LEA RDI,[RSP + 0xa0]
CALL 0x001d9e30
TEST AL,0x1
JNZ 0x001df4fa
MOV byte ptr [RSP + 0x5f],0x1
MOV EDI,0x10
CALL 0x0014f580
MOV qword ptr [RSP],RAX
LAB_001df422:
LEA RDI,[RSP + 0x60]
LEA RSI,[RSP + 0xa0]
MOV EDX,0x2
XOR ECX,ECX
CALL 0x0019fe90
JMP 0x001df43d
LAB_001df43d:
LEA RSI,[0x2b97a8]
LEA RDI,[RSP + 0x80]
LEA RDX,[RSP + 0x60]
CALL 0x00162680
JMP 0x001df458
LAB_001df458:
MOV RDI,qword ptr [RSP]
LEA RSI,[RSP + 0x80]
CALL 0x0014f3d0
JMP 0x001df46b
LAB_001df46b:
MOV RDI,qword ptr [RSP]
MOV byte ptr [RSP + 0x5f],0x0
MOV RSI,qword ptr [0x00335fa8]
MOV RDX,qword ptr [0x00335f68]
CALL 0x0014f940
LAB_001df4fa:
MOV RSI,qword ptr [RSP + 0x20]
ADD RSI,0x30
MOV RDX,qword ptr [RSP + 0x100]
LAB_001df50b:
LEA RDI,[RSP + 0x28]
CALL 0x001d7eb0
JMP 0x001df517
LAB_001df517:
MOV RDI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x100]
LAB_001df524:
LEA RSI,[RSP + 0xa0]
LEA RCX,[RSP + 0x28]
CALL 0x001d9e50
LAB_001df536:
JMP 0x001df538
LAB_001df538:
LEA RDI,[RSP + 0x28]
CALL 0x001da020
LEA RDI,[RSP + 0xa0]
CALL 0x0019f7d0
MOV RAX,qword ptr [RSP + 0x18]
ADD RSP,0x118
RET
|
/* minja::CallExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const */
shared_ptr * minja::CallExpr::do_evaluate(shared_ptr *param_1)
{
bool bVar1;
runtime_error *prVar2;
ulong uVar3;
long in_RSI;
shared_ptr local_f0 [55];
int1 local_b9;
int1 local_b8 [32];
string local_98 [32];
shared_ptr local_78 [112];
shared_ptr *local_8;
local_8 = param_1;
bVar1 = std::__shared_ptr::operator_cast_to_bool((__shared_ptr *)(in_RSI + 0x20));
if (!bVar1) {
prVar2 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001df38b to 001df396 has its CatchHandler @ 001df3b1 */
std::runtime_error::runtime_error(prVar2,"CallExpr.object is null");
/* WARNING: Subroutine does not return */
__cxa_throw(prVar2,PTR_typeinfo_00335fa8,PTR__runtime_error_00335f68);
}
std::__shared_ptr_access<minja::Expression,(__gnu_cxx::_Lock_policy)2,false,false>::operator->
((__shared_ptr_access<minja::Expression,(__gnu_cxx::_Lock_policy)2,false,false> *)
(in_RSI + 0x20));
Expression::evaluate(local_78);
uVar3 = Value::is_callable((Value *)local_78);
if ((uVar3 & 1) == 0) {
local_b9 = 1;
prVar2 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001df422 to 001df43a has its CatchHandler @ 001df48c */
Value::dump_abi_cxx11_((int)local_b8,SUB81(local_78,0));
/* try { // try from 001df43d to 001df455 has its CatchHandler @ 001df4a2 */
std::operator+((char *)local_98,(string *)"Object is not callable: ");
/* try { // try from 001df458 to 001df486 has its CatchHandler @ 001df4b8 */
std::runtime_error::runtime_error(prVar2,local_98);
local_b9 = 0;
/* WARNING: Subroutine does not return */
__cxa_throw(prVar2,PTR_typeinfo_00335fa8,PTR__runtime_error_00335f68);
}
/* try { // try from 001df50b to 001df514 has its CatchHandler @ 001df55c */
ArgumentsExpression::evaluate(local_f0);
/* try { // try from 001df524 to 001df535 has its CatchHandler @ 001df572 */
Value::call(param_1,(ArgumentsValue *)local_78);
ArgumentsValue::~ArgumentsValue((ArgumentsValue *)local_f0);
Value::~Value((Value *)local_78);
return param_1;
}
|
|
63,658
|
my_base64_decoder_getch
|
eloqsql/mysys/base64.c
|
static my_bool
my_base64_decoder_getch(MY_BASE64_DECODER *decoder)
{
if (my_base64_decoder_skip_spaces(decoder))
return TRUE; /* End-of-input */
if (!my_base64_add(decoder)) /* Valid base64 character found */
{
if (decoder->mark)
{
/* If we have scanned '=' already, then only '=' is valid */
DBUG_ASSERT(decoder->state == 3);
decoder->error= 1;
decoder->src--;
return TRUE; /* expected '=', but encoding character found */
}
decoder->state++;
return FALSE;
}
/* Process error */
switch (decoder->state)
{
case 0:
case 1:
decoder->src--;
return TRUE; /* base64 character expected */
break;
case 2:
case 3:
if (decoder->src[-1] == '=')
{
decoder->error= 0; /* Not an error - it's a pad character */
decoder->mark++;
}
else
{
decoder->src--;
return TRUE; /* base64 character or '=' expected */
}
break;
default:
DBUG_ASSERT(0);
return TRUE; /* Wrong state, should not happen */
}
decoder->state++;
return FALSE;
}
|
O3
|
c
|
my_base64_decoder_getch:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
cmpq %rdx, %rcx
jae 0x2709d
leaq 0x38be7(%rip), %rax # 0x5fc70
movzbl (%rcx), %esi
cmpb $-0x2, (%rsi,%rax)
jne 0x270ae
incq %rcx
movq %rcx, (%rdi)
cmpq %rdx, %rcx
jne 0x27089
movb $0x1, %al
cmpb $0x0, 0x18(%rdi)
je 0x270ac
movl $0x1, 0x14(%rdi)
popq %rbp
retq
movl 0x10(%rdi), %edx
shll $0x6, %edx
movl %edx, 0x10(%rdi)
leaq 0x1(%rcx), %rsi
movq %rsi, (%rdi)
movzbl (%rcx), %esi
movsbl (%rsi,%rax), %eax
testl %eax, %eax
js 0x270e2
addl %eax, %edx
movl %edx, 0x10(%rdi)
cmpb $0x0, 0x19(%rdi)
je 0x27102
movl $0x1, 0x14(%rdi)
movq %rcx, (%rdi)
movb $0x1, %al
jmp 0x270ac
movl $0x1, 0x14(%rdi)
movb 0x18(%rdi), %dl
movzbl %dl, %esi
movb $0x1, %al
leal -0x2(%rsi), %r8d
cmpl $0x2, %r8d
jb 0x27107
cmpl $0x1, %esi
jbe 0x2711f
jmp 0x270ac
incb 0x18(%rdi)
jmp 0x2711b
cmpb $0x3d, (%rcx)
jne 0x2711f
movl $0x0, 0x14(%rdi)
incb 0x19(%rdi)
incb %dl
movb %dl, 0x18(%rdi)
xorl %eax, %eax
jmp 0x270ac
movq %rcx, (%rdi)
jmp 0x270ac
|
my_base64_decoder_getch:
push rbp
mov rbp, rsp
mov rcx, [rdi]
mov rdx, [rdi+8]
cmp rcx, rdx
jnb short loc_2709D
lea rax, from_base64_table
loc_27089:
movzx esi, byte ptr [rcx]
cmp byte ptr [rsi+rax], 0FEh
jnz short loc_270AE
inc rcx
mov [rdi], rcx
cmp rcx, rdx
jnz short loc_27089
loc_2709D:
mov al, 1
cmp byte ptr [rdi+18h], 0
jz short loc_270AC
mov dword ptr [rdi+14h], 1
loc_270AC:
pop rbp
retn
loc_270AE:
mov edx, [rdi+10h]
shl edx, 6
mov [rdi+10h], edx
lea rsi, [rcx+1]
mov [rdi], rsi
movzx esi, byte ptr [rcx]
movsx eax, byte ptr [rsi+rax]
test eax, eax
js short loc_270E2
add edx, eax
mov [rdi+10h], edx
cmp byte ptr [rdi+19h], 0
jz short loc_27102
mov dword ptr [rdi+14h], 1
mov [rdi], rcx
mov al, 1
jmp short loc_270AC
loc_270E2:
mov dword ptr [rdi+14h], 1
mov dl, [rdi+18h]
movzx esi, dl
mov al, 1
lea r8d, [rsi-2]
cmp r8d, 2
jb short loc_27107
cmp esi, 1
jbe short loc_2711F
jmp short loc_270AC
loc_27102:
inc byte ptr [rdi+18h]
jmp short loc_2711B
loc_27107:
cmp byte ptr [rcx], 3Dh ; '='
jnz short loc_2711F
mov dword ptr [rdi+14h], 0
inc byte ptr [rdi+19h]
inc dl
mov [rdi+18h], dl
loc_2711B:
xor eax, eax
jmp short loc_270AC
loc_2711F:
mov [rdi], rcx
jmp short loc_270AC
|
char my_base64_decoder_getch(long long a1)
{
_BYTE *v1; // rcx
_BYTE *v2; // rdx
char result; // al
int v4; // edx
int v5; // eax
unsigned __int8 v6; // dl
v1 = *(_BYTE **)a1;
v2 = *(_BYTE **)(a1 + 8);
if ( *(_QWORD *)a1 < (unsigned long long)v2 )
{
while ( from_base64_table[(unsigned __int8)*v1] == 0xFE )
{
*(_QWORD *)a1 = ++v1;
if ( v1 == v2 )
goto LABEL_4;
}
v4 = *(_DWORD *)(a1 + 16) << 6;
*(_DWORD *)(a1 + 16) = v4;
*(_QWORD *)a1 = v1 + 1;
v5 = (char)from_base64_table[(unsigned __int8)*v1];
if ( v5 >= 0 )
{
*(_DWORD *)(a1 + 16) = v5 + v4;
if ( *(_BYTE *)(a1 + 25) )
{
*(_DWORD *)(a1 + 20) = 1;
*(_QWORD *)a1 = v1;
return 1;
}
++*(_BYTE *)(a1 + 24);
return 0;
}
*(_DWORD *)(a1 + 20) = 1;
v6 = *(_BYTE *)(a1 + 24);
result = 1;
if ( (unsigned int)v6 - 2 < 2 )
{
if ( *v1 == 61 )
{
*(_DWORD *)(a1 + 20) = 0;
++*(_BYTE *)(a1 + 25);
*(_BYTE *)(a1 + 24) = v6 + 1;
return 0;
}
}
else if ( v6 > 1u )
{
return result;
}
*(_QWORD *)a1 = v1;
return result;
}
LABEL_4:
result = 1;
if ( *(_BYTE *)(a1 + 24) )
*(_DWORD *)(a1 + 20) = 1;
return result;
}
|
my_base64_decoder_getch:
PUSH RBP
MOV RBP,RSP
MOV RCX,qword ptr [RDI]
MOV RDX,qword ptr [RDI + 0x8]
CMP RCX,RDX
JNC 0x0012709d
LEA RAX,[0x15fc70]
LAB_00127089:
MOVZX ESI,byte ptr [RCX]
CMP byte ptr [RSI + RAX*0x1],0xfe
JNZ 0x001270ae
INC RCX
MOV qword ptr [RDI],RCX
CMP RCX,RDX
JNZ 0x00127089
LAB_0012709d:
MOV AL,0x1
CMP byte ptr [RDI + 0x18],0x0
JZ 0x001270ac
MOV dword ptr [RDI + 0x14],0x1
LAB_001270ac:
POP RBP
RET
LAB_001270ae:
MOV EDX,dword ptr [RDI + 0x10]
SHL EDX,0x6
MOV dword ptr [RDI + 0x10],EDX
LEA RSI,[RCX + 0x1]
MOV qword ptr [RDI],RSI
MOVZX ESI,byte ptr [RCX]
MOVSX EAX,byte ptr [RSI + RAX*0x1]
TEST EAX,EAX
JS 0x001270e2
ADD EDX,EAX
MOV dword ptr [RDI + 0x10],EDX
CMP byte ptr [RDI + 0x19],0x0
JZ 0x00127102
MOV dword ptr [RDI + 0x14],0x1
MOV qword ptr [RDI],RCX
MOV AL,0x1
JMP 0x001270ac
LAB_001270e2:
MOV dword ptr [RDI + 0x14],0x1
MOV DL,byte ptr [RDI + 0x18]
MOVZX ESI,DL
MOV AL,0x1
LEA R8D,[RSI + -0x2]
CMP R8D,0x2
JC 0x00127107
CMP ESI,0x1
JBE 0x0012711f
JMP 0x001270ac
LAB_00127102:
INC byte ptr [RDI + 0x18]
JMP 0x0012711b
LAB_00127107:
CMP byte ptr [RCX],0x3d
JNZ 0x0012711f
MOV dword ptr [RDI + 0x14],0x0
INC byte ptr [RDI + 0x19]
INC DL
MOV byte ptr [RDI + 0x18],DL
LAB_0012711b:
XOR EAX,EAX
JMP 0x001270ac
LAB_0012711f:
MOV qword ptr [RDI],RCX
JMP 0x001270ac
|
int8 my_base64_decoder_getch(long *param_1)
{
byte bVar1;
byte *pbVar2;
int iVar3;
pbVar2 = (byte *)*param_1;
if (pbVar2 < (byte *)param_1[1]) {
do {
if (from_base64_table[*pbVar2] != -2) {
iVar3 = (int)param_1[2] * 0x40;
*(int *)(param_1 + 2) = iVar3;
*param_1 = (long)(pbVar2 + 1);
if (-1 < (char)from_base64_table[*pbVar2]) {
*(int *)(param_1 + 2) = iVar3 + (char)from_base64_table[*pbVar2];
if (*(char *)((long)param_1 + 0x19) == '\0') {
*(char *)(param_1 + 3) = (char)param_1[3] + '\x01';
return 0;
}
*(int4 *)((long)param_1 + 0x14) = 1;
*param_1 = (long)pbVar2;
return 1;
}
*(int4 *)((long)param_1 + 0x14) = 1;
bVar1 = *(byte *)(param_1 + 3);
if (bVar1 - 2 < 2) {
if (*pbVar2 == 0x3d) {
*(int4 *)((long)param_1 + 0x14) = 0;
*(char *)((long)param_1 + 0x19) = *(char *)((long)param_1 + 0x19) + '\x01';
*(byte *)(param_1 + 3) = bVar1 + 1;
return 0;
}
}
else if (1 < bVar1) {
return 1;
}
*param_1 = (long)pbVar2;
return 1;
}
pbVar2 = pbVar2 + 1;
*param_1 = (long)pbVar2;
} while (pbVar2 != (byte *)param_1[1]);
}
if ((char)param_1[3] != '\0') {
*(int4 *)((long)param_1 + 0x14) = 1;
}
return 1;
}
|
|
63,659
|
my_strxfrm_desc_and_reverse
|
eloqsql/strings/ctype-simple.c
|
void
my_strxfrm_desc_and_reverse(uchar *str, uchar *strend,
uint flags, uint level)
{
if (flags & (MY_STRXFRM_DESC_LEVEL1 << level))
{
if (flags & (MY_STRXFRM_REVERSE_LEVEL1 << level))
{
for (strend--; str <= strend;)
{
uchar tmp= *str;
*str++= ~*strend;
*strend--= ~tmp;
}
}
else
{
for (; str < strend; str++)
*str= ~*str;
}
}
else if (flags & (MY_STRXFRM_REVERSE_LEVEL1 << level))
{
for (strend--; str < strend;)
{
uchar tmp= *str;
*str++= *strend;
*strend--= tmp;
}
}
}
|
O0
|
c
|
my_strxfrm_desc_and_reverse:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl -0x18(%rbp), %ecx
movl $0x100, %edx # imm = 0x100
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x4469c
movl -0x14(%rbp), %eax
movl -0x18(%rbp), %ecx
movl $0x10000, %edx # imm = 0x10000
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x4466c
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
ja 0x4466a
movq -0x8(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
xorl $-0x1, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movzbl -0x19(%rbp), %eax
xorl $-0x1, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
jmp 0x4461e
jmp 0x4469a
jmp 0x4466e
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x44698
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
xorl $-0x1, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x4466e
jmp 0x4469a
jmp 0x44702
movl -0x14(%rbp), %eax
movl -0x18(%rbp), %ecx
movl $0x10000, %edx # imm = 0x10000
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x44700
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x446fe
movq -0x8(%rbp), %rax
movb (%rax), %al
movb %al, -0x1a(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movb -0x1a(%rbp), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
jmp 0x446be
jmp 0x44700
jmp 0x44702
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_strxfrm_desc_and_reverse:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_18], ecx
mov eax, [rbp+var_14]
mov ecx, [rbp+var_18]
mov edx, 100h
shl edx, cl
mov ecx, edx
and eax, ecx
cmp eax, 0
jz loc_4469C
mov eax, [rbp+var_14]
mov ecx, [rbp+var_18]
mov edx, 10000h
shl edx, cl
mov ecx, edx
and eax, ecx
cmp eax, 0
jz short loc_4466C
mov rax, [rbp+var_10]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_10], rax
loc_4461E:
mov rax, [rbp+var_8]
cmp rax, [rbp+var_10]
ja short loc_4466A
mov rax, [rbp+var_8]
mov al, [rax]
mov [rbp+var_19], al
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax]
xor eax, 0FFFFFFFFh
mov cl, al
mov rax, [rbp+var_8]
mov rdx, rax
add rdx, 1
mov [rbp+var_8], rdx
mov [rax], cl
movzx eax, [rbp+var_19]
xor eax, 0FFFFFFFFh
mov cl, al
mov rax, [rbp+var_10]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_10], rdx
mov [rax], cl
jmp short loc_4461E
loc_4466A:
jmp short loc_4469A
loc_4466C:
jmp short $+2
loc_4466E:
mov rax, [rbp+var_8]
cmp rax, [rbp+var_10]
jnb short loc_44698
mov rax, [rbp+var_8]
movzx eax, byte ptr [rax]
xor eax, 0FFFFFFFFh
mov cl, al
mov rax, [rbp+var_8]
mov [rax], cl
mov rax, [rbp+var_8]
add rax, 1
mov [rbp+var_8], rax
jmp short loc_4466E
loc_44698:
jmp short $+2
loc_4469A:
jmp short loc_44702
loc_4469C:
mov eax, [rbp+var_14]
mov ecx, [rbp+var_18]
mov edx, 10000h
shl edx, cl
mov ecx, edx
and eax, ecx
cmp eax, 0
jz short loc_44700
mov rax, [rbp+var_10]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_10], rax
loc_446BE:
mov rax, [rbp+var_8]
cmp rax, [rbp+var_10]
jnb short loc_446FE
mov rax, [rbp+var_8]
mov al, [rax]
mov [rbp+var_1A], al
mov rax, [rbp+var_10]
mov cl, [rax]
mov rax, [rbp+var_8]
mov rdx, rax
add rdx, 1
mov [rbp+var_8], rdx
mov [rax], cl
mov cl, [rbp+var_1A]
mov rax, [rbp+var_10]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_10], rdx
mov [rax], cl
jmp short loc_446BE
loc_446FE:
jmp short $+2
loc_44700:
jmp short $+2
loc_44702:
pop rbp
retn
|
_BYTE * my_strxfrm_desc_and_reverse(_BYTE *a1, unsigned long long a2, unsigned int a3, char a4)
{
_BYTE *result; // rax
_BYTE *v5; // rax
_BYTE *v6; // rax
_BYTE *v7; // rax
_BYTE *v8; // rax
char v9; // [rsp+0h] [rbp-1Ah]
char v10; // [rsp+1h] [rbp-19h]
_BYTE *i; // [rsp+Ah] [rbp-10h]
_BYTE *j; // [rsp+Ah] [rbp-10h]
if ( ((256 << a4) & a3) != 0 )
{
if ( ((0x10000 << a4) & a3) != 0 )
{
for ( i = (_BYTE *)(a2 - 1); ; --i )
{
result = a1;
if ( a1 > i )
break;
v10 = *a1;
v5 = a1++;
*v5 = ~*i;
v6 = i;
*v6 = ~v10;
}
}
else
{
while ( 1 )
{
result = a1;
if ( (unsigned long long)a1 >= a2 )
break;
*a1 = ~*a1;
++a1;
}
}
}
else
{
result = (_BYTE *)((0x10000 << a4) & a3);
if ( (_DWORD)result )
{
for ( j = (_BYTE *)(a2 - 1); ; --j )
{
result = a1;
if ( a1 >= j )
break;
v9 = *a1;
v7 = a1++;
*v7 = *j;
v8 = j;
*v8 = v9;
}
}
}
return result;
}
|
my_strxfrm_desc_and_reverse:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV dword ptr [RBP + -0x18],ECX
MOV EAX,dword ptr [RBP + -0x14]
MOV ECX,dword ptr [RBP + -0x18]
MOV EDX,0x100
SHL EDX,CL
MOV ECX,EDX
AND EAX,ECX
CMP EAX,0x0
JZ 0x0014469c
MOV EAX,dword ptr [RBP + -0x14]
MOV ECX,dword ptr [RBP + -0x18]
MOV EDX,0x10000
SHL EDX,CL
MOV ECX,EDX
AND EAX,ECX
CMP EAX,0x0
JZ 0x0014466c
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x10],RAX
LAB_0014461e:
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x10]
JA 0x0014466a
MOV RAX,qword ptr [RBP + -0x8]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x19],AL
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX]
XOR EAX,0xffffffff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x8],RDX
MOV byte ptr [RAX],CL
MOVZX EAX,byte ptr [RBP + -0x19]
XOR EAX,0xffffffff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RBP + -0x10],RDX
MOV byte ptr [RAX],CL
JMP 0x0014461e
LAB_0014466a:
JMP 0x0014469a
LAB_0014466c:
JMP 0x0014466e
LAB_0014466e:
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x10]
JNC 0x00144698
MOV RAX,qword ptr [RBP + -0x8]
MOVZX EAX,byte ptr [RAX]
XOR EAX,0xffffffff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x1
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0014466e
LAB_00144698:
JMP 0x0014469a
LAB_0014469a:
JMP 0x00144702
LAB_0014469c:
MOV EAX,dword ptr [RBP + -0x14]
MOV ECX,dword ptr [RBP + -0x18]
MOV EDX,0x10000
SHL EDX,CL
MOV ECX,EDX
AND EAX,ECX
CMP EAX,0x0
JZ 0x00144700
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x10],RAX
LAB_001446be:
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x10]
JNC 0x001446fe
MOV RAX,qword ptr [RBP + -0x8]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x1a],AL
MOV RAX,qword ptr [RBP + -0x10]
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x8]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x8],RDX
MOV byte ptr [RAX],CL
MOV CL,byte ptr [RBP + -0x1a]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RBP + -0x10],RDX
MOV byte ptr [RAX],CL
JMP 0x001446be
LAB_001446fe:
JMP 0x00144700
LAB_00144700:
JMP 0x00144702
LAB_00144702:
POP RBP
RET
|
void my_strxfrm_desc_and_reverse(byte *param_1,byte *param_2,uint param_3,byte param_4)
{
byte bVar1;
byte *local_18;
byte *local_10;
if ((param_3 & 0x100 << (param_4 & 0x1f)) == 0) {
if ((param_3 & 0x10000 << (param_4 & 0x1f)) != 0) {
local_18 = param_2 + -1;
local_10 = param_1;
while (local_10 < local_18) {
bVar1 = *local_10;
*local_10 = *local_18;
*local_18 = bVar1;
local_18 = local_18 + -1;
local_10 = local_10 + 1;
}
}
}
else {
local_10 = param_1;
if ((param_3 & 0x10000 << (param_4 & 0x1f)) == 0) {
for (; local_10 < param_2; local_10 = local_10 + 1) {
*local_10 = *local_10 ^ 0xff;
}
}
else {
local_18 = param_2 + -1;
local_10 = param_1;
while (local_10 <= local_18) {
bVar1 = *local_10;
*local_10 = *local_18 ^ 0xff;
*local_18 = bVar1 ^ 0xff;
local_18 = local_18 + -1;
local_10 = local_10 + 1;
}
}
}
return;
}
|
|
63,660
|
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::unget()
|
monkey531[P]llama/common/json.hpp
|
void unget()
{
next_unget = true;
--position.chars_read_total;
// in case we "unget" a newline, we have to also decrement the lines_read
if (position.chars_read_current_line == 0)
{
if (position.lines_read > 0)
{
--position.lines_read;
}
}
else
{
--position.chars_read_current_line;
}
if (JSON_HEDLEY_LIKELY(current != char_traits<char_type>::eof()))
{
JSON_ASSERT(!token_string.empty());
token_string.pop_back();
}
}
|
O2
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::unget():
movb $0x1, 0x18(%rdi)
decq 0x20(%rdi)
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x4a885
leaq 0x28(%rdi), %rcx
jmp 0x4a892
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x4a898
leaq 0x30(%rdi), %rcx
decq %rax
movq %rax, (%rcx)
cmpl $-0x1, 0x14(%rdi)
je 0x4a8af
movq 0x40(%rdi), %rax
cmpq %rax, 0x38(%rdi)
je 0x4a8b0
decq %rax
movq %rax, 0x40(%rdi)
retq
pushq %rax
leaq 0x7169f(%rip), %rdi # 0xbbf57
leaq 0x6b231(%rip), %rdx # 0xb5af0
leaq 0x71859(%rip), %rcx # 0xbc11f
movl $0x2240, %esi # imm = 0x2240
xorl %eax, %eax
callq 0x24f20
|
_ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE5ungetEv:
mov byte ptr [rdi+18h], 1
dec qword ptr [rdi+20h]
mov rax, [rdi+28h]
test rax, rax
jz short loc_4A885
lea rcx, [rdi+28h]
jmp short loc_4A892
loc_4A885:
mov rax, [rdi+30h]
test rax, rax
jz short loc_4A898
lea rcx, [rdi+30h]
loc_4A892:
dec rax
mov [rcx], rax
loc_4A898:
cmp dword ptr [rdi+14h], 0FFFFFFFFh
jz short locret_4A8AF
mov rax, [rdi+40h]
cmp [rdi+38h], rax
jz short loc_4A8B0
dec rax
mov [rdi+40h], rax
locret_4A8AF:
retn
loc_4A8B0:
push rax
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aTokenStringEmp; "!token_string.empty()"
mov esi, 2240h
xor eax, eax
call _ggml_abort
|
long long nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::unget(
long long a1)
{
long long result; // rax
_QWORD *v2; // rcx
long long v3; // rax
*(_BYTE *)(a1 + 24) = 1;
--*(_QWORD *)(a1 + 32);
result = *(_QWORD *)(a1 + 40);
if ( result )
{
v2 = (_QWORD *)(a1 + 40);
}
else
{
result = *(_QWORD *)(a1 + 48);
if ( !result )
goto LABEL_6;
v2 = (_QWORD *)(a1 + 48);
}
*v2 = --result;
LABEL_6:
if ( *(_DWORD *)(a1 + 20) != -1 )
{
v3 = *(_QWORD *)(a1 + 64);
if ( *(_QWORD *)(a1 + 56) == v3 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
8768LL,
"GGML_ASSERT(%s) failed",
"!token_string.empty()");
return std::vector<char>::emplace_back<char>("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp");
}
else
{
result = v3 - 1;
*(_QWORD *)(a1 + 64) = result;
}
}
return result;
}
|
unget:
MOV byte ptr [RDI + 0x18],0x1
DEC qword ptr [RDI + 0x20]
MOV RAX,qword ptr [RDI + 0x28]
TEST RAX,RAX
JZ 0x0014a885
LEA RCX,[RDI + 0x28]
JMP 0x0014a892
LAB_0014a885:
MOV RAX,qword ptr [RDI + 0x30]
TEST RAX,RAX
JZ 0x0014a898
LEA RCX,[RDI + 0x30]
LAB_0014a892:
DEC RAX
MOV qword ptr [RCX],RAX
LAB_0014a898:
CMP dword ptr [RDI + 0x14],-0x1
JZ 0x0014a8af
MOV RAX,qword ptr [RDI + 0x40]
CMP qword ptr [RDI + 0x38],RAX
JZ 0x0014a8b0
DEC RAX
MOV qword ptr [RDI + 0x40],RAX
LAB_0014a8af:
RET
LAB_0014a8b0:
PUSH RAX
LEA RDI,[0x1bbf57]
LEA RDX,[0x1b5af0]
LEA RCX,[0x1bc11f]
MOV ESI,0x2240
XOR EAX,EAX
CALL 0x00124f20
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > > >::unget() */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::unget(lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*this)
{
long lVar1;
lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*plVar2;
int8 in_R8;
int8 in_R9;
this[0x18] = (lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
)0x1;
*(long *)(this + 0x20) = *(long *)(this + 0x20) + -1;
lVar1 = *(long *)(this + 0x28);
if (lVar1 == 0) {
lVar1 = *(long *)(this + 0x30);
if (lVar1 == 0) goto LAB_0014a898;
plVar2 = this + 0x30;
}
else {
plVar2 = this + 0x28;
}
*(long *)plVar2 = lVar1 + -1;
LAB_0014a898:
if (*(int *)(this + 0x14) != -1) {
lVar1 = *(long *)(this + 0x40);
if (*(long *)(this + 0x38) == lVar1) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x2240,
"GGML_ASSERT(%s) failed","!token_string.empty()",in_R8,in_R9,lVar1);
}
*(long *)(this + 0x40) = lVar1 + -1;
}
return;
}
|
|
63,661
|
squarefree49
|
xtate/src/crypto/crypto-primegen.c
|
static void squarefree49(register uint32_t (*buf)[B32], uint64_t L,
uint32_t q) {
uint32_t qq;
register uint32_t qqhigh;
uint32_t i;
register uint32_t ilow;
register uint32_t ihigh;
register int n;
uint64_t base = 60 * L;
qq = q * q;
q = 60 * q + 900;
while (qq < B * 60) {
if (base < 2000000000)
i = qq - (((uint32_t)base) % qq);
else
i = qq - (base % qq);
if (!(i & 1))
i += qq;
if (i < B * 60) {
qqhigh = qq / 60;
ilow = i % 60;
ihigh = i / 60;
qqhigh += qqhigh;
qqhigh += 1;
while (ihigh < B) {
n = deltainverse[ilow];
if (n >= 0)
(*buf)[n + (ihigh >> 5)] |= two[ihigh & 31];
ilow += 38;
ihigh += qqhigh;
if (ilow >= 60) {
ilow -= 60;
ihigh += 1;
}
}
}
qq += q;
q += 1800;
}
squarefree49big(buf, base, q, qq);
}
|
O3
|
c
|
squarefree49:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r8d
movabsq $0x8228a20a08a2882, %r9 # imm = 0x8228A20A08A2882
imulq $0x3c, %rsi, %rcx
imull $0x3c, %edx, %esi
imull %edx, %r8d
addl $0x384, %esi # imm = 0x384
cmpl $0x754dff, %r8d # imm = 0x754DFF
ja 0x1dd98
movl $0x88888889, %r10d # imm = 0x88888889
leaq 0x429d3(%rip), %r11 # 0x606c0
leaq 0x4294c(%rip), %rbx # 0x60640
movl %r8d, %r14d
cmpq $0x773593ff, %rcx # imm = 0x773593FF
ja 0x1dd09
movl %ecx, %eax
xorl %edx, %edx
divl %r8d
jmp 0x1dd11
movq %rcx, %rax
xorl %edx, %edx
divq %r14
movl %r8d, %eax
subl %edx, %eax
testb $0x1, %al
movl $0x0, %edx
cmovel %r8d, %edx
addl %eax, %edx
cmpl $0x754dff, %edx # imm = 0x754DFF
ja 0x1dd82
imulq %r10, %r14
shrq $0x24, %r14
orl $0x1, %r14d
movl %edx, %eax
imulq %r10, %rax
shrq $0x25, %rax
imull $0x3c, %eax, %ebp
subl %ebp, %edx
movl %edx, %r15d
btq %rdx, %r9
jae 0x1dd66
movl %eax, %edx
andl $0x1f, %edx
movl %eax, %r12d
shrl $0x5, %r12d
addl (%r11,%r15,4), %r12d
movl (%rbx,%rdx,4), %edx
orl %edx, (%rdi,%r12,4)
addl %r14d, %eax
leal 0x26(%r15), %ebp
leal -0x16(%r15), %edx
cmpl $0x16, %r15d
cmovbl %ebp, %edx
sbbl $-0x1, %eax
cmpl $0x1f480, %eax # imm = 0x1F480
jb 0x1dd46
addl %esi, %r8d
addl $0x708, %esi # imm = 0x708
cmpl $0x754e00, %r8d # imm = 0x754E00
jb 0x1dcf4
movl %r8d, %r8d
leaq 0x754e00(%rcx), %r10
cmpq %r8, %r10
jbe 0x1de30
movl $0x88888889, %r11d # imm = 0x88888889
leaq 0x42908(%rip), %rbx # 0x606c0
leaq 0x42881(%rip), %r14 # 0x60640
cmpq $0x773593ff, %r10 # imm = 0x773593FF
ja 0x1ddd1
movl %ecx, %eax
xorl %edx, %edx
divl %r8d
jmp 0x1ddd9
movq %rcx, %rax
xorl %edx, %edx
divq %r8
movq %r8, %r15
subq %rdx, %r15
testb $0x1, %r15b
movl $0x0, %eax
cmoveq %r8, %rax
addq %r15, %rax
cmpq $0x754dff, %rax # imm = 0x754DFF
ja 0x1de20
movl %eax, %edx
imulq %r11, %rdx
shrq $0x25, %rdx
imull $0x3c, %edx, %ebp
subl %ebp, %eax
btq %rax, %r9
jae 0x1de20
movl %edx, %r15d
andl $0x1f, %r15d
shrl $0x5, %edx
addl (%rbx,%rax,4), %edx
movl (%r14,%r15,4), %eax
orl %eax, (%rdi,%rdx,4)
movl %esi, %eax
addq %rax, %r8
addl $0x708, %esi # imm = 0x708
cmpq %r10, %r8
jb 0x1ddbf
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
squarefree49:
push rbp
push r15
push r14
push r12
push rbx
mov r8d, edx
mov r9, 8228A20A08A2882h
imul rcx, rsi, 3Ch ; '<'
imul esi, edx, 3Ch ; '<'
imul r8d, edx
add esi, 384h
cmp r8d, 754DFFh
ja loc_1DD98
mov r10d, 88888889h
lea r11, deltainverse
lea rbx, two
loc_1DCF4:
mov r14d, r8d
cmp rcx, 773593FFh
ja short loc_1DD09
mov eax, ecx
xor edx, edx
div r8d
jmp short loc_1DD11
loc_1DD09:
mov rax, rcx
xor edx, edx
div r14
loc_1DD11:
mov eax, r8d
sub eax, edx
test al, 1
mov edx, 0
cmovz edx, r8d
add edx, eax
cmp edx, 754DFFh
ja short loc_1DD82
imul r14, r10
shr r14, 24h
or r14d, 1
mov eax, edx
imul rax, r10
shr rax, 25h
imul ebp, eax, 3Ch ; '<'
sub edx, ebp
loc_1DD46:
mov r15d, edx
bt r9, rdx
jnb short loc_1DD66
mov edx, eax
and edx, 1Fh
mov r12d, eax
shr r12d, 5
add r12d, [r11+r15*4]
mov edx, [rbx+rdx*4]
or [rdi+r12*4], edx
loc_1DD66:
add eax, r14d
lea ebp, [r15+26h]
lea edx, [r15-16h]
cmp r15d, 16h
cmovb edx, ebp
sbb eax, 0FFFFFFFFh
cmp eax, offset loc_1F480
jb short loc_1DD46
loc_1DD82:
add r8d, esi
add esi, 708h
cmp r8d, 754E00h
jb loc_1DCF4
loc_1DD98:
mov r8d, r8d
lea r10, [rcx+754E00h]
cmp r10, r8
jbe loc_1DE30
mov r11d, 88888889h
lea rbx, deltainverse
lea r14, two
loc_1DDBF:
cmp r10, 773593FFh
ja short loc_1DDD1
mov eax, ecx
xor edx, edx
div r8d
jmp short loc_1DDD9
loc_1DDD1:
mov rax, rcx
xor edx, edx
div r8
loc_1DDD9:
mov r15, r8
sub r15, rdx
test r15b, 1
mov eax, 0
cmovz rax, r8
add rax, r15
cmp rax, 754DFFh
ja short loc_1DE20
mov edx, eax
imul rdx, r11
shr rdx, 25h
imul ebp, edx, 3Ch ; '<'
sub eax, ebp
bt r9, rax
jnb short loc_1DE20
mov r15d, edx
and r15d, 1Fh
shr edx, 5
add edx, [rbx+rax*4]
mov eax, [r14+r15*4]
or [rdi+rdx*4], eax
loc_1DE20:
mov eax, esi
add r8, rax
add esi, 708h
cmp r8, r10
jb short loc_1DDBF
loc_1DE30:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
void squarefree49(long long a1, long long a2, int a3)
{
long long v3; // r9
unsigned long long v4; // rcx
unsigned long long v5; // r8
unsigned int v6; // esi
unsigned long long v7; // rdx
int v8; // eax
bool v9; // zf
int v10; // edx
unsigned int v11; // edx
unsigned int v12; // eax
unsigned long long v13; // rdx
unsigned int v14; // r15d
long long v15; // r12
unsigned int v16; // eax
unsigned long long i; // r10
unsigned long long v18; // rdx
unsigned long long v19; // rax
unsigned long long v20; // rax
unsigned int v21; // edx
unsigned long long v22; // rax
long long v23; // r15
long long v24; // rdx
v3 = 0x8228A20A08A2882LL;
v4 = 60 * a2;
LODWORD(v5) = a3 * a3;
v6 = 60 * a3 + 900;
if ( (unsigned int)(a3 * a3) <= 0x754DFF )
{
do
{
if ( v4 > 0x773593FF )
v7 = v4 % (unsigned int)v5;
else
LODWORD(v7) = (unsigned int)v4 % (unsigned int)v5;
v8 = v5 - v7;
v9 = (((_BYTE)v5 - (_BYTE)v7) & 1) == 0;
v10 = 0;
if ( v9 )
v10 = v5;
v11 = v8 + v10;
if ( v11 <= 0x754DFF )
{
v12 = v11 / 0x3C;
v13 = v11 % 0x3C;
do
{
v14 = v13;
if ( _bittest64(&v3, v13) )
{
v15 = deltainverse[(unsigned int)v13] + (v12 >> 5);
*(_DWORD *)(a1 + 4 * v15) |= two[v12 & 0x1F];
}
v16 = (((unsigned int)v5 / 0x1E) | 1) + v12;
v13 = (unsigned int)(v13 - 22);
if ( v14 < 0x16 )
v13 = v14 + 38;
v12 = v16 - ((v14 < 0x16) - 1);
}
while ( v12 < (unsigned int)&loc_1F480 );
}
LODWORD(v5) = v6 + v5;
v6 += 1800;
}
while ( (unsigned int)v5 < 0x754E00 );
}
v5 = (unsigned int)v5;
for ( i = v4 + 7687680; v5 < i; v6 += 1800 )
{
if ( i > 0x773593FF )
v18 = v4 % v5;
else
v18 = (unsigned int)v4 % (unsigned int)v5;
v19 = 0LL;
if ( (((_BYTE)v5 - (_BYTE)v18) & 1) == 0 )
v19 = v5;
v20 = v5 - v18 + v19;
if ( v20 <= 0x754DFF )
{
v21 = (unsigned int)v20 / 0x3C;
v22 = (unsigned int)v20 % 0x3C;
if ( _bittest64(&v3, v22) )
{
v23 = v21 & 0x1F;
v24 = deltainverse[v22] + (v21 >> 5);
*(_DWORD *)(a1 + 4 * v24) |= two[v23];
}
}
v5 += v6;
}
}
|
squarefree49:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R8D,EDX
MOV R9,0x8228a20a08a2882
IMUL RCX,RSI,0x3c
IMUL ESI,EDX,0x3c
IMUL R8D,EDX
ADD ESI,0x384
CMP R8D,0x754dff
JA 0x0011dd98
MOV R10D,0x88888889
LEA R11,[0x1606c0]
LEA RBX,[0x160640]
LAB_0011dcf4:
MOV R14D,R8D
CMP RCX,0x773593ff
JA 0x0011dd09
MOV EAX,ECX
XOR EDX,EDX
DIV R8D
JMP 0x0011dd11
LAB_0011dd09:
MOV RAX,RCX
XOR EDX,EDX
DIV R14
LAB_0011dd11:
MOV EAX,R8D
SUB EAX,EDX
TEST AL,0x1
MOV EDX,0x0
CMOVZ EDX,R8D
ADD EDX,EAX
CMP EDX,0x754dff
JA 0x0011dd82
IMUL R14,R10
SHR R14,0x24
OR R14D,0x1
MOV EAX,EDX
IMUL RAX,R10
SHR RAX,0x25
IMUL EBP,EAX,0x3c
SUB EDX,EBP
LAB_0011dd46:
MOV R15D,EDX
BT R9,RDX
JNC 0x0011dd66
MOV EDX,EAX
AND EDX,0x1f
MOV R12D,EAX
SHR R12D,0x5
ADD R12D,dword ptr [R11 + R15*0x4]
MOV EDX,dword ptr [RBX + RDX*0x4]
OR dword ptr [RDI + R12*0x4],EDX
LAB_0011dd66:
ADD EAX,R14D
LEA EBP,[R15 + 0x26]
LEA EDX,[R15 + -0x16]
CMP R15D,0x16
CMOVC EDX,EBP
SBB EAX,-0x1
CMP EAX,0x1f480
JC 0x0011dd46
LAB_0011dd82:
ADD R8D,ESI
ADD ESI,0x708
CMP R8D,0x754e00
JC 0x0011dcf4
LAB_0011dd98:
MOV R8D,R8D
LEA R10,[RCX + 0x754e00]
CMP R10,R8
JBE 0x0011de30
MOV R11D,0x88888889
LEA RBX,[0x1606c0]
LEA R14,[0x160640]
LAB_0011ddbf:
CMP R10,0x773593ff
JA 0x0011ddd1
MOV EAX,ECX
XOR EDX,EDX
DIV R8D
JMP 0x0011ddd9
LAB_0011ddd1:
MOV RAX,RCX
XOR EDX,EDX
DIV R8
LAB_0011ddd9:
MOV R15,R8
SUB R15,RDX
TEST R15B,0x1
MOV EAX,0x0
CMOVZ RAX,R8
ADD RAX,R15
CMP RAX,0x754dff
JA 0x0011de20
MOV EDX,EAX
IMUL RDX,R11
SHR RDX,0x25
IMUL EBP,EDX,0x3c
SUB EAX,EBP
BT R9,RAX
JNC 0x0011de20
MOV R15D,EDX
AND R15D,0x1f
SHR EDX,0x5
ADD EDX,dword ptr [RBX + RAX*0x4]
MOV EAX,dword ptr [R14 + R15*0x4]
OR dword ptr [RDI + RDX*0x4],EAX
LAB_0011de20:
MOV EAX,ESI
ADD R8,RAX
ADD ESI,0x708
CMP R8,R10
JC 0x0011ddbf
LAB_0011de30:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
void squarefree49(long param_1,long param_2,int param_3)
{
uint *puVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
int iVar5;
uint uVar6;
ulong uVar7;
uint uVar8;
uint uVar9;
uint uVar10;
bool bVar11;
uVar4 = param_2 * 0x3c;
uVar10 = param_3 * param_3;
uVar9 = param_3 * 0x3c + 900;
while (uVar10 < 0x754e00) {
if (uVar4 < 2000000000) {
iVar5 = (int)((uVar4 & 0xffffffff) % (ulong)uVar10);
}
else {
iVar5 = (int)(uVar4 % (ulong)uVar10);
}
uVar6 = 0;
if ((uVar10 - iVar5 & 1) == 0) {
uVar6 = uVar10;
}
uVar6 = uVar6 + (uVar10 - iVar5);
if (uVar6 < 0x754e00) {
uVar2 = (ulong)uVar6 / 0x3c;
uVar6 = uVar6 % 0x3c;
do {
if ((0x8228a20a08a2882U >> ((ulong)uVar6 & 0x3f) & 1) != 0) {
puVar1 = (uint *)(param_1 +
(ulong)(uint)((int)(uVar2 >> 5) +
*(int *)(deltainverse + (ulong)uVar6 * 4)) * 4);
*puVar1 = *puVar1 | *(uint *)(two + (ulong)((uint)uVar2 & 0x1f) * 4);
}
uVar8 = uVar6 + 0x26;
bVar11 = uVar6 < 0x16;
uVar6 = uVar6 - 0x16;
if (bVar11) {
uVar6 = uVar8;
}
uVar8 = ((uint)uVar2 + (uVar10 / 0x1e | 1) + 1) - (uint)bVar11;
uVar2 = (ulong)uVar8;
} while (uVar8 < 0x1f480);
}
uVar10 = uVar10 + uVar9;
uVar9 = uVar9 + 0x708;
}
for (uVar2 = (ulong)uVar10; uVar2 < uVar4 + 0x754e00; uVar2 = uVar2 + uVar7) {
if (uVar4 + 0x754e00 < 2000000000) {
uVar7 = (uVar4 & 0xffffffff) % (uVar2 & 0xffffffff);
}
else {
uVar7 = uVar4 % uVar2;
}
uVar3 = 0;
if ((uVar2 - uVar7 & 1) == 0) {
uVar3 = uVar2;
}
uVar3 = uVar3 + (uVar2 - uVar7);
if (uVar3 < 0x754e00) {
uVar10 = (uint)((uVar3 & 0xffffffff) / 0x3c);
uVar7 = (ulong)((int)uVar3 + uVar10 * -0x3c);
if ((0x8228a20a08a2882U >> (uVar7 & 0x3f) & 1) != 0) {
puVar1 = (uint *)(param_1 +
(ulong)(uint)((int)((uVar3 & 0xffffffff) / 0x780) +
*(int *)(deltainverse + uVar7 * 4)) * 4);
*puVar1 = *puVar1 | *(uint *)(two + (ulong)(uVar10 & 0x1f) * 4);
}
}
uVar7 = (ulong)uVar9;
uVar9 = uVar9 + 0x708;
}
return;
}
|
|
63,662
|
my_get_err_msg
|
eloqsql/mysys/my_error.c
|
const char *my_get_err_msg(uint nr)
{
const char *format;
struct my_err_head *meh_p;
/* Search for the range this error is in. */
for (meh_p= my_errmsgs_list; meh_p; meh_p= meh_p->meh_next)
if (nr <= meh_p->meh_last)
break;
/*
If we found the range this error number is in, get the format string.
If the string is empty, or a NULL pointer, or if we're out of return,
we return NULL.
*/
if (!(format= (meh_p && (nr >= meh_p->meh_first)) ?
meh_p->get_errmsgs(nr)[nr - meh_p->meh_first] : NULL) ||
!*format)
return NULL;
return format;
}
|
O0
|
c
|
my_get_err_msg:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq 0x1d9bd6(%rip), %rax # 0x2ca978
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xf0dca
movl -0xc(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x14(%rcx), %eax
ja 0xf0dbb
jmp 0xf0dca
jmp 0xf0dbd
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xf0da6
cmpq $0x0, -0x20(%rbp)
je 0xf0e00
movl -0xc(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jb 0xf0e00
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %edi
callq *%rax
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rdx
subl 0x10(%rdx), %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
jmp 0xf0e08
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0xf0e08
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xf0e1f
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xf0e29
movq $0x0, -0x8(%rbp)
jmp 0xf0e31
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
my_get_err_msg:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_C], edi
mov rax, cs:my_errmsgs_list
mov [rbp+var_20], rax
loc_F0DA6:
cmp [rbp+var_20], 0
jz short loc_F0DCA
mov eax, [rbp+var_C]
mov rcx, [rbp+var_20]
cmp eax, [rcx+14h]
ja short loc_F0DBB
jmp short loc_F0DCA
loc_F0DBB:
jmp short $+2
loc_F0DBD:
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_20], rax
jmp short loc_F0DA6
loc_F0DCA:
cmp [rbp+var_20], 0
jz short loc_F0E00
mov eax, [rbp+var_C]
mov rcx, [rbp+var_20]
cmp eax, [rcx+10h]
jb short loc_F0E00
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov edi, [rbp+var_C]
call rax
mov ecx, [rbp+var_C]
mov rdx, [rbp+var_20]
sub ecx, [rdx+10h]
mov ecx, ecx
mov rax, [rax+rcx*8]
mov [rbp+var_28], rax
jmp short loc_F0E08
loc_F0E00:
xor eax, eax
mov [rbp+var_28], rax
jmp short $+2
loc_F0E08:
mov rax, [rbp+var_28]
mov [rbp+var_18], rax
cmp rax, 0
jz short loc_F0E1F
mov rax, [rbp+var_18]
cmp byte ptr [rax], 0
jnz short loc_F0E29
loc_F0E1F:
mov [rbp+var_8], 0
jmp short loc_F0E31
loc_F0E29:
mov rax, [rbp+var_18]
mov [rbp+var_8], rax
loc_F0E31:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
|
_BYTE * my_get_err_msg(unsigned int a1)
{
_BYTE *v2; // [rsp+8h] [rbp-28h]
long long *i; // [rsp+10h] [rbp-20h]
for ( i = my_errmsgs_list; i && a1 > *((_DWORD *)i + 5); i = (long long *)*i )
;
if ( i && a1 >= *((_DWORD *)i + 4) )
v2 = *(_BYTE **)(((long long ( *)(_QWORD))i[1])(a1) + 8LL * (a1 - *((_DWORD *)i + 4)));
else
v2 = 0LL;
if ( v2 && *v2 )
return v2;
else
return 0LL;
}
|
my_get_err_msg:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0xc],EDI
MOV RAX,qword ptr [0x003ca978]
MOV qword ptr [RBP + -0x20],RAX
LAB_001f0da6:
CMP qword ptr [RBP + -0x20],0x0
JZ 0x001f0dca
MOV EAX,dword ptr [RBP + -0xc]
MOV RCX,qword ptr [RBP + -0x20]
CMP EAX,dword ptr [RCX + 0x14]
JA 0x001f0dbb
JMP 0x001f0dca
LAB_001f0dbb:
JMP 0x001f0dbd
LAB_001f0dbd:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001f0da6
LAB_001f0dca:
CMP qword ptr [RBP + -0x20],0x0
JZ 0x001f0e00
MOV EAX,dword ptr [RBP + -0xc]
MOV RCX,qword ptr [RBP + -0x20]
CMP EAX,dword ptr [RCX + 0x10]
JC 0x001f0e00
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV EDI,dword ptr [RBP + -0xc]
CALL RAX
MOV ECX,dword ptr [RBP + -0xc]
MOV RDX,qword ptr [RBP + -0x20]
SUB ECX,dword ptr [RDX + 0x10]
MOV ECX,ECX
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001f0e08
LAB_001f0e00:
XOR EAX,EAX
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001f0e08
LAB_001f0e08:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JZ 0x001f0e1f
MOV RAX,qword ptr [RBP + -0x18]
CMP byte ptr [RAX],0x0
JNZ 0x001f0e29
LAB_001f0e1f:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001f0e31
LAB_001f0e29:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x8],RAX
LAB_001f0e31:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
char * my_get_err_msg(uint param_1)
{
long lVar1;
char *local_30;
int8 *local_28;
char *local_10;
for (local_28 = (int8 *)my_errmsgs_list;
(local_28 != (int8 *)0x0 && (*(uint *)((long)local_28 + 0x14) < param_1));
local_28 = (int8 *)*local_28) {
}
if ((local_28 == (int8 *)0x0) || (param_1 < *(uint *)(local_28 + 2))) {
local_30 = (char *)0x0;
}
else {
lVar1 = (*(code *)local_28[1])(param_1);
local_30 = *(char **)(lVar1 + (ulong)(param_1 - *(int *)(local_28 + 2)) * 8);
}
if ((local_30 == (char *)0x0) || (*local_30 == '\0')) {
local_10 = (char *)0x0;
}
else {
local_10 = local_30;
}
return local_10;
}
|
|
63,663
|
my_xml_parse
|
eloqsql/strings/xml.c
|
int my_xml_parse(MY_XML_PARSER *p,const char *str, size_t len)
{
my_xml_attr_rewind(p);
p->beg=str;
p->cur=str;
p->end=str+len;
while ( p->cur < p->end )
{
MY_XML_ATTR a;
if (p->cur[0] == '<')
{
int lex;
int question=0;
int exclam=0;
lex=my_xml_scan(p,&a);
if (MY_XML_COMMENT == lex)
continue;
if (lex == MY_XML_CDATA)
{
a.beg+= 9;
a.end-= 3;
my_xml_value(p, a.beg, (size_t) (a.end-a.beg));
continue;
}
lex=my_xml_scan(p,&a);
if (MY_XML_SLASH == lex)
{
if (MY_XML_IDENT != (lex=my_xml_scan(p,&a)))
{
sprintf(p->errstr,"%s unexpected (ident wanted)",lex2str(lex));
return MY_XML_ERROR;
}
if (MY_XML_OK != my_xml_leave(p,a.beg,(size_t) (a.end-a.beg)))
return MY_XML_ERROR;
lex=my_xml_scan(p,&a);
goto gt;
}
if (MY_XML_EXCLAM == lex)
{
lex=my_xml_scan(p,&a);
exclam=1;
}
else if (MY_XML_QUESTION == lex)
{
lex=my_xml_scan(p,&a);
question=1;
}
if (MY_XML_IDENT == lex)
{
p->current_node_type= MY_XML_NODE_TAG;
if (MY_XML_OK != my_xml_enter(p,a.beg,(size_t) (a.end-a.beg)))
return MY_XML_ERROR;
}
else
{
sprintf(p->errstr,"%s unexpected (ident or '/' wanted)",
lex2str(lex));
return MY_XML_ERROR;
}
while ((MY_XML_IDENT == (lex=my_xml_scan(p,&a))) ||
((MY_XML_STRING == lex && exclam)))
{
MY_XML_ATTR b;
if (MY_XML_EQ == (lex=my_xml_scan(p,&b)))
{
lex=my_xml_scan(p,&b);
if ( (lex == MY_XML_IDENT) || (lex == MY_XML_STRING) )
{
p->current_node_type= MY_XML_NODE_ATTR;
if ((MY_XML_OK != my_xml_enter(p,a.beg,(size_t) (a.end-a.beg))) ||
(MY_XML_OK != my_xml_value(p,b.beg,(size_t) (b.end-b.beg))) ||
(MY_XML_OK != my_xml_leave(p,a.beg,(size_t) (a.end-a.beg))))
return MY_XML_ERROR;
}
else
{
sprintf(p->errstr,"%s unexpected (ident or string wanted)",
lex2str(lex));
return MY_XML_ERROR;
}
}
else if (MY_XML_IDENT == lex)
{
p->current_node_type= MY_XML_NODE_ATTR;
if ((MY_XML_OK != my_xml_enter(p,a.beg,(size_t) (a.end-a.beg))) ||
(MY_XML_OK != my_xml_leave(p,a.beg,(size_t) (a.end-a.beg))))
return MY_XML_ERROR;
}
else if ((MY_XML_STRING == lex) && exclam)
{
/*
We are in <!DOCTYPE>, e.g.
<!DOCTYPE name SYSTEM "SystemLiteral">
<!DOCTYPE name PUBLIC "PublidLiteral" "SystemLiteral">
Just skip "SystemLiteral" and "PublicidLiteral"
*/
}
else
break;
}
if (lex == MY_XML_SLASH)
{
if (MY_XML_OK != my_xml_leave(p,NULL,0))
return MY_XML_ERROR;
lex=my_xml_scan(p,&a);
}
gt:
if (question)
{
if (lex != MY_XML_QUESTION)
{
sprintf(p->errstr,"%s unexpected ('?' wanted)",lex2str(lex));
return MY_XML_ERROR;
}
if (MY_XML_OK != my_xml_leave(p,NULL,0))
return MY_XML_ERROR;
lex=my_xml_scan(p,&a);
}
if (exclam)
{
if (MY_XML_OK != my_xml_leave(p,NULL,0))
return MY_XML_ERROR;
}
if (lex != MY_XML_GT)
{
sprintf(p->errstr,"%s unexpected ('>' wanted)",lex2str(lex));
return MY_XML_ERROR;
}
}
else
{
a.beg=p->cur;
for ( ; (p->cur < p->end) && (p->cur[0] != '<') ; p->cur++);
a.end=p->cur;
if (!(p->flags & MY_XML_FLAG_SKIP_TEXT_NORMALIZATION))
my_xml_norm_text(&a);
if (a.beg != a.end)
{
my_xml_value(p,a.beg,(size_t) (a.end-a.beg));
}
}
}
if (p->attr.start[0])
{
sprintf(p->errstr,"unexpected END-OF-INPUT");
return MY_XML_ERROR;
}
return MY_XML_OK;
}
|
O3
|
c
|
my_xml_parse:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x118(%rdi), %rcx
movq %rcx, 0x120(%rdi)
movq %rsi, 0x128(%rdi)
movq %rsi, 0x130(%rdi)
leaq (%rsi,%rdx), %rax
movq %rax, 0x138(%rdi)
testq %rdx, %rdx
jle 0xd6f6d
leaq -0x40(%rbp), %r15
cmpb $0x3c, (%rsi)
jne 0xd6caf
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd7037
cmpl $0x43, %eax
je 0xd6f4f
cmpl $0x44, %eax
jne 0xd6d14
movq 0x150(%rbx), %rax
testq %rax, %rax
je 0xd6f4f
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
addq $0x9, %rsi
subq %rsi, %rdx
addq $-0x3, %rdx
jmp 0xd6d0a
movq %rsi, -0x40(%rbp)
movq %rsi, %rdx
cmpq %rax, %rsi
jae 0xd6cd5
subq %rsi, %rax
movq %rsi, %rdx
cmpb $0x3c, (%rdx)
je 0xd6cd5
incq %rdx
movq %rdx, 0x130(%rbx)
decq %rax
jne 0xd6cc1
movq %rdx, -0x38(%rbp)
testb $0x2, (%rbx)
jne 0xd6cee
movq %r15, %rdi
callq 0xd766f
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
cmpq %rdx, %rsi
je 0xd6f4f
movq 0x150(%rbx), %rax
testq %rax, %rax
je 0xd6f4f
subq %rsi, %rdx
movq %rbx, %rdi
callq *%rax
jmp 0xd6f4f
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd7037
cmpl $0x2f, %eax
jne 0xd6d66
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd7037
cmpl $0x49, %eax
jne 0xd6fcd
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
subq %rsi, %rdx
movq %rbx, %rdi
callq 0xd7335
testl %eax, %eax
jne 0xd701f
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd7037
movl %eax, %r13d
jmp 0xd6f49
movl %eax, %r14d
cmpl $0x21, %eax
sete %r12b
cmpl $0x3f, %eax
je 0xd6d7b
cmpl $0x21, %r14d
jne 0xd6d88
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd7037
jmp 0xd6d8e
movb $0x1, %r12b
movl %r14d, %eax
cmpl $0x49, %eax
jne 0xd6fb9
movl $0x0, 0x4(%rbx)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
subq %rsi, %rdx
movq %rbx, %rdi
callq 0xd74f8
testl %eax, %eax
jne 0xd701f
movb %r12b, -0x29(%rbp)
movl %r14d, %r12d
xorl $0x21, %r12d
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd7037
movl %eax, %r13d
xorl $0x53, %eax
orl %r12d, %eax
sete %al
cmpl $0x49, %r13d
je 0xd6de9
testb %al, %al
je 0xd6ed2
movq %rbx, %rdi
leaq -0x50(%rbp), %rsi
callq 0xd7037
cmpl $0x49, %eax
je 0xd6e77
movl %eax, %r13d
cmpl $0x3d, %eax
jne 0xd6eb6
movq %rbx, %rdi
leaq -0x50(%rbp), %rsi
callq 0xd7037
cmpl $0x53, %eax
je 0xd6e20
cmpl $0x49, %eax
jne 0xd6fe1
movl $0x1, 0x4(%rbx)
movq -0x40(%rbp), %r13
movq -0x38(%rbp), %r15
subq %r13, %r15
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xd74f8
testl %eax, %eax
jne 0xd701f
movq 0x150(%rbx), %rax
testq %rax, %rax
je 0xd6e6c
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
subq %rsi, %rdx
movq %rbx, %rdi
callq *%rax
testl %eax, %eax
jne 0xd701f
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
jmp 0xd6ea8
movl $0x1, 0x4(%rbx)
movq -0x40(%rbp), %r15
movq -0x38(%rbp), %r13
subq %r15, %r13
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xd74f8
testl %eax, %eax
jne 0xd701f
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xd7335
testl %eax, %eax
je 0xd6ec2
jmp 0xd701f
cmpl $0x21, %r14d
jne 0xd6ece
cmpl $0x53, %r13d
jne 0xd6ece
movq %rbx, %rdi
leaq -0x40(%rbp), %r15
jmp 0xd6dc7
leaq -0x40(%rbp), %r15
cmpl $0x2f, %r13d
movb -0x29(%rbp), %r12b
jne 0xd6efe
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xd7335
testl %eax, %eax
jne 0xd701f
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd7037
movl %eax, %r13d
testb %r12b, %r12b
jne 0xd6f2f
cmpl $0x3f, %r13d
jne 0xd6ff5
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xd7335
testl %eax, %eax
jne 0xd701f
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd7037
movl %eax, %r13d
cmpl $0x21, %r14d
jne 0xd6f49
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xd7335
testl %eax, %eax
jne 0xd701f
cmpl $0x3e, %r13d
jne 0xd6fa4
movq 0x130(%rbx), %rsi
movq 0x138(%rbx), %rax
cmpq %rax, %rsi
jb 0xd6c68
movq 0x118(%rbx), %rcx
cmpb $0x0, (%rcx)
je 0xd6f9c
addq $0x8, %rbx
leaq 0x8b12(%rip), %rcx # 0xdfa8f
movl $0x1, %r14d
movl $0x80, %edx
movq %rbx, %rdi
movl $0x1, %esi
xorl %eax, %eax
callq 0x29950
jmp 0xd7025
xorl %r14d, %r14d
jmp 0xd7025
addq $0x8, %rbx
movl %r13d, %edi
callq 0xd729a
leaq 0x8abd(%rip), %rcx # 0xdfa74
jmp 0xd7008
addq $0x8, %rbx
movl %eax, %edi
callq 0xd729a
leaq 0x8a43(%rip), %rcx # 0xdfa0e
jmp 0xd7008
addq $0x8, %rbx
movl %eax, %edi
callq 0xd729a
leaq 0x8a12(%rip), %rcx # 0xdf9f1
jmp 0xd7008
addq $0x8, %rbx
movl %eax, %edi
callq 0xd729a
leaq 0x8a3f(%rip), %rcx # 0xdfa32
jmp 0xd7008
addq $0x8, %rbx
movl %r13d, %edi
callq 0xd729a
leaq 0x8a51(%rip), %rcx # 0xdfa59
movl $0x80, %edx
movq %rbx, %rdi
movl $0x1, %esi
movq %rax, %r8
xorl %eax, %eax
callq 0x29950
movl $0x1, %r14d
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_xml_parse:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbx, rdi
mov rcx, [rdi+118h]
mov [rdi+120h], rcx
mov [rdi+128h], rsi
mov [rdi+130h], rsi
lea rax, [rsi+rdx]
mov [rdi+138h], rax
test rdx, rdx
jle loc_D6F6D
lea r15, [rbp+var_40]
loc_D6C68:
cmp byte ptr [rsi], 3Ch ; '<'
jnz short loc_D6CAF
mov rdi, rbx
mov rsi, r15
call my_xml_scan
cmp eax, 43h ; 'C'
jz loc_D6F4F
cmp eax, 44h ; 'D'
jnz loc_D6D14
mov rax, [rbx+150h]
test rax, rax
jz loc_D6F4F
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_38]
add rsi, 9
sub rdx, rsi
add rdx, 0FFFFFFFFFFFFFFFDh
jmp short loc_D6D0A
loc_D6CAF:
mov [rbp+var_40], rsi
mov rdx, rsi
cmp rsi, rax
jnb short loc_D6CD5
sub rax, rsi
mov rdx, rsi
loc_D6CC1:
cmp byte ptr [rdx], 3Ch ; '<'
jz short loc_D6CD5
inc rdx
mov [rbx+130h], rdx
dec rax
jnz short loc_D6CC1
loc_D6CD5:
mov [rbp+var_38], rdx
test byte ptr [rbx], 2
jnz short loc_D6CEE
mov rdi, r15
call my_xml_norm_text
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_38]
loc_D6CEE:
cmp rsi, rdx
jz loc_D6F4F
mov rax, [rbx+150h]
test rax, rax
jz loc_D6F4F
sub rdx, rsi
loc_D6D0A:
mov rdi, rbx
call rax
jmp loc_D6F4F
loc_D6D14:
mov rdi, rbx
mov rsi, r15
call my_xml_scan
cmp eax, 2Fh ; '/'
jnz short loc_D6D66
mov rdi, rbx
mov rsi, r15
call my_xml_scan
cmp eax, 49h ; 'I'
jnz loc_D6FCD
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_38]
sub rdx, rsi
mov rdi, rbx
call my_xml_leave
test eax, eax
jnz loc_D701F
mov rdi, rbx
mov rsi, r15
call my_xml_scan
mov r13d, eax
jmp loc_D6F49
loc_D6D66:
mov r14d, eax
cmp eax, 21h ; '!'
setz r12b
cmp eax, 3Fh ; '?'
jz short loc_D6D7B
cmp r14d, 21h ; '!'
jnz short loc_D6D88
loc_D6D7B:
mov rdi, rbx
mov rsi, r15
call my_xml_scan
jmp short loc_D6D8E
loc_D6D88:
mov r12b, 1
mov eax, r14d
loc_D6D8E:
cmp eax, 49h ; 'I'
jnz loc_D6FB9
mov dword ptr [rbx+4], 0
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_38]
sub rdx, rsi
mov rdi, rbx
call my_xml_enter
test eax, eax
jnz loc_D701F
mov [rbp+var_29], r12b
mov r12d, r14d
xor r12d, 21h
mov rdi, rbx
loc_D6DC7:
mov rsi, r15
call my_xml_scan
mov r13d, eax
xor eax, 53h
or eax, r12d
setz al
cmp r13d, 49h ; 'I'
jz short loc_D6DE9
test al, al
jz loc_D6ED2
loc_D6DE9:
mov rdi, rbx
lea rsi, [rbp+var_50]
call my_xml_scan
cmp eax, 49h ; 'I'
jz short loc_D6E77
mov r13d, eax
cmp eax, 3Dh ; '='
jnz loc_D6EB6
mov rdi, rbx
lea rsi, [rbp+var_50]
call my_xml_scan
cmp eax, 53h ; 'S'
jz short loc_D6E20
cmp eax, 49h ; 'I'
jnz loc_D6FE1
loc_D6E20:
mov dword ptr [rbx+4], 1
mov r13, [rbp+var_40]
mov r15, [rbp+var_38]
sub r15, r13
mov rdi, rbx
mov rsi, r13
mov rdx, r15
call my_xml_enter
test eax, eax
jnz loc_D701F
mov rax, [rbx+150h]
test rax, rax
jz short loc_D6E6C
mov rsi, [rbp+var_50]
mov rdx, [rbp+var_48]
sub rdx, rsi
mov rdi, rbx
call rax
test eax, eax
jnz loc_D701F
loc_D6E6C:
mov rdi, rbx
mov rsi, r13
mov rdx, r15
jmp short loc_D6EA8
loc_D6E77:
mov dword ptr [rbx+4], 1
mov r15, [rbp+var_40]
mov r13, [rbp+var_38]
sub r13, r15
mov rdi, rbx
mov rsi, r15
mov rdx, r13
call my_xml_enter
test eax, eax
jnz loc_D701F
mov rdi, rbx
mov rsi, r15
mov rdx, r13
loc_D6EA8:
call my_xml_leave
test eax, eax
jz short loc_D6EC2
jmp loc_D701F
loc_D6EB6:
cmp r14d, 21h ; '!'
jnz short loc_D6ECE
cmp r13d, 53h ; 'S'
jnz short loc_D6ECE
loc_D6EC2:
mov rdi, rbx
lea r15, [rbp+var_40]
jmp loc_D6DC7
loc_D6ECE:
lea r15, [rbp+var_40]
loc_D6ED2:
cmp r13d, 2Fh ; '/'
mov r12b, [rbp+var_29]
jnz short loc_D6EFE
mov rdi, rbx
xor esi, esi
xor edx, edx
call my_xml_leave
test eax, eax
jnz loc_D701F
mov rdi, rbx
mov rsi, r15
call my_xml_scan
mov r13d, eax
loc_D6EFE:
test r12b, r12b
jnz short loc_D6F2F
cmp r13d, 3Fh ; '?'
jnz loc_D6FF5
mov rdi, rbx
xor esi, esi
xor edx, edx
call my_xml_leave
test eax, eax
jnz loc_D701F
mov rdi, rbx
mov rsi, r15
call my_xml_scan
mov r13d, eax
loc_D6F2F:
cmp r14d, 21h ; '!'
jnz short loc_D6F49
mov rdi, rbx
xor esi, esi
xor edx, edx
call my_xml_leave
test eax, eax
jnz loc_D701F
loc_D6F49:
cmp r13d, 3Eh ; '>'
jnz short loc_D6FA4
loc_D6F4F:
mov rsi, [rbx+130h]
mov rax, [rbx+138h]
cmp rsi, rax
jb loc_D6C68
mov rcx, [rbx+118h]
loc_D6F6D:
cmp byte ptr [rcx], 0
jz short loc_D6F9C
add rbx, 8
lea rcx, aUnexpectedEndO; "unexpected END-OF-INPUT"
mov r14d, 1
mov edx, 80h
mov rdi, rbx
mov esi, 1
xor eax, eax
call ___sprintf_chk
jmp loc_D7025
loc_D6F9C:
xor r14d, r14d
jmp loc_D7025
loc_D6FA4:
add rbx, 8
mov edi, r13d
call lex2str
lea rcx, aSUnexpectedWan; "%s unexpected ('>' wanted)"
jmp short loc_D7008
loc_D6FB9:
add rbx, 8
mov edi, eax
call lex2str
lea rcx, aSUnexpectedIde; "%s unexpected (ident or '/' wanted)"
jmp short loc_D7008
loc_D6FCD:
add rbx, 8
mov edi, eax
call lex2str
lea rcx, aSUnexpectedIde_0; "%s unexpected (ident wanted)"
jmp short loc_D7008
loc_D6FE1:
add rbx, 8
mov edi, eax
call lex2str
lea rcx, aSUnexpectedIde_1; "%s unexpected (ident or string wanted)"
jmp short loc_D7008
loc_D6FF5:
add rbx, 8
mov edi, r13d
call lex2str
lea rcx, aSUnexpectedWan_0; "%s unexpected ('?' wanted)"
loc_D7008:
mov edx, 80h
mov rdi, rbx
mov esi, 1
mov r8, rax
xor eax, eax
call ___sprintf_chk
loc_D701F:
mov r14d, 1
loc_D7025:
mov eax, r14d
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long my_xml_parse(long long a1, _BYTE *a2, long long a3)
{
_BYTE *v4; // rcx
_BYTE *v5; // rax
int v6; // eax
void ( *v7)(long long, _BYTE *, long long); // rax
long long v8; // rdx
_BYTE *v9; // rdx
long long v10; // rax
unsigned int v11; // eax
unsigned int v12; // eax
unsigned int v13; // r13d
unsigned int v14; // r14d
bool v15; // r12
long long i; // rdi
unsigned int v17; // eax
unsigned int v18; // eax
_BYTE *v19; // r13
long long v20; // r15
unsigned int ( *v21)(long long, _QWORD, _QWORD); // rax
long long v22; // rdi
_BYTE *v23; // rsi
long long v24; // rdx
_BYTE *v25; // r15
long long v26; // r13
bool v27; // r12
unsigned int v28; // r14d
long long v29; // rax
long long v30; // rax
long long v31; // rax
long long v32; // rax
long long v33; // rax
_QWORD v35[2]; // [rsp+0h] [rbp-50h] BYREF
_BYTE *v36; // [rsp+10h] [rbp-40h] BYREF
_BYTE *v37; // [rsp+18h] [rbp-38h]
bool v38; // [rsp+27h] [rbp-29h]
v4 = *(_BYTE **)(a1 + 280);
*(_QWORD *)(a1 + 288) = v4;
*(_QWORD *)(a1 + 296) = a2;
*(_QWORD *)(a1 + 304) = a2;
v5 = &a2[a3];
*(_QWORD *)(a1 + 312) = &a2[a3];
if ( a3 <= 0 )
goto LABEL_57;
while ( *a2 != 60 )
{
v36 = a2;
v9 = a2;
if ( a2 < v5 )
{
v10 = v5 - a2;
v9 = a2;
do
{
if ( *v9 == 60 )
break;
*(_QWORD *)(a1 + 304) = ++v9;
--v10;
}
while ( v10 );
}
v37 = v9;
if ( (*(_BYTE *)a1 & 2) == 0 )
{
my_xml_norm_text(&v36);
a2 = v36;
v9 = v37;
}
if ( a2 != v9 )
{
v7 = *(void ( **)(long long, _BYTE *, long long))(a1 + 336);
if ( v7 )
{
v8 = v9 - a2;
LABEL_16:
v7(a1, a2, v8);
}
}
LABEL_55:
a2 = *(_BYTE **)(a1 + 304);
v5 = *(_BYTE **)(a1 + 312);
if ( a2 >= v5 )
{
v4 = *(_BYTE **)(a1 + 280);
LABEL_57:
if ( *v4 )
{
v28 = 1;
__sprintf_chk(a1 + 8, 1LL, 128LL, "unexpected END-OF-INPUT");
}
else
{
return 0;
}
return v28;
}
}
v6 = my_xml_scan(a1, &v36);
if ( v6 == 67 )
goto LABEL_55;
if ( v6 == 68 )
{
v7 = *(void ( **)(long long, _BYTE *, long long))(a1 + 336);
if ( !v7 )
goto LABEL_55;
a2 = v36 + 9;
v8 = v37 - (v36 + 9) - 3;
goto LABEL_16;
}
v11 = my_xml_scan(a1, &v36);
if ( v11 == 47 )
{
v12 = my_xml_scan(a1, &v36);
if ( v12 == 73 )
{
if ( !(unsigned int)my_xml_leave(a1, v36, v37 - v36) )
{
v13 = my_xml_scan(a1, &v36);
goto LABEL_54;
}
}
else
{
v31 = lex2str(v12);
__sprintf_chk(a1 + 8, 1LL, 128LL, "%s unexpected (ident wanted)", v31);
}
return 1;
}
v14 = v11;
v15 = v11 == 33;
if ( v11 == 63 || v11 == 33 )
v11 = my_xml_scan(a1, &v36);
else
v15 = 1;
if ( v11 != 73 )
{
v30 = lex2str(v11);
__sprintf_chk(a1 + 8, 1LL, 128LL, "%s unexpected (ident or '/' wanted)", v30);
return 1;
}
*(_DWORD *)(a1 + 4) = 0;
if ( (unsigned int)my_xml_enter(a1, v36, v37 - v36) )
return 1;
v38 = v15;
for ( i = a1; ; i = a1 )
{
v13 = my_xml_scan(i, &v36);
if ( v13 != 73 )
{
if ( v14 ^ 0x21 | v13 ^ 0x53 )
break;
}
v17 = my_xml_scan(a1, v35);
if ( v17 == 73 )
{
*(_DWORD *)(a1 + 4) = 1;
v25 = v36;
v26 = v37 - v36;
if ( (unsigned int)my_xml_enter(a1, v36, v37 - v36) )
return 1;
v22 = a1;
v23 = v25;
v24 = v26;
LABEL_40:
if ( (unsigned int)my_xml_leave(v22, v23, v24) )
return 1;
continue;
}
v13 = v17;
if ( v17 == 61 )
{
v18 = my_xml_scan(a1, v35);
if ( v18 != 83 && v18 != 73 )
{
v32 = lex2str(v18);
__sprintf_chk(a1 + 8, 1LL, 128LL, "%s unexpected (ident or string wanted)", v32);
return 1;
}
*(_DWORD *)(a1 + 4) = 1;
v19 = v36;
v20 = v37 - v36;
if ( (unsigned int)my_xml_enter(a1, v36, v37 - v36) )
return 1;
v21 = *(unsigned int ( **)(long long, _QWORD, _QWORD))(a1 + 336);
if ( v21 )
{
if ( v21(a1, v35[0], v35[1] - v35[0]) )
return 1;
}
v22 = a1;
v23 = v19;
v24 = v20;
goto LABEL_40;
}
if ( v14 != 33 || v17 != 83 )
break;
}
v27 = v38;
if ( v13 == 47 )
{
if ( (unsigned int)my_xml_leave(a1, 0LL, 0LL) )
return 1;
v13 = my_xml_scan(a1, &v36);
}
if ( v27 )
goto LABEL_52;
if ( v13 == 63 )
{
if ( (unsigned int)my_xml_leave(a1, 0LL, 0LL) )
return 1;
v13 = my_xml_scan(a1, &v36);
LABEL_52:
if ( v14 != 33 || !(unsigned int)my_xml_leave(a1, 0LL, 0LL) )
{
LABEL_54:
if ( v13 == 62 )
goto LABEL_55;
v29 = lex2str(v13);
__sprintf_chk(a1 + 8, 1LL, 128LL, "%s unexpected ('>' wanted)", v29);
}
}
else
{
v33 = lex2str(v13);
__sprintf_chk(a1 + 8, 1LL, 128LL, "%s unexpected ('?' wanted)", v33);
}
return 1;
}
|
my_xml_parse:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
MOV RCX,qword ptr [RDI + 0x118]
MOV qword ptr [RDI + 0x120],RCX
MOV qword ptr [RDI + 0x128],RSI
MOV qword ptr [RDI + 0x130],RSI
LEA RAX,[RSI + RDX*0x1]
MOV qword ptr [RDI + 0x138],RAX
TEST RDX,RDX
JLE 0x001d6f6d
LEA R15,[RBP + -0x40]
LAB_001d6c68:
CMP byte ptr [RSI],0x3c
JNZ 0x001d6caf
MOV RDI,RBX
MOV RSI,R15
CALL 0x001d7037
CMP EAX,0x43
JZ 0x001d6f4f
CMP EAX,0x44
JNZ 0x001d6d14
MOV RAX,qword ptr [RBX + 0x150]
TEST RAX,RAX
JZ 0x001d6f4f
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x38]
ADD RSI,0x9
SUB RDX,RSI
ADD RDX,-0x3
JMP 0x001d6d0a
LAB_001d6caf:
MOV qword ptr [RBP + -0x40],RSI
MOV RDX,RSI
CMP RSI,RAX
JNC 0x001d6cd5
SUB RAX,RSI
MOV RDX,RSI
LAB_001d6cc1:
CMP byte ptr [RDX],0x3c
JZ 0x001d6cd5
INC RDX
MOV qword ptr [RBX + 0x130],RDX
DEC RAX
JNZ 0x001d6cc1
LAB_001d6cd5:
MOV qword ptr [RBP + -0x38],RDX
TEST byte ptr [RBX],0x2
JNZ 0x001d6cee
MOV RDI,R15
CALL 0x001d766f
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x38]
LAB_001d6cee:
CMP RSI,RDX
JZ 0x001d6f4f
MOV RAX,qword ptr [RBX + 0x150]
TEST RAX,RAX
JZ 0x001d6f4f
SUB RDX,RSI
LAB_001d6d0a:
MOV RDI,RBX
CALL RAX
JMP 0x001d6f4f
LAB_001d6d14:
MOV RDI,RBX
MOV RSI,R15
CALL 0x001d7037
CMP EAX,0x2f
JNZ 0x001d6d66
MOV RDI,RBX
MOV RSI,R15
CALL 0x001d7037
CMP EAX,0x49
JNZ 0x001d6fcd
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,RSI
MOV RDI,RBX
CALL 0x001d7335
TEST EAX,EAX
JNZ 0x001d701f
MOV RDI,RBX
MOV RSI,R15
CALL 0x001d7037
MOV R13D,EAX
JMP 0x001d6f49
LAB_001d6d66:
MOV R14D,EAX
CMP EAX,0x21
SETZ R12B
CMP EAX,0x3f
JZ 0x001d6d7b
CMP R14D,0x21
JNZ 0x001d6d88
LAB_001d6d7b:
MOV RDI,RBX
MOV RSI,R15
CALL 0x001d7037
JMP 0x001d6d8e
LAB_001d6d88:
MOV R12B,0x1
MOV EAX,R14D
LAB_001d6d8e:
CMP EAX,0x49
JNZ 0x001d6fb9
MOV dword ptr [RBX + 0x4],0x0
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,RSI
MOV RDI,RBX
CALL 0x001d74f8
TEST EAX,EAX
JNZ 0x001d701f
MOV byte ptr [RBP + -0x29],R12B
MOV R12D,R14D
XOR R12D,0x21
MOV RDI,RBX
LAB_001d6dc7:
MOV RSI,R15
CALL 0x001d7037
MOV R13D,EAX
XOR EAX,0x53
OR EAX,R12D
SETZ AL
CMP R13D,0x49
JZ 0x001d6de9
TEST AL,AL
JZ 0x001d6ed2
LAB_001d6de9:
MOV RDI,RBX
LEA RSI,[RBP + -0x50]
CALL 0x001d7037
CMP EAX,0x49
JZ 0x001d6e77
MOV R13D,EAX
CMP EAX,0x3d
JNZ 0x001d6eb6
MOV RDI,RBX
LEA RSI,[RBP + -0x50]
CALL 0x001d7037
CMP EAX,0x53
JZ 0x001d6e20
CMP EAX,0x49
JNZ 0x001d6fe1
LAB_001d6e20:
MOV dword ptr [RBX + 0x4],0x1
MOV R13,qword ptr [RBP + -0x40]
MOV R15,qword ptr [RBP + -0x38]
SUB R15,R13
MOV RDI,RBX
MOV RSI,R13
MOV RDX,R15
CALL 0x001d74f8
TEST EAX,EAX
JNZ 0x001d701f
MOV RAX,qword ptr [RBX + 0x150]
TEST RAX,RAX
JZ 0x001d6e6c
MOV RSI,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x48]
SUB RDX,RSI
MOV RDI,RBX
CALL RAX
TEST EAX,EAX
JNZ 0x001d701f
LAB_001d6e6c:
MOV RDI,RBX
MOV RSI,R13
MOV RDX,R15
JMP 0x001d6ea8
LAB_001d6e77:
MOV dword ptr [RBX + 0x4],0x1
MOV R15,qword ptr [RBP + -0x40]
MOV R13,qword ptr [RBP + -0x38]
SUB R13,R15
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R13
CALL 0x001d74f8
TEST EAX,EAX
JNZ 0x001d701f
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R13
LAB_001d6ea8:
CALL 0x001d7335
TEST EAX,EAX
JZ 0x001d6ec2
JMP 0x001d701f
LAB_001d6eb6:
CMP R14D,0x21
JNZ 0x001d6ece
CMP R13D,0x53
JNZ 0x001d6ece
LAB_001d6ec2:
MOV RDI,RBX
LEA R15,[RBP + -0x40]
JMP 0x001d6dc7
LAB_001d6ece:
LEA R15,[RBP + -0x40]
LAB_001d6ed2:
CMP R13D,0x2f
MOV R12B,byte ptr [RBP + -0x29]
JNZ 0x001d6efe
MOV RDI,RBX
XOR ESI,ESI
XOR EDX,EDX
CALL 0x001d7335
TEST EAX,EAX
JNZ 0x001d701f
MOV RDI,RBX
MOV RSI,R15
CALL 0x001d7037
MOV R13D,EAX
LAB_001d6efe:
TEST R12B,R12B
JNZ 0x001d6f2f
CMP R13D,0x3f
JNZ 0x001d6ff5
MOV RDI,RBX
XOR ESI,ESI
XOR EDX,EDX
CALL 0x001d7335
TEST EAX,EAX
JNZ 0x001d701f
MOV RDI,RBX
MOV RSI,R15
CALL 0x001d7037
MOV R13D,EAX
LAB_001d6f2f:
CMP R14D,0x21
JNZ 0x001d6f49
MOV RDI,RBX
XOR ESI,ESI
XOR EDX,EDX
CALL 0x001d7335
TEST EAX,EAX
JNZ 0x001d701f
LAB_001d6f49:
CMP R13D,0x3e
JNZ 0x001d6fa4
LAB_001d6f4f:
MOV RSI,qword ptr [RBX + 0x130]
MOV RAX,qword ptr [RBX + 0x138]
CMP RSI,RAX
JC 0x001d6c68
MOV RCX,qword ptr [RBX + 0x118]
LAB_001d6f6d:
CMP byte ptr [RCX],0x0
JZ 0x001d6f9c
ADD RBX,0x8
LEA RCX,[0x1dfa8f]
MOV R14D,0x1
MOV EDX,0x80
MOV RDI,RBX
MOV ESI,0x1
XOR EAX,EAX
CALL 0x00129950
JMP 0x001d7025
LAB_001d6f9c:
XOR R14D,R14D
JMP 0x001d7025
LAB_001d6fa4:
ADD RBX,0x8
MOV EDI,R13D
CALL 0x001d729a
LEA RCX,[0x1dfa74]
JMP 0x001d7008
LAB_001d6fb9:
ADD RBX,0x8
MOV EDI,EAX
CALL 0x001d729a
LEA RCX,[0x1dfa0e]
JMP 0x001d7008
LAB_001d6fcd:
ADD RBX,0x8
MOV EDI,EAX
CALL 0x001d729a
LEA RCX,[0x1df9f1]
JMP 0x001d7008
LAB_001d6fe1:
ADD RBX,0x8
MOV EDI,EAX
CALL 0x001d729a
LEA RCX,[0x1dfa32]
JMP 0x001d7008
LAB_001d6ff5:
ADD RBX,0x8
MOV EDI,R13D
CALL 0x001d729a
LEA RCX,[0x1dfa59]
LAB_001d7008:
MOV EDX,0x80
MOV RDI,RBX
MOV ESI,0x1
MOV R8,RAX
XOR EAX,EAX
CALL 0x00129950
LAB_001d701f:
MOV R14D,0x1
LAB_001d7025:
MOV EAX,R14D
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Type propagation algorithm not settling */
bool my_xml_parse(byte *param_1,char *param_2,long param_3)
{
char cVar1;
int iVar2;
int iVar3;
code *pcVar4;
int8 uVar5;
char *pcVar6;
char *pcVar7;
long lVar8;
bool bVar9;
long local_58;
long local_50;
char *local_48;
char *local_40;
char local_31;
pcVar7 = *(char **)(param_1 + 0x118);
*(char **)(param_1 + 0x120) = pcVar7;
*(char **)(param_1 + 0x128) = param_2;
*(char **)(param_1 + 0x130) = param_2;
pcVar6 = param_2 + param_3;
*(char **)(param_1 + 0x138) = pcVar6;
if (0 < param_3) {
do {
if (*param_2 == '<') {
iVar2 = my_xml_scan(param_1,&local_48);
if (iVar2 != 0x43) {
if (iVar2 == 0x44) {
pcVar4 = *(code **)(param_1 + 0x150);
if (pcVar4 != (code *)0x0) {
pcVar7 = local_40 + (-3 - (long)(local_48 + 9));
pcVar6 = local_48 + 9;
goto LAB_001d6d0a;
}
}
else {
iVar2 = my_xml_scan(param_1,&local_48);
if (iVar2 != 0x2f) {
bVar9 = iVar2 == 0x21;
if ((iVar2 == 0x3f) || (iVar2 == 0x21)) {
iVar3 = my_xml_scan(param_1,&local_48);
}
else {
bVar9 = true;
iVar3 = iVar2;
}
if (iVar3 == 0x49) {
param_1[4] = 0;
param_1[5] = 0;
param_1[6] = 0;
param_1[7] = 0;
iVar3 = my_xml_enter(param_1,local_48,(long)local_40 - (long)local_48);
local_31 = bVar9;
do {
if (iVar3 != 0) {
return true;
}
LAB_001d6dc7:
iVar3 = my_xml_scan(param_1,&local_48);
if ((iVar3 != 0x49) && (iVar3 != 0x53 || iVar2 != 0x21)) goto LAB_001d6ed2;
iVar3 = my_xml_scan(param_1,&local_58);
pcVar6 = local_48;
if (iVar3 == 0x49) {
param_1[4] = 1;
param_1[5] = 0;
param_1[6] = 0;
param_1[7] = 0;
lVar8 = (long)local_40 - (long)local_48;
iVar3 = my_xml_enter(param_1,local_48,lVar8);
goto joined_r0x001d6e99;
}
if (iVar3 != 0x3d) goto LAB_001d6eb6;
iVar3 = my_xml_scan(param_1,&local_58);
pcVar6 = local_48;
if ((iVar3 != 0x53) && (iVar3 != 0x49)) {
uVar5 = lex2str(iVar3);
pcVar6 = "%s unexpected (ident or string wanted)";
goto LAB_001d7008;
}
param_1[4] = 1;
param_1[5] = 0;
param_1[6] = 0;
param_1[7] = 0;
lVar8 = (long)local_40 - (long)local_48;
iVar3 = my_xml_enter(param_1,local_48,lVar8);
if (iVar3 != 0) {
return true;
}
if (*(code **)(param_1 + 0x150) != (code *)0x0) {
iVar3 = (**(code **)(param_1 + 0x150))(param_1,local_58,local_50 - local_58);
joined_r0x001d6e99:
if (iVar3 != 0) {
return true;
}
}
iVar3 = my_xml_leave(param_1,pcVar6,lVar8);
} while( true );
}
uVar5 = lex2str(iVar3);
pcVar6 = "%s unexpected (ident or \'/\' wanted)";
LAB_001d7008:
__sprintf_chk(param_1 + 8,1,0x80,pcVar6,uVar5);
return true;
}
iVar2 = my_xml_scan(param_1,&local_48);
if (iVar2 != 0x49) {
uVar5 = lex2str(iVar2);
pcVar6 = "%s unexpected (ident wanted)";
goto LAB_001d7008;
}
iVar2 = my_xml_leave(param_1,local_48,(long)local_40 - (long)local_48);
if (iVar2 != 0) {
return true;
}
iVar3 = my_xml_scan(param_1,&local_48);
LAB_001d6f49:
if (iVar3 != 0x3e) {
uVar5 = lex2str(iVar3);
pcVar6 = "%s unexpected (\'>\' wanted)";
goto LAB_001d7008;
}
}
}
}
else {
local_40 = param_2;
if (param_2 < pcVar6) {
lVar8 = (long)pcVar6 - (long)param_2;
do {
if (*local_40 == '<') break;
local_40 = local_40 + 1;
*(char **)(param_1 + 0x130) = local_40;
lVar8 = lVar8 + -1;
} while (lVar8 != 0);
}
local_48 = param_2;
if ((*param_1 & 2) == 0) {
my_xml_norm_text(&local_48);
}
if ((local_48 != local_40) && (pcVar4 = *(code **)(param_1 + 0x150), pcVar4 != (code *)0x0))
{
pcVar7 = local_40 + -(long)local_48;
pcVar6 = local_48;
LAB_001d6d0a:
(*pcVar4)(param_1,pcVar6,pcVar7);
}
}
param_2 = *(char **)(param_1 + 0x130);
pcVar6 = *(char **)(param_1 + 0x138);
} while (param_2 < pcVar6);
pcVar7 = *(char **)(param_1 + 0x118);
}
cVar1 = *pcVar7;
if (cVar1 != '\0') {
__sprintf_chk(param_1 + 8,1,0x80,"unexpected END-OF-INPUT");
}
return cVar1 != '\0';
LAB_001d6eb6:
if ((iVar2 != 0x21) || (iVar3 != 0x53)) {
LAB_001d6ed2:
cVar1 = local_31;
if (iVar3 == 0x2f) {
iVar3 = my_xml_leave(param_1,0,0);
if (iVar3 != 0) {
return true;
}
iVar3 = my_xml_scan(param_1,&local_48);
}
if (cVar1 == '\0') {
if (iVar3 != 0x3f) {
uVar5 = lex2str(iVar3);
pcVar6 = "%s unexpected (\'?\' wanted)";
goto LAB_001d7008;
}
iVar3 = my_xml_leave(param_1,0,0);
if (iVar3 != 0) {
return true;
}
iVar3 = my_xml_scan(param_1,&local_48);
}
if ((iVar2 == 0x21) && (iVar2 = my_xml_leave(param_1,0,0), iVar2 != 0)) {
return true;
}
goto LAB_001d6f49;
}
goto LAB_001d6dc7;
}
|
|
63,664
|
LefDefParser::lefwMacroSite(char const*)
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp
|
int
lefwMacroSite(const char *siteName)
{
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (!lefwDidInit)
return LEFW_BAD_ORDER;
if (lefwState != LEFW_MACRO_START &&
lefwState != LEFW_MACRO)
return LEFW_BAD_ORDER;
if (!siteName || siteName == 0 || *siteName == 0)
return LEFW_BAD_DATA;
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*) " SITE %s ;\n", siteName);
else
fprintf(lefwFile, " SITE %s ;\n", siteName);
lefwLines++;
lefwState = LEFW_MACRO;
return LEFW_OK;
}
|
O0
|
cpp
|
LefDefParser::lefwMacroSite(char const*):
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
leaq 0x139b0(%rip), %rax # 0x32e00
cmpq $0x0, (%rax)
jne 0x1f463
movl $0x1, 0x14(%rsp)
jmp 0x1f537
leaq 0x13bea(%rip), %rax # 0x33054
cmpl $0x0, (%rax)
jne 0x1f47c
movl $0x2, 0x14(%rsp)
jmp 0x1f537
leaq 0x13bcd(%rip), %rax # 0x33050
cmpl $0x9, (%rax)
je 0x1f4a1
leaq 0x13bc1(%rip), %rax # 0x33050
cmpl $0x21, (%rax)
je 0x1f4a1
movl $0x2, 0x14(%rsp)
jmp 0x1f537
cmpq $0x0, 0x8(%rsp)
je 0x1f4be
cmpq $0x0, 0x8(%rsp)
je 0x1f4be
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1f4c8
movl $0x3, 0x14(%rsp)
jmp 0x1f537
cmpl $0x0, 0x13c1d(%rip) # 0x330ec
je 0x1f4f0
leaq 0x13928(%rip), %rax # 0x32e00
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0xc172(%rip), %rsi # 0x2b659
movb $0x0, %al
callq 0x289b0
jmp 0x1f50d
leaq 0x13909(%rip), %rax # 0x32e00
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0xc153(%rip), %rsi # 0x2b659
movb $0x0, %al
callq 0x1100
leaq 0x13b38(%rip), %rax # 0x3304c
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x13b2c(%rip), %rax # 0x3304c
movl %ecx, (%rax)
leaq 0x13b27(%rip), %rax # 0x33050
movl $0x21, (%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
|
_ZN12LefDefParser13lefwMacroSiteEPKc:
sub rsp, 18h
mov [rsp+18h+var_10], rdi
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
cmp qword ptr [rax], 0
jnz short loc_1F463
mov [rsp+18h+var_4], 1
jmp loc_1F537
loc_1F463:
lea rax, _ZN12LefDefParser11lefwDidInitE; LefDefParser::lefwDidInit
cmp dword ptr [rax], 0
jnz short loc_1F47C
mov [rsp+18h+var_4], 2
jmp loc_1F537
loc_1F47C:
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
cmp dword ptr [rax], 9
jz short loc_1F4A1
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
cmp dword ptr [rax], 21h ; '!'
jz short loc_1F4A1
mov [rsp+18h+var_4], 2
jmp loc_1F537
loc_1F4A1:
cmp [rsp+18h+var_10], 0
jz short loc_1F4BE
cmp [rsp+18h+var_10], 0
jz short loc_1F4BE
mov rax, [rsp+18h+var_10]
movsx eax, byte ptr [rax]
cmp eax, 0
jnz short loc_1F4C8
loc_1F4BE:
mov [rsp+18h+var_4], 3
jmp short loc_1F537
loc_1F4C8:
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 0; LefDefParser::lefwWriteEncrypt
jz short loc_1F4F0
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
mov rdx, [rsp+18h+var_10]
lea rsi, aSiteS_0; " SITE %s ;\n"
mov al, 0
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_1F50D
loc_1F4F0:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
mov rdx, [rsp+18h+var_10]
lea rsi, aSiteS_0; " SITE %s ;\n"
mov al, 0
call _fprintf
loc_1F50D:
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov ecx, [rax]
add ecx, 1
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov [rax], ecx
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
mov dword ptr [rax], 21h ; '!'
mov [rsp+18h+var_4], 0
loc_1F537:
mov eax, [rsp+18h+var_4]
add rsp, 18h
retn
|
long long LefDefParser::lefwMacroSite(LefDefParser *this, const char *a2, long long a3, int a4, int a5, int a6)
{
if ( *(_QWORD *)&LefDefParser::lefwFile )
{
if ( LefDefParser::lefwDidInit )
{
if ( LefDefParser::lefwState == 9 || LefDefParser::lefwState == 33 )
{
if ( this && *(_BYTE *)this )
{
if ( LefDefParser::lefwWriteEncrypt )
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)" SITE %s ;\n", (_DWORD)this, a4, a5, a6);
else
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " SITE %s ;\n", (const char *)this);
++LefDefParser::lefwLines;
LefDefParser::lefwState = 33;
return 0;
}
else
{
return 3;
}
}
else
{
return 2;
}
}
else
{
return 2;
}
}
else
{
return 1;
}
}
|
lefwMacroSite:
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDI
LEA RAX,[0x132e00]
CMP qword ptr [RAX],0x0
JNZ 0x0011f463
MOV dword ptr [RSP + 0x14],0x1
JMP 0x0011f537
LAB_0011f463:
LEA RAX,[0x133054]
CMP dword ptr [RAX],0x0
JNZ 0x0011f47c
MOV dword ptr [RSP + 0x14],0x2
JMP 0x0011f537
LAB_0011f47c:
LEA RAX,[0x133050]
CMP dword ptr [RAX],0x9
JZ 0x0011f4a1
LEA RAX,[0x133050]
CMP dword ptr [RAX],0x21
JZ 0x0011f4a1
MOV dword ptr [RSP + 0x14],0x2
JMP 0x0011f537
LAB_0011f4a1:
CMP qword ptr [RSP + 0x8],0x0
JZ 0x0011f4be
CMP qword ptr [RSP + 0x8],0x0
JZ 0x0011f4be
MOV RAX,qword ptr [RSP + 0x8]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JNZ 0x0011f4c8
LAB_0011f4be:
MOV dword ptr [RSP + 0x14],0x3
JMP 0x0011f537
LAB_0011f4c8:
CMP dword ptr [0x001330ec],0x0
JZ 0x0011f4f0
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
MOV RDX,qword ptr [RSP + 0x8]
LEA RSI,[0x12b659]
MOV AL,0x0
CALL 0x001289b0
JMP 0x0011f50d
LAB_0011f4f0:
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
MOV RDX,qword ptr [RSP + 0x8]
LEA RSI,[0x12b659]
MOV AL,0x0
CALL 0x00101100
LAB_0011f50d:
LEA RAX,[0x13304c]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x13304c]
MOV dword ptr [RAX],ECX
LEA RAX,[0x133050]
MOV dword ptr [RAX],0x21
MOV dword ptr [RSP + 0x14],0x0
LAB_0011f537:
MOV EAX,dword ptr [RSP + 0x14]
ADD RSP,0x18
RET
|
/* LefDefParser::lefwMacroSite(char const*) */
int4 LefDefParser::lefwMacroSite(char *param_1)
{
int4 local_4;
if (lefwFile == (_IO_FILE *)0x0) {
local_4 = 1;
}
else if (lefwDidInit == 0) {
local_4 = 2;
}
else if ((lefwState == 9) || (lefwState == 0x21)) {
if ((param_1 == (char *)0x0) || ((param_1 == (char *)0x0 || (*param_1 == '\0')))) {
local_4 = 3;
}
else {
if (lefwWriteEncrypt == 0) {
fprintf(lefwFile," SITE %s ;\n",param_1);
}
else {
encPrint(lefwFile," SITE %s ;\n",param_1);
}
lefwLines = lefwLines + 1;
lefwState = 0x21;
local_4 = 0;
}
}
else {
local_4 = 2;
}
return local_4;
}
|
|
63,665
|
mysql_autocommit_start_internal
|
eloqsql/libmariadb/libmariadb/mariadb_async.c
|
static void
mysql_autocommit_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_autocommit,
(parms->mysql, parms->auto_mode),
parms->mysql,
my_bool,
r_my_bool)
}
|
O0
|
c
|
mysql_autocommit_start_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movsbl 0x8(%rax), %esi
callq 0x267b0
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
mysql_autocommit_start_internal:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rdi, [rax]
mov rax, [rbp+var_10]
movsx esi, byte ptr [rax+8]
call mysql_autocommit
mov [rbp+var_11], al
mov cl, [rbp+var_11]
mov rax, [rbp+var_20]
mov [rax+8], cl
mov rax, [rbp+var_20]
mov dword ptr [rax], 0
add rsp, 20h
pop rbp
retn
|
long long mysql_autocommit_start_internal(long long a1)
{
long long result; // rax
long long v2; // [rsp+0h] [rbp-20h]
v2 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 1152LL) + 40LL);
*(_BYTE *)(v2 + 8) = mysql_autocommit(*(_QWORD *)a1, *(_BYTE *)(a1 + 8));
result = v2;
*(_DWORD *)v2 = 0;
return result;
}
|
mysql_autocommit_start_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOVSX ESI,byte ptr [RAX + 0x8]
CALL 0x001267b0
MOV byte ptr [RBP + -0x11],AL
MOV CL,byte ptr [RBP + -0x11]
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x8],CL
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0x0
ADD RSP,0x20
POP RBP
RET
|
void mysql_autocommit_start_internal(long *param_1)
{
int4 *puVar1;
int1 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_autocommit(*param_1,(int)(char)param_1[1]);
*(int1 *)(puVar1 + 2) = uVar2;
*puVar1 = 0;
return;
}
|
|
63,666
|
escape_string_for_mysql
|
eloqsql/mysys/charset.c
|
size_t escape_string_for_mysql(CHARSET_INFO *charset_info,
char *to, size_t to_length,
const char *from, size_t length,
my_bool *overflow)
{
const char *to_start= to;
const char *end, *to_end=to_start + (to_length ? to_length-1 : 2*length);
*overflow= FALSE;
for (end= from + length; from < end; from++)
{
char escape= 0;
#ifdef USE_MB
int tmp_length= my_ci_charlen(charset_info, (const uchar *) from, (const uchar *) end);
if (tmp_length > 1)
{
if (to + tmp_length > to_end)
{
*overflow= TRUE;
break;
}
while (tmp_length--)
*to++= *from++;
from--;
continue;
}
/*
If the next character appears to begin a multi-byte character, we
escape that first byte of that apparent multi-byte character. (The
character just looks like a multi-byte character -- if it were actually
a multi-byte character, it would have been passed through in the test
above.)
Without this check, we can create a problem by converting an invalid
multi-byte character into a valid one. For example, 0xbf27 is not
a valid GBK character, but 0xbf5c is. (0x27 = ', 0x5c = \)
*/
if (tmp_length < 1) /* Bad byte sequence */
escape= *from;
else
#endif
switch (*from) {
case 0: /* Must be escaped for 'mysql' */
escape= '0';
break;
case '\n': /* Must be escaped for logs */
escape= 'n';
break;
case '\r':
escape= 'r';
break;
case '\\':
escape= '\\';
break;
case '\'':
escape= '\'';
break;
case '"': /* Better safe than sorry */
escape= '"';
break;
case '\032': /* This gives problems on Win32 */
escape= 'Z';
break;
}
if (escape)
{
if (to + 2 > to_end)
{
*overflow= TRUE;
break;
}
*to++= '\\';
*to++= escape;
}
else
{
if (to + 1 > to_end)
{
*overflow= TRUE;
break;
}
*to++= *from;
}
}
*to= 0;
return (size_t) (to - to_start);
}
|
O3
|
c
|
escape_string_for_mysql:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
leaq (%r8,%r8), %rax
subq $0x1, %r12
cmovbq %rax, %r12
movq %r9, -0x38(%rbp)
movb $0x0, (%r9)
movq %rsi, -0x30(%rbp)
movq %rsi, %rax
testq %r8, %r8
jle 0x4b557
movq %r8, %r15
movq %rcx, %r13
movq %rdi, %r14
movq -0x30(%rbp), %rbx
addq %rbx, %r12
addq %rcx, %r15
movq 0xb8(%r14), %rax
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq *0xc0(%rax)
movl %eax, %ecx
cmpl $0x2, %eax
jl 0x4b4ce
movl %ecx, %eax
addq %rbx, %rax
cmpq %r12, %rax
ja 0x4b54d
decq %r13
movq %r13, %rdx
leaq 0x1(%rdx), %r13
leaq 0x1(%rbx), %rax
movb 0x1(%rdx), %dl
movb %dl, (%rbx)
movq %r13, %rdx
movq %rax, %rbx
decl %ecx
jne 0x4b4b5
jmp 0x4b524
movb (%r13), %dl
cmpl $0x1, %ecx
jne 0x4b4f0
movzbl %dl, %eax
cmpl $0x19, %eax
jle 0x4b505
cmpl $0x26, %eax
jg 0x4b535
cmpl $0x1a, %eax
je 0x4b545
cmpl $0x22, %eax
je 0x4b4f4
jmp 0x4b519
testb %dl, %dl
je 0x4b517
leaq 0x2(%rbx), %rax
cmpq %r12, %rax
ja 0x4b54d
movb $0x5c, (%rbx)
movb %dl, 0x1(%rbx)
jmp 0x4b524
testl %eax, %eax
je 0x4b541
cmpl $0xa, %eax
je 0x4b549
cmpl $0xd, %eax
jne 0x4b519
movb $0x72, %dl
jmp 0x4b4f4
xorl %edx, %edx
leaq 0x1(%rbx), %rax
cmpq %r12, %rax
ja 0x4b54d
movb %dl, (%rbx)
incq %r13
movq %rax, %rbx
cmpq %r15, %r13
jb 0x4b484
jmp 0x4b557
cmpl $0x27, %eax
je 0x4b4f4
cmpl $0x5c, %eax
je 0x4b4f4
jmp 0x4b519
movb $0x30, %dl
jmp 0x4b4f4
movb $0x5a, %dl
jmp 0x4b4f4
movb $0x6e, %dl
jmp 0x4b4f4
movq -0x38(%rbp), %rax
movb $0x1, (%rax)
movq %rbx, %rax
movb $0x0, (%rax)
subq -0x30(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
escape_string_for_mysql:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r12, rdx
lea rax, [r8+r8]
sub r12, 1
cmovb r12, rax
mov [rbp+var_38], r9
mov byte ptr [r9], 0
mov [rbp+var_30], rsi
mov rax, rsi
test r8, r8
jle loc_4B557
mov r15, r8
mov r13, rcx
mov r14, rdi
mov rbx, [rbp+var_30]
add r12, rbx
add r15, rcx
loc_4B484:
mov rax, [r14+0B8h]
mov rdi, r14
mov rsi, r13
mov rdx, r15
call qword ptr [rax+0C0h]
mov ecx, eax
cmp eax, 2
jl short loc_4B4CE
mov eax, ecx
add rax, rbx
cmp rax, r12
ja loc_4B54D
dec r13
mov rdx, r13
loc_4B4B5:
lea r13, [rdx+1]
lea rax, [rbx+1]
mov dl, [rdx+1]
mov [rbx], dl
mov rdx, r13
mov rbx, rax
dec ecx
jnz short loc_4B4B5
jmp short loc_4B524
loc_4B4CE:
mov dl, [r13+0]
cmp ecx, 1
jnz short loc_4B4F0
movzx eax, dl
cmp eax, 19h
jle short loc_4B505
cmp eax, 26h ; '&'
jg short loc_4B535
cmp eax, 1Ah
jz short loc_4B545
cmp eax, 22h ; '"'
jz short loc_4B4F4
jmp short loc_4B519
loc_4B4F0:
test dl, dl
jz short loc_4B517
loc_4B4F4:
lea rax, [rbx+2]
cmp rax, r12
ja short loc_4B54D
mov byte ptr [rbx], 5Ch ; '\'
mov [rbx+1], dl
jmp short loc_4B524
loc_4B505:
test eax, eax
jz short loc_4B541
cmp eax, 0Ah
jz short loc_4B549
cmp eax, 0Dh
jnz short loc_4B519
mov dl, 72h ; 'r'
jmp short loc_4B4F4
loc_4B517:
xor edx, edx
loc_4B519:
lea rax, [rbx+1]
cmp rax, r12
ja short loc_4B54D
mov [rbx], dl
loc_4B524:
inc r13
mov rbx, rax
cmp r13, r15
jb loc_4B484
jmp short loc_4B557
loc_4B535:
cmp eax, 27h ; '''
jz short loc_4B4F4
cmp eax, 5Ch ; '\'
jz short loc_4B4F4
jmp short loc_4B519
loc_4B541:
mov dl, 30h ; '0'
jmp short loc_4B4F4
loc_4B545:
mov dl, 5Ah ; 'Z'
jmp short loc_4B4F4
loc_4B549:
mov dl, 6Eh ; 'n'
jmp short loc_4B4F4
loc_4B54D:
mov rax, [rbp+var_38]
mov byte ptr [rax], 1
mov rax, rbx
loc_4B557:
mov byte ptr [rax], 0
sub rax, [rbp+var_30]
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
_BYTE * escape_string_for_mysql(
long long a1,
unsigned __int8 *a2,
long long a3,
unsigned __int8 *a4,
long long a5,
_BYTE *a6)
{
long long v6; // r12
unsigned __int8 *v7; // rax
unsigned __int8 *v8; // r13
unsigned __int8 *v9; // rbx
unsigned long long v10; // r12
unsigned long long v11; // r15
int v12; // ecx
unsigned __int8 *v13; // rdx
unsigned __int8 v14; // dl
v6 = a3 - 1;
if ( !a3 )
v6 = 2 * a5;
*a6 = 0;
v7 = a2;
if ( a5 > 0 )
{
v8 = a4;
v9 = a2;
v10 = (unsigned long long)&a2[v6];
v11 = (unsigned long long)&a4[a5];
do
{
v12 = (*(long long ( **)(long long, unsigned __int8 *, unsigned long long))(*(_QWORD *)(a1 + 184) + 192LL))(
a1,
v8,
v11);
if ( v12 >= 2 )
{
if ( (unsigned long long)&v9[v12] > v10 )
goto LABEL_34;
v13 = v8 - 1;
do
{
v8 = v13 + 1;
v7 = v9 + 1;
*v9++ = *++v13;
--v12;
}
while ( v12 );
goto LABEL_26;
}
v14 = *v8;
if ( v12 == 1 )
{
if ( v14 <= 0x19u )
{
switch ( v14 )
{
case 0u:
v14 = 48;
goto LABEL_17;
case 0xAu:
v14 = 110;
goto LABEL_17;
case 0xDu:
v14 = 114;
LABEL_17:
v7 = v9 + 2;
if ( (unsigned long long)(v9 + 2) > v10 )
goto LABEL_34;
*v9 = 92;
v9[1] = v14;
goto LABEL_26;
}
}
else if ( v14 > 0x26u )
{
if ( v14 == 39 || v14 == 92 )
goto LABEL_17;
}
else
{
if ( v14 == 26 )
{
v14 = 90;
goto LABEL_17;
}
if ( v14 == 34 )
goto LABEL_17;
}
}
else
{
if ( v14 )
goto LABEL_17;
v14 = 0;
}
v7 = v9 + 1;
if ( (unsigned long long)(v9 + 1) > v10 )
{
LABEL_34:
*a6 = 1;
v7 = v9;
break;
}
*v9 = v14;
LABEL_26:
++v8;
v9 = v7;
}
while ( (unsigned long long)v8 < v11 );
}
*v7 = 0;
return (_BYTE *)(v7 - a2);
}
|
escape_string_for_mysql:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R12,RDX
LEA RAX,[R8 + R8*0x1]
SUB R12,0x1
CMOVC R12,RAX
MOV qword ptr [RBP + -0x38],R9
MOV byte ptr [R9],0x0
MOV qword ptr [RBP + -0x30],RSI
MOV RAX,RSI
TEST R8,R8
JLE 0x0014b557
MOV R15,R8
MOV R13,RCX
MOV R14,RDI
MOV RBX,qword ptr [RBP + -0x30]
ADD R12,RBX
ADD R15,RCX
LAB_0014b484:
MOV RAX,qword ptr [R14 + 0xb8]
MOV RDI,R14
MOV RSI,R13
MOV RDX,R15
CALL qword ptr [RAX + 0xc0]
MOV ECX,EAX
CMP EAX,0x2
JL 0x0014b4ce
MOV EAX,ECX
ADD RAX,RBX
CMP RAX,R12
JA 0x0014b54d
DEC R13
MOV RDX,R13
LAB_0014b4b5:
LEA R13,[RDX + 0x1]
LEA RAX,[RBX + 0x1]
MOV DL,byte ptr [RDX + 0x1]
MOV byte ptr [RBX],DL
MOV RDX,R13
MOV RBX,RAX
DEC ECX
JNZ 0x0014b4b5
JMP 0x0014b524
LAB_0014b4ce:
MOV DL,byte ptr [R13]
CMP ECX,0x1
JNZ 0x0014b4f0
MOVZX EAX,DL
CMP EAX,0x19
JLE 0x0014b505
CMP EAX,0x26
JG 0x0014b535
CMP EAX,0x1a
JZ 0x0014b545
CMP EAX,0x22
JZ 0x0014b4f4
JMP 0x0014b519
LAB_0014b4f0:
TEST DL,DL
JZ 0x0014b517
LAB_0014b4f4:
LEA RAX,[RBX + 0x2]
CMP RAX,R12
JA 0x0014b54d
MOV byte ptr [RBX],0x5c
MOV byte ptr [RBX + 0x1],DL
JMP 0x0014b524
LAB_0014b505:
TEST EAX,EAX
JZ 0x0014b541
CMP EAX,0xa
JZ 0x0014b549
CMP EAX,0xd
JNZ 0x0014b519
MOV DL,0x72
JMP 0x0014b4f4
LAB_0014b517:
XOR EDX,EDX
LAB_0014b519:
LEA RAX,[RBX + 0x1]
CMP RAX,R12
JA 0x0014b54d
MOV byte ptr [RBX],DL
LAB_0014b524:
INC R13
MOV RBX,RAX
CMP R13,R15
JC 0x0014b484
JMP 0x0014b557
LAB_0014b535:
CMP EAX,0x27
JZ 0x0014b4f4
CMP EAX,0x5c
JZ 0x0014b4f4
JMP 0x0014b519
LAB_0014b541:
MOV DL,0x30
JMP 0x0014b4f4
LAB_0014b545:
MOV DL,0x5a
JMP 0x0014b4f4
LAB_0014b549:
MOV DL,0x6e
JMP 0x0014b4f4
LAB_0014b54d:
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],0x1
MOV RAX,RBX
LAB_0014b557:
MOV byte ptr [RAX],0x0
SUB RAX,qword ptr [RBP + -0x30]
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long escape_string_for_mysql
(long param_1,byte *param_2,long param_3,byte *param_4,long param_5,
int1 *param_6)
{
uint uVar1;
byte *pbVar2;
ulong uVar3;
byte bVar4;
byte *pbVar5;
byte *pbVar6;
long lVar7;
byte *pbVar8;
byte *pbVar9;
lVar7 = param_3 + -1;
if (param_3 == 0) {
lVar7 = param_5 * 2;
}
*param_6 = 0;
pbVar2 = param_2;
if (0 < param_5) {
pbVar8 = param_2 + lVar7;
pbVar9 = param_4 + param_5;
pbVar6 = param_2;
do {
uVar1 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xc0))(param_1,param_4,pbVar9);
uVar3 = (ulong)uVar1;
if ((int)uVar1 < 2) {
bVar4 = *param_4;
if (uVar1 == 1) {
if (bVar4 < 0x1a) {
if (bVar4 == 0) {
bVar4 = 0x30;
}
else if (bVar4 == 10) {
bVar4 = 0x6e;
}
else {
if (bVar4 != 0xd) goto LAB_0014b519;
bVar4 = 0x72;
}
}
else if (bVar4 < 0x27) {
if (bVar4 == 0x1a) {
bVar4 = 0x5a;
}
else if (bVar4 != 0x22) goto LAB_0014b519;
}
else if ((bVar4 != 0x27) && (bVar4 != 0x5c)) {
LAB_0014b519:
pbVar2 = pbVar6 + 1;
if (pbVar8 < pbVar2) goto LAB_0014b54d;
*pbVar6 = bVar4;
goto LAB_0014b524;
}
}
else if (bVar4 == 0) {
bVar4 = 0;
goto LAB_0014b519;
}
pbVar2 = pbVar6 + 2;
if (pbVar8 < pbVar2) goto LAB_0014b54d;
*pbVar6 = 0x5c;
pbVar6[1] = bVar4;
}
else {
if (pbVar8 < pbVar6 + uVar3) {
LAB_0014b54d:
*param_6 = 1;
pbVar2 = pbVar6;
break;
}
pbVar5 = param_4 + -1;
do {
param_4 = pbVar5 + 1;
pbVar2 = pbVar6 + 1;
*pbVar6 = pbVar5[1];
uVar1 = (int)uVar3 - 1;
uVar3 = (ulong)uVar1;
pbVar5 = param_4;
pbVar6 = pbVar2;
} while (uVar1 != 0);
}
LAB_0014b524:
param_4 = param_4 + 1;
pbVar6 = pbVar2;
} while (param_4 < pbVar9);
}
*pbVar2 = 0;
return (long)pbVar2 - (long)param_2;
}
|
|
63,667
|
my_hash_sort_latin1_de
|
eloqsql/strings/ctype-latin1.c
|
void my_hash_sort_latin1_de(CHARSET_INFO *cs __attribute__((unused)),
const uchar *key, size_t len,
ulong *nr1, ulong *nr2)
{
const uchar *end;
register ulong m1= *nr1, m2= *nr2;
/*
Remove end space. We have to do this to be able to compare
'AE' and 'Ä' as identical
*/
end= skip_trailing_space(key, len);
for (; key < end ; key++)
{
uint X= (uint) combo1map[(uint) *key];
MY_HASH_ADD(m1, m2, X);
if ((X= combo2map[*key]))
{
MY_HASH_ADD(m1, m2, X);
}
}
*nr1= m1;
*nr2= m2;
}
|
O3
|
c
|
my_hash_sort_latin1_de:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
leaq (%rsi,%rdx), %r9
cmpq $0x15, %rdx
jb 0xb5987
movq %r9, %rdx
andq $-0x4, %rdx
cmpq %rsi, %rdx
jbe 0xb5987
leaq 0x3(%rsi), %rax
andq $-0x4, %rax
movq %r9, %rdi
movb -0x1(%r9), %r10b
cmpq %rdx, %r9
jbe 0xb5a30
leaq -0x1(%rdi), %r9
cmpb $0x20, %r10b
je 0xb596b
jmp 0xb598a
movq %r9, %rdi
movq (%rcx), %r11
movq (%r8), %rax
cmpq %rsi, %rdi
jbe 0xb5a1d
leaq -0x1(%rdi), %rdx
cmpb $0x20, -0x1(%rdi)
movq %rdx, %rdi
je 0xb5990
incq %rdx
leaq 0x170f20(%rip), %r9 # 0x2268d0
leaq 0x171019(%rip), %r10 # 0x2269d0
movq %r11, %rdi
movzbl (%rsi), %r14d
movzbl (%r14,%r9), %ebx
movl %r11d, %r15d
andl $0x3f, %r15d
addq %rax, %r15
imulq %rbx, %r15
shlq $0x8, %rdi
addq %r15, %rdi
xorq %r11, %rdi
leaq 0x3(%rax), %rbx
movzbl (%r14,%r10), %r11d
testq %r11, %r11
je 0xb5a0d
movl %edi, %r14d
andl $0x3f, %r14d
addq %rbx, %r14
imulq %r11, %r14
movq %rdi, %r11
shlq $0x8, %r11
addq %r14, %r11
xorq %r11, %rdi
addq $0x6, %rax
movq %rax, %rbx
jmp 0xb5a10
movq %rbx, %rax
incq %rsi
movq %rdi, %r11
cmpq %rdx, %rsi
jb 0xb59ba
jmp 0xb5a23
movq %r11, %rdi
movq %rax, %rbx
movq %rdi, (%rcx)
movq %rbx, (%r8)
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x20, %r10b
setne %r9b
cmpq %rdx, %rax
setae %dl
orb %r9b, %dl
jne 0xb598a
movq %rdi, %rdx
movq %rdx, %rdi
cmpq %rax, %rdx
jbe 0xb598a
leaq -0x4(%rdi), %rdx
cmpl $0x20202020, -0x4(%rdi) # imm = 0x20202020
je 0xb5a4a
jmp 0xb598a
|
my_hash_sort_latin1_de:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
lea r9, [rsi+rdx]
cmp rdx, 15h
jb short loc_B5987
mov rdx, r9
and rdx, 0FFFFFFFFFFFFFFFCh
cmp rdx, rsi
jbe short loc_B5987
lea rax, [rsi+3]
and rax, 0FFFFFFFFFFFFFFFCh
loc_B596B:
mov rdi, r9
mov r10b, [r9-1]
cmp r9, rdx
jbe loc_B5A30
lea r9, [rdi-1]
cmp r10b, 20h ; ' '
jz short loc_B596B
jmp short loc_B598A
loc_B5987:
mov rdi, r9
loc_B598A:
mov r11, [rcx]
mov rax, [r8]
loc_B5990:
cmp rdi, rsi
jbe loc_B5A1D
lea rdx, [rdi-1]
cmp byte ptr [rdi-1], 20h ; ' '
mov rdi, rdx
jz short loc_B5990
inc rdx
lea r9, combo1map
lea r10, combo2map
mov rdi, r11
loc_B59BA:
movzx r14d, byte ptr [rsi]
movzx ebx, byte ptr [r14+r9]
mov r15d, r11d
and r15d, 3Fh
add r15, rax
imul r15, rbx
shl rdi, 8
add rdi, r15
xor rdi, r11
lea rbx, [rax+3]
movzx r11d, byte ptr [r14+r10]
test r11, r11
jz short loc_B5A0D
mov r14d, edi
and r14d, 3Fh
add r14, rbx
imul r14, r11
mov r11, rdi
shl r11, 8
add r11, r14
xor rdi, r11
add rax, 6
mov rbx, rax
jmp short loc_B5A10
loc_B5A0D:
mov rax, rbx
loc_B5A10:
inc rsi
mov r11, rdi
cmp rsi, rdx
jb short loc_B59BA
jmp short loc_B5A23
loc_B5A1D:
mov rdi, r11
mov rbx, rax
loc_B5A23:
mov [rcx], rdi
mov [r8], rbx
pop rbx
pop r14
pop r15
pop rbp
retn
loc_B5A30:
cmp r10b, 20h ; ' '
setnz r9b
cmp rax, rdx
setnb dl
or dl, r9b
jnz loc_B598A
mov rdx, rdi
loc_B5A4A:
mov rdi, rdx
cmp rdx, rax
jbe loc_B598A
lea rdx, [rdi-4]
cmp dword ptr [rdi-4], 20202020h
jz short loc_B5A4A
jmp loc_B598A
|
long long my_hash_sort_latin1_de(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
long long *a4,
long long *a5)
{
unsigned long long v5; // r9
unsigned long long v6; // rdx
unsigned long long v7; // rax
unsigned long long v8; // rdi
char v9; // r10
long long v10; // r11
long long result; // rax
unsigned long long v12; // rdx
unsigned long long v14; // rdx
long long v15; // rdi
long long v16; // r14
long long v17; // rbx
unsigned long long v18; // rdx
v5 = (unsigned long long)&a2[a3];
if ( a3 < 0x15 || (v6 = v5 & 0xFFFFFFFFFFFFFFFCLL, (v5 & 0xFFFFFFFFFFFFFFFCLL) <= (unsigned long long)a2) )
{
v8 = v5;
}
else
{
v7 = (unsigned long long)(a2 + 3) & 0xFFFFFFFFFFFFFFFCLL;
while ( 1 )
{
v8 = v5;
v9 = *(_BYTE *)(v5 - 1);
if ( v5 <= v6 )
break;
--v5;
if ( v9 != 32 )
goto LABEL_8;
}
if ( v9 == 32 && v7 < v6 )
{
v18 = v5;
do
{
v8 = v18;
if ( v18 <= v7 )
break;
v18 -= 4LL;
}
while ( *(_DWORD *)(v8 - 4) == 538976288 );
}
}
LABEL_8:
v10 = *a4;
result = *a5;
do
{
if ( v8 <= (unsigned long long)a2 )
{
v15 = *a4;
v17 = *a5;
goto LABEL_18;
}
v12 = v8 - 1;
}
while ( *(_BYTE *)--v8 == 32 );
v14 = v12 + 1;
v15 = *a4;
do
{
v16 = *a2;
v15 = v10 ^ (combo1map[v16] * (result + (v10 & 0x3F)) + (v15 << 8));
v17 = result + 3;
if ( combo2map[v16] )
{
v15 ^= combo2map[v16] * (v17 + (v15 & 0x3F)) + (v15 << 8);
result += 6LL;
v17 = result;
}
else
{
result += 3LL;
}
++a2;
v10 = v15;
}
while ( (unsigned long long)a2 < v14 );
LABEL_18:
*a4 = v15;
*a5 = v17;
return result;
}
|
my_hash_sort_latin1_de:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
LEA R9,[RSI + RDX*0x1]
CMP RDX,0x15
JC 0x001b5987
MOV RDX,R9
AND RDX,-0x4
CMP RDX,RSI
JBE 0x001b5987
LEA RAX,[RSI + 0x3]
AND RAX,-0x4
LAB_001b596b:
MOV RDI,R9
MOV R10B,byte ptr [R9 + -0x1]
CMP R9,RDX
JBE 0x001b5a30
LEA R9,[RDI + -0x1]
CMP R10B,0x20
JZ 0x001b596b
JMP 0x001b598a
LAB_001b5987:
MOV RDI,R9
LAB_001b598a:
MOV R11,qword ptr [RCX]
MOV RAX,qword ptr [R8]
LAB_001b5990:
CMP RDI,RSI
JBE 0x001b5a1d
LEA RDX,[RDI + -0x1]
CMP byte ptr [RDI + -0x1],0x20
MOV RDI,RDX
JZ 0x001b5990
INC RDX
LEA R9,[0x3268d0]
LEA R10,[0x3269d0]
MOV RDI,R11
LAB_001b59ba:
MOVZX R14D,byte ptr [RSI]
MOVZX EBX,byte ptr [R14 + R9*0x1]
MOV R15D,R11D
AND R15D,0x3f
ADD R15,RAX
IMUL R15,RBX
SHL RDI,0x8
ADD RDI,R15
XOR RDI,R11
LEA RBX,[RAX + 0x3]
MOVZX R11D,byte ptr [R14 + R10*0x1]
TEST R11,R11
JZ 0x001b5a0d
MOV R14D,EDI
AND R14D,0x3f
ADD R14,RBX
IMUL R14,R11
MOV R11,RDI
SHL R11,0x8
ADD R11,R14
XOR RDI,R11
ADD RAX,0x6
MOV RBX,RAX
JMP 0x001b5a10
LAB_001b5a0d:
MOV RAX,RBX
LAB_001b5a10:
INC RSI
MOV R11,RDI
CMP RSI,RDX
JC 0x001b59ba
JMP 0x001b5a23
LAB_001b5a1d:
MOV RDI,R11
MOV RBX,RAX
LAB_001b5a23:
MOV qword ptr [RCX],RDI
MOV qword ptr [R8],RBX
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001b5a30:
CMP R10B,0x20
SETNZ R9B
CMP RAX,RDX
SETNC DL
OR DL,R9B
JNZ 0x001b598a
MOV RDX,RDI
LAB_001b5a4a:
MOV RDI,RDX
CMP RDX,RAX
JBE 0x001b598a
LEA RDX,[RDI + -0x4]
CMP dword ptr [RDI + -0x4],0x20202020
JZ 0x001b5a4a
JMP 0x001b598a
|
void my_hash_sort_latin1_de
(int8 param_1,byte *param_2,ulong param_3,ulong *param_4,long *param_5)
{
byte *pbVar1;
long lVar2;
long lVar3;
byte *pbVar4;
byte *pbVar5;
ulong uVar6;
pbVar5 = param_2 + param_3;
if ((0x14 < param_3) && (pbVar4 = (byte *)((ulong)pbVar5 & 0xfffffffffffffffc), param_2 < pbVar4))
{
pbVar1 = pbVar5;
do {
pbVar5 = pbVar1;
if (pbVar5 <= pbVar4) {
pbVar1 = pbVar5;
if ((byte *)((ulong)(param_2 + 3) & 0xfffffffffffffffc) < pbVar4 && pbVar5[-1] == 0x20)
goto LAB_001b5a4a;
break;
}
pbVar1 = pbVar5 + -1;
} while (pbVar5[-1] == 0x20);
}
goto LAB_001b598a;
while (pbVar1 = pbVar5 + -4, *(int *)(pbVar5 + -4) == 0x20202020) {
LAB_001b5a4a:
pbVar5 = pbVar1;
if (pbVar5 <= (byte *)((ulong)(param_2 + 3) & 0xfffffffffffffffc)) break;
}
LAB_001b598a:
uVar6 = *param_4;
lVar2 = *param_5;
do {
pbVar4 = pbVar5;
lVar3 = lVar2;
if (pbVar4 <= param_2) goto LAB_001b5a23;
pbVar5 = pbVar4 + -1;
} while (pbVar4[-1] == 0x20);
do {
uVar6 = uVar6 * 0x100 + ((ulong)((uint)uVar6 & 0x3f) + lVar2) * (ulong)(byte)combo1map[*param_2]
^ uVar6;
lVar3 = lVar2 + 3;
if ((ulong)(byte)combo2map[*param_2] != 0) {
uVar6 = uVar6 ^ uVar6 * 0x100 +
((ulong)((uint)uVar6 & 0x3f) + lVar3) * (ulong)(byte)combo2map[*param_2];
lVar3 = lVar2 + 6;
}
param_2 = param_2 + 1;
lVar2 = lVar3;
} while (param_2 < pbVar4);
LAB_001b5a23:
*param_4 = uVar6;
*param_5 = lVar3;
return;
}
|
|
63,668
|
maria_filecopy
|
eloqsql/storage/maria/ma_check.c
|
int maria_filecopy(HA_CHECK *param, File to,File from,my_off_t start,
my_off_t length, const char *type)
{
uchar tmp_buff[IO_SIZE], *buff;
ulong buff_length;
DBUG_ENTER("maria_filecopy");
buff_length=(ulong) MY_MIN(param->write_buffer_length,length);
if (!(buff=my_malloc(PSI_INSTRUMENT_ME, buff_length,
MYF(param->malloc_flags))))
{
buff=tmp_buff; buff_length=IO_SIZE;
}
mysql_file_seek(from, start, MY_SEEK_SET,MYF(0));
while (length > buff_length)
{
if (mysql_file_read(from, buff, buff_length, MYF(MY_NABP)) ||
mysql_file_write(to, buff, buff_length, param->myf_rw))
goto err;
length-= buff_length;
}
if (mysql_file_read(from, buff, (size_t) length,MYF(MY_NABP)) ||
mysql_file_write(to, buff, (size_t) length,param->myf_rw))
goto err;
if (buff != tmp_buff)
my_free(buff);
DBUG_RETURN(0);
err:
if (buff != tmp_buff)
my_free(buff);
_ma_check_print_error(param,"Can't copy %s to tempfile, error %d",
type,my_errno);
DBUG_RETURN(1);
}
|
O3
|
c
|
maria_filecopy:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1078, %rsp # imm = 0x1078
movq %r9, -0x1058(%rbp)
movq %r8, %r12
movq %rcx, -0x1048(%rbp)
movl %edx, %r14d
movl %esi, -0x103c(%rbp)
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq 0xb50(%rdi), %rbx
cmpq %r8, %rbx
cmovaeq %r8, %rbx
movq %rdi, -0x1050(%rbp)
movq 0x20d38(%rdi), %rdx
xorl %edi, %edi
movq %rbx, %rsi
callq 0xc3acd
movq %rax, %r13
testq %rax, %rax
leaq -0x1030(%rbp), %rax
cmoveq %rax, %r13
movl $0x1000, %eax # imm = 0x1000
cmovneq %rbx, %rax
movq %rax, -0x1038(%rbp)
movl %r14d, %ebx
leaq 0x351bc0(%rip), %r15 # 0x3b8c08
movq (%r15), %rax
leaq -0x10a0(%rbp), %rdi
movl %r14d, %esi
movl $0x8, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x6733c
movl %ebx, %edi
movq -0x1048(%rbp), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xc4d18
cmpq %r12, -0x1038(%rbp)
jae 0x67238
movl %ebx, -0x1048(%rbp)
movq (%r15), %rax
leaq -0x10a0(%rbp), %rdi
movl %ebx, %esi
movl $0x6, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x67156
movl $0x4, %ecx
movl %ebx, %edi
movq %r13, %rsi
movq -0x1038(%rbp), %rdx
callq 0xc4738
movq %rax, %rbx
testq %rbx, %rbx
leaq 0x351b37(%rip), %rcx # 0x3b8c08
jne 0x672c1
movq %r12, %r14
movq -0x1050(%rbp), %rax
movq 0x20998(%rax), %r12
movq (%rcx), %rax
leaq -0x10a0(%rbp), %rdi
movl -0x103c(%rbp), %ebx
movl %ebx, %esi
movl $0x7, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x671bb
movl %ebx, %edi
movq %r13, %rsi
movq -0x1038(%rbp), %rdx
movq %r12, %rcx
callq 0x32935
movq %rax, %rbx
testq %rbx, %rbx
leaq 0x351ad9(%rip), %r15 # 0x3b8c08
jne 0x672c1
movq %r14, %r12
movq -0x1038(%rbp), %rax
subq %rax, %r12
cmpq %rax, %r12
movl -0x1048(%rbp), %ebx
ja 0x6708e
jmp 0x67238
movq %rax, %r15
leaq 0x351aa8(%rip), %rax # 0x3b8c08
movq (%rax), %rax
movq %r15, %rdi
movq -0x1038(%rbp), %r14
movq %r14, %rsi
leaq 0x9b5a1(%rip), %rdx # 0x102718
movl $0xe95, %ecx # imm = 0xE95
callq *0x210(%rax)
movl $0x4, %ecx
movl %ebx, %edi
movq %r13, %rsi
movq %r14, %rdx
callq 0xc4738
movq %rax, %rbx
testq %rax, %rax
movl $0x0, %esi
cmoveq %r14, %rsi
leaq 0x351a5e(%rip), %rax # 0x3b8c08
movq (%rax), %rax
movq %r15, %rdi
callq *0x218(%rax)
jmp 0x670c7
movq %rax, %r15
leaq 0x351a43(%rip), %rax # 0x3b8c08
movq (%rax), %rax
movq %r15, %rdi
movq -0x1038(%rbp), %rsi
leaq 0x9b53f(%rip), %rdx # 0x102718
movl $0xe96, %ecx # imm = 0xE96
callq *0x210(%rax)
movl %ebx, %edi
movq %r13, %rsi
movq -0x1038(%rbp), %rdx
movq %r12, %rcx
callq 0x32935
movq %rax, %rbx
testq %rax, %rax
movl $0x0, %esi
cmoveq -0x1038(%rbp), %rsi
cmpq $-0x1, %rax
movl $0x0, %ecx
cmoveq %rcx, %rax
testb $0x6, %r12b
cmoveq %rax, %rsi
leaq 0x3519e1(%rip), %rax # 0x3b8c08
movq (%rax), %rax
movq %r15, %rdi
callq *0x218(%rax)
jmp 0x67125
movq (%r15), %rax
leaq -0x10a0(%rbp), %rdi
movl %ebx, %esi
movl $0x6, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x67352
movl $0x4, %ecx
movl %ebx, %edi
movq %r13, %rsi
movq %r12, %rdx
callq 0xc4738
movq %rax, %rbx
testq %rbx, %rbx
jne 0x672c1
movq -0x1050(%rbp), %rax
movq 0x20998(%rax), %r14
movq (%r15), %rax
leaq -0x10a0(%rbp), %rdi
movl -0x103c(%rbp), %r15d
movl %r15d, %esi
movl $0x7, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x6739f
movl %r15d, %edi
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x32935
movq %rax, %r15
testq %r15, %r15
je 0x67324
leaq -0x1030(%rbp), %rax
cmpq %rax, %r13
je 0x672d5
movq %r13, %rdi
callq 0xc3cfa
callq 0xc5c9a
movl (%rax), %ecx
leaq 0x9c05e(%rip), %rsi # 0x103341
movq -0x1050(%rbp), %rdi
movq -0x1058(%rbp), %rdx
xorl %eax, %eax
callq 0x33f2d
movl $0x1, %ebx
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x67409
movl %ebx, %eax
addq $0x1078, %rsp # imm = 0x1078
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebx, %ebx
leaq -0x1030(%rbp), %rax
cmpq %rax, %r13
je 0x672fd
movq %r13, %rdi
callq 0xc3cfa
jmp 0x672fd
movq %rax, %rdi
movl %ebx, %esi
movq -0x1048(%rbp), %rdx
callq 0x2cc8e
jmp 0x6707b
movq %rax, %r14
movq (%r15), %rax
leaq 0x9b3b9(%rip), %rdx # 0x102718
movq %r14, %rdi
movq %r12, %rsi
movl $0xe9a, %ecx # imm = 0xE9A
callq *0x210(%rax)
movl $0x4, %ecx
movl %ebx, %edi
movq %r13, %rsi
movq %r12, %rdx
callq 0xc4738
movq %rax, %rbx
xorl %esi, %esi
testq %rax, %rax
cmoveq %r12, %rsi
movq (%r15), %rax
movq %r14, %rdi
callq *0x218(%rax)
jmp 0x6726d
movq %rax, %rbx
leaq 0x35185f(%rip), %rax # 0x3b8c08
movq (%rax), %rax
leaq 0x9b365(%rip), %rdx # 0x102718
movq %rbx, %rdi
movq %r12, %rsi
movl $0xe9b, %ecx # imm = 0xE9B
callq *0x210(%rax)
movl %r15d, %edi
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x32935
movq %rax, %r15
xorl %esi, %esi
testq %rax, %rax
cmovneq %rsi, %r12
cmpq $-0x1, %rax
cmovneq %rax, %rsi
testb $0x6, %r14b
cmovneq %r12, %rsi
leaq 0x351810(%rip), %rax # 0x3b8c08
movq (%rax), %rax
movq %rbx, %rdi
callq *0x218(%rax)
jmp 0x672bc
callq 0x2b280
|
maria_filecopy:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 1078h
mov [rbp+var_1058], r9
mov r12, r8
mov [rbp+var_1048], rcx
mov r14d, edx
mov [rbp+var_103C], esi
mov rax, fs:28h
mov [rbp+var_30], rax
mov rbx, [rdi+0B50h]
cmp rbx, r8
cmovnb rbx, r8
mov [rbp+var_1050], rdi
mov rdx, qword ptr ds:stru_20D38.r_offset[rdi]
xor edi, edi
mov rsi, rbx
call my_malloc
mov r13, rax
test rax, rax
lea rax, [rbp+var_1030]
cmovz r13, rax
mov eax, 1000h
cmovnz rax, rbx
mov [rbp+var_1038], rax
mov ebx, r14d
lea r15, PSI_server
mov rax, [r15]
lea rdi, [rbp+var_10A0]
mov esi, r14d
mov edx, 8
call qword ptr [rax+158h]
test rax, rax
jnz loc_6733C
mov edi, ebx
mov rsi, [rbp+var_1048]
xor edx, edx
xor ecx, ecx
call my_seek
loc_6707B:
cmp [rbp+var_1038], r12
jnb loc_67238
mov dword ptr [rbp+var_1048], ebx
loc_6708E:
mov rax, [r15]
lea rdi, [rbp+var_10A0]
mov esi, ebx
mov edx, 6
call qword ptr [rax+158h]
test rax, rax
jnz loc_67156
mov ecx, 4
mov edi, ebx
mov rsi, r13
mov rdx, [rbp+var_1038]
call my_read
mov rbx, rax
loc_670C7:
test rbx, rbx
lea rcx, PSI_server
jnz loc_672C1
mov r14, r12
mov rax, [rbp+var_1050]
mov r12, [rax+20998h]
mov rax, [rcx]
lea rdi, [rbp+var_10A0]
mov ebx, [rbp+var_103C]
mov esi, ebx
mov edx, 7
call qword ptr [rax+158h]
test rax, rax
jnz loc_671BB
mov edi, ebx
mov rsi, r13
mov rdx, [rbp+var_1038]
mov rcx, r12
call my_write
mov rbx, rax
loc_67125:
test rbx, rbx
lea r15, PSI_server
jnz loc_672C1
mov r12, r14
mov rax, [rbp+var_1038]
sub r12, rax
cmp r12, rax
mov ebx, dword ptr [rbp+var_1048]
ja loc_6708E
jmp loc_67238
loc_67156:
mov r15, rax
lea rax, PSI_server
mov rax, [rax]
mov rdi, r15
mov r14, [rbp+var_1038]
mov rsi, r14
lea rdx, aWorkspaceLlm4b_9; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 0E95h
call qword ptr [rax+210h]
mov ecx, 4
mov edi, ebx
mov rsi, r13
mov rdx, r14
call my_read
mov rbx, rax
test rax, rax
mov esi, 0
cmovz rsi, r14
lea rax, PSI_server
mov rax, [rax]
mov rdi, r15
call qword ptr [rax+218h]
jmp loc_670C7
loc_671BB:
mov r15, rax
lea rax, PSI_server
mov rax, [rax]
mov rdi, r15
mov rsi, [rbp+var_1038]
lea rdx, aWorkspaceLlm4b_9; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 0E96h
call qword ptr [rax+210h]
mov edi, ebx
mov rsi, r13
mov rdx, [rbp+var_1038]
mov rcx, r12
call my_write
mov rbx, rax
test rax, rax
mov esi, 0
cmovz rsi, [rbp+var_1038]
cmp rax, 0FFFFFFFFFFFFFFFFh
mov ecx, 0
cmovz rax, rcx
test r12b, 6
cmovz rsi, rax
lea rax, PSI_server
mov rax, [rax]
mov rdi, r15
call qword ptr [rax+218h]
jmp loc_67125
loc_67238:
mov rax, [r15]
lea rdi, [rbp+var_10A0]
mov esi, ebx
mov edx, 6
call qword ptr [rax+158h]
test rax, rax
jnz loc_67352
mov ecx, 4
mov edi, ebx
mov rsi, r13
mov rdx, r12
call my_read
mov rbx, rax
loc_6726D:
test rbx, rbx
jnz short loc_672C1
mov rax, [rbp+var_1050]
mov r14, [rax+20998h]
mov rax, [r15]
lea rdi, [rbp+var_10A0]
mov r15d, [rbp+var_103C]
mov esi, r15d
mov edx, 7
call qword ptr [rax+158h]
test rax, rax
jnz loc_6739F
mov edi, r15d
mov rsi, r13
mov rdx, r12
mov rcx, r14
call my_write
mov r15, rax
loc_672BC:
test r15, r15
jz short loc_67324
loc_672C1:
lea rax, [rbp+var_1030]
cmp r13, rax
jz short loc_672D5
mov rdi, r13
call my_free
loc_672D5:
call _my_thread_var
mov ecx, [rax]
lea rsi, aCanTCopySToTem; "Can't copy %s to tempfile, error %d"
mov rdi, [rbp+var_1050]
mov rdx, [rbp+var_1058]
xor eax, eax
call _ma_check_print_error
mov ebx, 1
loc_672FD:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz loc_67409
mov eax, ebx
add rsp, 1078h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_67324:
xor ebx, ebx
lea rax, [rbp+var_1030]
cmp r13, rax
jz short loc_672FD
mov rdi, r13
call my_free
jmp short loc_672FD
loc_6733C:
mov rdi, rax
mov esi, ebx
mov rdx, [rbp+var_1048]
call maria_filecopy_cold_1
jmp loc_6707B
loc_67352:
mov r14, rax
mov rax, [r15]
lea rdx, aWorkspaceLlm4b_9; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r14
mov rsi, r12
mov ecx, 0E9Ah
call qword ptr [rax+210h]
mov ecx, 4
mov edi, ebx
mov rsi, r13
mov rdx, r12
call my_read
mov rbx, rax
xor esi, esi
test rax, rax
cmovz rsi, r12
mov rax, [r15]
mov rdi, r14
call qword ptr [rax+218h]
jmp loc_6726D
loc_6739F:
mov rbx, rax
lea rax, PSI_server
mov rax, [rax]
lea rdx, aWorkspaceLlm4b_9; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, rbx
mov rsi, r12
mov ecx, 0E9Bh
call qword ptr [rax+210h]
mov edi, r15d
mov rsi, r13
mov rdx, r12
mov rcx, r14
call my_write
mov r15, rax
xor esi, esi
test rax, rax
cmovnz r12, rsi
cmp rax, 0FFFFFFFFFFFFFFFFh
cmovnz rsi, rax
test r14b, 6
cmovnz rsi, r12
lea rax, PSI_server
mov rax, [rax]
mov rdi, rbx
call qword ptr [rax+218h]
jmp loc_672BC
loc_67409:
call ___stack_chk_fail
|
long long maria_filecopy(
long long a1,
unsigned int a2,
unsigned int a3,
long long a4,
unsigned long long a5,
const char *a6)
{
unsigned long long v6; // r12
unsigned long long v8; // rbx
_BYTE *v9; // r13
bool v10; // zf
long long v11; // rax
unsigned int v12; // ebx
long long v13; // rax
long long v14; // rax
_BYTE *v15; // rdi
long long v16; // rbx
unsigned long long v17; // r14
long long v18; // r12
unsigned int v19; // ebx
long long v20; // rax
long long v21; // rbx
long long v22; // r15
unsigned long long v23; // r14
unsigned long long v24; // rsi
long long v25; // r15
long long v26; // rax
unsigned long long v27; // rsi
long long v28; // rax
long long v29; // rbx
long long v30; // r14
unsigned int v31; // r15d
long long v32; // rax
long long v33; // r15
_DWORD *v34; // rax
unsigned int v35; // ebx
long long v37; // r14
unsigned long long v38; // rsi
long long v39; // rbx
_BYTE v40[72]; // [rsp+0h] [rbp-10A0h] BYREF
const char *v41; // [rsp+48h] [rbp-1058h]
long long v42; // [rsp+50h] [rbp-1050h]
long long v43; // [rsp+58h] [rbp-1048h]
unsigned int v44; // [rsp+64h] [rbp-103Ch]
unsigned long long v45; // [rsp+68h] [rbp-1038h]
_BYTE v46[4096]; // [rsp+70h] [rbp-1030h] BYREF
unsigned long long v47; // [rsp+1070h] [rbp-30h]
v41 = a6;
v6 = a5;
v43 = a4;
v44 = a2;
v47 = __readfsqword(0x28u);
v8 = *(_QWORD *)(a1 + 2896);
if ( v8 >= a5 )
v8 = a5;
v42 = a1;
v9 = (_BYTE *)my_malloc(0LL, v8, *(unsigned long long *)((char *)&stru_20D38.r_offset + a1));
v10 = v9 == 0LL;
if ( !v9 )
v9 = v46;
v11 = 4096LL;
if ( !v10 )
v11 = v8;
v45 = v11;
v12 = a3;
v13 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v40, a3, 8LL);
if ( v13 )
maria_filecopy_cold_1(v13, a3, v43);
else
my_seek(a3, v43, 0LL, 0LL);
if ( v45 < v6 )
{
LODWORD(v43) = a3;
do
{
v14 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v40, v12, 6LL);
if ( v14 )
{
v22 = v14;
v23 = v45;
((void ( *)(long long, unsigned long long, const char *, long long))PSI_server[66])(
v14,
v45,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_check.c",
3733LL);
v16 = my_read(v12, v9, v23, 4LL);
v24 = 0LL;
if ( !v16 )
v24 = v23;
v15 = (_BYTE *)v22;
((void ( *)(long long, unsigned long long))PSI_server[67])(v22, v24);
}
else
{
v15 = (_BYTE *)v12;
v16 = my_read(v12, v9, v45, 4LL);
}
if ( v16 )
goto LABEL_35;
v17 = v6;
v18 = *(_QWORD *)(v42 + 133528);
v19 = v44;
v20 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v40, v44, 7LL);
if ( v20 )
{
v25 = v20;
((void ( *)(long long, unsigned long long, const char *, long long))PSI_server[66])(
v20,
v45,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_check.c",
3734LL);
v26 = my_write(v19, (long long)v9, v45, v18);
v21 = v26;
v27 = 0LL;
if ( !v26 )
v27 = v45;
if ( v26 == -1 )
v26 = 0LL;
if ( (v18 & 6) == 0 )
v27 = v26;
v15 = (_BYTE *)v25;
((void ( *)(long long, unsigned long long))PSI_server[67])(v25, v27);
}
else
{
v15 = (_BYTE *)v19;
v21 = my_write(v19, (long long)v9, v45, v18);
}
if ( v21 )
goto LABEL_35;
v6 = v17 - v45;
v12 = v43;
}
while ( v17 - v45 > v45 );
}
v28 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v40, v12, 6LL);
if ( v28 )
{
v37 = v28;
((void ( *)(long long, unsigned long long, const char *, long long))PSI_server[66])(
v28,
v6,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_check.c",
3738LL);
v29 = my_read(v12, v9, v6, 4LL);
v38 = 0LL;
if ( !v29 )
v38 = v6;
v15 = (_BYTE *)v37;
((void ( *)(long long, unsigned long long))PSI_server[67])(v37, v38);
}
else
{
v15 = (_BYTE *)v12;
v29 = my_read(v12, v9, v6, 4LL);
}
if ( v29 )
goto LABEL_35;
v30 = *(_QWORD *)(v42 + 133528);
v31 = v44;
v32 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v40, v44, 7LL);
if ( v32 )
{
v39 = v32;
((void ( *)(long long, unsigned long long, const char *, long long))PSI_server[66])(
v32,
v6,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_check.c",
3739LL);
v33 = my_write(v31, (long long)v9, v6, v30);
v15 = (_BYTE *)v39;
((void ( *)(long long))PSI_server[67])(v39);
}
else
{
v15 = (_BYTE *)v31;
v33 = my_write(v31, (long long)v9, v6, v30);
}
if ( v33 )
{
LABEL_35:
if ( v9 != v46 )
{
v15 = v9;
my_free(v9);
}
v34 = (_DWORD *)my_thread_var(v15);
ma_check_print_error(v42, (long long)"Can't copy %s to tempfile, error %d", v41, *v34);
return 1;
}
v35 = 0;
if ( v9 != v46 )
my_free(v9);
return v35;
}
|
maria_filecopy:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x1078
MOV qword ptr [RBP + -0x1058],R9
MOV R12,R8
MOV qword ptr [RBP + -0x1048],RCX
MOV R14D,EDX
MOV dword ptr [RBP + -0x103c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RBX,qword ptr [RDI + 0xb50]
CMP RBX,R8
CMOVNC RBX,R8
MOV qword ptr [RBP + -0x1050],RDI
MOV RDX,qword ptr [RDI + 0x20d38]
XOR EDI,EDI
MOV RSI,RBX
CALL 0x001c3acd
MOV R13,RAX
TEST RAX,RAX
LEA RAX,[RBP + -0x1030]
CMOVZ R13,RAX
MOV EAX,0x1000
CMOVNZ RAX,RBX
MOV qword ptr [RBP + -0x1038],RAX
MOV EBX,R14D
LEA R15,[0x4b8c08]
MOV RAX,qword ptr [R15]
LEA RDI,[RBP + -0x10a0]
MOV ESI,R14D
MOV EDX,0x8
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x0016733c
MOV EDI,EBX
MOV RSI,qword ptr [RBP + -0x1048]
XOR EDX,EDX
XOR ECX,ECX
CALL 0x001c4d18
LAB_0016707b:
CMP qword ptr [RBP + -0x1038],R12
JNC 0x00167238
MOV dword ptr [RBP + -0x1048],EBX
LAB_0016708e:
MOV RAX,qword ptr [R15]
LEA RDI,[RBP + -0x10a0]
MOV ESI,EBX
MOV EDX,0x6
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x00167156
MOV ECX,0x4
MOV EDI,EBX
MOV RSI,R13
MOV RDX,qword ptr [RBP + -0x1038]
CALL 0x001c4738
MOV RBX,RAX
LAB_001670c7:
TEST RBX,RBX
LEA RCX,[0x4b8c08]
JNZ 0x001672c1
MOV R14,R12
MOV RAX,qword ptr [RBP + -0x1050]
MOV R12,qword ptr [RAX + 0x20998]
MOV RAX,qword ptr [RCX]
LEA RDI,[RBP + -0x10a0]
MOV EBX,dword ptr [RBP + -0x103c]
MOV ESI,EBX
MOV EDX,0x7
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x001671bb
MOV EDI,EBX
MOV RSI,R13
MOV RDX,qword ptr [RBP + -0x1038]
MOV RCX,R12
CALL 0x00132935
MOV RBX,RAX
LAB_00167125:
TEST RBX,RBX
LEA R15,[0x4b8c08]
JNZ 0x001672c1
MOV R12,R14
MOV RAX,qword ptr [RBP + -0x1038]
SUB R12,RAX
CMP R12,RAX
MOV EBX,dword ptr [RBP + -0x1048]
JA 0x0016708e
JMP 0x00167238
LAB_00167156:
MOV R15,RAX
LEA RAX,[0x4b8c08]
MOV RAX,qword ptr [RAX]
MOV RDI,R15
MOV R14,qword ptr [RBP + -0x1038]
MOV RSI,R14
LEA RDX,[0x202718]
MOV ECX,0xe95
CALL qword ptr [RAX + 0x210]
MOV ECX,0x4
MOV EDI,EBX
MOV RSI,R13
MOV RDX,R14
CALL 0x001c4738
MOV RBX,RAX
TEST RAX,RAX
MOV ESI,0x0
CMOVZ RSI,R14
LEA RAX,[0x4b8c08]
MOV RAX,qword ptr [RAX]
MOV RDI,R15
CALL qword ptr [RAX + 0x218]
JMP 0x001670c7
LAB_001671bb:
MOV R15,RAX
LEA RAX,[0x4b8c08]
MOV RAX,qword ptr [RAX]
MOV RDI,R15
MOV RSI,qword ptr [RBP + -0x1038]
LEA RDX,[0x202718]
MOV ECX,0xe96
CALL qword ptr [RAX + 0x210]
MOV EDI,EBX
MOV RSI,R13
MOV RDX,qword ptr [RBP + -0x1038]
MOV RCX,R12
CALL 0x00132935
MOV RBX,RAX
TEST RAX,RAX
MOV ESI,0x0
CMOVZ RSI,qword ptr [RBP + -0x1038]
CMP RAX,-0x1
MOV ECX,0x0
CMOVZ RAX,RCX
TEST R12B,0x6
CMOVZ RSI,RAX
LEA RAX,[0x4b8c08]
MOV RAX,qword ptr [RAX]
MOV RDI,R15
CALL qword ptr [RAX + 0x218]
JMP 0x00167125
LAB_00167238:
MOV RAX,qword ptr [R15]
LEA RDI,[RBP + -0x10a0]
MOV ESI,EBX
MOV EDX,0x6
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x00167352
MOV ECX,0x4
MOV EDI,EBX
MOV RSI,R13
MOV RDX,R12
CALL 0x001c4738
MOV RBX,RAX
LAB_0016726d:
TEST RBX,RBX
JNZ 0x001672c1
MOV RAX,qword ptr [RBP + -0x1050]
MOV R14,qword ptr [RAX + 0x20998]
MOV RAX,qword ptr [R15]
LEA RDI,[RBP + -0x10a0]
MOV R15D,dword ptr [RBP + -0x103c]
MOV ESI,R15D
MOV EDX,0x7
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x0016739f
MOV EDI,R15D
MOV RSI,R13
MOV RDX,R12
MOV RCX,R14
CALL 0x00132935
MOV R15,RAX
LAB_001672bc:
TEST R15,R15
JZ 0x00167324
LAB_001672c1:
LEA RAX,[RBP + -0x1030]
CMP R13,RAX
JZ 0x001672d5
MOV RDI,R13
CALL 0x001c3cfa
LAB_001672d5:
CALL 0x001c5c9a
MOV ECX,dword ptr [RAX]
LEA RSI,[0x203341]
MOV RDI,qword ptr [RBP + -0x1050]
MOV RDX,qword ptr [RBP + -0x1058]
XOR EAX,EAX
CALL 0x00133f2d
MOV EBX,0x1
LAB_001672fd:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00167409
MOV EAX,EBX
ADD RSP,0x1078
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00167324:
XOR EBX,EBX
LEA RAX,[RBP + -0x1030]
CMP R13,RAX
JZ 0x001672fd
MOV RDI,R13
CALL 0x001c3cfa
JMP 0x001672fd
LAB_0016733c:
MOV RDI,RAX
MOV ESI,EBX
MOV RDX,qword ptr [RBP + -0x1048]
CALL 0x0012cc8e
JMP 0x0016707b
LAB_00167352:
MOV R14,RAX
MOV RAX,qword ptr [R15]
LEA RDX,[0x202718]
MOV RDI,R14
MOV RSI,R12
MOV ECX,0xe9a
CALL qword ptr [RAX + 0x210]
MOV ECX,0x4
MOV EDI,EBX
MOV RSI,R13
MOV RDX,R12
CALL 0x001c4738
MOV RBX,RAX
XOR ESI,ESI
TEST RAX,RAX
CMOVZ RSI,R12
MOV RAX,qword ptr [R15]
MOV RDI,R14
CALL qword ptr [RAX + 0x218]
JMP 0x0016726d
LAB_0016739f:
MOV RBX,RAX
LEA RAX,[0x4b8c08]
MOV RAX,qword ptr [RAX]
LEA RDX,[0x202718]
MOV RDI,RBX
MOV RSI,R12
MOV ECX,0xe9b
CALL qword ptr [RAX + 0x210]
MOV EDI,R15D
MOV RSI,R13
MOV RDX,R12
MOV RCX,R14
CALL 0x00132935
MOV R15,RAX
XOR ESI,ESI
TEST RAX,RAX
CMOVNZ R12,RSI
CMP RAX,-0x1
CMOVNZ RSI,RAX
TEST R14B,0x6
CMOVNZ RSI,R12
LEA RAX,[0x4b8c08]
MOV RAX,qword ptr [RAX]
MOV RDI,RBX
CALL qword ptr [RAX + 0x218]
JMP 0x001672bc
LAB_00167409:
CALL 0x0012b280
|
int8
maria_filecopy(long param_1,int4 param_2,int4 param_3,int8 param_4,ulong param_5,
int8 param_6)
{
int4 uVar1;
int1 *puVar2;
long lVar3;
long lVar4;
ulong uVar5;
ulong uVar6;
ulong uVar7;
int4 *puVar8;
ulong uVar9;
int8 uVar10;
int1 *puVar11;
long in_FS_OFFSET;
int1 local_10a8 [72];
int8 local_1060;
long local_1058;
int8 local_1050;
int4 local_1044;
ulong local_1040;
int1 local_1038 [4096];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
uVar9 = *(ulong *)(param_1 + 0xb50);
if (param_5 <= *(ulong *)(param_1 + 0xb50)) {
uVar9 = param_5;
}
local_1060 = param_6;
local_1058 = param_1;
local_1050 = param_4;
local_1044 = param_2;
puVar2 = (int1 *)my_malloc(0,uVar9,*(int8 *)(param_1 + 0x20d38));
puVar11 = puVar2;
if (puVar2 == (int1 *)0x0) {
puVar11 = local_1038;
}
local_1040 = 0x1000;
if (puVar2 != (int1 *)0x0) {
local_1040 = uVar9;
}
lVar3 = (**(code **)(PSI_server + 0x158))(local_10a8,param_3,8);
if (lVar3 == 0) {
my_seek(param_3,local_1050,0,0);
}
else {
maria_filecopy_cold_1(lVar3,param_3,local_1050);
}
if (local_1040 < param_5) {
local_1050 = CONCAT44(local_1050._4_4_,param_3);
do {
lVar3 = (**(code **)(PSI_server + 0x158))(local_10a8,param_3,6);
uVar9 = local_1040;
if (lVar3 == 0) {
lVar4 = my_read(param_3,puVar11,local_1040,4);
}
else {
(**(code **)(PSI_server + 0x210))
(lVar3,local_1040,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_check.c",0xe95);
lVar4 = my_read(param_3,puVar11,uVar9,4);
uVar7 = 0;
if (lVar4 == 0) {
uVar7 = uVar9;
}
(**(code **)(PSI_server + 0x218))(lVar3,uVar7);
}
uVar1 = local_1044;
if (lVar4 != 0) goto LAB_001672c1;
uVar9 = *(ulong *)(local_1058 + 0x20998);
lVar3 = (**(code **)(PSI_server + 0x158))(local_10a8,local_1044,7);
if (lVar3 == 0) {
uVar5 = my_write(uVar1,puVar11,local_1040,uVar9);
}
else {
(**(code **)(PSI_server + 0x210))
(lVar3,local_1040,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_check.c",0xe96);
uVar5 = my_write(uVar1,puVar11,local_1040,uVar9);
uVar7 = 0;
if (uVar5 == 0) {
uVar7 = local_1040;
}
uVar6 = uVar5;
if (uVar5 == 0xffffffffffffffff) {
uVar6 = 0;
}
if ((uVar9 & 6) == 0) {
uVar7 = uVar6;
}
(**(code **)(PSI_server + 0x218))(lVar3,uVar7);
}
if (uVar5 != 0) goto LAB_001672c1;
param_5 = param_5 - local_1040;
param_3 = (int4)local_1050;
} while (local_1040 < param_5);
}
lVar3 = (**(code **)(PSI_server + 0x158))(local_10a8,param_3,6);
if (lVar3 == 0) {
lVar4 = my_read(param_3,puVar11,param_5,4);
}
else {
(**(code **)(PSI_server + 0x210))
(lVar3,param_5,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_check.c",
0xe9a);
lVar4 = my_read(param_3,puVar11,param_5,4);
uVar9 = 0;
if (lVar4 == 0) {
uVar9 = param_5;
}
(**(code **)(PSI_server + 0x218))(lVar3,uVar9);
}
uVar1 = local_1044;
if (lVar4 == 0) {
uVar9 = *(ulong *)(local_1058 + 0x20998);
lVar3 = (**(code **)(PSI_server + 0x158))(local_10a8,local_1044,7);
if (lVar3 == 0) {
uVar7 = my_write(uVar1,puVar11,param_5,uVar9);
}
else {
(**(code **)(PSI_server + 0x210))
(lVar3,param_5,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_check.c",
0xe9b);
uVar7 = my_write(uVar1,puVar11,param_5,uVar9);
if (uVar7 != 0) {
param_5 = 0;
}
uVar5 = 0;
if (uVar7 != 0xffffffffffffffff) {
uVar5 = uVar7;
}
if ((uVar9 & 6) != 0) {
uVar5 = param_5;
}
(**(code **)(PSI_server + 0x218))(lVar3,uVar5);
}
if (uVar7 == 0) {
uVar10 = 0;
if (puVar11 != local_1038) {
my_free(puVar11);
}
goto LAB_001672fd;
}
}
LAB_001672c1:
if (puVar11 != local_1038) {
my_free(puVar11);
}
puVar8 = (int4 *)_my_thread_var();
_ma_check_print_error(local_1058,"Can\'t copy %s to tempfile, error %d",local_1060,*puVar8);
uVar10 = 1;
LAB_001672fd:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar10;
}
|
|
63,669
|
fmt::v10::detail::compute_width(fmt::v10::basic_string_view<char>)::count_code_points::operator()(unsigned int, fmt::v10::basic_string_view<char>) const
|
aimrt_mujoco_sim/_deps/fmt-src/include/fmt/format.h
|
FMT_CONSTEXPR auto operator()(uint32_t cp, string_view) const -> bool {
*count += detail::to_unsigned(
1 +
(cp >= 0x1100 &&
(cp <= 0x115f || // Hangul Jamo init. consonants
cp == 0x2329 || // LEFT-POINTING ANGLE BRACKET
cp == 0x232a || // RIGHT-POINTING ANGLE BRACKET
// CJK ... Yi except IDEOGRAPHIC HALF FILL SPACE:
(cp >= 0x2e80 && cp <= 0xa4cf && cp != 0x303f) ||
(cp >= 0xac00 && cp <= 0xd7a3) || // Hangul Syllables
(cp >= 0xf900 && cp <= 0xfaff) || // CJK Compatibility Ideographs
(cp >= 0xfe10 && cp <= 0xfe19) || // Vertical Forms
(cp >= 0xfe30 && cp <= 0xfe6f) || // CJK Compatibility Forms
(cp >= 0xff00 && cp <= 0xff60) || // Fullwidth Forms
(cp >= 0xffe0 && cp <= 0xffe6) || // Fullwidth Forms
(cp >= 0x20000 && cp <= 0x2fffd) || // CJK
(cp >= 0x30000 && cp <= 0x3fffd) ||
// Miscellaneous Symbols and Pictographs + Emoticons:
(cp >= 0x1f300 && cp <= 0x1f64f) ||
// Supplemental Symbols and Pictographs:
(cp >= 0x1f900 && cp <= 0x1f9ff))));
return true;
}
|
O3
|
c
|
fmt::v10::detail::compute_width(fmt::v10::basic_string_view<char>)::count_code_points::operator()(unsigned int, fmt::v10::basic_string_view<char>) const:
movl $0x1, %eax
cmpl $0x1100, %esi # imm = 0x1100
jb 0x986b1
cmpl $0x1160, %esi # imm = 0x1160
setb %al
leal -0x2329(%rsi), %ecx
cmpl $0x2, %ecx
setb %cl
orb %al, %cl
movl $0x2, %eax
jne 0x986b1
leal -0x2e80(%rsi), %ecx
cmpl $0x7650, %ecx # imm = 0x7650
setb %cl
cmpl $0x303f, %esi # imm = 0x303F
setne %dl
movl %esi, %r8d
andl $0xfffefffe, %r8d # imm = 0xFFFEFFFE
movd %esi, %xmm0
movd %r8d, %xmm1
punpckldq %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
pshufd $0x50, %xmm0, %xmm2 # xmm2 = xmm0[0,0,1,1]
punpcklqdq %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
pshufd $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
paddd 0x156ad2(%rip), %xmm2 # 0x1ef130
paddd 0x156ada(%rip), %xmm0 # 0x1ef140
movdqa 0x156a82(%rip), %xmm1 # 0x1ef0f0
pxor %xmm1, %xmm0
pcmpgtd 0x156ad6(%rip), %xmm0 # 0x1ef150
pxor %xmm1, %xmm2
pcmpgtd 0x156ada(%rip), %xmm2 # 0x1ef160
packssdw %xmm2, %xmm0
packsswb %xmm0, %xmm0
pmovmskb %xmm0, %r8d
xorb $-0x1, %r8b
jne 0x986b1
andb %cl, %dl
jne 0x986b1
andl $0xffffff00, %esi # imm = 0xFFFFFF00
xorl %eax, %eax
cmpl $0x1f900, %esi # imm = 0x1F900
sete %al
incq %rax
movq (%rdi), %rcx
addq %rax, (%rcx)
movb $0x1, %al
retq
|
_ZZN3fmt3v106detail13compute_widthENS0_17basic_string_viewIcEEENK17count_code_pointsclEjS3_:
mov eax, 1
cmp esi, 1100h
jb loc_986B1
cmp esi, 1160h
setb al
lea ecx, [rsi-2329h]
cmp ecx, 2
setb cl
or cl, al
mov eax, 2
jnz loc_986B1
lea ecx, [rsi-2E80h]
cmp ecx, 7650h
setb cl
cmp esi, 303Fh
setnz dl
mov r8d, esi
and r8d, 0FFFEFFFEh
movd xmm0, esi
movd xmm1, r8d
punpckldq xmm1, xmm0
pshufd xmm2, xmm0, 50h ; 'P'
punpcklqdq xmm2, xmm1
pshufd xmm0, xmm0, 0
paddd xmm2, cs:xmmword_1EF130
paddd xmm0, cs:xmmword_1EF140
movdqa xmm1, cs:xmmword_1EF0F0
pxor xmm0, xmm1
pcmpgtd xmm0, cs:xmmword_1EF150
pxor xmm2, xmm1
pcmpgtd xmm2, cs:xmmword_1EF160
packssdw xmm0, xmm2
packsswb xmm0, xmm0
pmovmskb r8d, xmm0
xor r8b, 0FFh
jnz short loc_986B1
and dl, cl
jnz short loc_986B1
and esi, 0FFFFFF00h
xor eax, eax
cmp esi, 1F900h
setz al
inc rax
loc_986B1:
mov rcx, [rdi]
add [rcx], rax
mov al, 1
retn
|
char fmt::v10::detail::compute_width(fmt::v10::basic_string_view<char>)::count_code_points::operator()(
_QWORD **a1,
unsigned int a2)
{
long long v2; // rax
__m128i v3; // xmm0
__m128i si128; // xmm1
__m128i v5; // xmm0
v2 = 1LL;
if ( a2 >= 0x1100 )
{
v2 = 2LL;
if ( a2 >= 0x1160 && a2 - 9001 >= 2 )
{
v3 = _mm_cvtsi32_si128(a2);
si128 = _mm_load_si128((const __m128i *)&xmmword_1EF0F0);
v5 = _mm_packs_epi32(
_mm_cmpgt_epi32(
_mm_xor_si128(_mm_add_epi32(_mm_shuffle_epi32(v3, 0), (__m128i)xmmword_1EF140), si128),
(__m128i)xmmword_1EF150),
_mm_cmpgt_epi32(
_mm_xor_si128(
_mm_add_epi32(
_mm_unpacklo_epi64(
_mm_shuffle_epi32(v3, 80),
_mm_unpacklo_epi32(_mm_cvtsi32_si128(a2 & 0xFFFEFFFE), v3)),
(__m128i)xmmword_1EF130),
si128),
(__m128i)xmmword_1EF160));
if ( (unsigned __int8)_mm_movemask_epi8(_mm_packs_epi16(v5, v5)) == 0xFF && (a2 - 11904 >= 0x7650 || a2 == 12351) )
v2 = ((a2 & 0xFFFFFF00) == 129280) + 1LL;
}
}
**a1 += v2;
return 1;
}
|
operator():
MOV EAX,0x1
CMP ESI,0x1100
JC 0x001986b1
CMP ESI,0x1160
SETC AL
LEA ECX,[RSI + -0x2329]
CMP ECX,0x2
SETC CL
OR CL,AL
MOV EAX,0x2
JNZ 0x001986b1
LEA ECX,[RSI + -0x2e80]
CMP ECX,0x7650
SETC CL
CMP ESI,0x303f
SETNZ DL
MOV R8D,ESI
AND R8D,0xfffefffe
MOVD XMM0,ESI
MOVD XMM1,R8D
PUNPCKLDQ XMM1,XMM0
PSHUFD XMM2,XMM0,0x50
PUNPCKLQDQ XMM2,XMM1
PSHUFD XMM0,XMM0,0x0
PADDD XMM2,xmmword ptr [0x002ef130]
PADDD XMM0,xmmword ptr [0x002ef140]
MOVDQA XMM1,xmmword ptr [0x002ef0f0]
PXOR XMM0,XMM1
PCMPGTD XMM0,xmmword ptr [0x002ef150]
PXOR XMM2,XMM1
PCMPGTD XMM2,xmmword ptr [0x002ef160]
PACKSSDW XMM0,XMM2
PACKSSWB XMM0,XMM0
PMOVMSKB R8D,XMM0
XOR R8B,0xff
JNZ 0x001986b1
AND DL,CL
JNZ 0x001986b1
AND ESI,0xffffff00
XOR EAX,EAX
CMP ESI,0x1f900
SETZ AL
INC RAX
LAB_001986b1:
MOV RCX,qword ptr [RDI]
ADD qword ptr [RCX],RAX
MOV AL,0x1
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* fmt::v10::detail::compute_width(fmt::v10::basic_string_view<char>)::count_code_points::TEMPNAMEPLACEHOLDERVALUE(unsigned
int, fmt::v10::basic_string_view<char>) const */
int8
fmt::v10::detail::compute_width(fmt::v10::basic_string_view<char>)::count_code_points::operator()
(int8 *param_1,uint param_2)
{
long lVar1;
int1 auVar2 [16];
int1 auVar3 [16];
lVar1 = 1;
if ((0x10ff < param_2) && (lVar1 = 2, 1 < param_2 - 0x2329 && 0x115f < param_2)) {
auVar2._0_4_ = -(uint)(_DAT_002ef150 < (int)(param_2 + _DAT_002ef140 ^ _DAT_002ef0f0));
auVar2._4_4_ = -(uint)(_UNK_002ef154 < (int)(param_2 + _UNK_002ef144 ^ _UNK_002ef0f4));
auVar2._8_4_ = -(uint)(_UNK_002ef158 < (int)(param_2 + _UNK_002ef148 ^ _UNK_002ef0f8));
auVar2._12_4_ = -(uint)(_UNK_002ef15c < (int)(param_2 + _UNK_002ef14c ^ _UNK_002ef0fc));
auVar3._0_4_ = -(uint)(_DAT_002ef160 < (int)(param_2 + ram0x002ef130 ^ _DAT_002ef0f0));
auVar3._4_4_ = -(uint)(_UNK_002ef164 < (int)(param_2 + _UNK_002ef134 ^ _UNK_002ef0f4));
auVar3._8_4_ = -(uint)(_UNK_002ef168 <
(int)((param_2 & 0xfffefffe) + _UNK_002ef138 ^ _UNK_002ef0f8));
auVar3._12_4_ = -(uint)(_UNK_002ef16c < (int)(param_2 + _UNK_002ef13c ^ _UNK_002ef0fc));
auVar2 = packssdw(auVar2,auVar3);
auVar2 = packsswb(auVar2,auVar2);
if (((byte)(SUB161(auVar2 >> 7,0) & 1 | (SUB161(auVar2 >> 0xf,0) & 1) << 1 |
(SUB161(auVar2 >> 0x17,0) & 1) << 2 | (SUB161(auVar2 >> 0x1f,0) & 1) << 3 |
(SUB161(auVar2 >> 0x27,0) & 1) << 4 | (SUB161(auVar2 >> 0x2f,0) & 1) << 5 |
(SUB161(auVar2 >> 0x37,0) & 1) << 6 | SUB161(auVar2 >> 0x3f,0) << 7) == 0xff) &&
(param_2 == 0x303f || 0x764f < param_2 - 0x2e80)) {
lVar1 = (ulong)((param_2 & 0xffffff00) == 0x1f900) + 1;
}
}
*(long *)*param_1 = *(long *)*param_1 + lVar1;
return 1;
}
|
|
63,670
|
test_bug28386
|
eloqsql/tests/mysql_client_test.c
|
static void test_bug28386()
{
int rc;
MYSQL_STMT *stmt;
MYSQL_RES *result;
MYSQL_ROW row;
MYSQL_BIND bind;
const char hello[]= "hello world!";
DBUG_ENTER("test_bug28386");
myheader("test_bug28386");
rc= mysql_query(mysql, "select @@global.log_output");
myquery(rc);
result= mysql_store_result(mysql);
DIE_UNLESS(result);
row= mysql_fetch_row(result);
if (! strstr(row[0], "TABLE"))
{
mysql_free_result(result);
if (! opt_silent)
printf("Skipping the test since logging to tables is not enabled\n");
/* Log output is not to tables */
DBUG_VOID_RETURN;
}
mysql_free_result(result);
enable_query_logs(1);
stmt= mysql_simple_prepare(mysql, "SELECT ?");
check_stmt(stmt);
memset(&bind, 0, sizeof(bind));
bind.buffer_type= MYSQL_TYPE_STRING;
bind.buffer= (void *) hello;
bind.buffer_length= sizeof(hello);
mysql_stmt_bind_param(stmt, &bind);
mysql_stmt_send_long_data(stmt, 0, hello, sizeof(hello));
rc= mysql_stmt_execute(stmt);
check_execute(stmt, rc);
rc= my_process_stmt_result(stmt);
DIE_UNLESS(rc == 1);
rc= mysql_stmt_reset(stmt);
check_execute(stmt, rc);
rc= mysql_stmt_close(stmt);
DIE_UNLESS(!rc);
rc= mysql_query(mysql, "select * from mysql.general_log where "
"command_type='Close stmt' or "
"command_type='Reset stmt' or "
"command_type='Long Data'");
myquery(rc);
result= mysql_store_result(mysql);
mytest(result);
DIE_UNLESS(mysql_num_rows(result) == 3);
mysql_free_result(result);
restore_query_logs();
DBUG_VOID_RETURN;
}
|
O0
|
c
|
test_bug28386:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq 0xba333(%rip), %rax # 0x142182
movq %rax, -0x15(%rbp)
movl 0xba331(%rip), %eax # 0x14218a
movl %eax, -0xd(%rbp)
movb 0xba32c(%rip), %al # 0x14218e
movb %al, -0x9(%rbp)
jmp 0x87e67
movsbl 0x3e2663(%rip), %eax # 0x46a4d1
cmpl $0x2, %eax
jge 0x87eef
movq 0x22715e(%rip), %rax # 0x2aefd8
movq (%rax), %rdi
leaq 0xa64a0(%rip), %rsi # 0x12e324
movb $0x0, %al
callq 0x3a1c0
movq 0x227146(%rip), %rax # 0x2aefd8
movq (%rax), %rdi
movl 0x3e2881(%rip), %edx # 0x46a71c
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x3e2876(%rip) # 0x46a71c
movl 0x3e286c(%rip), %ecx # 0x46a718
movl 0x3e2649(%rip), %r8d # 0x46a4fc
leaq 0xa7772(%rip), %rsi # 0x12f62c
leaq 0xa73e5(%rip), %r9 # 0x12f2a6
movb $0x0, %al
callq 0x3a1c0
movq 0x227109(%rip), %rax # 0x2aefd8
movq (%rax), %rdi
leaq 0xa6483(%rip), %rsi # 0x12e35c
movb $0x0, %al
callq 0x3a1c0
movq 0x2270f1(%rip), %rax # 0x2aefd8
movq (%rax), %rdi
callq 0x3a4a0
movq 0x3e25e2(%rip), %rdi # 0x46a4d8
leaq 0xba292(%rip), %rsi # 0x14218f
callq 0x3b3d0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0xac(%rbp)
cmpl $0x0, -0xac(%rbp)
je 0x87f20
xorl %eax, %eax
movl %eax, %edi
callq 0x3bf10
cmpl $0x0, -0xac(%rbp)
jne 0x87f2b
jmp 0x87f43
leaq 0xa5cda(%rip), %rdi # 0x12dc0c
movl $0x4495, %esi # imm = 0x4495
leaq 0xbc031(%rip), %rdx # 0x143f6f
callq 0x3c010
movq 0x3e258e(%rip), %rdi # 0x46a4d8
callq 0x3b210
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x87f5c
jmp 0x87f74
leaq 0xa5ca9(%rip), %rdi # 0x12dc0c
movl $0x4498, %esi # imm = 0x4498
leaq 0xac3f4(%rip), %rdx # 0x134363
callq 0x3c010
movq -0x30(%rbp), %rdi
callq 0x3b000
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rdi
leaq 0xba21b(%rip), %rsi # 0x1421aa
callq 0x3a470
cmpq $0x0, %rax
jne 0x87fc1
movq -0x30(%rbp), %rdi
callq 0x3b280
cmpb $0x0, 0x3e2527(%rip) # 0x46a4d1
jne 0x87fba
leaq 0xba1fd(%rip), %rdi # 0x1421b0
movb $0x0, %al
callq 0x3a070
jmp 0x87fbc
jmp 0x8820e
movq -0x30(%rbp), %rdi
callq 0x3b280
movl $0x1, %edi
callq 0x7e0a0
movq 0x3e24fd(%rip), %rdi # 0x46a4d8
leaq 0xba208(%rip), %rsi # 0x1421ea
callq 0x3be90
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x87ffb
xorl %eax, %eax
movl %eax, %edi
callq 0x3bf10
cmpq $0x0, -0x28(%rbp)
je 0x88004
jmp 0x8801c
leaq 0xa5c01(%rip), %rdi # 0x12dc0c
movl $0x44a8, %esi # imm = 0x44A8
leaq 0xa5953(%rip), %rdx # 0x12d96a
callq 0x3c010
leaq -0xa8(%rbp), %rdi
xorl %esi, %esi
movl $0x70, %edx
callq 0x3a2e0
movl $0xfe, -0x48(%rbp)
leaq -0x15(%rbp), %rax
movq %rax, -0x98(%rbp)
movq $0xd, -0x68(%rbp)
movq -0x28(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0xb1100
movq -0x28(%rbp), %rdi
leaq -0x15(%rbp), %rdx
xorl %esi, %esi
movl $0xd, %ecx
callq 0x3bb40
movq -0x28(%rbp), %rdi
callq 0x3b8a0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x8808c
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3c0b0
cmpl $0x0, -0x1c(%rbp)
jne 0x88094
jmp 0x880ac
leaq 0xa5b71(%rip), %rdi # 0x12dc0c
movl $0x44b4, %esi # imm = 0x44B4
leaq 0xb1765(%rip), %rdx # 0x13980c
callq 0x3c010
movq -0x28(%rbp), %rdi
callq 0x3c1c0
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0x1c(%rbp)
jne 0x880c0
jmp 0x880d8
leaq 0xa5b45(%rip), %rdi # 0x12dc0c
movl $0x44b7, %esi # imm = 0x44B7
leaq 0xa7db7(%rip), %rdx # 0x12fe8a
callq 0x3c010
movq -0x28(%rbp), %rdi
callq 0x3ba60
movsbl %al, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x880fa
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3c0b0
cmpl $0x0, -0x1c(%rbp)
jne 0x88102
jmp 0x8811a
leaq 0xa5b03(%rip), %rdi # 0x12dc0c
movl $0x44ba, %esi # imm = 0x44BA
leaq 0xb16f7(%rip), %rdx # 0x13980c
callq 0x3c010
movq -0x28(%rbp), %rdi
callq 0x3b9f0
movsbl %al, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x88131
jmp 0x88149
leaq 0xa5ad4(%rip), %rdi # 0x12dc0c
movl $0x44bd, %esi # imm = 0x44BD
leaq 0xb9f6e(%rip), %rdx # 0x1420b2
callq 0x3c010
movq 0x3e2388(%rip), %rdi # 0x46a4d8
leaq 0xba09c(%rip), %rsi # 0x1421f3
callq 0x3b3d0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0xb0(%rbp)
cmpl $0x0, -0xb0(%rbp)
je 0x8817a
xorl %eax, %eax
movl %eax, %edi
callq 0x3bf10
cmpl $0x0, -0xb0(%rbp)
jne 0x88185
jmp 0x8819d
leaq 0xa5a80(%rip), %rdi # 0x12dc0c
movl $0x44c3, %esi # imm = 0x44C3
leaq 0xbbdd7(%rip), %rdx # 0x143f6f
callq 0x3c010
movq 0x3e2334(%rip), %rdi # 0x46a4d8
callq 0x3b210
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x881d5
xorl %eax, %eax
movl %eax, %edi
callq 0x3bf10
leaq 0xa5a48(%rip), %rdi # 0x12dc0c
movl $0x44c6, %esi # imm = 0x44C6
leaq 0xa580c(%rip), %rdx # 0x12d9dc
callq 0x3c010
movq -0x30(%rbp), %rdi
callq 0xaa020
cmpq $0x3, %rax
jne 0x881e6
jmp 0x881fe
leaq 0xa5a1f(%rip), %rdi # 0x12dc0c
movl $0x44c8, %esi # imm = 0x44C8
leaq 0xba073(%rip), %rdx # 0x14226c
callq 0x3c010
movq -0x30(%rbp), %rdi
callq 0x3b280
callq 0x7e280
jmp 0x8820e
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x88229
addq $0xb0, %rsp
popq %rbp
retq
callq 0x3a2a0
nop
|
test_bug28386:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov rax, cs:qword_142182
mov [rbp+var_15], rax
mov eax, cs:dword_14218A
mov [rbp+var_D], eax
mov al, cs:byte_14218E
mov [rbp+var_9], al
jmp short $+2
loc_87E67:
movsx eax, cs:opt_silent
cmp eax, 2
jge short loc_87EEF
mov rax, cs:stdout_ptr
mov rdi, [rax]
lea rsi, asc_12E324; "\n\n###################################"...
mov al, 0
call _fprintf
mov rax, cs:stdout_ptr
mov rdi, [rax]
mov edx, cs:test_count
mov eax, edx
add eax, 1
mov cs:test_count, eax
mov ecx, cs:iter_count
mov r8d, cs:opt_count
lea rsi, aUOfUUS; "%u of (%u/%u): %s"
lea r9, aTestBug28386; "test_bug28386"
mov al, 0
call _fprintf
mov rax, cs:stdout_ptr
mov rdi, [rax]
lea rsi, asc_12E35C; " \n###################################"...
mov al, 0
call _fprintf
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
loc_87EEF:
mov rdi, cs:mysql
lea rsi, aSelectGlobalLo; "select @@global.log_output"
call wrap_mysql_query
mov [rbp+var_1C], eax
mov eax, [rbp+var_1C]
mov [rbp+var_AC], eax
cmp [rbp+var_AC], 0
jz short loc_87F20
xor eax, eax
mov edi, eax
call print_error
loc_87F20:
cmp [rbp+var_AC], 0
jnz short loc_87F2B
jmp short loc_87F43
loc_87F2B:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 4495h
lea rdx, aTmIYear0+9; "r == 0"
call die
loc_87F43:
mov rdi, cs:mysql
call wrap_mysql_store_result
mov [rbp+var_30], rax
cmp [rbp+var_30], 0
jz short loc_87F5C
jmp short loc_87F74
loc_87F5C:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 4498h
lea rdx, aDropTableIfExi_31+28h; "result"
call die
loc_87F74:
mov rdi, [rbp+var_30]
call wrap_mysql_fetch_row
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov rdi, [rax]
lea rsi, aTable_0; "TABLE"
call _strstr
cmp rax, 0
jnz short loc_87FC1
mov rdi, [rbp+var_30]
call wrap_mysql_free_result
cmp cs:opt_silent, 0
jnz short loc_87FBA
lea rdi, aSkippingTheTes; "Skipping the test since logging to tabl"...
mov al, 0
call _printf
loc_87FBA:
jmp short $+2
loc_87FBC:
jmp loc_8820E
loc_87FC1:
mov rdi, [rbp+var_30]
call wrap_mysql_free_result
mov edi, 1
call enable_query_logs
mov rdi, cs:mysql
lea rsi, aSelect; "SELECT ?"
call mysql_simple_prepare
mov [rbp+var_28], rax
cmp [rbp+var_28], 0
jnz short loc_87FFB
xor eax, eax
mov edi, eax
call print_error
loc_87FFB:
cmp [rbp+var_28], 0
jz short loc_88004
jmp short loc_8801C
loc_88004:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 44A8h
lea rdx, aStmt0; "stmt != 0"
call die
loc_8801C:
lea rdi, [rbp+var_A8]
xor esi, esi
mov edx, 70h ; 'p'
call _memset
mov [rbp+var_48], 0FEh
lea rax, [rbp+var_15]
mov [rbp+var_98], rax
mov [rbp+var_68], 0Dh
mov rdi, [rbp+var_28]
lea rsi, [rbp+var_A8]
call mysql_stmt_bind_param
mov rdi, [rbp+var_28]
lea rdx, [rbp+var_15]
xor esi, esi
mov ecx, 0Dh
call wrap_mysql_stmt_send_long_data
mov rdi, [rbp+var_28]
call wrap_mysql_stmt_execute
mov [rbp+var_1C], eax
cmp [rbp+var_1C], 0
jz short loc_8808C
mov rdi, [rbp+var_28]
xor eax, eax
mov esi, eax
call print_st_error
loc_8808C:
cmp [rbp+var_1C], 0
jnz short loc_88094
jmp short loc_880AC
loc_88094:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 44B4h
lea rdx, aRcMysqlDataTru+1Eh; "rc == 0"
call die
loc_880AC:
mov rdi, [rbp+var_28]
call my_process_stmt_result
mov [rbp+var_1C], eax
cmp [rbp+var_1C], 1
jnz short loc_880C0
jmp short loc_880D8
loc_880C0:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 44B7h
lea rdx, aRc1; "rc == 1"
call die
loc_880D8:
mov rdi, [rbp+var_28]
call wrap_mysql_stmt_reset
movsx eax, al
mov [rbp+var_1C], eax
cmp [rbp+var_1C], 0
jz short loc_880FA
mov rdi, [rbp+var_28]
xor eax, eax
mov esi, eax
call print_st_error
loc_880FA:
cmp [rbp+var_1C], 0
jnz short loc_88102
jmp short loc_8811A
loc_88102:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 44BAh
lea rdx, aRcMysqlDataTru+1Eh; "rc == 0"
call die
loc_8811A:
mov rdi, [rbp+var_28]
call wrap_mysql_stmt_close
movsx eax, al
mov [rbp+var_1C], eax
cmp [rbp+var_1C], 0
jnz short loc_88131
jmp short loc_88149
loc_88131:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 44BDh
lea rdx, aIsNullRc_0+0Ch; "!rc"
call die
loc_88149:
mov rdi, cs:mysql
lea rsi, aSelectFromMysq; "select * from mysql.general_log where c"...
call wrap_mysql_query
mov [rbp+var_1C], eax
mov eax, [rbp+var_1C]
mov [rbp+var_B0], eax
cmp [rbp+var_B0], 0
jz short loc_8817A
xor eax, eax
mov edi, eax
call print_error
loc_8817A:
cmp [rbp+var_B0], 0
jnz short loc_88185
jmp short loc_8819D
loc_88185:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 44C3h
lea rdx, aTmIYear0+9; "r == 0"
call die
loc_8819D:
mov rdi, cs:mysql
call wrap_mysql_store_result
mov [rbp+var_30], rax
cmp [rbp+var_30], 0
jnz short loc_881D5
xor eax, eax
mov edi, eax
call print_error
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 44C6h
lea rdx, aFalse; "FALSE"
call die
loc_881D5:
mov rdi, [rbp+var_30]
call mysql_num_rows
cmp rax, 3
jnz short loc_881E6
jmp short loc_881FE
loc_881E6:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 44C8h
lea rdx, aMysqlNumRowsRe; "mysql_num_rows(result) == 3"
call die
loc_881FE:
mov rdi, [rbp+var_30]
call wrap_mysql_free_result
call restore_query_logs
jmp short $+2
loc_8820E:
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_88229
add rsp, 0B0h
pop rbp
retn
loc_88229:
call ___stack_chk_fail
|
unsigned long long test_bug28386()
{
int v0; // edx
char v1; // al
char v2; // al
int v4; // [rsp+0h] [rbp-B0h]
_BYTE v5[16]; // [rsp+8h] [rbp-A8h] BYREF
_BYTE *v6; // [rsp+18h] [rbp-98h]
long long v7; // [rsp+48h] [rbp-68h]
int v8; // [rsp+68h] [rbp-48h]
_QWORD *row; // [rsp+78h] [rbp-38h]
long long v10; // [rsp+80h] [rbp-30h]
long long v11; // [rsp+88h] [rbp-28h]
int v12; // [rsp+94h] [rbp-1Ch]
_BYTE v13[21]; // [rsp+9Bh] [rbp-15h] BYREF
*(_QWORD *)&v13[13] = __readfsqword(0x28u);
strcpy(v13, "hello world!");
if ( opt_silent < 2 )
{
fprintf(stdout, "\n\n#####################################\n");
v0 = test_count++;
fprintf(stdout, "%u of (%u/%u): %s", v0, iter_count, opt_count, "test_bug28386");
fprintf(stdout, " \n#####################################\n");
fflush(stdout);
}
v12 = wrap_mysql_query(mysql, (long long)"select @@global.log_output");
if ( v12 )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 17557, "r == 0");
}
v10 = wrap_mysql_store_result(mysql);
if ( !v10 )
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 17560, "result");
row = (_QWORD *)wrap_mysql_fetch_row(v10);
if ( strstr(*row, "TABLE") )
{
wrap_mysql_free_result(v10);
enable_query_logs(1);
v11 = mysql_simple_prepare(mysql, (long long)"SELECT ?");
if ( !v11 )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 17576, "stmt != 0");
}
memset(v5, 0LL, 112LL);
v8 = 254;
v6 = v13;
v7 = 13LL;
mysql_stmt_bind_param(v11, v5);
wrap_mysql_stmt_send_long_data(v11, 0, (long long)v13, 13LL);
v12 = wrap_mysql_stmt_execute(v11);
if ( v12 )
print_st_error(v11, 0LL);
if ( v12 )
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 17588, "rc == 0");
v12 = my_process_stmt_result(v11);
if ( v12 != 1 )
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 17591, "rc == 1");
v1 = wrap_mysql_stmt_reset(v11);
v12 = v1;
if ( v1 )
print_st_error(v11, 0LL);
if ( v12 )
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 17594, "rc == 0");
v2 = wrap_mysql_stmt_close(v11);
v12 = v2;
if ( v2 )
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 17597, "!rc");
v12 = wrap_mysql_query(
mysql,
(long long)"select * from mysql.general_log where command_type='Close stmt' or command_type='Reset stmt' or com"
"mand_type='Long Data'");
v4 = v12;
if ( v12 )
print_error(0LL);
if ( v4 )
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 17603, "r == 0");
v10 = wrap_mysql_store_result(mysql);
if ( !v10 )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 17606, "FALSE");
}
if ( mysql_num_rows(v10) != 3 )
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 17608, "mysql_num_rows(result) == 3");
wrap_mysql_free_result(v10);
restore_query_logs();
}
else
{
wrap_mysql_free_result(v10);
if ( !opt_silent )
printf("Skipping the test since logging to tables is not enabled\n");
}
return __readfsqword(0x28u);
}
|
test_bug28386:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [0x00242182]
MOV qword ptr [RBP + -0x15],RAX
MOV EAX,dword ptr [0x0024218a]
MOV dword ptr [RBP + -0xd],EAX
MOV AL,byte ptr [0x0024218e]
MOV byte ptr [RBP + -0x9],AL
JMP 0x00187e67
LAB_00187e67:
MOVSX EAX,byte ptr [0x0056a4d1]
CMP EAX,0x2
JGE 0x00187eef
MOV RAX,qword ptr [0x003aefd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x22e324]
MOV AL,0x0
CALL 0x0013a1c0
MOV RAX,qword ptr [0x003aefd8]
MOV RDI,qword ptr [RAX]
MOV EDX,dword ptr [0x0056a71c]
MOV EAX,EDX
ADD EAX,0x1
MOV dword ptr [0x0056a71c],EAX
MOV ECX,dword ptr [0x0056a718]
MOV R8D,dword ptr [0x0056a4fc]
LEA RSI,[0x22f62c]
LEA R9,[0x22f2a6]
MOV AL,0x0
CALL 0x0013a1c0
MOV RAX,qword ptr [0x003aefd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x22e35c]
MOV AL,0x0
CALL 0x0013a1c0
MOV RAX,qword ptr [0x003aefd8]
MOV RDI,qword ptr [RAX]
CALL 0x0013a4a0
LAB_00187eef:
MOV RDI,qword ptr [0x0056a4d8]
LEA RSI,[0x24218f]
CALL 0x0013b3d0
MOV dword ptr [RBP + -0x1c],EAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0xac],EAX
CMP dword ptr [RBP + -0xac],0x0
JZ 0x00187f20
XOR EAX,EAX
MOV EDI,EAX
CALL 0x0013bf10
LAB_00187f20:
CMP dword ptr [RBP + -0xac],0x0
JNZ 0x00187f2b
JMP 0x00187f43
LAB_00187f2b:
LEA RDI,[0x22dc0c]
MOV ESI,0x4495
LEA RDX,[0x243f6f]
CALL 0x0013c010
LAB_00187f43:
MOV RDI,qword ptr [0x0056a4d8]
CALL 0x0013b210
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x30],0x0
JZ 0x00187f5c
JMP 0x00187f74
LAB_00187f5c:
LEA RDI,[0x22dc0c]
MOV ESI,0x4498
LEA RDX,[0x234363]
CALL 0x0013c010
LAB_00187f74:
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x0013b000
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x2421aa]
CALL 0x0013a470
CMP RAX,0x0
JNZ 0x00187fc1
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x0013b280
CMP byte ptr [0x0056a4d1],0x0
JNZ 0x00187fba
LEA RDI,[0x2421b0]
MOV AL,0x0
CALL 0x0013a070
LAB_00187fba:
JMP 0x00187fbc
LAB_00187fbc:
JMP 0x0018820e
LAB_00187fc1:
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x0013b280
MOV EDI,0x1
CALL 0x0017e0a0
MOV RDI,qword ptr [0x0056a4d8]
LEA RSI,[0x2421ea]
CALL 0x0013be90
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],0x0
JNZ 0x00187ffb
XOR EAX,EAX
MOV EDI,EAX
CALL 0x0013bf10
LAB_00187ffb:
CMP qword ptr [RBP + -0x28],0x0
JZ 0x00188004
JMP 0x0018801c
LAB_00188004:
LEA RDI,[0x22dc0c]
MOV ESI,0x44a8
LEA RDX,[0x22d96a]
CALL 0x0013c010
LAB_0018801c:
LEA RDI,[RBP + -0xa8]
XOR ESI,ESI
MOV EDX,0x70
CALL 0x0013a2e0
MOV dword ptr [RBP + -0x48],0xfe
LEA RAX,[RBP + -0x15]
MOV qword ptr [RBP + -0x98],RAX
MOV qword ptr [RBP + -0x68],0xd
MOV RDI,qword ptr [RBP + -0x28]
LEA RSI,[RBP + -0xa8]
CALL 0x001b1100
MOV RDI,qword ptr [RBP + -0x28]
LEA RDX,[RBP + -0x15]
XOR ESI,ESI
MOV ECX,0xd
CALL 0x0013bb40
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x0013b8a0
MOV dword ptr [RBP + -0x1c],EAX
CMP dword ptr [RBP + -0x1c],0x0
JZ 0x0018808c
MOV RDI,qword ptr [RBP + -0x28]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x0013c0b0
LAB_0018808c:
CMP dword ptr [RBP + -0x1c],0x0
JNZ 0x00188094
JMP 0x001880ac
LAB_00188094:
LEA RDI,[0x22dc0c]
MOV ESI,0x44b4
LEA RDX,[0x23980c]
CALL 0x0013c010
LAB_001880ac:
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x0013c1c0
MOV dword ptr [RBP + -0x1c],EAX
CMP dword ptr [RBP + -0x1c],0x1
JNZ 0x001880c0
JMP 0x001880d8
LAB_001880c0:
LEA RDI,[0x22dc0c]
MOV ESI,0x44b7
LEA RDX,[0x22fe8a]
CALL 0x0013c010
LAB_001880d8:
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x0013ba60
MOVSX EAX,AL
MOV dword ptr [RBP + -0x1c],EAX
CMP dword ptr [RBP + -0x1c],0x0
JZ 0x001880fa
MOV RDI,qword ptr [RBP + -0x28]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x0013c0b0
LAB_001880fa:
CMP dword ptr [RBP + -0x1c],0x0
JNZ 0x00188102
JMP 0x0018811a
LAB_00188102:
LEA RDI,[0x22dc0c]
MOV ESI,0x44ba
LEA RDX,[0x23980c]
CALL 0x0013c010
LAB_0018811a:
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x0013b9f0
MOVSX EAX,AL
MOV dword ptr [RBP + -0x1c],EAX
CMP dword ptr [RBP + -0x1c],0x0
JNZ 0x00188131
JMP 0x00188149
LAB_00188131:
LEA RDI,[0x22dc0c]
MOV ESI,0x44bd
LEA RDX,[0x2420b2]
CALL 0x0013c010
LAB_00188149:
MOV RDI,qword ptr [0x0056a4d8]
LEA RSI,[0x2421f3]
CALL 0x0013b3d0
MOV dword ptr [RBP + -0x1c],EAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0xb0],EAX
CMP dword ptr [RBP + -0xb0],0x0
JZ 0x0018817a
XOR EAX,EAX
MOV EDI,EAX
CALL 0x0013bf10
LAB_0018817a:
CMP dword ptr [RBP + -0xb0],0x0
JNZ 0x00188185
JMP 0x0018819d
LAB_00188185:
LEA RDI,[0x22dc0c]
MOV ESI,0x44c3
LEA RDX,[0x243f6f]
CALL 0x0013c010
LAB_0018819d:
MOV RDI,qword ptr [0x0056a4d8]
CALL 0x0013b210
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x001881d5
XOR EAX,EAX
MOV EDI,EAX
CALL 0x0013bf10
LEA RDI,[0x22dc0c]
MOV ESI,0x44c6
LEA RDX,[0x22d9dc]
CALL 0x0013c010
LAB_001881d5:
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x001aa020
CMP RAX,0x3
JNZ 0x001881e6
JMP 0x001881fe
LAB_001881e6:
LEA RDI,[0x22dc0c]
MOV ESI,0x44c8
LEA RDX,[0x24226c]
CALL 0x0013c010
LAB_001881fe:
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x0013b280
CALL 0x0017e280
JMP 0x0018820e
LAB_0018820e:
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00188229
ADD RSP,0xb0
POP RBP
RET
LAB_00188229:
CALL 0x0013a2a0
|
void test_bug28386(void)
{
char cVar1;
char *pcVar2;
long lVar3;
ulong uVar4;
long in_FS_OFFSET;
int1 local_b0 [16];
char *local_a0;
int8 local_70;
int4 local_50;
int8 *local_40;
long local_38;
long local_30;
int local_24;
char local_1d [8];
char local_15 [4];
char local_11;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_1d = (char [8])s_hello_world__00242182._0_8_;
local_15 = (char [4])s_hello_world__00242182._8_4_;
local_11 = s_hello_world__00242182[0xc];
if (opt_silent < '\x02') {
fprintf(*(FILE **)PTR_stdout_003aefd8,"\n\n#####################################\n");
uVar4 = (ulong)test_count;
test_count = test_count + 1;
fprintf(*(FILE **)PTR_stdout_003aefd8,"%u of (%u/%u): %s",uVar4,(ulong)iter_count,
(ulong)opt_count,"test_bug28386");
fprintf(*(FILE **)PTR_stdout_003aefd8," \n#####################################\n");
fflush(*(FILE **)PTR_stdout_003aefd8);
}
local_24 = wrap_mysql_query(mysql,"select @@global.log_output");
if (local_24 != 0) {
print_error(0);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x4495,"r == 0");
}
local_38 = wrap_mysql_store_result(mysql);
if (local_38 == 0) {
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x4498,"result");
}
local_40 = (int8 *)wrap_mysql_fetch_row(local_38);
pcVar2 = strstr((char *)*local_40,"TABLE");
if (pcVar2 == (char *)0x0) {
wrap_mysql_free_result(local_38);
if (opt_silent == '\0') {
printf("Skipping the test since logging to tables is not enabled\n");
}
}
else {
wrap_mysql_free_result(local_38);
enable_query_logs(1);
local_30 = mysql_simple_prepare(mysql);
if (local_30 == 0) {
print_error(0);
}
if (local_30 == 0) {
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x44a8,"stmt != 0");
}
memset(local_b0,0,0x70);
local_50 = 0xfe;
local_a0 = local_1d;
local_70 = 0xd;
mysql_stmt_bind_param(local_30,local_b0);
wrap_mysql_stmt_send_long_data(local_30,0,local_1d,0xd);
local_24 = wrap_mysql_stmt_execute(local_30);
if (local_24 != 0) {
print_st_error(local_30,0);
}
if (local_24 != 0) {
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x44b4,"rc == 0");
}
local_24 = my_process_stmt_result(local_30);
if (local_24 != 1) {
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x44b7,"rc == 1");
}
cVar1 = wrap_mysql_stmt_reset(local_30);
local_24 = (int)cVar1;
if (local_24 != 0) {
print_st_error(local_30,0);
}
if (local_24 != 0) {
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x44ba,"rc == 0");
}
cVar1 = wrap_mysql_stmt_close(local_30);
local_24 = (int)cVar1;
if (local_24 != 0) {
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x44bd,"!rc");
}
local_24 = wrap_mysql_query(mysql,
"select * from mysql.general_log where command_type=\'Close stmt\' or command_type=\'Reset stmt\' or command_type=\'Long Data\'"
);
if (local_24 != 0) {
print_error(0);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x44c3,"r == 0");
}
local_38 = wrap_mysql_store_result(mysql);
if (local_38 == 0) {
print_error(0);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x44c6,"FALSE");
}
lVar3 = mysql_num_rows(local_38);
if (lVar3 != 3) {
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x44c8,
"mysql_num_rows(result) == 3");
}
wrap_mysql_free_result(local_38);
restore_query_logs();
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
63,671
|
evmone::instr::core::selfdestruct(evmone::StackTop, long, evmone::ExecutionState&)
|
corpus-core[P]colibri-stateless/build_O2/_deps/evmone_external-src/lib/evmone/instructions.hpp
|
inline TermResult selfdestruct(StackTop stack, int64_t gas_left, ExecutionState& state) noexcept
{
if (state.in_static_mode())
return {EVMC_STATIC_MODE_VIOLATION, gas_left};
const auto beneficiary = intx::be::trunc<evmc::address>(stack[0]);
if (state.rev >= EVMC_BERLIN && state.host.access_account(beneficiary) == EVMC_ACCESS_COLD)
{
if ((gas_left -= instr::cold_account_access_cost) < 0)
return {EVMC_OUT_OF_GAS, gas_left};
}
if (state.rev >= EVMC_TANGERINE_WHISTLE)
{
if (state.rev == EVMC_TANGERINE_WHISTLE || state.host.get_balance(state.msg->recipient))
{
// After TANGERINE_WHISTLE apply additional cost of
// sending value to a non-existing account.
if (!state.host.account_exists(beneficiary))
{
if ((gas_left -= 25000) < 0)
return {EVMC_OUT_OF_GAS, gas_left};
}
}
}
if (state.host.selfdestruct(state.msg->recipient, beneficiary))
{
if (state.rev < EVMC_LONDON)
state.gas_refund += 24000;
}
return {EVMC_SUCCESS, gas_left};
}
|
O2
|
cpp
|
evmone::instr::core::selfdestruct(evmone::StackTop, long, evmone::ExecutionState&):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq 0x20(%rdx), %rax
testb $0x1, 0x4(%rax)
jne 0x3cabf
movq %rdx, %r14
movq %rdi, %rsi
leaq 0xc(%rsp), %rdi
callq 0x3a597
movl 0x40(%r14), %eax
pushq $0x3
popq %rbp
cmpl $0x8, %eax
jl 0x3cae6
leaq 0x28(%r14), %rdi
leaq 0xc(%rsp), %rsi
callq 0x2e6a8
testl %eax, %eax
je 0x3cac7
movq %rbx, %rcx
jmp 0x3cadf
pushq $0xb
popq %rbp
jmp 0x3cb7d
leaq -0xa28(%rbx), %rcx
cmpq $0xa28, %rbx # imm = 0xA28
jge 0x3cadf
movq %rcx, %rbx
jmp 0x3cb7d
movl 0x40(%r14), %eax
movq %rcx, %rbx
cmpl $0x2, %eax
jl 0x3cb45
je 0x3cb20
leaq 0x28(%r14), %rsi
movq 0x20(%r14), %rax
movl 0x28(%rax), %ecx
leaq 0x40(%rsp), %rdx
movl %ecx, 0x10(%rdx)
movups 0x18(%rax), %xmm0
movaps %xmm0, (%rdx)
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x2e554
movq %r15, %rdi
callq 0x3cb8e
testb %al, %al
je 0x3cb45
leaq 0x28(%r14), %rdi
leaq 0xc(%rsp), %rsi
callq 0x2e4f0
testb %al, %al
jne 0x3cb45
leaq -0x61a8(%rbx), %rax
cmpq $0x61a8, %rbx # imm = 0x61A8
movq %rax, %rbx
jl 0x3cb7d
leaq 0x28(%r14), %rdi
movq 0x20(%r14), %rax
movl 0x28(%rax), %ecx
leaq 0x20(%rsp), %rsi
movl %ecx, 0x10(%rsi)
movups 0x18(%rax), %xmm0
movaps %xmm0, (%rsi)
leaq 0xc(%rsp), %rdx
callq 0x2e5f0
xorl %ebp, %ebp
testb %al, %al
je 0x3cb7d
cmpl $0x8, 0x40(%r14)
jg 0x3cb7d
addq $0x5dc0, (%r14) # imm = 0x5DC0
movl %ebp, %eax
movq %rbx, %rdx
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
_ZN6evmone5instr4core12selfdestructENS_8StackTopElRNS_14ExecutionStateE:
push rbp
push r15
push r14
push rbx
sub rsp, 58h
mov rbx, rsi
mov rax, [rdx+20h]
test byte ptr [rax+4], 1
jnz short loc_3CABF
mov r14, rdx
mov rsi, rdi
lea rdi, [rsp+78h+var_6C]
call _ZN4intx2be5truncIN4evmc7addressELj256EEET_RKNS_4uintIXT0_EEE; intx::be::trunc<evmc::address,256u>(intx::uint<256u> const&)
mov eax, [r14+40h]
push 3
pop rbp
cmp eax, 8
jl short loc_3CAE6
lea rdi, [r14+28h]
lea rsi, [rsp+78h+var_6C]
call _ZN4evmc11HostContext14access_accountERKNS_7addressE; evmc::HostContext::access_account(evmc::address const&)
test eax, eax
jz short loc_3CAC7
mov rcx, rbx
jmp short loc_3CADF
loc_3CABF:
push 0Bh
pop rbp
jmp loc_3CB7D
loc_3CAC7:
lea rcx, [rbx-0A28h]
cmp rbx, 0A28h
jge short loc_3CADF
mov rbx, rcx
jmp loc_3CB7D
loc_3CADF:
mov eax, [r14+40h]
mov rbx, rcx
loc_3CAE6:
cmp eax, 2
jl short loc_3CB45
jz short loc_3CB20
lea rsi, [r14+28h]
mov rax, [r14+20h]
mov ecx, [rax+28h]
lea rdx, [rsp+78h+var_38]
mov [rdx+10h], ecx
movups xmm0, xmmword ptr [rax+18h]
movaps xmmword ptr [rdx], xmm0
lea r15, [rsp+78h+var_58]
mov rdi, r15
call _ZNK4evmc11HostContext11get_balanceERKNS_7addressE; evmc::HostContext::get_balance(evmc::address const&)
mov rdi, r15
call _ZNK4evmc7bytes32cvbEv; evmc::bytes32::operator bool(void)
test al, al
jz short loc_3CB45
loc_3CB20:
lea rdi, [r14+28h]
lea rsi, [rsp+78h+var_6C]
call _ZNK4evmc11HostContext14account_existsERKNS_7addressE; evmc::HostContext::account_exists(evmc::address const&)
test al, al
jnz short loc_3CB45
lea rax, [rbx-61A8h]
cmp rbx, 61A8h
mov rbx, rax
jl short loc_3CB7D
loc_3CB45:
lea rdi, [r14+28h]
mov rax, [r14+20h]
mov ecx, [rax+28h]
lea rsi, [rsp+78h+var_58]
mov [rsi+10h], ecx
movups xmm0, xmmword ptr [rax+18h]
movaps xmmword ptr [rsi], xmm0
lea rdx, [rsp+78h+var_6C]
call _ZN4evmc11HostContext12selfdestructERKNS_7addressES3_; evmc::HostContext::selfdestruct(evmc::address const&,evmc::address const&)
xor ebp, ebp
test al, al
jz short loc_3CB7D
cmp dword ptr [r14+40h], 8
jg short loc_3CB7D
add qword ptr [r14], 5DC0h
loc_3CB7D:
mov eax, ebp
mov rdx, rbx
add rsp, 58h
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long evmone::instr::core::selfdestruct(long long a1, long long a2, long long a3)
{
long long v3; // rbx
int v5; // eax
unsigned int v6; // ebp
long long v7; // rcx
long long v8; // rax
long long v9; // rax
_BYTE v11[20]; // [rsp+Ch] [rbp-6Ch] BYREF
__int128 v12; // [rsp+20h] [rbp-58h] BYREF
int v13; // [rsp+30h] [rbp-48h]
__int128 v14; // [rsp+40h] [rbp-38h]
int v15; // [rsp+50h] [rbp-28h]
v3 = a2;
if ( (*(_BYTE *)(*(_QWORD *)(a3 + 32) + 4LL) & 1) != 0 )
{
return 11;
}
else
{
intx::be::trunc<evmc::address,256u>((long long)v11);
v5 = *(_DWORD *)(a3 + 64);
v6 = 3;
if ( v5 >= 8 )
{
if ( (unsigned int)evmc::HostContext::access_account(a3 + 40) )
{
v7 = a2;
}
else
{
v7 = a2 - 2600;
if ( a2 < 2600 )
return v6;
}
v5 = *(_DWORD *)(a3 + 64);
v3 = v7;
}
if ( v5 < 2
|| v5 != 2
&& (v8 = *(_QWORD *)(a3 + 32),
v15 = *(_DWORD *)(v8 + 40),
v14 = *(_OWORD *)(v8 + 24),
evmc::HostContext::get_balance(&v12, a3 + 40),
!(unsigned __int8)evmc::bytes32::operator bool(&v12))
|| (unsigned __int8)evmc::HostContext::account_exists(a3 + 40)
|| v3 >= 25000 )
{
v9 = *(_QWORD *)(a3 + 32);
v13 = *(_DWORD *)(v9 + 40);
v12 = *(_OWORD *)(v9 + 24);
v6 = 0;
if ( (unsigned __int8)evmc::HostContext::selfdestruct(a3 + 40) && *(int *)(a3 + 64) <= 8 )
*(_QWORD *)a3 += 24000LL;
}
}
return v6;
}
|
selfdestruct:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x58
MOV RBX,RSI
MOV RAX,qword ptr [RDX + 0x20]
TEST byte ptr [RAX + 0x4],0x1
JNZ 0x0013cabf
MOV R14,RDX
MOV RSI,RDI
LEA RDI,[RSP + 0xc]
CALL 0x0013a597
MOV EAX,dword ptr [R14 + 0x40]
PUSH 0x3
POP RBP
CMP EAX,0x8
JL 0x0013cae6
LEA RDI,[R14 + 0x28]
LEA RSI,[RSP + 0xc]
CALL 0x0012e6a8
TEST EAX,EAX
JZ 0x0013cac7
MOV RCX,RBX
JMP 0x0013cadf
LAB_0013cabf:
PUSH 0xb
POP RBP
JMP 0x0013cb7d
LAB_0013cac7:
LEA RCX,[RBX + -0xa28]
CMP RBX,0xa28
JGE 0x0013cadf
MOV RBX,RCX
JMP 0x0013cb7d
LAB_0013cadf:
MOV EAX,dword ptr [R14 + 0x40]
MOV RBX,RCX
LAB_0013cae6:
CMP EAX,0x2
JL 0x0013cb45
JZ 0x0013cb20
LEA RSI,[R14 + 0x28]
MOV RAX,qword ptr [R14 + 0x20]
MOV ECX,dword ptr [RAX + 0x28]
LEA RDX,[RSP + 0x40]
MOV dword ptr [RDX + 0x10],ECX
MOVUPS XMM0,xmmword ptr [RAX + 0x18]
MOVAPS xmmword ptr [RDX],XMM0
LEA R15,[RSP + 0x20]
MOV RDI,R15
CALL 0x0012e554
MOV RDI,R15
CALL 0x0013cb8e
TEST AL,AL
JZ 0x0013cb45
LAB_0013cb20:
LEA RDI,[R14 + 0x28]
LEA RSI,[RSP + 0xc]
CALL 0x0012e4f0
TEST AL,AL
JNZ 0x0013cb45
LEA RAX,[RBX + -0x61a8]
CMP RBX,0x61a8
MOV RBX,RAX
JL 0x0013cb7d
LAB_0013cb45:
LEA RDI,[R14 + 0x28]
MOV RAX,qword ptr [R14 + 0x20]
MOV ECX,dword ptr [RAX + 0x28]
LEA RSI,[RSP + 0x20]
MOV dword ptr [RSI + 0x10],ECX
MOVUPS XMM0,xmmword ptr [RAX + 0x18]
MOVAPS xmmword ptr [RSI],XMM0
LEA RDX,[RSP + 0xc]
CALL 0x0012e5f0
XOR EBP,EBP
TEST AL,AL
JZ 0x0013cb7d
CMP dword ptr [R14 + 0x40],0x8
JG 0x0013cb7d
ADD qword ptr [R14],0x5dc0
LAB_0013cb7d:
MOV EAX,EBP
MOV RDX,RBX
ADD RSP,0x58
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* evmone::instr::core::selfdestruct(evmone::StackTop, long, evmone::ExecutionState&) */
int1 [16] evmone::instr::core::selfdestruct(uint *param_1,long param_2,long *param_3)
{
long lVar1;
bool bVar2;
char cVar3;
int iVar4;
long lVar5;
int8 uVar6;
int1 auVar7 [16];
be local_6c [20];
int8 local_58;
int8 uStack_50;
int4 local_48;
int8 local_38;
int8 uStack_30;
int4 local_28;
if ((*(byte *)(param_3[4] + 4) & 1) != 0) {
uVar6 = 0xb;
lVar5 = param_2;
goto LAB_0013cb7d;
}
intx::be::trunc<evmc::address,256u>(local_6c,param_1);
iVar4 = (int)param_3[8];
uVar6 = 3;
if (7 < iVar4) {
iVar4 = evmc::HostContext::access_account((address *)(param_3 + 5));
if ((iVar4 == 0) && (lVar5 = param_2 + -0xa28, bVar2 = param_2 < 0xa28, param_2 = lVar5, bVar2))
goto LAB_0013cb7d;
iVar4 = (int)param_3[8];
}
lVar5 = param_2;
if (1 < iVar4) {
if (iVar4 != 2) {
lVar1 = param_3[4];
local_28 = *(int4 *)(lVar1 + 0x28);
local_38 = *(int8 *)(lVar1 + 0x18);
uStack_30 = *(int8 *)(lVar1 + 0x20);
evmc::HostContext::get_balance((HostContext *)&local_58,(address *)(param_3 + 5));
bVar2 = evmc::bytes32::operator_cast_to_bool((bytes32 *)&local_58);
if (!bVar2) goto LAB_0013cb45;
}
cVar3 = evmc::HostContext::account_exists((address *)(param_3 + 5));
if ((cVar3 == '\0') && (lVar5 = param_2 + -25000, param_2 < 25000)) goto LAB_0013cb7d;
}
LAB_0013cb45:
lVar1 = param_3[4];
local_48 = *(int4 *)(lVar1 + 0x28);
local_58 = *(int8 *)(lVar1 + 0x18);
uStack_50 = *(int8 *)(lVar1 + 0x20);
cVar3 = evmc::HostContext::selfdestruct((address *)(param_3 + 5),(address *)&local_58);
uVar6 = 0;
if ((cVar3 != '\0') && ((int)param_3[8] < 9)) {
*param_3 = *param_3 + 24000;
uVar6 = 0;
}
LAB_0013cb7d:
auVar7._8_8_ = lVar5;
auVar7._0_8_ = uVar6;
return auVar7;
}
|
|
63,672
|
httplib::detail::file_extension(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
hkr04[P]cpp-mcp/common/httplib.h
|
inline std::string file_extension(const std::string &path) {
std::smatch m;
static auto re = std::regex("\\.([a-zA-Z0-9]+)$");
if (std::regex_search(path, m, re)) { return m[1].str(); }
return std::string();
}
|
O0
|
c
|
httplib::detail::file_extension(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
subq $0x68, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x11da0
cmpb $0x0, 0xdd33c(%rip) # 0x1414c8
jne 0x641df
leaq 0xdd333(%rip), %rdi # 0x1414c8
callq 0xce90
cmpl $0x0, %eax
je 0x641df
leaq 0xdd302(%rip), %rdi # 0x1414a8
leaq 0x80e62(%rip), %rsi # 0xe500f
movl $0x10, %edx
callq 0x3c750
jmp 0x641b9
leaq -0x4cde0(%rip), %rdi # 0x173e0
leaq 0xdd2e1(%rip), %rsi # 0x1414a8
leaq 0xda61a(%rip), %rdx # 0x13e7e8
callq 0xc7b0
leaq 0xdd2ee(%rip), %rdi # 0x1414c8
callq 0xc5c0
movq 0x58(%rsp), %rdi
leaq 0xdd2bd(%rip), %rdx # 0x1414a8
leaq 0x38(%rsp), %rsi
xorl %ecx, %ecx
callq 0x64340
movb %al, 0x17(%rsp)
jmp 0x641fd
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x64207
jmp 0x64264
leaq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x3c900
movq %rax, 0x8(%rsp)
jmp 0x6421d
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdi
callq 0x5e080
jmp 0x6422e
movl $0x1, 0x28(%rsp)
jmp 0x64276
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0xdd27b(%rip), %rdi # 0x1414c8
callq 0xc5b0
jmp 0x6428a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x6428a
movq 0x18(%rsp), %rdi
callq 0xcbb0
movl $0x1, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x11e20
movq 0x20(%rsp), %rax
addq $0x68, %rsp
retq
leaq 0x38(%rsp), %rdi
callq 0x11e20
movq 0x30(%rsp), %rdi
callq 0xce40
nop
|
_ZN7httplib6detail14file_extensionERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
sub rsp, 68h
mov [rsp+68h+var_50], rdi
mov rax, rdi
mov [rsp+68h+var_48], rax
mov [rsp+68h+var_8], rdi
mov [rsp+68h+var_10], rsi
lea rdi, [rsp+68h+var_30]
call _ZNSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEEC2Ev; std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::match_results(void)
cmp cs:_ZGVZN7httplib6detail14file_extensionERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE2reB5cxx11, 0; `guard variable for'httplib::detail::file_extension(std::string const&)::re
jnz short loc_641DF
lea rdi, _ZGVZN7httplib6detail14file_extensionERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE2reB5cxx11; __guard *
call ___cxa_guard_acquire
cmp eax, 0
jz short loc_641DF
lea rdi, _ZZN7httplib6detail14file_extensionERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE2reB5cxx11; httplib::detail::file_extension(std::string const&)::re
lea rsi, aAZaZ09; "\\.([a-zA-Z0-9]+)$"
mov edx, 10h
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2EPKcNSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex(char const*,std::regex_constants::syntax_option_type)
jmp short $+2
loc_641B9:
lea rdi, _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; lpfunc
lea rsi, _ZZN7httplib6detail14file_extensionERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE2reB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZN7httplib6detail14file_extensionERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE2reB5cxx11; __guard *
call ___cxa_guard_release
loc_641DF:
mov rdi, [rsp+68h+var_10]
lea rdx, _ZZN7httplib6detail14file_extensionERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE2reB5cxx11; httplib::detail::file_extension(std::string const&)::re
lea rsi, [rsp+68h+var_30]
xor ecx, ecx
call _ZSt12regex_searchISt11char_traitsIcESaIcESaINSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS3_12basic_stringIcS1_S2_EEEEEEEcNS3_12regex_traitsIcEEEbRKNS9_IT2_T_T0_EERNS3_13match_resultsINSJ_14const_iteratorET1_EERKNS3_11basic_regexISG_T3_EENSt15regex_constants15match_flag_typeE; std::regex_search<std::char_traits<char>,std::allocator<char>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>>(std::string const&,std::match_results<std::string::const_iterator> &,std::basic_regex<char,std::regex_traits<char>> const&,std::regex_constants::match_flag_type)
mov [rsp+68h+var_51], al
jmp short $+2
loc_641FD:
mov al, [rsp+68h+var_51]
test al, 1
jnz short loc_64207
jmp short loc_64264
loc_64207:
lea rdi, [rsp+68h+var_30]
mov esi, 1
call _ZNKSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEEixEm; std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::operator[](ulong)
mov [rsp+68h+var_60], rax
jmp short $+2
loc_6421D:
mov rsi, [rsp+68h+var_60]
mov rdi, [rsp+68h+var_50]
call _ZNKSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEEE3strEv; std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>::str(void)
jmp short $+2
loc_6422E:
mov [rsp+68h+var_40], 1
jmp short loc_64276
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
lea rdi, _ZGVZN7httplib6detail14file_extensionERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE2reB5cxx11; __guard *
call ___cxa_guard_abort
jmp short loc_6428A
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
jmp short loc_6428A
loc_64264:
mov rdi, [rsp+68h+var_50]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string(void)
mov [rsp+68h+var_40], 1
loc_64276:
lea rdi, [rsp+68h+var_30]
call _ZNSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEED2Ev; std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::~match_results()
mov rax, [rsp+68h+var_48]
add rsp, 68h
retn
loc_6428A:
lea rdi, [rsp+arg_30]
call _ZNSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEED2Ev; std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::~match_results()
mov rdi, [rsp+arg_28]
call __Unwind_Resume
|
long long httplib::detail::file_extension(long long a1, long long a2)
{
long long *v3; // [rsp+8h] [rbp-60h]
_BYTE v4[32]; // [rsp+38h] [rbp-30h] BYREF
long long v5; // [rsp+58h] [rbp-10h]
long long v6; // [rsp+60h] [rbp-8h]
v6 = a1;
v5 = a2;
std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::match_results((long long)v4);
if ( !(_BYTE)`guard variable for'httplib::detail::file_extension(std::string const&)::re[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'httplib::detail::file_extension(std::string const&)::re[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&httplib::detail::file_extension(std::string const&)::re[abi:cxx11],
(long long)"\\.([a-zA-Z0-9]+)$",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&httplib::detail::file_extension(std::string const&)::re[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'httplib::detail::file_extension(std::string const&)::re[abi:cxx11]);
}
if ( (std::regex_search<std::char_traits<char>,std::allocator<char>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>>(
v5,
v4,
&httplib::detail::file_extension(std::string const&)::re[abi:cxx11],
0LL) & 1) != 0 )
{
v3 = (long long *)std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::operator[](
(long long)v4,
1uLL);
std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>::str(a1, v3);
}
else
{
std::string::basic_string(a1);
}
std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::~match_results((long long)v4);
return a1;
}
|
file_extension:
SUB RSP,0x68
MOV qword ptr [RSP + 0x18],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x60],RDI
MOV qword ptr [RSP + 0x58],RSI
LEA RDI,[RSP + 0x38]
CALL 0x00111da0
CMP byte ptr [0x002414c8],0x0
JNZ 0x001641df
LEA RDI,[0x2414c8]
CALL 0x0010ce90
CMP EAX,0x0
JZ 0x001641df
LAB_0016419f:
LEA RDI,[0x2414a8]
LEA RSI,[0x1e500f]
MOV EDX,0x10
CALL 0x0013c750
JMP 0x001641b9
LAB_001641b9:
LEA RDI,[0x1173e0]
LEA RSI,[0x2414a8]
LEA RDX,[0x23e7e8]
CALL 0x0010c7b0
LEA RDI,[0x2414c8]
CALL 0x0010c5c0
LAB_001641df:
MOV RDI,qword ptr [RSP + 0x58]
LAB_001641e4:
LEA RDX,[0x2414a8]
LEA RSI,[RSP + 0x38]
XOR ECX,ECX
CALL 0x00164340
MOV byte ptr [RSP + 0x17],AL
JMP 0x001641fd
LAB_001641fd:
MOV AL,byte ptr [RSP + 0x17]
TEST AL,0x1
JNZ 0x00164207
JMP 0x00164264
LAB_00164207:
LEA RDI,[RSP + 0x38]
MOV ESI,0x1
CALL 0x0013c900
MOV qword ptr [RSP + 0x8],RAX
JMP 0x0016421d
LAB_0016421d:
MOV RSI,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x0015e080
LAB_0016422c:
JMP 0x0016422e
LAB_0016422e:
MOV dword ptr [RSP + 0x28],0x1
JMP 0x00164276
LAB_00164264:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x0010cbb0
MOV dword ptr [RSP + 0x28],0x1
LAB_00164276:
LEA RDI,[RSP + 0x38]
CALL 0x00111e20
MOV RAX,qword ptr [RSP + 0x20]
ADD RSP,0x68
RET
|
/* httplib::detail::file_extension(std::__cxx11::string const&) */
detail * __thiscall httplib::detail::file_extension(detail *this,string *param_1)
{
bool bVar1;
int iVar2;
match_results<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>>
local_30 [32];
string *local_10;
detail *local_8;
local_10 = param_1;
local_8 = this;
std::__cxx11::
match_results<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>>
::match_results(local_30);
if (file_extension(std::__cxx11::string_const&)::re_abi_cxx11_ == '\0') {
iVar2 = __cxa_guard_acquire(&file_extension(std::__cxx11::string_const&)::re_abi_cxx11_);
if (iVar2 != 0) {
/* try { // try from 0016419f to 001641b6 has its CatchHandler @ 00164238 */
std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::basic_regex
(file_extension(std::__cxx11::string_const&)::re_abi_cxx11_,"\\.([a-zA-Z0-9]+)$",
0x10);
__cxa_atexit(std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::~basic_regex,
file_extension(std::__cxx11::string_const&)::re_abi_cxx11_,&__dso_handle);
__cxa_guard_release(&file_extension(std::__cxx11::string_const&)::re_abi_cxx11_);
}
}
/* try { // try from 001641e4 to 0016422b has its CatchHandler @ 00164254 */
bVar1 = std::
regex_search<std::char_traits<char>,std::allocator<char>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>,char,std::__cxx11::regex_traits<char>>
(local_10,local_30,file_extension(std::__cxx11::string_const&)::re_abi_cxx11_,0)
;
if (bVar1) {
std::__cxx11::
match_results<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>>
::operator[](local_30,1);
std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>::str();
}
else {
std::__cxx11::string::string((string *)this);
}
std::__cxx11::
match_results<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>>
::~match_results(local_30);
return this;
}
|
|
63,673
|
js_alloc_string_rt
|
bluesky950520[P]quickjs/quickjs.c
|
static JSString *js_alloc_string_rt(JSRuntime *rt, int max_len, int is_wide_char)
{
JSString *str;
str = js_malloc_rt(rt, sizeof(JSString) + (max_len << is_wide_char) + 1 - is_wide_char);
if (unlikely(!str))
return NULL;
str->header.ref_count = 1;
str->is_wide_char = is_wide_char;
str->len = max_len;
str->atom_type = 0;
str->hash = 0; /* optional but costless */
str->hash_next = 0; /* optional */
#ifdef DUMP_LEAKS
list_add_tail(&str->link, &rt->string_list);
#endif
return str;
}
|
O0
|
c
|
js_alloc_string_rt:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %eax
movl 0x10(%rsp), %ecx
shll %cl, %eax
movslq %eax, %rsi
addq $0x18, %rsi
addq $0x1, %rsi
movslq 0x10(%rsp), %rax
subq %rax, %rsi
callq 0x205d0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x5c2c7
movq $0x0, 0x20(%rsp)
jmp 0x5c374
movq 0x8(%rsp), %rax
movl $0x1, (%rax)
movl 0x10(%rsp), %eax
movb %al, %cl
movq 0x8(%rsp), %rax
movzbl %cl, %ecx
movl %ecx, %edx
movq 0x4(%rax), %rcx
andq $0x1, %rdx
shlq $0x1f, %rdx
movabsq $-0x80000001, %rsi # imm = 0xFFFFFFFF7FFFFFFF
andq %rsi, %rcx
orq %rdx, %rcx
movq %rcx, 0x4(%rax)
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, %ecx
movl %ecx, %edx
movq 0x4(%rax), %rcx
andq $0x7fffffff, %rdx # imm = 0x7FFFFFFF
andq $-0x80000000, %rcx # imm = 0x80000000
orq %rdx, %rcx
movq %rcx, 0x4(%rax)
movq 0x8(%rsp), %rax
movabsq $0x3fffffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFFFF
andq 0x4(%rax), %rcx
orq $0x0, %rcx
movq %rcx, 0x4(%rax)
movq 0x8(%rsp), %rax
movabsq $-0x3fffffff00000001, %rcx # imm = 0xC0000000FFFFFFFF
andq 0x4(%rax), %rcx
orq $0x0, %rcx
movq %rcx, 0x4(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0xc(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
|
js_alloc_string_rt:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov [rsp+28h+var_14], esi
mov [rsp+28h+var_18], edx
mov rdi, [rsp+28h+var_10]
mov eax, [rsp+28h+var_14]
mov ecx, [rsp+28h+var_18]
shl eax, cl
movsxd rsi, eax
add rsi, 18h
add rsi, 1
movsxd rax, [rsp+28h+var_18]
sub rsi, rax
call js_malloc_rt
mov [rsp+28h+var_20], rax
cmp [rsp+28h+var_20], 0
setnz al
xor al, 0FFh
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_5C2C7
mov [rsp+28h+var_8], 0
jmp loc_5C374
loc_5C2C7:
mov rax, [rsp+28h+var_20]
mov dword ptr [rax], 1
mov eax, [rsp+28h+var_18]
mov cl, al
mov rax, [rsp+28h+var_20]
movzx ecx, cl
mov edx, ecx
mov rcx, [rax+4]
and rdx, 1
shl rdx, 1Fh
mov rsi, 0FFFFFFFF7FFFFFFFh
and rcx, rsi
or rcx, rdx
mov [rax+4], rcx
mov ecx, [rsp+28h+var_14]
mov rax, [rsp+28h+var_20]
mov ecx, ecx
mov edx, ecx
mov rcx, [rax+4]
and rdx, 7FFFFFFFh
and rcx, 0FFFFFFFF80000000h
or rcx, rdx
mov [rax+4], rcx
mov rax, [rsp+28h+var_20]
mov rcx, 3FFFFFFFFFFFFFFFh
and rcx, [rax+4]
or rcx, 0
mov [rax+4], rcx
mov rax, [rsp+28h+var_20]
mov rcx, 0C0000000FFFFFFFFh
and rcx, [rax+4]
or rcx, 0
mov [rax+4], rcx
mov rax, [rsp+28h+var_20]
mov dword ptr [rax+0Ch], 0
mov rax, [rsp+28h+var_20]
mov [rsp+28h+var_8], rax
loc_5C374:
mov rax, [rsp+28h+var_8]
add rsp, 28h
retn
|
long long js_alloc_string_rt(long long a1, int a2, int a3)
{
long long v4; // [rsp+8h] [rbp-20h]
char v5; // [rsp+10h] [rbp-18h]
v5 = a3;
v4 = js_malloc_rt(a1, (a2 << a3) + 25LL - a3);
if ( !v4 )
return 0LL;
*(_DWORD *)v4 = 1;
*(_QWORD *)(v4 + 4) = ((unsigned long long)(v5 & 1) << 31) | *(_QWORD *)(v4 + 4) & 0xFFFFFFFF7FFFFFFFLL;
*(_QWORD *)(v4 + 4) = a2 & 0x7FFFFFFF | *(_QWORD *)(v4 + 4) & 0xFFFFFFFF80000000LL;
*(_QWORD *)(v4 + 4) &= 0x3FFFFFFFFFFFFFFFuLL;
*(_QWORD *)(v4 + 4) &= 0xC0000000FFFFFFFFLL;
*(_DWORD *)(v4 + 12) = 0;
return v4;
}
|
js_alloc_string_rt:
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
MOV dword ptr [RSP + 0x14],ESI
MOV dword ptr [RSP + 0x10],EDX
MOV RDI,qword ptr [RSP + 0x18]
MOV EAX,dword ptr [RSP + 0x14]
MOV ECX,dword ptr [RSP + 0x10]
SHL EAX,CL
MOVSXD RSI,EAX
ADD RSI,0x18
ADD RSI,0x1
MOVSXD RAX,dword ptr [RSP + 0x10]
SUB RSI,RAX
CALL 0x001205d0
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x8],0x0
SETNZ AL
XOR AL,0xff
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0015c2c7
MOV qword ptr [RSP + 0x20],0x0
JMP 0x0015c374
LAB_0015c2c7:
MOV RAX,qword ptr [RSP + 0x8]
MOV dword ptr [RAX],0x1
MOV EAX,dword ptr [RSP + 0x10]
MOV CL,AL
MOV RAX,qword ptr [RSP + 0x8]
MOVZX ECX,CL
MOV EDX,ECX
MOV RCX,qword ptr [RAX + 0x4]
AND RDX,0x1
SHL RDX,0x1f
MOV RSI,-0x80000001
AND RCX,RSI
OR RCX,RDX
MOV qword ptr [RAX + 0x4],RCX
MOV ECX,dword ptr [RSP + 0x14]
MOV RAX,qword ptr [RSP + 0x8]
MOV ECX,ECX
MOV EDX,ECX
MOV RCX,qword ptr [RAX + 0x4]
AND RDX,0x7fffffff
AND RCX,-0x80000000
OR RCX,RDX
MOV qword ptr [RAX + 0x4],RCX
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,0x3fffffffffffffff
AND RCX,qword ptr [RAX + 0x4]
OR RCX,0x0
MOV qword ptr [RAX + 0x4],RCX
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,-0x3fffffff00000001
AND RCX,qword ptr [RAX + 0x4]
OR RCX,0x0
MOV qword ptr [RAX + 0x4],RCX
MOV RAX,qword ptr [RSP + 0x8]
MOV dword ptr [RAX + 0xc],0x0
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x20],RAX
LAB_0015c374:
MOV RAX,qword ptr [RSP + 0x20]
ADD RSP,0x28
RET
|
int4 * js_alloc_string_rt(int8 param_1,uint param_2,uint param_3)
{
int4 *local_8;
local_8 = (int4 *)
js_malloc_rt(param_1,((long)(int)(param_2 << ((byte)param_3 & 0x1f)) + 0x19) -
(long)(int)param_3);
if (local_8 == (int4 *)0x0) {
local_8 = (int4 *)0x0;
}
else {
*local_8 = 1;
*(ulong *)(local_8 + 1) =
*(ulong *)(local_8 + 1) & 0xffffffff7fffffff | ((ulong)(param_3 & 0xff) & 1) << 0x1f;
*(ulong *)(local_8 + 1) =
*(ulong *)(local_8 + 1) & 0xffffffff80000000 | (ulong)param_2 & 0x7fffffff;
*(ulong *)(local_8 + 1) = *(ulong *)(local_8 + 1) & 0x3fffffffffffffff;
*(ulong *)(local_8 + 1) = *(ulong *)(local_8 + 1) & 0xc0000000ffffffff;
local_8[3] = 0;
}
return local_8;
}
|
|
63,674
|
js_alloc_string_rt
|
bluesky950520[P]quickjs/quickjs.c
|
static JSString *js_alloc_string_rt(JSRuntime *rt, int max_len, int is_wide_char)
{
JSString *str;
str = js_malloc_rt(rt, sizeof(JSString) + (max_len << is_wide_char) + 1 - is_wide_char);
if (unlikely(!str))
return NULL;
str->header.ref_count = 1;
str->is_wide_char = is_wide_char;
str->len = max_len;
str->atom_type = 0;
str->hash = 0; /* optional but costless */
str->hash_next = 0; /* optional */
#ifdef DUMP_LEAKS
list_add_tail(&str->link, &rt->string_list);
#endif
return str;
}
|
O1
|
c
|
js_alloc_string_rt:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %ebx
movl %esi, %eax
movl %ebp, %ecx
shll %cl, %eax
movslq %eax, %rsi
movl %edx, %eax
subq %rax, %rsi
addq $0x19, %rsi
callq 0xece0
testq %rax, %rax
je 0x10994
movl $0x1, (%rax)
shll $0x1f, %ebp
andl $0x7fffffff, %ebx # imm = 0x7FFFFFFF
orl %ebp, %ebx
movq %rbx, 0x4(%rax)
andl $0x0, 0xc(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %eax, %eax
jmp 0x1098d
|
js_alloc_string_rt:
push rbp
push rbx
push rax
mov ebp, edx
mov ebx, esi
mov eax, esi
mov ecx, ebp
shl eax, cl
movsxd rsi, eax
mov eax, edx
sub rsi, rax
add rsi, 19h
call js_malloc_rt
test rax, rax
jz short loc_10994
mov dword ptr [rax], 1
shl ebp, 1Fh
and ebx, 7FFFFFFFh
or ebx, ebp
mov [rax+4], rbx
and dword ptr [rax+0Ch], 0
loc_1098D:
add rsp, 8
pop rbx
pop rbp
retn
loc_10994:
xor eax, eax
jmp short loc_1098D
|
long long js_alloc_string_rt(long long a1, int a2, unsigned int a3)
{
long long result; // rax
result = js_malloc_rt(a1, (a2 << a3) - (unsigned long long)a3 + 25);
if ( !result )
return 0LL;
*(_DWORD *)result = 1;
*(_QWORD *)(result + 4) = (a3 << 31) | a2 & 0x7FFFFFFF;
*(_DWORD *)(result + 12) = 0;
return result;
}
|
js_alloc_string_rt:
PUSH RBP
PUSH RBX
PUSH RAX
MOV EBP,EDX
MOV EBX,ESI
MOV EAX,ESI
MOV ECX,EBP
SHL EAX,CL
MOVSXD RSI,EAX
MOV EAX,EDX
SUB RSI,RAX
ADD RSI,0x19
CALL 0x0010ece0
TEST RAX,RAX
JZ 0x00110994
MOV dword ptr [RAX],0x1
SHL EBP,0x1f
AND EBX,0x7fffffff
OR EBX,EBP
MOV qword ptr [RAX + 0x4],RBX
AND dword ptr [RAX + 0xc],0x0
LAB_0011098d:
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_00110994:
XOR EAX,EAX
JMP 0x0011098d
|
int4 * js_alloc_string_rt(int8 param_1,uint param_2,uint param_3)
{
int4 *puVar1;
puVar1 = (int4 *)
js_malloc_rt(param_1,((long)(int)(param_2 << ((byte)param_3 & 0x1f)) - (ulong)param_3) +
0x19);
if (puVar1 == (int4 *)0x0) {
puVar1 = (int4 *)0x0;
}
else {
*puVar1 = 1;
*(ulong *)(puVar1 + 1) = (ulong)(param_2 & 0x7fffffff | param_3 << 0x1f);
puVar1[3] = 0;
}
return puVar1;
}
|
|
63,675
|
js_alloc_string_rt
|
bluesky950520[P]quickjs/quickjs.c
|
static JSString *js_alloc_string_rt(JSRuntime *rt, int max_len, int is_wide_char)
{
JSString *str;
str = js_malloc_rt(rt, sizeof(JSString) + (max_len << is_wide_char) + 1 - is_wide_char);
if (unlikely(!str))
return NULL;
str->header.ref_count = 1;
str->is_wide_char = is_wide_char;
str->len = max_len;
str->atom_type = 0;
str->hash = 0; /* optional but costless */
str->hash_next = 0; /* optional */
#ifdef DUMP_LEAKS
list_add_tail(&str->link, &rt->string_list);
#endif
return str;
}
|
O3
|
c
|
js_alloc_string_rt:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %ebx
movl %esi, %eax
movl %ebp, %ecx
shll %cl, %eax
movslq %eax, %rsi
movl %edx, %eax
subq %rax, %rsi
addq $0x19, %rsi
callq 0xecff
testq %rax, %rax
je 0x10c7a
movl $0x1, (%rax)
shll $0x1f, %ebp
andl $0x7fffffff, %ebx # imm = 0x7FFFFFFF
orl %ebp, %ebx
movq %rbx, 0x4(%rax)
andl $0x0, 0xc(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
js_alloc_string_rt:
push rbp
push rbx
push rax
mov ebp, edx
mov ebx, esi
mov eax, esi
mov ecx, ebp
shl eax, cl
movsxd rsi, eax
mov eax, edx
sub rsi, rax
add rsi, 19h
call js_malloc_rt
test rax, rax
jz short loc_10C7A
mov dword ptr [rax], 1
shl ebp, 1Fh
and ebx, 7FFFFFFFh
or ebx, ebp
mov [rax+4], rbx
and dword ptr [rax+0Ch], 0
loc_10C7A:
add rsp, 8
pop rbx
pop rbp
retn
|
long long js_alloc_string_rt(long long a1, int a2, unsigned int a3)
{
long long result; // rax
result = js_malloc_rt(a1, (a2 << a3) - (unsigned long long)a3 + 25);
if ( result )
{
*(_DWORD *)result = 1;
*(_QWORD *)(result + 4) = (a3 << 31) | a2 & 0x7FFFFFFF;
*(_DWORD *)(result + 12) = 0;
}
return result;
}
|
js_alloc_string_rt:
PUSH RBP
PUSH RBX
PUSH RAX
MOV EBP,EDX
MOV EBX,ESI
MOV EAX,ESI
MOV ECX,EBP
SHL EAX,CL
MOVSXD RSI,EAX
MOV EAX,EDX
SUB RSI,RAX
ADD RSI,0x19
CALL 0x0010ecff
TEST RAX,RAX
JZ 0x00110c7a
MOV dword ptr [RAX],0x1
SHL EBP,0x1f
AND EBX,0x7fffffff
OR EBX,EBP
MOV qword ptr [RAX + 0x4],RBX
AND dword ptr [RAX + 0xc],0x0
LAB_00110c7a:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void js_alloc_string_rt(int8 param_1,uint param_2,uint param_3)
{
int4 *puVar1;
puVar1 = (int4 *)
js_malloc_rt(param_1,((long)(int)(param_2 << ((byte)param_3 & 0x1f)) - (ulong)param_3) +
0x19);
if (puVar1 != (int4 *)0x0) {
*puVar1 = 1;
*(ulong *)(puVar1 + 1) = (ulong)(param_2 & 0x7fffffff | param_3 << 0x1f);
puVar1[3] = 0;
}
return;
}
|
|
63,676
|
js_regexp_compile
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_regexp_compile(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSRegExp *re1, *re;
JSValue pattern1, flags1;
JSValue bc, pattern;
re = js_get_regexp(ctx, this_val, TRUE);
if (!re)
return JS_EXCEPTION;
pattern1 = argv[0];
flags1 = argv[1];
re1 = js_get_regexp(ctx, pattern1, FALSE);
if (re1) {
if (!JS_IsUndefined(flags1))
return JS_ThrowTypeError(ctx, "flags must be undefined");
pattern = js_dup(JS_MKPTR(JS_TAG_STRING, re1->pattern));
bc = js_dup(JS_MKPTR(JS_TAG_STRING, re1->bytecode));
} else {
bc = JS_UNDEFINED;
if (JS_IsUndefined(pattern1))
pattern = JS_AtomToString(ctx, JS_ATOM_empty_string);
else
pattern = JS_ToString(ctx, pattern1);
if (JS_IsException(pattern))
goto fail;
bc = js_compile_regexp(ctx, pattern, flags1);
if (JS_IsException(bc))
goto fail;
}
JS_FreeValue(ctx, JS_MKPTR(JS_TAG_STRING, re->pattern));
JS_FreeValue(ctx, JS_MKPTR(JS_TAG_STRING, re->bytecode));
re->pattern = JS_VALUE_GET_STRING(pattern);
re->bytecode = JS_VALUE_GET_STRING(bc);
if (JS_SetProperty(ctx, this_val, JS_ATOM_lastIndex,
js_int32(0)) < 0)
return JS_EXCEPTION;
return js_dup(this_val);
fail:
JS_FreeValue(ctx, pattern);
JS_FreeValue(ctx, bc);
return JS_EXCEPTION;
}
|
O3
|
c
|
js_regexp_compile:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rdi, %r14
cmpl $-0x1, %ebx
jne 0x49eae
movq %rsi, %r15
cmpw $0x12, 0x6(%rsi)
jne 0x49eae
movq 0x8(%r8), %rdx
movq 0x10(%r8), %rcx
movq 0x18(%r8), %rbp
movl %edx, %eax
cmpq $0x3, %rax
je 0x49ef5
movq (%r8), %rsi
cmpl $-0x1, %eax
jne 0x49edd
cmpw $0x12, 0x6(%rsi)
jne 0x49edd
cmpl $0x3, %ebp
jne 0x4a052
movq 0x30(%rsi), %r12
incl (%r12)
movq 0x38(%rsi), %rax
movq %rax, %r13
incl (%rax)
jmp 0x49fae
movq %r14, %rdi
movl $0x12, %esi
callq 0x270bb
movl $0x6, %ebx
xorl %r12d, %r12d
xorl %eax, %eax
orq %rax, %r12
movq %r12, %rax
movq %rbx, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rcx, %r12
xorl %ecx, %ecx
callq 0x27518
movq %r12, %rcx
movq %rax, %r12
movq %rdx, %r13
jmp 0x49f0f
movq 0x18(%r14), %rax
movq 0x68(%rax), %rax
movq 0x178(%rax), %r12
incl (%r12)
movq $-0x7, %r13
cmpl $0x6, %r13d
jne 0x49f21
movl $0x3, %ebp
xorl %r15d, %r15d
xorl %eax, %eax
jmp 0x49f47
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %r8
callq 0x33773
movq %rdx, %rbp
cmpl $0x6, %ebp
jne 0x49fab
movabsq $-0x100000000, %r15 # imm = 0xFFFFFFFF00000000
andq %rax, %r15
movq 0x18(%r14), %rdi
cmpl $-0x9, %r13d
jb 0x49f76
movl (%r12), %edx
leal -0x1(%rdx), %ecx
movl %ecx, (%r12)
cmpl $0x1, %edx
jg 0x49f76
movq %rax, %rbx
movq %r12, %rsi
movq %r13, %rdx
callq 0x20d90
movq %rbx, %rax
movq 0x18(%r14), %rdi
movl $0x6, %ebx
cmpl $-0x9, %ebp
jb 0x49ec0
movl %eax, %eax
orq %rax, %r15
movl (%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%r15)
cmpl $0x1, %eax
jg 0x49ec0
movq %r15, %rsi
movq %rbp, %rdx
callq 0x20d90
jmp 0x49ec0
movq %rax, %r13
movq 0x30(%r15), %rsi
movq 0x18(%r14), %rdi
movl (%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %eax
jg 0x49fd2
movq $-0x7, %rdx
callq 0x20d90
movq 0x18(%r14), %rdi
movq 0x38(%r15), %rsi
movl (%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %eax
jg 0x49fee
movq $-0x7, %rdx
callq 0x20d90
movq %r12, 0x30(%r15)
movq %r13, 0x38(%r15)
movq %r15, 0x28(%rsp)
movq %rbx, 0x30(%rsp)
movups 0x28(%rsp), %xmm0
movups %xmm0, (%rsp)
movq $0x0, 0x18(%rsp)
movl $0x4000, 0x10(%rsp) # imm = 0x4000
xorl %r12d, %r12d
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movl $0x56, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x23d7f
testl %eax, %eax
js 0x4a066
incl (%r15)
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
andq %r15, %rax
movl %r15d, %r12d
jmp 0x49ec5
leaq 0x57422(%rip), %rsi # 0xa147b
xorl %r12d, %r12d
movq %r14, %rdi
xorl %eax, %eax
callq 0x2214f
movl $0x6, %ebx
jmp 0x49ec3
|
js_regexp_compile:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov rbx, rdx
mov r14, rdi
cmp ebx, 0FFFFFFFFh
jnz short loc_49EAE
mov r15, rsi
cmp word ptr [rsi+6], 12h
jnz short loc_49EAE
mov rdx, [r8+8]
mov rcx, [r8+10h]
mov rbp, [r8+18h]
mov eax, edx
cmp rax, 3
jz short loc_49EF5
mov rsi, [r8]
cmp eax, 0FFFFFFFFh
jnz short loc_49EDD
cmp word ptr [rsi+6], 12h
jnz short loc_49EDD
cmp ebp, 3
jnz loc_4A052
mov r12, [rsi+30h]
inc dword ptr [r12]
mov rax, [rsi+38h]
mov r13, rax
inc dword ptr [rax]
jmp loc_49FAE
loc_49EAE:
mov rdi, r14
mov esi, 12h
call JS_ThrowTypeErrorInvalidClass
mov ebx, 6
loc_49EC0:
xor r12d, r12d
loc_49EC3:
xor eax, eax
loc_49EC5:
or r12, rax
mov rax, r12
mov rdx, rbx
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_49EDD:
mov rdi, r14
mov r12, rcx
xor ecx, ecx
call JS_ToStringInternal
mov rcx, r12
mov r12, rax
mov r13, rdx
jmp short loc_49F0F
loc_49EF5:
mov rax, [r14+18h]
mov rax, [rax+68h]
mov r12, [rax+178h]
inc dword ptr [r12]
mov r13, 0FFFFFFFFFFFFFFF9h
loc_49F0F:
cmp r13d, 6
jnz short loc_49F21
mov ebp, 3
xor r15d, r15d
xor eax, eax
jmp short loc_49F47
loc_49F21:
mov rdi, r14
mov rsi, r12
mov rdx, r13
mov r8, rbp
call js_compile_regexp
mov rbp, rdx
cmp ebp, 6
jnz short loc_49FAB
mov r15, 0FFFFFFFF00000000h
and r15, rax
loc_49F47:
mov rdi, [r14+18h]
cmp r13d, 0FFFFFFF7h
jb short loc_49F76
mov edx, [r12]
lea ecx, [rdx-1]
mov [r12], ecx
cmp edx, 1
jg short loc_49F76
mov rbx, rax
mov rsi, r12
mov rdx, r13
call js_free_value_rt
mov rax, rbx
mov rdi, [r14+18h]
loc_49F76:
mov ebx, 6
cmp ebp, 0FFFFFFF7h
jb loc_49EC0
mov eax, eax
or r15, rax
mov eax, [r15]
lea ecx, [rax-1]
mov [r15], ecx
cmp eax, 1
jg loc_49EC0
mov rsi, r15
mov rdx, rbp
call js_free_value_rt
jmp loc_49EC0
loc_49FAB:
mov r13, rax
loc_49FAE:
mov rsi, [r15+30h]
mov rdi, [r14+18h]
mov eax, [rsi]
lea ecx, [rax-1]
mov [rsi], ecx
cmp eax, 1
jg short loc_49FD2
mov rdx, 0FFFFFFFFFFFFFFF9h
call js_free_value_rt
mov rdi, [r14+18h]
loc_49FD2:
mov rsi, [r15+38h]
mov eax, [rsi]
lea ecx, [rax-1]
mov [rsi], ecx
cmp eax, 1
jg short loc_49FEE
mov rdx, 0FFFFFFFFFFFFFFF9h
call js_free_value_rt
loc_49FEE:
mov [r15+30h], r12
mov [r15+38h], r13
mov qword ptr [rsp+68h+var_40], r15
mov qword ptr [rsp+68h+var_40+8], rbx
movups xmm0, [rsp+68h+var_40]
movups [rsp+68h+var_68], xmm0
mov [rsp+68h+var_50], 0
mov [rsp+68h+var_58], 4000h
xor r12d, r12d
mov rdi, r14
mov rsi, r15
mov rdx, rbx
mov ecx, 56h ; 'V'
xor r8d, r8d
xor r9d, r9d
call JS_SetPropertyInternal2
test eax, eax
js short loc_4A066
inc dword ptr [r15]
mov rax, 0FFFFFFFF00000000h
and rax, r15
mov r12d, r15d
jmp loc_49EC5
loc_4A052:
lea rsi, aFlagsMustBeUnd; "flags must be undefined"
xor r12d, r12d
mov rdi, r14
xor eax, eax
call JS_ThrowTypeError
loc_4A066:
mov ebx, 6
jmp loc_49EC3
|
unsigned long long js_regexp_compile(
long long a1,
long long 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 v17; // rdx
_DWORD *v18; // rcx
long long v19; // rbp
long long v20; // rsi
int *v21; // r12
_DWORD *v22; // r13
long long v23; // r12
unsigned long long v24; // rax
_DWORD *v26; // r12
unsigned long long v27; // rax
long long v28; // rdx
long long v29; // r13
long long v30; // rbp
unsigned long long v31; // r15
unsigned long long v32; // rax
long long v33; // rdx
long long v34; // rdi
int v35; // edx
long long v36; // rcx
int v37; // ebx
_QWORD *v38; // r15
int v39; // eax
long long v40; // rcx
_QWORD *v41; // rsi
long long v42; // rdi
int v43; // eax
long long v44; // rcx
_QWORD *v45; // rsi
int v46; // eax
long long v47; // rcx
char v48; // [rsp+0h] [rbp-68h]
__m128 v49; // [rsp+28h] [rbp-40h]
if ( (_DWORD)a3 != -1 || *(_WORD *)(a2 + 6) != 18 )
{
JS_ThrowTypeErrorInvalidClass(a1, 18, a4, a5, a6, a7, *(double *)a8.m128_u64, *(double *)a9.m128_u64, a10, a11);
LABEL_9:
v23 = 0LL;
goto LABEL_10;
}
v17 = a13[1];
v18 = (_DWORD *)a13[2];
v19 = a13[3];
if ( (unsigned int)v17 == 3LL )
{
v21 = *(int **)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 104LL) + 376LL);
++*v21;
v29 = -7LL;
}
else
{
v20 = *a13;
if ( (_DWORD)v17 == -1 && *(_WORD *)(v20 + 6) == 18 )
{
if ( (_DWORD)v19 != 3 )
{
v23 = 0LL;
JS_ThrowTypeError(
a1,
(long long)"flags must be undefined",
v17,
(long long)v18,
(long long)a13,
a14,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
v48);
goto LABEL_10;
}
v21 = *(int **)(v20 + 48);
++*v21;
v22 = *(_DWORD **)(v20 + 56);
++*v22;
goto LABEL_25;
}
v26 = (_DWORD *)a13[2];
v27 = JS_ToStringInternal(a1, (_DWORD *)v20, v17, 0LL, (long long)a13, a14, a4, a5, a6, a7, a8, a9, a10, a11);
v18 = v26;
v21 = (int *)v27;
v29 = v28;
}
if ( (_DWORD)v29 == 6 )
{
v30 = 3LL;
v31 = 0LL;
LODWORD(v32) = 0;
goto LABEL_18;
}
v32 = js_compile_regexp(
a1,
v21,
v29,
v18,
v19,
a4,
a5,
a6,
a7,
*(double *)a8.m128_u64,
*(double *)a9.m128_u64,
a10,
a11);
v30 = v33;
if ( (_DWORD)v33 == 6 )
{
v31 = v32 & 0xFFFFFFFF00000000LL;
LABEL_18:
v34 = *(_QWORD *)(a1 + 24);
if ( (unsigned int)v29 >= 0xFFFFFFF7 )
{
v35 = *v21;
v36 = (unsigned int)(*v21 - 1);
*v21 = v36;
if ( v35 <= 1 )
{
v37 = v32;
js_free_value_rt(v34, v21, v29, v36, (long long)a13, a14);
LODWORD(v32) = v37;
v34 = *(_QWORD *)(a1 + 24);
}
}
if ( (unsigned int)v30 >= 0xFFFFFFF7 )
{
v38 = (_QWORD *)((unsigned int)v32 | v31);
v39 = *(_DWORD *)v38;
v40 = (unsigned int)(*(_DWORD *)v38 - 1);
*(_DWORD *)v38 = v40;
if ( v39 <= 1 )
js_free_value_rt(v34, v38, v30, v40, (long long)a13, a14);
}
goto LABEL_9;
}
v22 = (_DWORD *)v32;
LABEL_25:
v41 = *(_QWORD **)(a2 + 48);
v42 = *(_QWORD *)(a1 + 24);
v43 = *(_DWORD *)v41;
v44 = (unsigned int)(*(_DWORD *)v41 - 1);
*(_DWORD *)v41 = v44;
if ( v43 <= 1 )
{
js_free_value_rt(v42, v41, -7LL, v44, (long long)a13, a14);
v42 = *(_QWORD *)(a1 + 24);
}
v45 = *(_QWORD **)(a2 + 56);
v46 = *(_DWORD *)v45;
v47 = (unsigned int)(*(_DWORD *)v45 - 1);
*(_DWORD *)v45 = v47;
if ( v46 <= 1 )
js_free_value_rt(v42, v45, -7LL, v47, (long long)a13, a14);
*(_QWORD *)(a2 + 48) = v21;
*(_QWORD *)(a2 + 56) = v22;
v49.m128_u64[0] = a2;
v49.m128_u64[1] = a3;
v23 = 0LL;
if ( (int)JS_SetPropertyInternal2(
a1,
a2,
a3,
0x56u,
0LL,
0LL,
v49,
a5,
a6,
a7,
*(double *)a8.m128_u64,
*(double *)a9.m128_u64,
a10,
a11,
a2,
a3,
0x4000u,
0LL) >= 0 )
{
++*(_DWORD *)a2;
v24 = a2 & 0xFFFFFFFF00000000LL;
v23 = (unsigned int)a2;
return v24 | v23;
}
LABEL_10:
v24 = 0LL;
return v24 | v23;
}
|
js_regexp_compile:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RBX,RDX
MOV R14,RDI
CMP EBX,-0x1
JNZ 0x00149eae
MOV R15,RSI
CMP word ptr [RSI + 0x6],0x12
JNZ 0x00149eae
MOV RDX,qword ptr [R8 + 0x8]
MOV RCX,qword ptr [R8 + 0x10]
MOV RBP,qword ptr [R8 + 0x18]
MOV EAX,EDX
CMP RAX,0x3
JZ 0x00149ef5
MOV RSI,qword ptr [R8]
CMP EAX,-0x1
JNZ 0x00149edd
CMP word ptr [RSI + 0x6],0x12
JNZ 0x00149edd
CMP EBP,0x3
JNZ 0x0014a052
MOV R12,qword ptr [RSI + 0x30]
INC dword ptr [R12]
MOV RAX,qword ptr [RSI + 0x38]
MOV R13,RAX
INC dword ptr [RAX]
JMP 0x00149fae
LAB_00149eae:
MOV RDI,R14
MOV ESI,0x12
CALL 0x001270bb
MOV EBX,0x6
LAB_00149ec0:
XOR R12D,R12D
LAB_00149ec3:
XOR EAX,EAX
LAB_00149ec5:
OR R12,RAX
MOV RAX,R12
MOV RDX,RBX
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00149edd:
MOV RDI,R14
MOV R12,RCX
XOR ECX,ECX
CALL 0x00127518
MOV RCX,R12
MOV R12,RAX
MOV R13,RDX
JMP 0x00149f0f
LAB_00149ef5:
MOV RAX,qword ptr [R14 + 0x18]
MOV RAX,qword ptr [RAX + 0x68]
MOV R12,qword ptr [RAX + 0x178]
INC dword ptr [R12]
MOV R13,-0x7
LAB_00149f0f:
CMP R13D,0x6
JNZ 0x00149f21
MOV EBP,0x3
XOR R15D,R15D
XOR EAX,EAX
JMP 0x00149f47
LAB_00149f21:
MOV RDI,R14
MOV RSI,R12
MOV RDX,R13
MOV R8,RBP
CALL 0x00133773
MOV RBP,RDX
CMP EBP,0x6
JNZ 0x00149fab
MOV R15,-0x100000000
AND R15,RAX
LAB_00149f47:
MOV RDI,qword ptr [R14 + 0x18]
CMP R13D,-0x9
JC 0x00149f76
MOV EDX,dword ptr [R12]
LEA ECX,[RDX + -0x1]
MOV dword ptr [R12],ECX
CMP EDX,0x1
JG 0x00149f76
MOV RBX,RAX
MOV RSI,R12
MOV RDX,R13
CALL 0x00120d90
MOV RAX,RBX
MOV RDI,qword ptr [R14 + 0x18]
LAB_00149f76:
MOV EBX,0x6
CMP EBP,-0x9
JC 0x00149ec0
MOV EAX,EAX
OR R15,RAX
MOV EAX,dword ptr [R15]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R15],ECX
CMP EAX,0x1
JG 0x00149ec0
MOV RSI,R15
MOV RDX,RBP
CALL 0x00120d90
JMP 0x00149ec0
LAB_00149fab:
MOV R13,RAX
LAB_00149fae:
MOV RSI,qword ptr [R15 + 0x30]
MOV RDI,qword ptr [R14 + 0x18]
MOV EAX,dword ptr [RSI]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSI],ECX
CMP EAX,0x1
JG 0x00149fd2
MOV RDX,-0x7
CALL 0x00120d90
MOV RDI,qword ptr [R14 + 0x18]
LAB_00149fd2:
MOV RSI,qword ptr [R15 + 0x38]
MOV EAX,dword ptr [RSI]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSI],ECX
CMP EAX,0x1
JG 0x00149fee
MOV RDX,-0x7
CALL 0x00120d90
LAB_00149fee:
MOV qword ptr [R15 + 0x30],R12
MOV qword ptr [R15 + 0x38],R13
MOV qword ptr [RSP + 0x28],R15
MOV qword ptr [RSP + 0x30],RBX
MOVUPS XMM0,xmmword ptr [RSP + 0x28]
MOVUPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x18],0x0
MOV dword ptr [RSP + 0x10],0x4000
XOR R12D,R12D
MOV RDI,R14
MOV RSI,R15
MOV RDX,RBX
MOV ECX,0x56
XOR R8D,R8D
XOR R9D,R9D
CALL 0x00123d7f
TEST EAX,EAX
JS 0x0014a066
INC dword ptr [R15]
MOV RAX,-0x100000000
AND RAX,R15
MOV R12D,R15D
JMP 0x00149ec5
LAB_0014a052:
LEA RSI,[0x1a147b]
XOR R12D,R12D
MOV RDI,R14
XOR EAX,EAX
CALL 0x0012214f
LAB_0014a066:
MOV EBX,0x6
JMP 0x00149ec3
|
int1 [16]
js_regexp_compile(long param_1,int *param_2,int8 param_3,int8 param_4,long *param_5)
{
long lVar1;
long lVar2;
long lVar3;
int *piVar4;
int iVar5;
ulong uVar6;
int8 uVar7;
ulong uVar8;
int *piVar9;
int *piVar10;
int1 auVar11 [16];
int1 auVar12 [16];
int4 local_40;
if (((int)param_3 == -1) && (*(short *)((long)param_2 + 6) == 0x12)) {
uVar6 = param_5[1];
lVar1 = param_5[2];
lVar2 = param_5[3];
if ((uVar6 & 0xffffffff) == 3) {
piVar10 = *(int **)(*(long *)(*(long *)(param_1 + 0x18) + 0x68) + 0x178);
*piVar10 = *piVar10 + 1;
auVar11._8_8_ = 0xfffffffffffffff9;
auVar11._0_8_ = piVar10;
LAB_00149f0f:
piVar10 = auVar11._0_8_;
if (auVar11._8_4_ == 6) {
uVar6 = 0;
auVar12 = ZEXT816(3) << 0x40;
}
else {
auVar12 = js_compile_regexp(param_1,piVar10,auVar11._8_8_,lVar1,lVar2);
piVar9 = auVar12._0_8_;
if (auVar12._8_4_ != 6) goto LAB_00149fae;
uVar6 = (ulong)piVar9 & 0xffffffff00000000;
}
uVar7 = *(int8 *)(param_1 + 0x18);
if ((0xfffffff6 < auVar11._8_4_) && (iVar5 = *piVar10, *piVar10 = iVar5 + -1, iVar5 < 2)) {
js_free_value_rt(uVar7,piVar10,auVar11._8_8_);
uVar7 = *(int8 *)(param_1 + 0x18);
}
if (0xfffffff6 < auVar12._8_4_) {
piVar10 = (int *)(uVar6 | auVar12._0_8_ & 0xffffffff);
iVar5 = *piVar10;
*piVar10 = iVar5 + -1;
if (iVar5 < 2) {
js_free_value_rt(uVar7,piVar10,auVar12._8_8_);
}
}
}
else {
lVar3 = *param_5;
if (((int)uVar6 != -1) || (*(short *)(lVar3 + 6) != 0x12)) {
auVar11 = JS_ToStringInternal(param_1,lVar3,uVar6,0);
goto LAB_00149f0f;
}
if ((int)lVar2 != 3) {
JS_ThrowTypeError(param_1,"flags must be int");
goto LAB_00149ec3;
}
piVar10 = *(int **)(lVar3 + 0x30);
*piVar10 = *piVar10 + 1;
piVar9 = *(int **)(lVar3 + 0x38);
*piVar9 = *piVar9 + 1;
LAB_00149fae:
piVar4 = *(int **)(param_2 + 0xc);
uVar7 = *(int8 *)(param_1 + 0x18);
iVar5 = *piVar4;
*piVar4 = iVar5 + -1;
if (iVar5 < 2) {
js_free_value_rt(uVar7,piVar4,0xfffffffffffffff9);
uVar7 = *(int8 *)(param_1 + 0x18);
}
piVar4 = *(int **)(param_2 + 0xe);
iVar5 = *piVar4;
*piVar4 = iVar5 + -1;
if (iVar5 < 2) {
js_free_value_rt(uVar7,piVar4,0xfffffffffffffff9);
}
*(int **)(param_2 + 0xc) = piVar10;
*(int **)(param_2 + 0xe) = piVar9;
local_40 = SUB84(param_2,0);
iVar5 = JS_SetPropertyInternal2(param_1,param_2,param_3,0x56,0,0,local_40,0xffffffff,0x4000,0)
;
if (-1 < iVar5) {
*param_2 = *param_2 + 1;
uVar6 = (ulong)param_2 & 0xffffffff00000000;
uVar8 = (ulong)param_2 & 0xffffffff;
goto LAB_00149ec5;
}
}
}
else {
JS_ThrowTypeErrorInvalidClass(param_1,0x12);
}
LAB_00149ec3:
uVar8 = 0;
param_3 = 6;
uVar6 = 0;
LAB_00149ec5:
auVar12._8_8_ = param_3;
auVar12._0_8_ = uVar8 | uVar6;
return auVar12;
}
|
|
63,677
|
eth_get_final_hash
|
corpus-core[P]colibri-stateless/src/chains/eth/proofer/beacon.c
|
static inline c4_status_t eth_get_final_hash(proofer_ctx_t* ctx, bool safe, bytes32_t hash) {
json_t result = {0};
beacon_head_t hashes[2] = {0};
buffer_t buf_justified = {.allocated = -32, .data = {.data = hashes[0].root, .len = 0}};
buffer_t buf_finalized = {.allocated = -32, .data = {.data = hashes[1].root, .len = 0}};
// uint8_t* root = safe ? blockroot : blockroot + 32;
TRY_ASYNC(get_finality_check_points(ctx, &result));
json_get_bytes(json_get(result, "current_justified"), "root", &buf_justified);
json_get_bytes(json_get(result, "finalized"), "root", &buf_finalized);
#ifdef PROOFER_CACHE
bytes32_t key = {0};
sprintf((char*) key, FINALITY_KEY);
c4_proofer_cache_set(ctx, key, bytes_dup(bytes(hashes, sizeof(hashes))).data, sizeof(hashes), 1000 * 60 * 7, free); // 6 min
#endif
memcpy(hash, hashes[safe ? 0 : 1].root, 32);
return C4_SUCCESS;
}
|
O0
|
c
|
eth_get_final_hash:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x5110
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x5110
movl $0x0, -0xa8(%rbp)
leaq -0x90(%rbp), %rax
addq $0x8, %rax
movq %rax, -0xa0(%rbp)
movl $0xffffffe0, -0x98(%rbp) # imm = 0xFFFFFFE0
movl $0x0, -0xc0(%rbp)
leaq -0x90(%rbp), %rax
addq $0x28, %rax
addq $0x8, %rax
movq %rax, -0xb8(%rbp)
movl $0xffffffe0, -0xb0(%rbp) # imm = 0xFFFFFFE0
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xbdd0
movl %eax, -0xc4(%rbp)
cmpl $0x0, -0xc4(%rbp)
je 0xba28
movl -0xc4(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xbbaf
jmp 0xba2a
leaq -0xf8(%rbp), %rdi
leaq -0x38(%rbp), %rax
leaq 0x46ee7(%rip), %rsi # 0x52923
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x20500
leaq -0xe0(%rbp), %rdi
leaq -0xf8(%rbp), %rax
leaq 0x46e20(%rip), %rsi # 0x5288f
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x20500
leaq -0xe0(%rbp), %rax
leaq -0xa8(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x20a60
movl %eax, -0x108(%rbp)
movq %rdx, -0x100(%rbp)
leaq -0x138(%rbp), %rdi
leaq -0x38(%rbp), %rax
leaq 0x46e5d(%rip), %rsi # 0x52935
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x20500
leaq -0x120(%rbp), %rdi
leaq -0x138(%rbp), %rax
leaq 0x46d84(%rip), %rsi # 0x5288f
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x20500
leaq -0x120(%rbp), %rax
leaq -0xc0(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x20a60
movl %eax, -0x148(%rbp)
movq %rdx, -0x140(%rbp)
movq -0x20(%rbp), %rax
movb -0x11(%rbp), %sil
movl $0x1, %ecx
xorl %edx, %edx
testb $0x1, %sil
cmovnel %edx, %ecx
movslq %ecx, %rdx
leaq -0x90(%rbp), %rcx
imulq $0x28, %rdx, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rdx
movq %rdx, (%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x18(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x20(%rcx), %rcx
movq %rcx, 0x18(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x160, %rsp # imm = 0x160
popq %rbp
retq
nopl (%rax,%rax)
|
eth_get_final_hash:
push rbp
mov rbp, rsp
sub rsp, 160h
mov al, sil
mov [rbp+var_10], rdi
and al, 1
mov [rbp+var_11], al
mov [rbp+var_20], rdx
lea rdi, [rbp+var_38]
xor esi, esi
mov edx, 18h
call _memset
lea rdi, [rbp+var_90]
xor esi, esi
mov edx, 50h ; 'P'
call _memset
mov [rbp+var_A8], 0
lea rax, [rbp+var_90]
add rax, 8
mov [rbp+var_A0], rax
mov [rbp+var_98], 0FFFFFFE0h
mov [rbp+var_C0], 0
lea rax, [rbp+var_90]
add rax, 28h ; '('
add rax, 8
mov [rbp+var_B8], rax
mov [rbp+var_B0], 0FFFFFFE0h
mov rdi, [rbp+var_10]
lea rsi, [rbp+var_38]
call get_finality_check_points
mov [rbp+var_C4], eax
cmp [rbp+var_C4], 0
jz short loc_BA28
mov eax, [rbp+var_C4]
mov [rbp+var_4], eax
jmp loc_BBAF
loc_BA28:
jmp short $+2
loc_BA2A:
lea rdi, [rbp+var_F8]
lea rax, [rbp+var_38]
lea rsi, aCurrentJustifi; "current_justified"
mov rcx, [rax]
mov [rsp+160h+var_160], rcx
mov rcx, [rax+8]
mov [rsp+160h+var_158], rcx
mov rax, [rax+10h]
mov [rsp+160h+var_150], rax
call json_get
lea rdi, [rbp+var_E0]
lea rax, [rbp+var_F8]
lea rsi, aRoot; "root"
mov rcx, [rax]
mov [rsp+160h+var_160], rcx
mov rcx, [rax+8]
mov [rsp+160h+var_158], rcx
mov rax, [rax+10h]
mov [rsp+160h+var_150], rax
call json_get
lea rax, [rbp+var_E0]
lea rdi, [rbp+var_A8]
mov rcx, [rax]
mov [rsp+160h+var_160], rcx
mov rcx, [rax+8]
mov [rsp+160h+var_158], rcx
mov rax, [rax+10h]
mov [rsp+160h+var_150], rax
call json_as_bytes
mov [rbp+var_108], eax
mov [rbp+var_100], rdx
lea rdi, [rbp+var_138]
lea rax, [rbp+var_38]
lea rsi, aFinalized_0; "finalized"
mov rcx, [rax]
mov [rsp+160h+var_160], rcx
mov rcx, [rax+8]
mov [rsp+160h+var_158], rcx
mov rax, [rax+10h]
mov [rsp+160h+var_150], rax
call json_get
lea rdi, [rbp+var_120]
lea rax, [rbp+var_138]
lea rsi, aRoot; "root"
mov rcx, [rax]
mov [rsp+160h+var_160], rcx
mov rcx, [rax+8]
mov [rsp+160h+var_158], rcx
mov rax, [rax+10h]
mov [rsp+160h+var_150], rax
call json_get
lea rax, [rbp+var_120]
lea rdi, [rbp+var_C0]
mov rcx, [rax]
mov [rsp+160h+var_160], rcx
mov rcx, [rax+8]
mov [rsp+160h+var_158], rcx
mov rax, [rax+10h]
mov [rsp+160h+var_150], rax
call json_as_bytes
mov [rbp+var_148], eax
mov [rbp+var_140], rdx
mov rax, [rbp+var_20]
mov sil, [rbp+var_11]
mov ecx, 1
xor edx, edx
test sil, 1
cmovnz ecx, edx
movsxd rdx, ecx
lea rcx, [rbp+var_90]
imul rdx, 28h ; '('
add rcx, rdx
mov rdx, [rcx+8]
mov [rax], rdx
mov rdx, [rcx+10h]
mov [rax+8], rdx
mov rdx, [rcx+18h]
mov [rax+10h], rdx
mov rcx, [rcx+20h]
mov [rax+18h], rcx
mov [rbp+var_4], 0
loc_BBAF:
mov eax, [rbp+var_4]
add rsp, 160h
pop rbp
retn
|
long long eth_get_final_hash(long long a1, char a2, _QWORD *a3)
{
int v3; // edx
int v4; // r8d
int v5; // r9d
int v6; // edx
int v7; // r8d
int v8; // r9d
int v9; // edx
int v10; // r8d
int v11; // r9d
long long v12; // rdx
int v13; // r8d
int v14; // r9d
int v15; // edx
int v16; // r8d
int v17; // r9d
int v18; // edx
int v19; // r8d
int v20; // r9d
_QWORD *v21; // rax
long long v22; // rdx
long long v24; // [rsp+28h] [rbp-138h] BYREF
long long v25; // [rsp+30h] [rbp-130h]
long long v26; // [rsp+38h] [rbp-128h]
long long v27; // [rsp+40h] [rbp-120h] BYREF
long long v28; // [rsp+48h] [rbp-118h]
long long v29; // [rsp+50h] [rbp-110h]
int v30; // [rsp+58h] [rbp-108h]
long long v31; // [rsp+60h] [rbp-100h]
long long v32; // [rsp+68h] [rbp-F8h] BYREF
long long v33; // [rsp+70h] [rbp-F0h]
long long v34; // [rsp+78h] [rbp-E8h]
long long v35; // [rsp+80h] [rbp-E0h] BYREF
long long v36; // [rsp+88h] [rbp-D8h]
long long v37; // [rsp+90h] [rbp-D0h]
unsigned int v38; // [rsp+9Ch] [rbp-C4h]
int v39; // [rsp+A0h] [rbp-C0h] BYREF
long long *v40; // [rsp+A8h] [rbp-B8h]
int v41; // [rsp+B0h] [rbp-B0h]
int v42; // [rsp+B8h] [rbp-A8h] BYREF
long long *v43; // [rsp+C0h] [rbp-A0h]
int v44; // [rsp+C8h] [rbp-98h]
_BYTE v45[8]; // [rsp+D0h] [rbp-90h] BYREF
long long v46; // [rsp+D8h] [rbp-88h] BYREF
long long v47; // [rsp+100h] [rbp-60h] BYREF
long long v48; // [rsp+128h] [rbp-38h] BYREF
long long v49; // [rsp+130h] [rbp-30h]
long long v50; // [rsp+138h] [rbp-28h]
_QWORD *v51; // [rsp+140h] [rbp-20h]
char v52; // [rsp+14Fh] [rbp-11h]
long long v53; // [rsp+150h] [rbp-10h]
v53 = a1;
v52 = a2 & 1;
v51 = a3;
memset(&v48, 0LL, 24LL);
memset(v45, 0LL, 80LL);
v42 = 0;
v43 = &v46;
v44 = -32;
v39 = 0;
v40 = &v47;
v41 = -32;
v38 = get_finality_check_points(v53, &v48);
if ( v38 )
{
return v38;
}
else
{
json_get((unsigned int)&v32, (unsigned int)"current_justified", v3, v49, v4, v5, v48, v49, v50);
json_get((unsigned int)&v35, (unsigned int)"root", v6, v33, v7, v8, v32, v33, v34);
v30 = json_as_bytes((unsigned int)&v42, (unsigned int)"root", v9, v36, v10, v11, v35, v36, v37);
v31 = v12;
json_get((unsigned int)&v24, (unsigned int)"finalized", v12, v49, v13, v14, v48, v49, v50);
json_get((unsigned int)&v27, (unsigned int)"root", v15, v25, v16, v17, v24, v25, v26);
json_as_bytes((unsigned int)&v39, (unsigned int)"root", v18, v28, v19, v20, v27, v28, v29);
v21 = v51;
v22 = 40LL * ((v52 & 1) == 0);
*v51 = *(_QWORD *)&v45[v22 + 8];
v21[1] = *(_QWORD *)&v45[v22 + 16];
v21[2] = *(_QWORD *)&v45[v22 + 24];
v21[3] = *(_QWORD *)&v45[v22 + 32];
return 0;
}
}
|
eth_get_final_hash:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x160
MOV AL,SIL
MOV qword ptr [RBP + -0x10],RDI
AND AL,0x1
MOV byte ptr [RBP + -0x11],AL
MOV qword ptr [RBP + -0x20],RDX
LEA RDI,[RBP + -0x38]
XOR ESI,ESI
MOV EDX,0x18
CALL 0x00105110
LEA RDI,[RBP + -0x90]
XOR ESI,ESI
MOV EDX,0x50
CALL 0x00105110
MOV dword ptr [RBP + -0xa8],0x0
LEA RAX,[RBP + -0x90]
ADD RAX,0x8
MOV qword ptr [RBP + -0xa0],RAX
MOV dword ptr [RBP + -0x98],0xffffffe0
MOV dword ptr [RBP + -0xc0],0x0
LEA RAX,[RBP + -0x90]
ADD RAX,0x28
ADD RAX,0x8
MOV qword ptr [RBP + -0xb8],RAX
MOV dword ptr [RBP + -0xb0],0xffffffe0
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[RBP + -0x38]
CALL 0x0010bdd0
MOV dword ptr [RBP + -0xc4],EAX
CMP dword ptr [RBP + -0xc4],0x0
JZ 0x0010ba28
MOV EAX,dword ptr [RBP + -0xc4]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0010bbaf
LAB_0010ba28:
JMP 0x0010ba2a
LAB_0010ba2a:
LEA RDI,[RBP + -0xf8]
LEA RAX,[RBP + -0x38]
LEA RSI,[0x152923]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RCX
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x00120500
LEA RDI,[RBP + -0xe0]
LEA RAX,[RBP + -0xf8]
LEA RSI,[0x15288f]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RCX
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x00120500
LEA RAX,[RBP + -0xe0]
LEA RDI,[RBP + -0xa8]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RCX
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x00120a60
MOV dword ptr [RBP + -0x108],EAX
MOV qword ptr [RBP + -0x100],RDX
LEA RDI,[RBP + -0x138]
LEA RAX,[RBP + -0x38]
LEA RSI,[0x152935]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RCX
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x00120500
LEA RDI,[RBP + -0x120]
LEA RAX,[RBP + -0x138]
LEA RSI,[0x15288f]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RCX
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x00120500
LEA RAX,[RBP + -0x120]
LEA RDI,[RBP + -0xc0]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RCX
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x00120a60
MOV dword ptr [RBP + -0x148],EAX
MOV qword ptr [RBP + -0x140],RDX
MOV RAX,qword ptr [RBP + -0x20]
MOV SIL,byte ptr [RBP + -0x11]
MOV ECX,0x1
XOR EDX,EDX
TEST SIL,0x1
CMOVNZ ECX,EDX
MOVSXD RDX,ECX
LEA RCX,[RBP + -0x90]
IMUL RDX,RDX,0x28
ADD RCX,RDX
MOV RDX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX],RDX
MOV RDX,qword ptr [RCX + 0x10]
MOV qword ptr [RAX + 0x8],RDX
MOV RDX,qword ptr [RCX + 0x18]
MOV qword ptr [RAX + 0x10],RDX
MOV RCX,qword ptr [RCX + 0x20]
MOV qword ptr [RAX + 0x18],RCX
MOV dword ptr [RBP + -0x4],0x0
LAB_0010bbaf:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x160
POP RBP
RET
|
int eth_get_final_hash(int8 param_1,byte param_2,int8 *param_3)
{
int8 extraout_RDX;
long lVar1;
int1 local_140 [24];
int1 local_128 [24];
int4 local_110;
int8 local_108;
int1 local_100 [24];
int1 local_e8 [28];
int local_cc;
int4 local_c8 [2];
int1 *local_c0;
int4 local_b8;
int4 local_b0 [2];
int8 *local_a8;
int4 local_a0;
int1 local_98 [8];
int8 auStack_90 [5];
int1 auStack_68 [40];
int1 local_40 [24];
int8 *local_28;
byte local_19;
int8 local_18;
int local_c;
local_19 = param_2 & 1;
local_28 = param_3;
local_18 = param_1;
memset(local_40,0,0x18);
memset(local_98,0,0x50);
local_b0[0] = 0;
local_a8 = auStack_90;
local_a0 = 0xffffffe0;
local_c8[0] = 0;
local_c0 = auStack_68;
local_b8 = 0xffffffe0;
local_cc = get_finality_check_points(local_18,local_40);
local_c = local_cc;
if (local_cc == 0) {
json_get(local_100,"current_justified");
json_get(local_e8,&DAT_0015288f);
local_110 = json_as_bytes(local_b0);
local_108 = extraout_RDX;
json_get(local_140,"finalized");
json_get(local_128,&DAT_0015288f);
json_as_bytes(local_c8);
lVar1 = (long)(int)(uint)((local_19 & 1) == 0);
*local_28 = auStack_90[lVar1 * 5];
local_28[1] = auStack_90[lVar1 * 5 + 1];
local_28[2] = auStack_90[lVar1 * 5 + 2];
local_28[3] = *(int8 *)(auStack_68 + lVar1 * 0x28 + -0x10);
local_c = 0;
}
return local_c;
}
|
|
63,678
|
eth_get_final_hash
|
corpus-core[P]colibri-stateless/src/chains/eth/proofer/beacon.c
|
static inline c4_status_t eth_get_final_hash(proofer_ctx_t* ctx, bool safe, bytes32_t hash) {
json_t result = {0};
beacon_head_t hashes[2] = {0};
buffer_t buf_justified = {.allocated = -32, .data = {.data = hashes[0].root, .len = 0}};
buffer_t buf_finalized = {.allocated = -32, .data = {.data = hashes[1].root, .len = 0}};
// uint8_t* root = safe ? blockroot : blockroot + 32;
TRY_ASYNC(get_finality_check_points(ctx, &result));
json_get_bytes(json_get(result, "current_justified"), "root", &buf_justified);
json_get_bytes(json_get(result, "finalized"), "root", &buf_finalized);
#ifdef PROOFER_CACHE
bytes32_t key = {0};
sprintf((char*) key, FINALITY_KEY);
c4_proofer_cache_set(ctx, key, bytes_dup(bytes(hashes, sizeof(hashes))).data, sizeof(hashes), 1000 * 60 * 7, free); // 6 min
#endif
memcpy(hash, hashes[safe ? 0 : 1].root, 32);
return C4_SUCCESS;
}
|
O1
|
c
|
eth_get_final_hash:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rdx, %rbx
movl %esi, %ebp
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r8
movaps %xmm0, (%r8)
movq $0x0, 0x10(%r8)
leaq 0xa0(%rsp), %rax
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movaps %xmm0, -0x10(%rax)
movaps %xmm0, -0x20(%rax)
movaps %xmm0, -0x30(%rax)
xorl %ecx, %ecx
movl %ecx, 0x58(%rsp)
leaq 0x78(%rsp), %rdx
movq %rdx, 0x60(%rsp)
movl $0xffffffe0, %edx # imm = 0xFFFFFFE0
movl %edx, 0x68(%rsp)
movl %ecx, 0x40(%rsp)
movq %rax, 0x48(%rsp)
movl %edx, 0x50(%rsp)
leaq 0x33872(%rip), %rsi # 0x3d958
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x9dbc
testl %eax, %eax
jne 0xa131
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x33f34(%rip), %rsi # 0x3e041
leaq 0x120(%rsp), %r14
movq %r14, %rdi
callq 0x174bc
movq 0x10(%r14), %rax
movq %rax, 0x30(%rsp)
movups (%r14), %xmm0
movaps %xmm0, 0x20(%rsp)
xorl %eax, %eax
testl %eax, %eax
jne 0xa234
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x337e9(%rip), %rsi # 0x3d93c
leaq 0xf0(%rsp), %r14
movq %r14, %rdi
callq 0x174bc
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
leaq 0x3372d(%rip), %r14 # 0x3d8a8
leaq 0x108(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x174bc
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
leaq 0x58(%rsp), %rdi
callq 0x1785b
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x3378b(%rip), %rsi # 0x3d94e
leaq 0xc0(%rsp), %r15
movq %r15, %rdi
callq 0x174bc
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
leaq 0xd8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x174bc
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
leaq 0x40(%rsp), %rdi
callq 0x1785b
xorb $0x1, %bpl
movzbl %bpl, %eax
leaq (%rax,%rax,4), %rax
movups 0x78(%rsp,%rax,8), %xmm0
movups 0x88(%rsp,%rax,8), %xmm1
movups %xmm0, (%rbx)
movups %xmm1, 0x10(%rbx)
xorl %eax, %eax
addq $0x138, %rsp # imm = 0x138
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
eth_get_final_hash:
push rbp
push r15
push r14
push rbx
sub rsp, 138h
mov rbx, rdx
mov ebp, esi
xorps xmm0, xmm0
lea r8, [rsp+158h+var_138]
movaps xmmword ptr [r8], xmm0
mov qword ptr [r8+10h], 0
lea rax, [rsp+158h+var_B8]
movaps xmmword ptr [rax+10h], xmm0
movaps xmmword ptr [rax], xmm0
movaps xmmword ptr [rax-10h], xmm0
movaps xmmword ptr [rax-20h], xmm0
movaps xmmword ptr [rax-30h], xmm0
xor ecx, ecx
mov [rsp+158h+var_100], ecx
lea rdx, [rsp+158h+var_E0]
mov [rsp+158h+var_F8], rdx
mov edx, 0FFFFFFE0h
mov [rsp+158h+var_F0], edx
mov [rsp+158h+var_118], ecx
mov [rsp+158h+var_110], rax
mov [rsp+158h+var_108], edx
lea rsi, aEthV1BeaconSta; "eth/v1/beacon/states/head/finality_chec"...
xor edx, edx
xor ecx, ecx
call c4_send_beacon_json
test eax, eax
jnz short loc_A131
mov rax, [rsp+158h+var_128]
mov [rsp+158h+var_148], rax
movaps xmm0, [rsp+158h+var_138]
movups [rsp+158h+var_158], xmm0
lea rsi, aSyncData+5; "data"
lea r14, [rsp+158h+var_38]
mov rdi, r14
call json_get
mov rax, [r14+10h]
mov [rsp+158h+var_128], rax
movups xmm0, xmmword ptr [r14]
movaps [rsp+158h+var_138], xmm0
xor eax, eax
loc_A131:
test eax, eax
jnz loc_A234
mov rax, [rsp+158h+var_128]
mov [rsp+158h+var_148], rax
movaps xmm0, [rsp+158h+var_138]
movups [rsp+158h+var_158], xmm0
lea rsi, aCurrentJustifi; "current_justified"
lea r14, [rsp+158h+var_68]
mov rdi, r14
call json_get
mov rax, [r14+10h]
mov [rsp+158h+var_148], rax
movups xmm0, xmmword ptr [r14]
movups [rsp+158h+var_158], xmm0
lea r14, aRoot; "root"
lea r15, [rsp+158h+var_50]
mov rdi, r15
mov rsi, r14
call json_get
mov rax, [r15+10h]
mov [rsp+158h+var_148], rax
movups xmm0, xmmword ptr [r15]
movups [rsp+158h+var_158], xmm0
lea rdi, [rsp+158h+var_100]
call json_as_bytes
mov rax, [rsp+158h+var_128]
mov [rsp+158h+var_148], rax
movaps xmm0, [rsp+158h+var_138]
movups [rsp+158h+var_158], xmm0
lea rsi, aFinalized_0; "finalized"
lea r15, [rsp+158h+var_98]
mov rdi, r15
call json_get
mov rax, [r15+10h]
mov [rsp+158h+var_148], rax
movups xmm0, xmmword ptr [r15]
movups [rsp+158h+var_158], xmm0
lea r15, [rsp+158h+var_80]
mov rdi, r15
mov rsi, r14
call json_get
mov rax, [r15+10h]
mov [rsp+158h+var_148], rax
movups xmm0, xmmword ptr [r15]
movups [rsp+158h+var_158], xmm0
lea rdi, [rsp+158h+var_118]
call json_as_bytes
xor bpl, 1
movzx eax, bpl
lea rax, [rax+rax*4]
movups xmm0, [rsp+rax*8+158h+var_E0]
movups xmm1, [rsp+rax*8+158h+var_D0]
movups xmmword ptr [rbx], xmm0
movups xmmword ptr [rbx+10h], xmm1
xor eax, eax
loc_A234:
add rsp, 138h
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long eth_get_final_hash(long long a1, unsigned __int8 a2, _OWORD *a3)
{
long long result; // rax
int v5; // edx
int v6; // ecx
int v7; // r8d
int v8; // r9d
int v9; // edx
int v10; // ecx
int v11; // r8d
int v12; // r9d
int v13; // edx
int v14; // ecx
int v15; // r8d
int v16; // r9d
int v17; // edx
int v18; // ecx
int v19; // r8d
int v20; // r9d
int v21; // edx
int v22; // ecx
int v23; // r8d
int v24; // r9d
int v25; // edx
int v26; // ecx
int v27; // r8d
int v28; // r9d
__int128 v29; // xmm1
__int128 v30; // [rsp+20h] [rbp-138h] BYREF
long long v31; // [rsp+30h] [rbp-128h]
int v32; // [rsp+40h] [rbp-118h] BYREF
_BYTE *v33; // [rsp+48h] [rbp-110h]
int v34; // [rsp+50h] [rbp-108h]
int v35; // [rsp+58h] [rbp-100h] BYREF
_QWORD *v36; // [rsp+60h] [rbp-F8h]
int v37; // [rsp+68h] [rbp-F0h]
_QWORD v38[6]; // [rsp+70h] [rbp-E8h] BYREF
_BYTE v39[32]; // [rsp+A0h] [rbp-B8h] BYREF
_QWORD v40[3]; // [rsp+C0h] [rbp-98h] BYREF
_QWORD v41[3]; // [rsp+D8h] [rbp-80h] BYREF
_QWORD v42[3]; // [rsp+F0h] [rbp-68h] BYREF
_QWORD v43[3]; // [rsp+108h] [rbp-50h] BYREF
__int128 v44; // [rsp+120h] [rbp-38h] BYREF
long long v45; // [rsp+130h] [rbp-28h]
v30 = 0LL;
v31 = 0LL;
memset(v39, 0, sizeof(v39));
memset(v38, 0, sizeof(v38));
v35 = 0;
v36 = &v38[1];
v37 = -32;
v32 = 0;
v33 = v39;
v34 = -32;
result = c4_send_beacon_json(a1, (long long)"eth/v1/beacon/states/head/finality_checkpoints", 0LL, 0, (long long)&v30);
if ( !(_DWORD)result )
{
json_get((unsigned int)&v44, (unsigned int)"data", v5, v6, v7, v8, v30, v31);
v31 = v45;
v30 = v44;
result = 0LL;
}
if ( !(_DWORD)result )
{
json_get((unsigned int)v42, (unsigned int)"current_justified", v5, v6, v7, v8, v30, v31);
json_get((unsigned int)v43, (unsigned int)"root", v9, v10, v11, v12, v42[0], v42[1], v42[2]);
json_as_bytes((unsigned int)&v35, (unsigned int)"root", v13, v14, v15, v16, v43[0], v43[1], v43[2]);
json_get((unsigned int)v40, (unsigned int)"finalized", v17, v18, v19, v20, v30, v31);
json_get((unsigned int)v41, (unsigned int)"root", v21, v22, v23, v24, v40[0], v40[1], v40[2]);
json_as_bytes((unsigned int)&v32, (unsigned int)"root", v25, v26, v27, v28, v41[0], v41[1], v41[2]);
v29 = *(_OWORD *)&v38[5 * (a2 ^ 1u) + 3];
*a3 = *(_OWORD *)&v38[5 * (a2 ^ 1u) + 1];
a3[1] = v29;
return 0LL;
}
return result;
}
|
eth_get_final_hash:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x138
MOV RBX,RDX
MOV EBP,ESI
XORPS XMM0,XMM0
LEA R8,[RSP + 0x20]
MOVAPS xmmword ptr [R8],XMM0
MOV qword ptr [R8 + 0x10],0x0
LEA RAX,[RSP + 0xa0]
MOVAPS xmmword ptr [RAX + 0x10],XMM0
MOVAPS xmmword ptr [RAX],XMM0
MOVAPS xmmword ptr [RAX + -0x10],XMM0
MOVAPS xmmword ptr [RAX + -0x20],XMM0
MOVAPS xmmword ptr [RAX + -0x30],XMM0
XOR ECX,ECX
MOV dword ptr [RSP + 0x58],ECX
LEA RDX,[RSP + 0x78]
MOV qword ptr [RSP + 0x60],RDX
MOV EDX,0xffffffe0
MOV dword ptr [RSP + 0x68],EDX
MOV dword ptr [RSP + 0x40],ECX
MOV qword ptr [RSP + 0x48],RAX
MOV dword ptr [RSP + 0x50],EDX
LEA RSI,[0x13d958]
XOR EDX,EDX
XOR ECX,ECX
CALL 0x00109dbc
TEST EAX,EAX
JNZ 0x0010a131
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x10],RAX
MOVAPS XMM0,xmmword ptr [RSP + 0x20]
MOVUPS xmmword ptr [RSP],XMM0
LEA RSI,[0x13e041]
LEA R14,[RSP + 0x120]
MOV RDI,R14
CALL 0x001174bc
MOV RAX,qword ptr [R14 + 0x10]
MOV qword ptr [RSP + 0x30],RAX
MOVUPS XMM0,xmmword ptr [R14]
MOVAPS xmmword ptr [RSP + 0x20],XMM0
XOR EAX,EAX
LAB_0010a131:
TEST EAX,EAX
JNZ 0x0010a234
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x10],RAX
MOVAPS XMM0,xmmword ptr [RSP + 0x20]
MOVUPS xmmword ptr [RSP],XMM0
LEA RSI,[0x13d93c]
LEA R14,[RSP + 0xf0]
MOV RDI,R14
CALL 0x001174bc
MOV RAX,qword ptr [R14 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R14]
MOVUPS xmmword ptr [RSP],XMM0
LEA R14,[0x13d8a8]
LEA R15,[RSP + 0x108]
MOV RDI,R15
MOV RSI,R14
CALL 0x001174bc
MOV RAX,qword ptr [R15 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [RSP],XMM0
LEA RDI,[RSP + 0x58]
CALL 0x0011785b
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x10],RAX
MOVAPS XMM0,xmmword ptr [RSP + 0x20]
MOVUPS xmmword ptr [RSP],XMM0
LEA RSI,[0x13d94e]
LEA R15,[RSP + 0xc0]
MOV RDI,R15
CALL 0x001174bc
MOV RAX,qword ptr [R15 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [RSP],XMM0
LEA R15,[RSP + 0xd8]
MOV RDI,R15
MOV RSI,R14
CALL 0x001174bc
MOV RAX,qword ptr [R15 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [RSP],XMM0
LEA RDI,[RSP + 0x40]
CALL 0x0011785b
XOR BPL,0x1
MOVZX EAX,BPL
LEA RAX,[RAX + RAX*0x4]
MOVUPS XMM0,xmmword ptr [RSP + RAX*0x8 + 0x78]
MOVUPS XMM1,xmmword ptr [RSP + RAX*0x8 + 0x88]
MOVUPS xmmword ptr [RBX],XMM0
MOVUPS xmmword ptr [RBX + 0x10],XMM1
XOR EAX,EAX
LAB_0010a234:
ADD RSP,0x138
POP RBX
POP R14
POP R15
POP RBP
RET
|
int8 eth_get_final_hash(int8 param_1,byte param_2,int8 *param_3)
{
int8 uVar1;
int8 uVar2;
int8 uVar3;
ulong uVar4;
int4 local_118 [2];
int8 *local_110;
int4 local_108;
int4 local_100 [2];
int8 *local_f8;
int4 local_f0;
int8 local_e8;
int8 auStack_e0 [9];
int1 local_98 [24];
int1 local_80 [24];
int1 local_68 [24];
int1 local_50 [24];
int1 local_38 [24];
local_110 = auStack_e0 + 5;
auStack_e0[7] = 0;
auStack_e0[8] = 0;
auStack_e0[5] = 0;
auStack_e0[6] = 0;
auStack_e0[3] = 0;
auStack_e0[4] = 0;
auStack_e0[1] = 0;
auStack_e0[2] = 0;
local_e8 = 0;
auStack_e0[0] = 0;
local_100[0] = 0;
local_f8 = auStack_e0;
local_f0 = 0xffffffe0;
local_118[0] = 0;
local_108 = 0xffffffe0;
uVar3 = c4_send_beacon_json(param_1,"eth/v1/beacon/states/head/finality_checkpoints",0,0);
if ((int)uVar3 == 0) {
json_get(local_38,"data");
uVar3 = 0;
}
if ((int)uVar3 == 0) {
json_get(local_68,"current_justified");
json_get(local_50,&DAT_0013d8a8);
json_as_bytes(local_100);
json_get(local_98,"finalized");
json_get(local_80,&DAT_0013d8a8);
json_as_bytes(local_118);
uVar4 = (ulong)(param_2 ^ 1);
uVar3 = auStack_e0[uVar4 * 5 + 1];
uVar1 = auStack_e0[uVar4 * 5 + 2];
uVar2 = auStack_e0[uVar4 * 5 + 3];
*param_3 = auStack_e0[uVar4 * 5];
param_3[1] = uVar3;
param_3[2] = uVar1;
param_3[3] = uVar2;
uVar3 = 0;
}
return uVar3;
}
|
|
63,679
|
directory_file_name
|
eloqsql/mysys/my_lib.c
|
static char *directory_file_name (char * dst, const char *src)
{
/* Process as Unix format: just remove test the final slash. */
char *end;
DBUG_ASSERT(strlen(src) < (FN_REFLEN + 1));
if (src[0] == 0)
src= (char*) "."; /* Use empty as current */
end= strnmov(dst, src, FN_REFLEN + 1);
if (end[-1] != FN_LIBCHAR)
{
*end++= FN_LIBCHAR; /* Add last '/' */
*end='\0';
}
return end;
}
|
O0
|
c
|
directory_file_name:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x7dc42
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x7dc59
leaq 0x52472(%rip), %rax # 0xd00c7
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x201, %edx # imm = 0x201
callq 0xc8780
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x2f, %eax
je 0x7dc95
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x2f, (%rax)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
|
directory_file_name:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
jmp short $+2
loc_7DC42:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 0
jnz short loc_7DC59
lea rax, aInvalidOrMissi+21h; "."
mov [rbp+var_10], rax
loc_7DC59:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov edx, 201h
call strnmov
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
movsx eax, byte ptr [rax-1]
cmp eax, 2Fh ; '/'
jz short loc_7DC95
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 1
mov [rbp+var_18], rcx
mov byte ptr [rax], 2Fh ; '/'
mov rax, [rbp+var_18]
mov byte ptr [rax], 0
loc_7DC95:
mov rax, [rbp+var_18]
add rsp, 20h
pop rbp
retn
|
_BYTE * directory_file_name(long long a1, char *a2)
{
_BYTE *v2; // rax
_BYTE *v4; // [rsp+8h] [rbp-18h]
char *v5; // [rsp+10h] [rbp-10h]
v5 = a2;
if ( !*a2 )
v5 = ".";
v4 = (_BYTE *)strnmov(a1, v5, 513LL);
if ( *(v4 - 1) != 47 )
{
v2 = v4++;
*v2 = 47;
*v4 = 0;
}
return v4;
}
|
directory_file_name:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
JMP 0x0017dc42
LAB_0017dc42:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JNZ 0x0017dc59
LEA RAX,[0x1d00c7]
MOV qword ptr [RBP + -0x10],RAX
LAB_0017dc59:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,0x201
CALL 0x001c8780
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOVSX EAX,byte ptr [RAX + -0x1]
CMP EAX,0x2f
JZ 0x0017dc95
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x18],RCX
MOV byte ptr [RAX],0x2f
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX],0x0
LAB_0017dc95:
MOV RAX,qword ptr [RBP + -0x18]
ADD RSP,0x20
POP RBP
RET
|
int1 * directory_file_name(int8 param_1,char *param_2)
{
int1 *puVar1;
int1 *local_20;
char *local_18;
local_18 = param_2;
if (*param_2 == '\0') {
local_18 = ".";
}
puVar1 = (int1 *)strnmov(param_1,local_18,0x201);
local_20 = puVar1;
if (puVar1[-1] != '/') {
local_20 = puVar1 + 1;
*puVar1 = 0x2f;
*local_20 = 0;
}
return local_20;
}
|
|
63,680
|
nlohmann::json_abi_v3_11_3::detail::other_error nlohmann::json_abi_v3_11_3::detail::other_error::create<std::nullptr_t, 0>(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::nullptr_t)
|
monkey531[P]llama/common/json.hpp
|
static other_error create(int id_, const std::string& what_arg, BasicJsonContext context)
{
const std::string w = concat(exception::name("other_error", id_), exception::diagnostics(context), what_arg);
return {id_, w.c_str()};
}
|
O0
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::other_error nlohmann::json_abi_v3_11_3::detail::other_error::create<std::nullptr_t, 0>(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::nullptr_t):
subq $0xd8, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0xd0(%rsp)
movl %esi, 0xcc(%rsp)
movq %rdx, 0xc0(%rsp)
movq %rcx, 0xb8(%rsp)
leaq 0x57(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x5b0f0
movq 0x18(%rsp), %rdx
leaq 0x16bac2(%rip), %rsi # 0x20d3d0
leaq 0x58(%rsp), %rdi
callq 0x63270
jmp 0xa191a
movl 0xcc(%rsp), %edx
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xa33b0
jmp 0xa1932
xorl %eax, %eax
movl %eax, %esi
leaq 0x20(%rsp), %rdi
callq 0xa3450
jmp 0xa1942
movq 0xc0(%rsp), %rcx
leaq 0x98(%rsp), %rdi
leaq 0x78(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0xa32f0
jmp 0xa1963
leaq 0x20(%rsp), %rdi
callq 0x5b588
leaq 0x78(%rsp), %rdi
callq 0x5b588
leaq 0x58(%rsp), %rdi
callq 0x5b588
leaq 0x57(%rsp), %rdi
callq 0x5b560
movl 0xcc(%rsp), %eax
movl %eax, 0x4(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x5a1c0
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
movq %rax, %rdx
callq 0xa34d0
jmp 0xa19b6
leaq 0x98(%rsp), %rdi
callq 0x5b588
movq 0x10(%rsp), %rax
addq $0xd8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0xa1a2c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0xa1a22
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0xa1a18
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x5b588
leaq 0x78(%rsp), %rdi
callq 0x5b588
leaq 0x58(%rsp), %rdi
callq 0x5b588
leaq 0x57(%rsp), %rdi
callq 0x5b560
jmp 0xa1a53
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x5b588
movq 0x48(%rsp), %rdi
callq 0x5abf0
nopl (%rax)
|
_ZN8nlohmann16json_abi_v3_11_36detail11other_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_:
sub rsp, 0D8h
mov [rsp+0D8h+var_D0], rdi; int
mov rax, rdi
mov qword ptr [rsp+0D8h+var_C8], rax; int
mov [rsp+0D8h+var_8], rdi
mov [rsp+0D8h+var_C], esi
mov qword ptr [rsp+0D8h+var_18], rdx
mov [rsp+0D8h+var_20], rcx
lea rdi, [rsp+0D8h+var_81]
mov qword ptr [rsp+0D8h+var_C0], rdi; int
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdx, qword ptr [rsp+0D8h+var_C0]
lea rsi, aOtherError; "other_error"
lea rdi, [rsp+0D8h+var_81+1]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_A191A:
mov edx, [rsp+0D8h+var_C]
lea rdi, [rsp+0D8h+var_60]; int
lea rsi, [rsp+0D8h+var_81+1]
call _ZN8nlohmann16json_abi_v3_11_36detail9exception4nameERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi; nlohmann::json_abi_v3_11_3::detail::exception::name(std::string const&,int)
jmp short $+2
loc_A1932:
xor eax, eax
mov esi, eax
lea rdi, [rsp+0D8h+var_B8]
call _ZN8nlohmann16json_abi_v3_11_36detail9exception11diagnosticsB5cxx11EDn; nlohmann::json_abi_v3_11_3::detail::exception::diagnostics(decltype(nullptr))
jmp short $+2
loc_A1942:
mov rcx, qword ptr [rsp+0D8h+var_18]; int
lea rdi, [rsp+0D8h+var_40]; int
lea rsi, [rsp+0D8h+var_60]; int
lea rdx, [rsp+0D8h+var_B8]; int
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJS8_S8_RKS8_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,std::string,std::string,std::string const&>(std::string,std::string,std::string const&)
jmp short $+2
loc_A1963:
lea rdi, [rsp+0D8h+var_B8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+0D8h+var_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+0D8h+var_81+1]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+0D8h+var_81]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
mov eax, [rsp+0D8h+var_C]
mov [rsp+0D8h+var_D4], eax
lea rdi, [rsp+0D8h+var_40]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rdi, [rsp+0D8h+var_D0]; this
mov esi, [rsp+0D8h+var_D4]; int
mov rdx, rax; char *
call _ZN8nlohmann16json_abi_v3_11_36detail11other_errorC2EiPKc; nlohmann::json_abi_v3_11_3::detail::other_error::other_error(int,char const*)
jmp short $+2
loc_A19B6:
lea rdi, [rsp+0D8h+var_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov rax, qword ptr [rsp+0D8h+var_C8]
add rsp, 0D8h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_40], rcx
mov [rsp+arg_3C], eax
jmp short loc_A1A2C
mov rcx, rax
mov eax, edx
mov [rsp+arg_40], rcx
mov [rsp+arg_3C], eax
jmp short loc_A1A22
mov rcx, rax
mov eax, edx
mov [rsp+arg_40], rcx
mov [rsp+arg_3C], eax
jmp short loc_A1A18
mov rcx, rax
mov eax, edx
mov [rsp+arg_40], rcx
mov [rsp+arg_3C], eax
lea rdi, [rsp+arg_18]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_A1A18:
lea rdi, [rsp+arg_70]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_A1A22:
lea rdi, [rsp+arg_50]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_A1A2C:
lea rdi, [rsp+arg_4F]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_A1A53
mov rcx, rax
mov eax, edx
mov [rsp+arg_40], rcx
mov [rsp+arg_3C], eax
lea rdi, [rsp+arg_90]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_A1A53:
mov rdi, [rsp+arg_40]
call __Unwind_Resume
|
long long ZN8nlohmann16json_abi_v3_11_36detail11other_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_(
long long a1,
int a2,
long long a3,
long long a4)
{
int v4; // edx
int v5; // ecx
int v6; // r8d
int v7; // r9d
int v8; // r8d
int v9; // r9d
const char *v10; // rax
int v12; // [rsp+0h] [rbp-D8h]
int v13; // [rsp+0h] [rbp-D8h]
void *v14; // [rsp+0h] [rbp-D8h]
int v15; // [rsp+4h] [rbp-D4h]
int v16; // [rsp+8h] [rbp-D0h]
int v17; // [rsp+8h] [rbp-D0h]
nlohmann::json_abi_v3_11_3::detail::other_error *v18; // [rsp+8h] [rbp-D0h]
int v19; // [rsp+10h] [rbp-C8h]
int v20; // [rsp+10h] [rbp-C8h]
int v21[2]; // [rsp+10h] [rbp-C8h]
int v22; // [rsp+18h] [rbp-C0h]
int v23; // [rsp+18h] [rbp-C0h]
long long v24; // [rsp+20h] [rbp-B8h] BYREF
int v25; // [rsp+28h] [rbp-B0h]
int v26[8]; // [rsp+57h] [rbp-81h] BYREF
int v27[8]; // [rsp+78h] [rbp-60h] BYREF
int v28[8]; // [rsp+98h] [rbp-40h] BYREF
long long v29; // [rsp+B8h] [rbp-20h]
int v30[3]; // [rsp+C0h] [rbp-18h]
int v31; // [rsp+CCh] [rbp-Ch]
long long v32; // [rsp+D0h] [rbp-8h]
v32 = a1;
v31 = a2;
*(_QWORD *)v30 = a3;
v29 = a4;
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>((long long)v26 + 1, (long long)"other_error", (long long)v26);
nlohmann::json_abi_v3_11_3::detail::exception::name((int)v27, v12, a1, a1, (int)v26, v24, v25);
nlohmann::json_abi_v3_11_3::detail::exception::diagnostics[abi:cxx11](
(unsigned int)&v24,
0,
v4,
v5,
v6,
v7,
v13,
v16,
v19,
v22,
v24,
v25);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,std::string,std::string,std::string const&>(
(int)v28,
(int)v27,
(int)&v24,
v30[0],
v8,
v9,
v14,
v17,
v20,
v23,
v24);
std::string::~string(&v24);
std::string::~string(v27);
std::string::~string((char *)v26 + 1);
std::allocator<char>::~allocator(v26);
v15 = v31;
v10 = (const char *)std::string::c_str(v28);
nlohmann::json_abi_v3_11_3::detail::other_error::other_error(v18, v15, v10);
std::string::~string(v28);
return *(_QWORD *)v21;
}
|
_ZN8nlohmann16json_abi_v3_11_36detail11other_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_:
SUB RSP,0xd8
MOV qword ptr [RSP + 0x8],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0xd0],RDI
MOV dword ptr [RSP + 0xcc],ESI
MOV qword ptr [RSP + 0xc0],RDX
MOV qword ptr [RSP + 0xb8],RCX
LEA RDI,[RSP + 0x57]
MOV qword ptr [RSP + 0x18],RDI
CALL 0x0015b0f0
MOV RDX,qword ptr [RSP + 0x18]
LAB_001a1907:
LEA RSI,[0x30d3d0]
LEA RDI,[RSP + 0x58]
CALL 0x00163270
JMP 0x001a191a
LAB_001a191a:
MOV EDX,dword ptr [RSP + 0xcc]
LAB_001a1921:
LEA RDI,[RSP + 0x78]
LEA RSI,[RSP + 0x58]
CALL 0x001a33b0
JMP 0x001a1932
LAB_001a1932:
XOR EAX,EAX
MOV ESI,EAX
LEA RDI,[RSP + 0x20]
CALL 0x001a3450
JMP 0x001a1942
LAB_001a1942:
MOV RCX,qword ptr [RSP + 0xc0]
LAB_001a194a:
LEA RDI,[RSP + 0x98]
LEA RSI,[RSP + 0x78]
LEA RDX,[RSP + 0x20]
CALL 0x001a32f0
JMP 0x001a1963
LAB_001a1963:
LEA RDI,[RSP + 0x20]
CALL 0x0015b588
LEA RDI,[RSP + 0x78]
CALL 0x0015b588
LEA RDI,[RSP + 0x58]
CALL 0x0015b588
LEA RDI,[RSP + 0x57]
CALL 0x0015b560
MOV EAX,dword ptr [RSP + 0xcc]
MOV dword ptr [RSP + 0x4],EAX
LEA RDI,[RSP + 0x98]
CALL 0x0015a1c0
MOV RDI,qword ptr [RSP + 0x8]
MOV ESI,dword ptr [RSP + 0x4]
MOV RDX,RAX
LAB_001a19af:
CALL 0x001a34d0
LAB_001a19b4:
JMP 0x001a19b6
LAB_001a19b6:
LEA RDI,[RSP + 0x98]
CALL 0x0015b588
MOV RAX,qword ptr [RSP + 0x10]
ADD RSP,0xd8
RET
|
other_error *
_ZN8nlohmann16json_abi_v3_11_36detail11other_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_
(other_error *param_1,int param_2,string *param_3,int8 param_4)
{
int iVar1;
char *pcVar2;
exception local_b8 [55];
allocator local_81;
string local_80 [32];
exception local_60 [32];
detail local_40 [32];
int8 local_20;
string *local_18;
int local_c;
other_error *local_8;
local_20 = param_4;
local_18 = param_3;
local_c = param_2;
local_8 = param_1;
std::allocator<char>::allocator();
/* try { // try from 001a1907 to 001a1917 has its CatchHandler @ 001a19d0 */
std::__cxx11::string::string<std::allocator<char>>(local_80,"other_error",&local_81);
/* try { // try from 001a1921 to 001a192f has its CatchHandler @ 001a19e0 */
nlohmann::json_abi_v3_11_3::detail::exception::name(local_60,local_80,local_c);
/* try { // try from 001a1932 to 001a193f has its CatchHandler @ 001a19f0 */
nlohmann::json_abi_v3_11_3::detail::exception::diagnostics_abi_cxx11_
(local_b8,(_func_decltype_nullptr *)0x0);
/* try { // try from 001a194a to 001a1960 has its CatchHandler @ 001a1a00 */
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,std::__cxx11::string,std::__cxx11::string,std::__cxx11::string_const&>
(local_40,(string *)local_60,(string *)local_b8,local_18);
std::__cxx11::string::~string((string *)local_b8);
std::__cxx11::string::~string((string *)local_60);
std::__cxx11::string::~string(local_80);
std::allocator<char>::~allocator((allocator<char> *)&local_81);
iVar1 = local_c;
pcVar2 = (char *)std::__cxx11::string::c_str();
/* try { // try from 001a19af to 001a19b3 has its CatchHandler @ 001a1a38 */
nlohmann::json_abi_v3_11_3::detail::other_error::other_error(param_1,iVar1,pcVar2);
std::__cxx11::string::~string((string *)local_40);
return param_1;
}
|
|
63,681
|
translog_scanner_init
|
eloqsql/storage/maria/ma_loghandler.c
|
my_bool translog_scanner_init(LSN lsn,
my_bool fixed_horizon,
TRANSLOG_SCANNER_DATA *scanner,
my_bool use_direct)
{
DBUG_ENTER("translog_scanner_init");
DBUG_PRINT("enter", ("Scanner: %p LSN: " LSN_FMT,
scanner, LSN_IN_PARTS(lsn)));
DBUG_ASSERT(translog_status == TRANSLOG_OK ||
translog_status == TRANSLOG_READONLY);
scanner->page_offset= LSN_OFFSET(lsn) % TRANSLOG_PAGE_SIZE;
scanner->fixed_horizon= fixed_horizon;
scanner->use_direct_link= use_direct;
scanner->direct_link= NULL;
scanner->horizon= translog_get_horizon();
DBUG_PRINT("info", ("horizon: " LSN_FMT, LSN_IN_PARTS(scanner->horizon)));
/* lsn < horizon */
DBUG_ASSERT(lsn <= scanner->horizon);
scanner->page_addr= lsn;
scanner->page_addr-= scanner->page_offset; /*decrease offset */
if (translog_scanner_set_last_page(scanner))
DBUG_RETURN(1);
if (translog_scanner_get_page(scanner))
DBUG_RETURN(1);
DBUG_RETURN(0);
}
|
O3
|
c
|
translog_scanner_init:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movl %r14d, %eax
andl $0x1fff, %eax # imm = 0x1FFF
movl %eax, 0x2028(%rdx)
movb %sil, 0x202c(%rdx)
movb %cl, 0x202d(%rdx)
movq $0x0, 0x2020(%rdx)
callq 0x4720c
movq %rax, 0x2008(%rbx)
movl 0x2028(%rbx), %eax
subq %rax, %r14
movq %r14, 0x2000(%rbx)
movq %rbx, %rdi
callq 0x47268
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x45fb1
leaq 0x2020(%rbx), %rax
leaq 0x2000(%rbx), %rcx
leaq -0x20(%rbp), %rdi
movq %rcx, (%rdi)
movb $0x0, 0x8(%rdi)
xorl %edx, %edx
cmpb $0x0, 0x202d(%rbx)
cmovneq %rax, %rdx
movq %rbx, %rsi
callq 0x45804
movq %rax, 0x2018(%rbx)
testq %rax, %rax
sete %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
|
translog_scanner_init:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 10h
mov rbx, rdx
mov r14, rdi
mov eax, r14d
and eax, 1FFFh
mov [rdx+2028h], eax
mov [rdx+202Ch], sil
mov [rdx+202Dh], cl
mov qword ptr [rdx+2020h], 0
call translog_get_horizon
mov [rbx+2008h], rax
mov eax, [rbx+2028h]
sub r14, rax
mov [rbx+2000h], r14
mov rdi, rbx
call translog_scanner_set_last_page
mov ecx, eax
mov al, 1
test cl, cl
jnz short loc_45FB1
lea rax, [rbx+2020h]
lea rcx, [rbx+2000h]
lea rdi, [rbp+var_20]
mov [rdi], rcx
mov byte ptr [rdi+8], 0
xor edx, edx
cmp byte ptr [rbx+202Dh], 0
cmovnz rdx, rax
mov rsi, rbx
call translog_get_page
mov [rbx+2018h], rax
test rax, rax
setz al
loc_45FB1:
add rsp, 10h
pop rbx
pop r14
pop rbp
retn
|
bool translog_scanner_init(long long a1, char a2, long long a3, char a4)
{
char page; // cl
bool result; // al
_QWORD *v7; // rdx
long long v8; // rax
long long *v9; // [rsp+0h] [rbp-20h] BYREF
char v10; // [rsp+8h] [rbp-18h]
*(_DWORD *)(a3 + 8232) = a1 & 0x1FFF;
*(_BYTE *)(a3 + 8236) = a2;
*(_BYTE *)(a3 + 8237) = a4;
*(_QWORD *)(a3 + 8224) = 0LL;
*(_QWORD *)(a3 + 8200) = translog_get_horizon();
*(_QWORD *)(a3 + 0x2000) = a1 - *(unsigned int *)(a3 + 8232);
page = translog_scanner_set_last_page(a3);
result = 1;
if ( !page )
{
v9 = (long long *)(a3 + 0x2000);
v10 = 0;
v7 = 0LL;
if ( *(_BYTE *)(a3 + 8237) )
v7 = (_QWORD *)(a3 + 8224);
v8 = translog_get_page(&v9, a3, v7);
*(_QWORD *)(a3 + 8216) = v8;
return v8 == 0;
}
return result;
}
|
translog_scanner_init:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV RBX,RDX
MOV R14,RDI
MOV EAX,R14D
AND EAX,0x1fff
MOV dword ptr [RDX + 0x2028],EAX
MOV byte ptr [RDX + 0x202c],SIL
MOV byte ptr [RDX + 0x202d],CL
MOV qword ptr [RDX + 0x2020],0x0
CALL 0x0014720c
MOV qword ptr [RBX + 0x2008],RAX
MOV EAX,dword ptr [RBX + 0x2028]
SUB R14,RAX
MOV qword ptr [RBX + 0x2000],R14
MOV RDI,RBX
CALL 0x00147268
MOV ECX,EAX
MOV AL,0x1
TEST CL,CL
JNZ 0x00145fb1
LEA RAX,[RBX + 0x2020]
LEA RCX,[RBX + 0x2000]
LEA RDI,[RBP + -0x20]
MOV qword ptr [RDI],RCX
MOV byte ptr [RDI + 0x8],0x0
XOR EDX,EDX
CMP byte ptr [RBX + 0x202d],0x0
CMOVNZ RDX,RAX
MOV RSI,RBX
CALL 0x00145804
MOV qword ptr [RBX + 0x2018],RAX
TEST RAX,RAX
SETZ AL
LAB_00145fb1:
ADD RSP,0x10
POP RBX
POP R14
POP RBP
RET
|
bool translog_scanner_init(long param_1,int1 param_2,long param_3,int1 param_4)
{
char cVar1;
int8 uVar2;
long lVar3;
bool bVar4;
long local_28;
int1 local_20;
*(uint *)(param_3 + 0x2028) = (uint)param_1 & 0x1fff;
*(int1 *)(param_3 + 0x202c) = param_2;
*(int1 *)(param_3 + 0x202d) = param_4;
*(int8 *)(param_3 + 0x2020) = 0;
uVar2 = translog_get_horizon();
*(int8 *)(param_3 + 0x2008) = uVar2;
*(ulong *)(param_3 + 0x2000) = param_1 - (ulong)*(uint *)(param_3 + 0x2028);
cVar1 = translog_scanner_set_last_page(param_3);
bVar4 = true;
if (cVar1 == '\0') {
local_28 = param_3 + 0x2000;
local_20 = 0;
lVar3 = 0;
if (*(char *)(param_3 + 0x202d) != '\0') {
lVar3 = param_3 + 0x2020;
}
lVar3 = translog_get_page(&local_28,param_3,lVar3);
*(long *)(param_3 + 0x2018) = lVar3;
bVar4 = lVar3 == 0;
}
return bVar4;
}
|
|
63,682
|
aimrt::plugins::time_manipulator_plugin::TimeManipulatorPlugin::~TimeManipulatorPlugin()
|
aimrt_mujoco_sim/_deps/aimrt-src/src/plugins/time_manipulator_plugin/../time_manipulator_plugin/time_manipulator_plugin.h
|
~TimeManipulatorPlugin() override = default;
|
O3
|
c
|
aimrt::plugins::time_manipulator_plugin::TimeManipulatorPlugin::~TimeManipulatorPlugin():
pushq %rbx
movq %rdi, %rbx
leaq 0x1f0dad(%rip), %rax # 0x297258
movq %rax, (%rdi)
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0xa64bd
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x38(%rbx)
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
cmpq %rbx, %rdi
je 0xa64de
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x82190
popq %rbx
retq
|
_ZN5aimrt7plugins23time_manipulator_plugin21TimeManipulatorPluginD2Ev:
push rbx
mov rbx, rdi
lea rax, off_297258
mov [rdi], rax
mov rdi, [rdi+38h]
test rdi, rdi
jz short loc_A64BD
mov rax, [rdi]
call qword ptr [rax+8]
loc_A64BD:
mov qword ptr [rbx+38h], 0
mov rdi, [rbx+10h]; void *
add rbx, 20h ; ' '
cmp rdi, rbx
jz short loc_A64DE
mov rsi, [rbx]
inc rsi; unsigned __int64
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
loc_A64DE:
pop rbx
retn
|
void aimrt::plugins::time_manipulator_plugin::TimeManipulatorPlugin::~TimeManipulatorPlugin(
aimrt::plugins::time_manipulator_plugin::TimeManipulatorPlugin *this)
{
long long v2; // rdi
_QWORD *v3; // rdi
_QWORD *v4; // rbx
*(_QWORD *)this = off_297258;
v2 = *((_QWORD *)this + 7);
if ( v2 )
(*(void ( **)(long long))(*(_QWORD *)v2 + 8LL))(v2);
*((_QWORD *)this + 7) = 0LL;
v3 = (_QWORD *)*((_QWORD *)this + 2);
v4 = (_QWORD *)((char *)this + 32);
if ( v3 != v4 )
operator delete(v3, *v4 + 1LL);
}
|
~TimeManipulatorPlugin:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x397258]
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x38]
TEST RDI,RDI
JZ 0x001a64bd
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_001a64bd:
MOV qword ptr [RBX + 0x38],0x0
MOV RDI,qword ptr [RBX + 0x10]
ADD RBX,0x20
CMP RDI,RBX
JZ 0x001a64de
MOV RSI,qword ptr [RBX]
INC RSI
POP RBX
JMP 0x00182190
LAB_001a64de:
POP RBX
RET
|
/* aimrt::plugins::time_manipulator_plugin::TimeManipulatorPlugin::~TimeManipulatorPlugin() */
void __thiscall
aimrt::plugins::time_manipulator_plugin::TimeManipulatorPlugin::~TimeManipulatorPlugin
(TimeManipulatorPlugin *this)
{
*(int ***)this = &PTR__TimeManipulatorPlugin_00397258;
if (*(long **)(this + 0x38) != (long *)0x0) {
(**(code **)(**(long **)(this + 0x38) + 8))();
}
*(int8 *)(this + 0x38) = 0;
if (*(TimeManipulatorPlugin **)(this + 0x10) != this + 0x20) {
operator_delete(*(TimeManipulatorPlugin **)(this + 0x10),*(long *)(this + 0x20) + 1);
return;
}
return;
}
|
|
63,683
|
ss_check
|
bluesky950520[P]quickjs/quickjs.c
|
static __exception int ss_check(JSContext *ctx, StackSizeState *s,
int pos, int op, int stack_len, int catch_pos)
{
if ((unsigned)pos >= s->bc_len) {
JS_ThrowInternalError(ctx, "bytecode buffer overflow (op=%d, pc=%d)", op, pos);
return -1;
}
if (stack_len > s->stack_len_max) {
s->stack_len_max = stack_len;
if (s->stack_len_max > JS_STACK_SIZE_MAX) {
JS_ThrowInternalError(ctx, "stack overflow (op=%d, pc=%d)", op, pos);
return -1;
}
}
if (s->stack_level_tab[pos] != 0xffff) {
/* already explored: check that the stack size is consistent */
if (s->stack_level_tab[pos] != stack_len) {
JS_ThrowInternalError(ctx, "inconsistent stack size: %d %d (pc=%d)",
s->stack_level_tab[pos], stack_len, pos);
return -1;
} else if (s->catch_pos_tab[pos] != catch_pos) {
JS_ThrowInternalError(ctx, "inconsistent catch position: %d %d (pc=%d)",
s->catch_pos_tab[pos], catch_pos, pos);
return -1;
} else {
return 0;
}
}
/* mark as explored and store the stack size */
s->stack_level_tab[pos] = stack_len;
s->catch_pos_tab[pos] = catch_pos;
/* queue the new PC to explore */
if (js_resize_array(ctx, (void **)&s->pc_stack, sizeof(s->pc_stack[0]),
&s->pc_stack_size, s->pc_stack_len + 1))
return -1;
s->pc_stack[s->pc_stack_len++] = pos;
return 0;
}
|
O1
|
c
|
ss_check:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
cmpl %edx, (%rsi)
jbe 0x6f7a8
movq %rsi, %r14
cmpl %r8d, 0x4(%rsi)
jge 0x6f7bc
movl %r8d, 0x4(%r14)
cmpl $0xffff, %r8d # imm = 0xFFFF
jl 0x6f7bc
leaq 0x31fd3(%rip), %rsi # 0xa1779
jmp 0x6f7af
leaq 0x31f83(%rip), %rsi # 0xa1732
movl %ecx, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x22693
jmp 0x6f82f
movq 0x8(%r14), %rcx
movslq %ebx, %rax
movzwl (%rcx,%rax,2), %edx
cmpl $0xffff, %edx # imm = 0xFFFF
je 0x6f7ee
cmpl %r8d, %edx
jne 0x6f81b
movq 0x10(%r14), %rcx
movl (%rcx,%rax,4), %edx
xorl %eax, %eax
cmpl %r9d, %edx
je 0x6f834
leaq 0x31ff4(%rip), %rsi # 0xa17dd
movl %r9d, %ecx
jmp 0x6f825
movw %r8w, (%rcx,%rax,2)
movq 0x10(%r14), %rcx
movl %r9d, (%rcx,%rax,4)
movl 0x20(%r14), %r8d
cmpl %r8d, 0x24(%r14)
jle 0x6f83c
movq 0x18(%r14), %rax
movslq 0x20(%r14), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x20(%r14)
movl %ebx, (%rax,%rcx,4)
xorl %eax, %eax
jmp 0x6f834
leaq 0x31f94(%rip), %rsi # 0xa17b6
movl %r8d, %ecx
movl %ebx, %r8d
xorl %eax, %eax
callq 0x22693
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x18(%r14), %rsi
leaq 0x24(%r14), %rcx
incl %r8d
movl $0x4, %edx
callq 0x434ef
movl %eax, %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x6f834
jmp 0x6f805
|
ss_check:
push r14
push rbx
push rax
mov ebx, edx
cmp [rsi], edx
jbe short loc_6F7A8
mov r14, rsi
cmp [rsi+4], r8d
jge short loc_6F7BC
mov [r14+4], r8d
cmp r8d, 0FFFFh
jl short loc_6F7BC
lea rsi, aStackOverflowO; "stack overflow (op=%d, pc=%d)"
jmp short loc_6F7AF
loc_6F7A8:
lea rsi, aBytecodeBuffer; "bytecode buffer overflow (op=%d, pc=%d)"
loc_6F7AF:
mov edx, ecx
mov ecx, ebx
xor eax, eax
call JS_ThrowInternalError
jmp short loc_6F82F
loc_6F7BC:
mov rcx, [r14+8]
movsxd rax, ebx
movzx edx, word ptr [rcx+rax*2]
cmp edx, 0FFFFh
jz short loc_6F7EE
cmp edx, r8d
jnz short loc_6F81B
mov rcx, [r14+10h]
mov edx, [rcx+rax*4]
xor eax, eax
cmp edx, r9d
jz short loc_6F834
lea rsi, aInconsistentCa; "inconsistent catch position: %d %d (pc="...
mov ecx, r9d
jmp short loc_6F825
loc_6F7EE:
mov [rcx+rax*2], r8w
mov rcx, [r14+10h]
mov [rcx+rax*4], r9d
mov r8d, [r14+20h]
cmp [r14+24h], r8d
jle short loc_6F83C
loc_6F805:
mov rax, [r14+18h]
movsxd rcx, dword ptr [r14+20h]
lea edx, [rcx+1]
mov [r14+20h], edx
mov [rax+rcx*4], ebx
xor eax, eax
jmp short loc_6F834
loc_6F81B:
lea rsi, aInconsistentSt; "inconsistent stack size: %d %d (pc=%d)"
mov ecx, r8d
loc_6F825:
mov r8d, ebx
xor eax, eax
call JS_ThrowInternalError
loc_6F82F:
mov eax, 0FFFFFFFFh
loc_6F834:
add rsp, 8
pop rbx
pop r14
retn
loc_6F83C:
lea rsi, [r14+18h]
lea rcx, [r14+24h]
inc r8d
mov edx, 4
call js_realloc_array
mov ecx, eax
mov eax, 0FFFFFFFFh
test ecx, ecx
jnz short loc_6F834
jmp short loc_6F805
|
long long ss_check(
long long a1,
long long a2,
unsigned int a3,
unsigned int a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
char v14; // al
const char *v16; // rsi
long long v17; // rcx
long long v18; // rdx
long long result; // rax
const char *v20; // rsi
long long v21; // rcx
int v22; // r8d
long long v23; // rax
long long v24; // rcx
int v25; // ecx
char v26; // [rsp-8h] [rbp-18h]
v26 = v14;
if ( *(_DWORD *)a2 <= a3 )
{
v16 = "bytecode buffer overflow (op=%d, pc=%d)";
goto LABEL_6;
}
if ( *(_DWORD *)(a2 + 4) < (int)a5 )
{
*(_DWORD *)(a2 + 4) = a5;
if ( (int)a5 >= 0xFFFF )
{
v16 = "stack overflow (op=%d, pc=%d)";
LABEL_6:
JS_ThrowInternalError(a1, (long long)v16, a4, a3, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v14);
return 0xFFFFFFFFLL;
}
}
v17 = *(_QWORD *)(a2 + 8);
v18 = *(unsigned __int16 *)(v17 + 2LL * (int)a3);
if ( (_DWORD)v18 != 0xFFFF )
{
if ( (_DWORD)v18 == (_DWORD)a5 )
{
v18 = *(unsigned int *)(*(_QWORD *)(a2 + 16) + 4LL * (int)a3);
result = 0LL;
if ( (_DWORD)v18 == (_DWORD)a6 )
return result;
v20 = "inconsistent catch position: %d %d (pc=%d)";
v21 = (unsigned int)a6;
}
else
{
v20 = "inconsistent stack size: %d %d (pc=%d)";
v21 = (unsigned int)a5;
}
JS_ThrowInternalError(a1, (long long)v20, v18, v21, a3, a6, a7, a8, a9, a10, a11, a12, a13, a14, v26);
return 0xFFFFFFFFLL;
}
*(_WORD *)(v17 + 2LL * (int)a3) = a5;
*(_DWORD *)(*(_QWORD *)(a2 + 16) + 4LL * (int)a3) = a6;
v22 = *(_DWORD *)(a2 + 32);
if ( *(_DWORD *)(a2 + 36) > v22
|| (v25 = js_realloc_array(a1, (long long *)(a2 + 24), 4u, (_DWORD *)(a2 + 36), v22 + 1), result = 0xFFFFFFFFLL, !v25) )
{
v23 = *(_QWORD *)(a2 + 24);
v24 = *(int *)(a2 + 32);
*(_DWORD *)(a2 + 32) = v24 + 1;
*(_DWORD *)(v23 + 4 * v24) = a3;
return 0LL;
}
return result;
}
| |||
63,684
|
ss_check
|
bluesky950520[P]quickjs/quickjs.c
|
static __exception int ss_check(JSContext *ctx, StackSizeState *s,
int pos, int op, int stack_len, int catch_pos)
{
if ((unsigned)pos >= s->bc_len) {
JS_ThrowInternalError(ctx, "bytecode buffer overflow (op=%d, pc=%d)", op, pos);
return -1;
}
if (stack_len > s->stack_len_max) {
s->stack_len_max = stack_len;
if (s->stack_len_max > JS_STACK_SIZE_MAX) {
JS_ThrowInternalError(ctx, "stack overflow (op=%d, pc=%d)", op, pos);
return -1;
}
}
if (s->stack_level_tab[pos] != 0xffff) {
/* already explored: check that the stack size is consistent */
if (s->stack_level_tab[pos] != stack_len) {
JS_ThrowInternalError(ctx, "inconsistent stack size: %d %d (pc=%d)",
s->stack_level_tab[pos], stack_len, pos);
return -1;
} else if (s->catch_pos_tab[pos] != catch_pos) {
JS_ThrowInternalError(ctx, "inconsistent catch position: %d %d (pc=%d)",
s->catch_pos_tab[pos], catch_pos, pos);
return -1;
} else {
return 0;
}
}
/* mark as explored and store the stack size */
s->stack_level_tab[pos] = stack_len;
s->catch_pos_tab[pos] = catch_pos;
/* queue the new PC to explore */
if (js_resize_array(ctx, (void **)&s->pc_stack, sizeof(s->pc_stack[0]),
&s->pc_stack_size, s->pc_stack_len + 1))
return -1;
s->pc_stack[s->pc_stack_len++] = pos;
return 0;
}
|
O2
|
c
|
ss_check:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
cmpl %edx, (%rsi)
jbe 0x5dc16
movq %rsi, %r14
cmpl %r8d, 0x4(%rsi)
jge 0x5dc2d
movl %r8d, 0x4(%r14)
cmpl $0xffff, %r8d # imm = 0xFFFF
jl 0x5dc2d
leaq 0x2aa9f(%rip), %rsi # 0x886b3
jmp 0x5dc1d
leaq 0x2aa4f(%rip), %rsi # 0x8866c
movl %ecx, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1c771
jmp 0x5dcb1
movq 0x8(%r14), %rcx
movslq %ebx, %rax
movzwl (%rcx,%rax,2), %edx
cmpl $0xffff, %edx # imm = 0xFFFF
je 0x5dc5f
cmpl %r8d, %edx
jne 0x5dc9d
movq 0x10(%r14), %rcx
movl (%rcx,%rax,4), %edx
xorl %eax, %eax
cmpl %r9d, %edx
je 0x5dcb4
leaq 0x2aabd(%rip), %rsi # 0x88717
movl %r9d, %ecx
jmp 0x5dca7
movw %r8w, (%rcx,%rax,2)
movq 0x10(%r14), %rcx
movl %r9d, (%rcx,%rax,4)
leaq 0x18(%r14), %rsi
leaq 0x24(%r14), %rcx
movl 0x20(%r14), %r8d
incl %r8d
pushq $0x4
popq %rdx
callq 0x3b0ef
testl %eax, %eax
jne 0x5dcb1
movq 0x18(%r14), %rax
movslq 0x20(%r14), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x20(%r14)
movl %ebx, (%rax,%rcx,4)
xorl %eax, %eax
jmp 0x5dcb4
leaq 0x2aa4c(%rip), %rsi # 0x886f0
movl %r8d, %ecx
movl %ebx, %r8d
xorl %eax, %eax
callq 0x1c771
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
ss_check:
push r14
push rbx
push rax
mov ebx, edx
cmp [rsi], edx
jbe short loc_5DC16
mov r14, rsi
cmp [rsi+4], r8d
jge short loc_5DC2D
mov [r14+4], r8d
cmp r8d, 0FFFFh
jl short loc_5DC2D
lea rsi, aStackOverflowO; "stack overflow (op=%d, pc=%d)"
jmp short loc_5DC1D
loc_5DC16:
lea rsi, aBytecodeBuffer; "bytecode buffer overflow (op=%d, pc=%d)"
loc_5DC1D:
mov edx, ecx
mov ecx, ebx
xor eax, eax
call JS_ThrowInternalError
jmp loc_5DCB1
loc_5DC2D:
mov rcx, [r14+8]
movsxd rax, ebx
movzx edx, word ptr [rcx+rax*2]
cmp edx, 0FFFFh
jz short loc_5DC5F
cmp edx, r8d
jnz short loc_5DC9D
mov rcx, [r14+10h]
mov edx, [rcx+rax*4]
xor eax, eax
cmp edx, r9d
jz short loc_5DCB4
lea rsi, aInconsistentCa; "inconsistent catch position: %d %d (pc="...
mov ecx, r9d
jmp short loc_5DCA7
loc_5DC5F:
mov [rcx+rax*2], r8w
mov rcx, [r14+10h]
mov [rcx+rax*4], r9d
lea rsi, [r14+18h]
lea rcx, [r14+24h]
mov r8d, [r14+20h]
inc r8d
push 4
pop rdx
call js_resize_array
test eax, eax
jnz short loc_5DCB1
mov rax, [r14+18h]
movsxd rcx, dword ptr [r14+20h]
lea edx, [rcx+1]
mov [r14+20h], edx
mov [rax+rcx*4], ebx
xor eax, eax
jmp short loc_5DCB4
loc_5DC9D:
lea rsi, aInconsistentSt; "inconsistent stack size: %d %d (pc=%d)"
mov ecx, r8d
loc_5DCA7:
mov r8d, ebx
xor eax, eax
call JS_ThrowInternalError
loc_5DCB1:
push 0FFFFFFFFFFFFFFFFh
pop rax
loc_5DCB4:
add rsp, 8
pop rbx
pop r14
retn
|
long long ss_check(
long long a1,
long long a2,
unsigned int a3,
unsigned int a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
char v14; // al
const char *v16; // rsi
long long v17; // rcx
long long v18; // rdx
long long result; // rax
const char *v20; // rsi
long long v21; // rcx
long long v22; // rax
long long v23; // rcx
char v24; // [rsp-8h] [rbp-18h]
v24 = v14;
if ( *(_DWORD *)a2 <= a3 )
{
v16 = "bytecode buffer overflow (op=%d, pc=%d)";
goto LABEL_6;
}
if ( *(_DWORD *)(a2 + 4) < (int)a5 )
{
*(_DWORD *)(a2 + 4) = a5;
if ( (int)a5 >= 0xFFFF )
{
v16 = "stack overflow (op=%d, pc=%d)";
LABEL_6:
JS_ThrowInternalError(a1, (long long)v16, a4, a3, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v14);
return -1LL;
}
}
v17 = *(_QWORD *)(a2 + 8);
v18 = *(unsigned __int16 *)(v17 + 2LL * (int)a3);
if ( (_DWORD)v18 == 0xFFFF )
{
*(_WORD *)(v17 + 2LL * (int)a3) = a5;
*(_DWORD *)(*(_QWORD *)(a2 + 16) + 4LL * (int)a3) = a6;
if ( !(unsigned int)js_resize_array(a1, a2 + 24, 4LL, (_DWORD *)(a2 + 36), *(_DWORD *)(a2 + 32) + 1) )
{
v22 = *(_QWORD *)(a2 + 24);
v23 = *(int *)(a2 + 32);
*(_DWORD *)(a2 + 32) = v23 + 1;
*(_DWORD *)(v22 + 4 * v23) = a3;
return 0LL;
}
}
else
{
if ( (_DWORD)v18 == (_DWORD)a5 )
{
v18 = *(unsigned int *)(*(_QWORD *)(a2 + 16) + 4LL * (int)a3);
result = 0LL;
if ( (_DWORD)v18 == (_DWORD)a6 )
return result;
v20 = "inconsistent catch position: %d %d (pc=%d)";
v21 = (unsigned int)a6;
}
else
{
v20 = "inconsistent stack size: %d %d (pc=%d)";
v21 = (unsigned int)a5;
}
JS_ThrowInternalError(a1, (long long)v20, v18, v21, a3, a6, a7, a8, a9, a10, a11, a12, a13, a14, v24);
}
return -1LL;
}
|
ss_check:
PUSH R14
PUSH RBX
PUSH RAX
MOV EBX,EDX
CMP dword ptr [RSI],EDX
JBE 0x0015dc16
MOV R14,RSI
CMP dword ptr [RSI + 0x4],R8D
JGE 0x0015dc2d
MOV dword ptr [R14 + 0x4],R8D
CMP R8D,0xffff
JL 0x0015dc2d
LEA RSI,[0x1886b3]
JMP 0x0015dc1d
LAB_0015dc16:
LEA RSI,[0x18866c]
LAB_0015dc1d:
MOV EDX,ECX
MOV ECX,EBX
XOR EAX,EAX
CALL 0x0011c771
JMP 0x0015dcb1
LAB_0015dc2d:
MOV RCX,qword ptr [R14 + 0x8]
MOVSXD RAX,EBX
MOVZX EDX,word ptr [RCX + RAX*0x2]
CMP EDX,0xffff
JZ 0x0015dc5f
CMP EDX,R8D
JNZ 0x0015dc9d
MOV RCX,qword ptr [R14 + 0x10]
MOV EDX,dword ptr [RCX + RAX*0x4]
XOR EAX,EAX
CMP EDX,R9D
JZ 0x0015dcb4
LEA RSI,[0x188717]
MOV ECX,R9D
JMP 0x0015dca7
LAB_0015dc5f:
MOV word ptr [RCX + RAX*0x2],R8W
MOV RCX,qword ptr [R14 + 0x10]
MOV dword ptr [RCX + RAX*0x4],R9D
LEA RSI,[R14 + 0x18]
LEA RCX,[R14 + 0x24]
MOV R8D,dword ptr [R14 + 0x20]
INC R8D
PUSH 0x4
POP RDX
CALL 0x0013b0ef
TEST EAX,EAX
JNZ 0x0015dcb1
MOV RAX,qword ptr [R14 + 0x18]
MOVSXD RCX,dword ptr [R14 + 0x20]
LEA EDX,[RCX + 0x1]
MOV dword ptr [R14 + 0x20],EDX
MOV dword ptr [RAX + RCX*0x4],EBX
XOR EAX,EAX
JMP 0x0015dcb4
LAB_0015dc9d:
LEA RSI,[0x1886f0]
MOV ECX,R8D
LAB_0015dca7:
MOV R8D,EBX
XOR EAX,EAX
CALL 0x0011c771
LAB_0015dcb1:
PUSH -0x1
POP RAX
LAB_0015dcb4:
ADD RSP,0x8
POP RBX
POP R14
RET
|
int8
ss_check(int8 param_1,uint *param_2,uint param_3,int4 param_4,uint param_5,uint param_6)
{
ushort uVar1;
int iVar2;
long lVar3;
uint uVar4;
char *pcVar5;
if (param_3 < *param_2) {
if (((int)param_5 <= (int)param_2[1]) || (param_2[1] = param_5, (int)param_5 < 0xffff)) {
lVar3 = (long)(int)param_3;
uVar1 = *(ushort *)(*(long *)(param_2 + 2) + lVar3 * 2);
uVar4 = (uint)uVar1;
if (uVar1 == 0xffff) {
*(short *)(*(long *)(param_2 + 2) + lVar3 * 2) = (short)param_5;
*(uint *)(*(long *)(param_2 + 4) + lVar3 * 4) = param_6;
iVar2 = js_resize_array(param_1,param_2 + 6,4,param_2 + 9,param_2[8] + 1);
if (iVar2 != 0) {
return 0xffffffffffffffff;
}
uVar4 = param_2[8];
param_2[8] = uVar4 + 1;
*(uint *)(*(long *)(param_2 + 6) + (long)(int)uVar4 * 4) = param_3;
return 0;
}
if (uVar1 == param_5) {
uVar4 = *(uint *)(*(long *)(param_2 + 4) + lVar3 * 4);
if (uVar4 == param_6) {
return 0;
}
pcVar5 = "inconsistent catch position: %d %d (pc=%d)";
param_5 = param_6;
}
else {
pcVar5 = "inconsistent stack size: %d %d (pc=%d)";
}
JS_ThrowInternalError(param_1,pcVar5,uVar4,param_5,param_3);
return 0xffffffffffffffff;
}
pcVar5 = "stack overflow (op=%d, pc=%d)";
}
else {
pcVar5 = "bytecode buffer overflow (op=%d, pc=%d)";
}
JS_ThrowInternalError(param_1,pcVar5,param_4,param_3);
return 0xffffffffffffffff;
}
|
|
63,685
|
my_os_charset_to_mysql_charset
|
eloqsql/mysys/charset.c
|
static const char*
my_os_charset_to_mysql_charset(const char* csname)
{
const MY_CSET_OS_NAME* csp;
for (csp = charsets; csp->os_name; csp++)
{
if (!strcasecmp(csp->os_name, csname))
{
switch (csp->param)
{
case my_cs_exact:
return csp->my_name;
case my_cs_approx:
/*
Maybe we should print a warning eventually:
character set correspondence is not exact.
*/
return csp->my_name;
default:
return NULL;
}
}
}
return NULL;
}
|
O0
|
c
|
my_os_charset_to_mysql_charset:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x19954d(%rip), %rax # 0x1c38f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2a416
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x242c0
cmpl $0x0, %eax
jne 0x2a406
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0x2a3e0
jmp 0x2a3d6
movl -0x1c(%rbp), %eax
subl $0x1, %eax
je 0x2a3ee
jmp 0x2a3fc
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2a41e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2a41e
movq $0x0, -0x8(%rbp)
jmp 0x2a41e
jmp 0x2a408
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
jmp 0x2a3a7
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
my_os_charset_to_mysql_charset:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
lea rax, charsets
mov [rbp+var_18], rax
loc_2A3A7:
mov rax, [rbp+var_18]
cmp qword ptr [rax], 0
jz short loc_2A416
mov rax, [rbp+var_18]
mov rdi, [rax]
mov rsi, [rbp+var_10]
call _strcasecmp
cmp eax, 0
jnz short loc_2A406
mov rax, [rbp+var_18]
mov eax, [rax+10h]
mov [rbp+var_1C], eax
test eax, eax
jz short loc_2A3E0
jmp short $+2
loc_2A3D6:
mov eax, [rbp+var_1C]
sub eax, 1
jz short loc_2A3EE
jmp short loc_2A3FC
loc_2A3E0:
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov [rbp+var_8], rax
jmp short loc_2A41E
loc_2A3EE:
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov [rbp+var_8], rax
jmp short loc_2A41E
loc_2A3FC:
mov [rbp+var_8], 0
jmp short loc_2A41E
loc_2A406:
jmp short $+2
loc_2A408:
mov rax, [rbp+var_18]
add rax, 18h
mov [rbp+var_18], rax
jmp short loc_2A3A7
loc_2A416:
mov [rbp+var_8], 0
loc_2A41E:
mov rax, [rbp+var_8]
add rsp, 20h
pop rbp
retn
|
char * my_os_charset_to_mysql_charset(long long a1)
{
int v2; // [rsp+4h] [rbp-1Ch]
char **i; // [rsp+8h] [rbp-18h]
for ( i = charsets; ; i += 3 )
{
if ( !*i )
return 0LL;
if ( !(unsigned int)strcasecmp(*i, a1) )
break;
}
v2 = *((_DWORD *)i + 4);
if ( !v2 )
return i[1];
if ( v2 == 1 )
return i[1];
return 0LL;
}
|
my_os_charset_to_mysql_charset:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
LEA RAX,[0x2c38f0]
MOV qword ptr [RBP + -0x18],RAX
LAB_0012a3a7:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX],0x0
JZ 0x0012a416
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x001242c0
CMP EAX,0x0
JNZ 0x0012a406
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x10]
MOV dword ptr [RBP + -0x1c],EAX
TEST EAX,EAX
JZ 0x0012a3e0
JMP 0x0012a3d6
LAB_0012a3d6:
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
JZ 0x0012a3ee
JMP 0x0012a3fc
LAB_0012a3e0:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0012a41e
LAB_0012a3ee:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0012a41e
LAB_0012a3fc:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0012a41e
LAB_0012a406:
JMP 0x0012a408
LAB_0012a408:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x18
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0012a3a7
LAB_0012a416:
MOV qword ptr [RBP + -0x8],0x0
LAB_0012a41e:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x20
POP RBP
RET
|
int * my_os_charset_to_mysql_charset(char *param_1)
{
int iVar1;
int **local_20;
local_20 = &charsets;
while( true ) {
if (*local_20 == (int *)0x0) {
return (int *)0x0;
}
iVar1 = strcasecmp(*local_20,param_1);
if (iVar1 == 0) break;
local_20 = local_20 + 3;
}
if (*(int *)(local_20 + 2) != 0) {
if (*(int *)(local_20 + 2) != 1) {
return (int *)0x0;
}
return local_20[1];
}
return local_20[1];
}
|
|
63,686
|
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::findSharedEdgePoint(int, int, int, int)
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchTableFactory.cpp
|
Index
PatchTableBuilder::LocalPointHelper::findSharedEdgePoint(int levelIndex,
Index edgeIndex, int edgeEnd, Index localPointIndex) {
if (_sharedEdgePoints.empty()) {
_sharedEdgePoints.resize(_refiner.GetNumLevels());
}
IndexVector & edgePoints = _sharedEdgePoints[levelIndex];
if (edgePoints.empty()) {
edgePoints.resize(
2 * _refiner.GetLevel(levelIndex).GetNumEdges(), INDEX_INVALID);
}
Index & assignedIndex = edgePoints[2 * edgeIndex + edgeEnd];
if (!IndexIsValid(assignedIndex)) {
assignedIndex = localPointIndex;
} else {
}
return assignedIndex;
}
|
O1
|
cpp
|
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::findSharedEdgePoint(int, int, int, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %r14d
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %r12
leaq 0x30(%rdi), %r13
movq 0x30(%rdi), %rax
cmpq 0x38(%rdi), %rax
jne 0x6e134
movq (%r12), %rax
movq 0x68(%rax), %rcx
subq 0x60(%rax), %rcx
shrq $0x3, %rcx
imull $0xaaaaaaab, %ecx, %eax # imm = 0xAAAAAAAB
movslq %eax, %rsi
movq %r13, %rdi
callq 0x3af00
movslq %ebp, %rax
movq (%r13), %rcx
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %r13
movq (%r13), %rcx
cmpq 0x8(%r13), %rcx
jne 0x6e16f
movq (%r12), %rcx
movq 0x60(%rcx), %rcx
movq (%rcx,%rax,8), %rax
movslq 0x4(%rax), %rsi
addq %rsi, %rsi
leaq 0x4ad7d(%rip), %rdx # 0xb8ee4
movq %r13, %rdi
callq 0x38f90
leal (%r14,%r15,2), %eax
cltq
movq (%r13), %rcx
cmpl $-0x1, (%rcx,%rax,4)
jne 0x6e182
movl %ebx, (%rcx,%rax,4)
movl (%rcx,%rax,4), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ZN10OpenSubdiv6v3_6_03Far17PatchTableBuilder16LocalPointHelper19findSharedEdgePointEiiii:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ebx, r8d
mov r14d, ecx
mov r15d, edx
mov ebp, esi
mov r12, rdi
lea r13, [rdi+30h]
mov rax, [rdi+30h]
cmp rax, [rdi+38h]
jnz short loc_6E134
mov rax, [r12]
mov rcx, [rax+68h]
sub rcx, [rax+60h]
shr rcx, 3
imul eax, ecx, 0AAAAAAABh
movsxd rsi, eax
mov rdi, r13
call __ZNSt6vectorIS_IiSaIiEESaIS1_EE6resizeEm; std::vector<std::vector<int>>::resize(ulong)
loc_6E134:
movsxd rax, ebp
mov rcx, [r13+0]
lea rax, [rax+rax*2]
lea r13, [rcx+rax*8]
mov rcx, [r13+0]
cmp rcx, [r13+8]
jnz short loc_6E16F
mov rcx, [r12]
mov rcx, [rcx+60h]
mov rax, [rcx+rax*8]
movsxd rsi, dword ptr [rax+4]
add rsi, rsi
lea rdx, _ZN10OpenSubdiv6v3_6_03FarL13INDEX_INVALIDE; OpenSubdiv::v3_6_0::Far::INDEX_INVALID
mov rdi, r13
call __ZNSt6vectorIiSaIiEE6resizeEmRKi; std::vector<int>::resize(ulong,int const&)
loc_6E16F:
lea eax, [r14+r15*2]
cdqe
mov rcx, [r13+0]
cmp dword ptr [rcx+rax*4], 0FFFFFFFFh
jnz short loc_6E182
mov [rcx+rax*4], ebx
loc_6E182:
mov eax, [rcx+rax*4]
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::findSharedEdgePoint(
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper *this,
int a2,
int a3,
int a4,
int a5)
{
long long *v8; // r13
long long v9; // rax
long long v10; // rcx
if ( *((_QWORD *)this + 6) == *((_QWORD *)this + 7) )
std::vector<std::vector<int>>::resize(
(char *)this + 48,
(int)(-1431655765 * ((*(_QWORD *)(*(_QWORD *)this + 104LL) - *(_QWORD *)(*(_QWORD *)this + 96LL)) >> 3)));
v8 = (long long *)(*((_QWORD *)this + 6) + 24LL * a2);
if ( *v8 == v8[1] )
std::vector<int>::resize(
v8,
2LL * *(int *)(*(_QWORD *)(*(_QWORD *)(*(_QWORD *)this + 96LL) + 24LL * a2) + 4LL),
&OpenSubdiv::v3_6_0::Far::INDEX_INVALID);
v9 = a4 + 2 * a3;
v10 = *v8;
if ( *(_DWORD *)(*v8 + 4 * v9) == -1 )
*(_DWORD *)(v10 + 4 * v9) = a5;
return *(unsigned int *)(v10 + 4 * v9);
}
|
findSharedEdgePoint:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV EBX,R8D
MOV R14D,ECX
MOV R15D,EDX
MOV EBP,ESI
MOV R12,RDI
LEA R13,[RDI + 0x30]
MOV RAX,qword ptr [RDI + 0x30]
CMP RAX,qword ptr [RDI + 0x38]
JNZ 0x0016e134
MOV RAX,qword ptr [R12]
MOV RCX,qword ptr [RAX + 0x68]
SUB RCX,qword ptr [RAX + 0x60]
SHR RCX,0x3
IMUL EAX,ECX,-0x55555555
MOVSXD RSI,EAX
MOV RDI,R13
CALL 0x0013af00
LAB_0016e134:
MOVSXD RAX,EBP
MOV RCX,qword ptr [R13]
LEA RAX,[RAX + RAX*0x2]
LEA R13,[RCX + RAX*0x8]
MOV RCX,qword ptr [R13]
CMP RCX,qword ptr [R13 + 0x8]
JNZ 0x0016e16f
MOV RCX,qword ptr [R12]
MOV RCX,qword ptr [RCX + 0x60]
MOV RAX,qword ptr [RCX + RAX*0x8]
MOVSXD RSI,dword ptr [RAX + 0x4]
ADD RSI,RSI
LEA RDX,[0x1b8ee4]
MOV RDI,R13
CALL 0x00138f90
LAB_0016e16f:
LEA EAX,[R14 + R15*0x2]
CDQE
MOV RCX,qword ptr [R13]
CMP dword ptr [RCX + RAX*0x4],-0x1
JNZ 0x0016e182
MOV dword ptr [RCX + RAX*0x4],EBX
LAB_0016e182:
MOV EAX,dword ptr [RCX + RAX*0x4]
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::findSharedEdgePoint(int, int, int,
int) */
int4 __thiscall
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::findSharedEdgePoint
(LocalPointHelper *this,int param_1,int param_2,int param_3,int param_4)
{
vector<int,std::allocator<int>> *this_00;
long lVar1;
long lVar2;
if (*(long *)(this + 0x30) == *(long *)(this + 0x38)) {
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::resize((vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*)(this + 0x30),
(long)((int)((ulong)(*(long *)(*(long *)this + 0x68) - *(long *)(*(long *)this + 0x60))
>> 3) * -0x55555555));
}
this_00 = (vector<int,std::allocator<int>> *)(*(long *)(this + 0x30) + (long)param_1 * 0x18);
if (*(long *)this_00 == *(long *)(this_00 + 8)) {
std::vector<int,std::allocator<int>>::resize
(this_00,(long)*(int *)(*(long *)(*(long *)(*(long *)this + 0x60) +
(long)param_1 * 0x18) + 4) * 2,&INDEX_INVALID);
}
lVar2 = (long)(param_3 + param_2 * 2);
lVar1 = *(long *)this_00;
if (*(int *)(lVar1 + lVar2 * 4) == -1) {
*(int *)(lVar1 + lVar2 * 4) = param_4;
}
return *(int4 *)(lVar1 + lVar2 * 4);
}
|
|
63,687
|
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::findSharedEdgePoint(int, int, int, int)
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchTableFactory.cpp
|
Index
PatchTableBuilder::LocalPointHelper::findSharedEdgePoint(int levelIndex,
Index edgeIndex, int edgeEnd, Index localPointIndex) {
if (_sharedEdgePoints.empty()) {
_sharedEdgePoints.resize(_refiner.GetNumLevels());
}
IndexVector & edgePoints = _sharedEdgePoints[levelIndex];
if (edgePoints.empty()) {
edgePoints.resize(
2 * _refiner.GetLevel(levelIndex).GetNumEdges(), INDEX_INVALID);
}
Index & assignedIndex = edgePoints[2 * edgeIndex + edgeEnd];
if (!IndexIsValid(assignedIndex)) {
assignedIndex = localPointIndex;
} else {
}
return assignedIndex;
}
|
O3
|
cpp
|
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::findSharedEdgePoint(int, int, int, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %r14d
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %r12
movq 0x30(%rdi), %rax
cmpq 0x38(%rdi), %rax
jne 0x6f76d
movq (%r12), %rax
movq 0x68(%rax), %rcx
subq 0x60(%rax), %rcx
leaq 0x30(%r12), %rdi
shrq $0x3, %rcx
imull $0xaaaaaaab, %ecx, %eax # imm = 0xAAAAAAAB
movslq %eax, %rsi
callq 0x3aec0
movq 0x30(%r12), %rax
movslq %ebp, %rcx
leaq (%rcx,%rcx,2), %rdx
movq (%rax,%rdx,8), %rcx
cmpq 0x8(%rax,%rdx,8), %rcx
jne 0x6f7a9
leaq (%rax,%rdx,8), %r13
movq (%r12), %rax
movq 0x60(%rax), %rax
movq (%rax,%rdx,8), %rax
movslq 0x4(%rax), %rsi
addq %rsi, %rsi
leaq 0x4ce87(%rip), %rdx # 0xbc624
movq %r13, %rdi
callq 0x38f80
movq (%r13), %rcx
leal (%r14,%r15,2), %eax
movslq %eax, %rdx
movl (%rcx,%rdx,4), %eax
cmpl $-0x1, %eax
jne 0x6f7bd
movl %ebx, (%rcx,%rdx,4)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ZN10OpenSubdiv6v3_6_03Far17PatchTableBuilder16LocalPointHelper19findSharedEdgePointEiiii:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ebx, r8d
mov r14d, ecx
mov r15d, edx
mov ebp, esi
mov r12, rdi
mov rax, [rdi+30h]
cmp rax, [rdi+38h]
jnz short loc_6F76D
mov rax, [r12]
mov rcx, [rax+68h]
sub rcx, [rax+60h]
lea rdi, [r12+30h]
shr rcx, 3
imul eax, ecx, 0AAAAAAABh
movsxd rsi, eax
call __ZNSt6vectorIS_IiSaIiEESaIS1_EE6resizeEm; std::vector<std::vector<int>>::resize(ulong)
mov rax, [r12+30h]
loc_6F76D:
movsxd rcx, ebp
lea rdx, [rcx+rcx*2]
mov rcx, [rax+rdx*8]
cmp rcx, [rax+rdx*8+8]
jnz short loc_6F7A9
lea r13, [rax+rdx*8]
mov rax, [r12]
mov rax, [rax+60h]
mov rax, [rax+rdx*8]
movsxd rsi, dword ptr [rax+4]
add rsi, rsi
lea rdx, _ZN10OpenSubdiv6v3_6_03FarL13INDEX_INVALIDE; OpenSubdiv::v3_6_0::Far::INDEX_INVALID
mov rdi, r13
call __ZNSt6vectorIiSaIiEE6resizeEmRKi; std::vector<int>::resize(ulong,int const&)
mov rcx, [r13+0]
loc_6F7A9:
lea eax, [r14+r15*2]
movsxd rdx, eax
mov eax, [rcx+rdx*4]
cmp eax, 0FFFFFFFFh
jnz short loc_6F7BD
mov [rcx+rdx*4], ebx
mov eax, ebx
loc_6F7BD:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::findSharedEdgePoint(
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper *this,
int a2,
int a3,
int a4,
unsigned int a5)
{
long long v8; // rax
long long v9; // rcx
long long *v10; // r13
long long v11; // rdx
long long result; // rax
v8 = *((_QWORD *)this + 6);
if ( v8 == *((_QWORD *)this + 7) )
{
std::vector<std::vector<int>>::resize(
(char *)this + 48,
(int)(-1431655765 * ((*(_QWORD *)(*(_QWORD *)this + 104LL) - *(_QWORD *)(*(_QWORD *)this + 96LL)) >> 3)));
v8 = *((_QWORD *)this + 6);
}
v9 = *(_QWORD *)(v8 + 24LL * a2);
if ( v9 == *(_QWORD *)(v8 + 24LL * a2 + 8) )
{
v10 = (long long *)(v8 + 24LL * a2);
std::vector<int>::resize(
v10,
2LL * *(int *)(*(_QWORD *)(*(_QWORD *)(*(_QWORD *)this + 96LL) + 24LL * a2) + 4LL),
&OpenSubdiv::v3_6_0::Far::INDEX_INVALID);
v9 = *v10;
}
v11 = a4 + 2 * a3;
result = *(unsigned int *)(v9 + 4 * v11);
if ( (_DWORD)result == -1 )
{
*(_DWORD *)(v9 + 4 * v11) = a5;
return a5;
}
return result;
}
|
findSharedEdgePoint:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV EBX,R8D
MOV R14D,ECX
MOV R15D,EDX
MOV EBP,ESI
MOV R12,RDI
MOV RAX,qword ptr [RDI + 0x30]
CMP RAX,qword ptr [RDI + 0x38]
JNZ 0x0016f76d
MOV RAX,qword ptr [R12]
MOV RCX,qword ptr [RAX + 0x68]
SUB RCX,qword ptr [RAX + 0x60]
LEA RDI,[R12 + 0x30]
SHR RCX,0x3
IMUL EAX,ECX,-0x55555555
MOVSXD RSI,EAX
CALL 0x0013aec0
MOV RAX,qword ptr [R12 + 0x30]
LAB_0016f76d:
MOVSXD RCX,EBP
LEA RDX,[RCX + RCX*0x2]
MOV RCX,qword ptr [RAX + RDX*0x8]
CMP RCX,qword ptr [RAX + RDX*0x8 + 0x8]
JNZ 0x0016f7a9
LEA R13,[RAX + RDX*0x8]
MOV RAX,qword ptr [R12]
MOV RAX,qword ptr [RAX + 0x60]
MOV RAX,qword ptr [RAX + RDX*0x8]
MOVSXD RSI,dword ptr [RAX + 0x4]
ADD RSI,RSI
LEA RDX,[0x1bc624]
MOV RDI,R13
CALL 0x00138f80
MOV RCX,qword ptr [R13]
LAB_0016f7a9:
LEA EAX,[R14 + R15*0x2]
MOVSXD RDX,EAX
MOV EAX,dword ptr [RCX + RDX*0x4]
CMP EAX,-0x1
JNZ 0x0016f7bd
MOV dword ptr [RCX + RDX*0x4],EBX
MOV EAX,EBX
LAB_0016f7bd:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::findSharedEdgePoint(int, int, int,
int) */
int __thiscall
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::findSharedEdgePoint
(LocalPointHelper *this,int param_1,int param_2,int param_3,int param_4)
{
vector<int,std::allocator<int>> *this_00;
int iVar1;
long lVar2;
long lVar3;
long lVar4;
lVar4 = *(long *)(this + 0x30);
if (lVar4 == *(long *)(this + 0x38)) {
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::resize((vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*)(this + 0x30),
(long)((int)((ulong)(*(long *)(*(long *)this + 0x68) - *(long *)(*(long *)this + 0x60))
>> 3) * -0x55555555));
lVar4 = *(long *)(this + 0x30);
}
lVar2 = (long)param_1;
lVar3 = *(long *)(lVar4 + lVar2 * 0x18);
if (lVar3 == *(long *)(lVar4 + 8 + lVar2 * 0x18)) {
this_00 = (vector<int,std::allocator<int>> *)(lVar4 + lVar2 * 0x18);
std::vector<int,std::allocator<int>>::resize
(this_00,(long)*(int *)(*(long *)(*(long *)(*(long *)this + 0x60) + lVar2 * 0x18) + 4)
* 2,&INDEX_INVALID);
lVar3 = *(long *)this_00;
}
lVar4 = (long)(param_3 + param_2 * 2);
iVar1 = *(int *)(lVar3 + lVar4 * 4);
if (iVar1 == -1) {
*(int *)(lVar3 + lVar4 * 4) = param_4;
iVar1 = param_4;
}
return iVar1;
}
|
|
63,688
|
cxxopts::exceptions::option_already_exists::~option_already_exists()
|
zkingston[P]unknot/build_O1/_deps/cxxopts-src/include/cxxopts.hpp
|
explicit option_already_exists(const std::string& option)
: specification("Option " + LQUOTE + option + RQUOTE + " already exists")
{
}
|
O1
|
cpp
|
cxxopts::exceptions::option_already_exists::~option_already_exists():
pushq %rbx
movq %rdi, %rbx
leaq 0x30c06d(%rip), %rax # 0x333118
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x270c6
movq (%rax), %rsi
incq %rsi
callq 0xfa70
movq %rbx, %rdi
callq 0x10260
movl $0x28, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xfa70
|
_ZN7cxxopts10exceptions21option_already_existsD0Ev:
push rbx
mov rbx, rdi
lea rax, off_333118
mov [rdi], rax
mov rdi, [rdi+8]; void *
lea rax, [rbx+18h]
cmp rdi, rax
jz short loc_270C6
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_270C6:
mov rdi, rbx; this
call __ZNSt9exceptionD2Ev; std::exception::~exception()
mov esi, 28h ; '('; unsigned __int64
mov rdi, rbx; void *
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
|
void cxxopts::exceptions::option_already_exists::~option_already_exists(
cxxopts::exceptions::option_already_exists *this)
{
char *v2; // rdi
*(_QWORD *)this = off_333118;
v2 = (char *)*((_QWORD *)this + 1);
if ( v2 != (char *)this + 24 )
operator delete(v2, *((_QWORD *)this + 3) + 1LL);
std::exception::~exception(this);
operator delete(this, 0x28uLL);
}
|
~option_already_exists:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x433118]
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x8]
LEA RAX,[RBX + 0x18]
CMP RDI,RAX
JZ 0x001270c6
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x0010fa70
LAB_001270c6:
MOV RDI,RBX
CALL 0x00110260
MOV ESI,0x28
MOV RDI,RBX
POP RBX
JMP 0x0010fa70
|
/* cxxopts::exceptions::option_already_exists::~option_already_exists() */
void __thiscall
cxxopts::exceptions::option_already_exists::~option_already_exists(option_already_exists *this)
{
*(int ***)this = &PTR__exception_00433118;
if (*(option_already_exists **)(this + 8) != this + 0x18) {
operator_delete(*(option_already_exists **)(this + 8),*(long *)(this + 0x18) + 1);
}
std::exception::~exception((exception *)this);
operator_delete(this,0x28);
return;
}
|
|
63,689
|
my_once_free
|
eloqsql/mysys/my_once.c
|
void my_once_free(void)
{
reg1 USED_MEM *next,*old;
DBUG_ENTER("my_once_free");
for (next=my_once_root_block ; next ; )
{
old=next; next= next->next ;
free((uchar*) old);
}
my_once_root_block=0;
DBUG_VOID_RETURN;
}
|
O3
|
c
|
my_once_free:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0xb67e12(%rip), %rbx # 0xc081d0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xa03d6
movq (%rdi), %r14
callq 0x29140
movq %r14, %rdi
testq %r14, %r14
jne 0xa03c6
movq $0x0, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
|
my_once_free:
push rbp
mov rbp, rsp
push r14
push rbx
lea rbx, my_once_root_block
mov rdi, [rbx]
test rdi, rdi
jz short loc_A03D6
loc_A03C6:
mov r14, [rdi]
call _free
mov rdi, r14
test r14, r14
jnz short loc_A03C6
loc_A03D6:
mov qword ptr [rbx], 0
pop rbx
pop r14
pop rbp
retn
|
long long my_once_free()
{
_QWORD *v0; // rdi
_QWORD *v1; // r14
long long result; // rax
v0 = (_QWORD *)my_once_root_block;
if ( my_once_root_block )
{
do
{
v1 = (_QWORD *)*v0;
result = free(v0);
v0 = v1;
}
while ( v1 );
}
my_once_root_block = 0LL;
return result;
}
|
my_once_free:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
LEA RBX,[0xd081d0]
MOV RDI,qword ptr [RBX]
TEST RDI,RDI
JZ 0x001a03d6
LAB_001a03c6:
MOV R14,qword ptr [RDI]
CALL 0x00129140
MOV RDI,R14
TEST R14,R14
JNZ 0x001a03c6
LAB_001a03d6:
MOV qword ptr [RBX],0x0
POP RBX
POP R14
POP RBP
RET
|
void my_once_free(void)
{
long *plVar1;
long *__ptr;
__ptr = my_once_root_block;
if (my_once_root_block != (long *)0x0) {
do {
plVar1 = (long *)*__ptr;
free(__ptr);
__ptr = plVar1;
} while (plVar1 != (long *)0x0);
}
my_once_root_block = (long *)0x0;
return;
}
|
|
63,690
|
gguf_get_key
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp
|
const char * gguf_get_key(const struct gguf_context * ctx, int64_t key_id) {
GGML_ASSERT(key_id >= 0 && key_id < gguf_get_n_kv(ctx));
return ctx->kv[key_id].get_key().c_str();
}
|
O1
|
cpp
|
gguf_get_key:
pushq %rax
testq %rsi, %rsi
js 0x3e842
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $0x2e8ba2e8ba2e8ba3, %rcx # imm = 0x2E8BA2E8BA2E8BA3
imulq %rcx, %rdx
cmpq %rsi, %rdx
jle 0x3e842
movq 0x10(%rdi), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %rcx, %rdx
cmpq %rsi, %rdx
jbe 0x3e83d
imulq $0x58, %rsi, %rcx
movq (%rax,%rcx), %rax
popq %rcx
retq
callq 0x19a11
leaq 0x1e7a4(%rip), %rdi # 0x5cfed
leaq 0xdd71(%rip), %rdx # 0x4c5c1
leaq 0x1ec0c(%rip), %rcx # 0x5d463
movl $0x2f7, %esi # imm = 0x2F7
xorl %eax, %eax
callq 0x18ce0
|
gguf_get_key:
push rax
test rsi, rsi
js short loc_3E842
mov rax, [rdi+8]
mov rdx, [rdi+10h]
sub rdx, rax
sar rdx, 3
mov rcx, 2E8BA2E8BA2E8BA3h
imul rdx, rcx
cmp rdx, rsi
jle short loc_3E842
mov rdx, [rdi+10h]
sub rdx, rax
sar rdx, 3
imul rdx, rcx
cmp rdx, rsi
jbe short loc_3E83D
imul rcx, rsi, 58h ; 'X'
mov rax, [rax+rcx]
pop rcx
retn
loc_3E83D:
call gguf_get_key_cold_1
loc_3E842:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKeyId0KeyIdGgu; "key_id >= 0 && key_id < gguf_get_n_kv(c"...
mov esi, 2F7h
xor eax, eax
call _ggml_abort
|
long long gguf_get_key(long long a1, long long a2, long long a3, long long a4, int a5, int a6)
{
long long v6; // rax
if ( a2 < 0 || (v6 = *(_QWORD *)(a1 + 8), 0x2E8BA2E8BA2E8BA3LL * ((*(_QWORD *)(a1 + 16) - v6) >> 3) <= a2) )
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp",
759,
(unsigned int)"GGML_ASSERT(%s) failed",
(unsigned int)"key_id >= 0 && key_id < gguf_get_n_kv(ctx)",
a5,
a6);
if ( 0x2E8BA2E8BA2E8BA3LL * ((*(_QWORD *)(a1 + 16) - v6) >> 3) <= (unsigned long long)a2 )
gguf_get_key_cold_1(a1);
return *(_QWORD *)(v6 + 88 * a2);
}
|
gguf_get_key:
PUSH RAX
TEST RSI,RSI
JS 0x0013e842
MOV RAX,qword ptr [RDI + 0x8]
MOV RDX,qword ptr [RDI + 0x10]
SUB RDX,RAX
SAR RDX,0x3
MOV RCX,0x2e8ba2e8ba2e8ba3
IMUL RDX,RCX
CMP RDX,RSI
JLE 0x0013e842
MOV RDX,qword ptr [RDI + 0x10]
SUB RDX,RAX
SAR RDX,0x3
IMUL RDX,RCX
CMP RDX,RSI
JBE 0x0013e83d
IMUL RCX,RSI,0x58
MOV RAX,qword ptr [RAX + RCX*0x1]
POP RCX
RET
LAB_0013e83d:
CALL 0x00119a11
LAB_0013e842:
LEA RDI,[0x15cfed]
LEA RDX,[0x14c5c1]
LEA RCX,[0x15d463]
MOV ESI,0x2f7
XOR EAX,EAX
CALL 0x00118ce0
|
int8 gguf_get_key(long param_1,ulong param_2)
{
long lVar1;
long lVar2;
ulong uVar3;
if ((-1 < (long)param_2) &&
(lVar1 = *(long *)(param_1 + 8),
lVar2 = (*(long *)(param_1 + 0x10) - lVar1 >> 3) * 0x2e8ba2e8ba2e8ba3,
lVar2 - param_2 != 0 && (long)param_2 <= lVar2)) {
uVar3 = (*(long *)(param_1 + 0x10) - lVar1 >> 3) * 0x2e8ba2e8ba2e8ba3;
if (param_2 <= uVar3 && uVar3 - param_2 != 0) {
return *(int8 *)(lVar1 + param_2 * 0x58);
}
gguf_get_key_cold_1();
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp",
0x2f7,"GGML_ASSERT(%s) failed","key_id >= 0 && key_id < gguf_get_n_kv(ctx)");
}
|
|
63,691
|
gguf_get_key
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp
|
const char * gguf_get_key(const struct gguf_context * ctx, int64_t key_id) {
GGML_ASSERT(key_id >= 0 && key_id < gguf_get_n_kv(ctx));
return ctx->kv[key_id].get_key().c_str();
}
|
O2
|
cpp
|
gguf_get_key:
pushq %rax
testq %rsi, %rsi
js 0x40c6b
movq 0x10(%rdi), %rax
subq 0x8(%rdi), %rax
pushq $0x58
popq %rcx
cqto
idivq %rcx
cmpq %rsi, %rax
jle 0x40c6b
addq $0x8, %rdi
callq 0x1e480
movq (%rax), %rax
popq %rcx
retq
leaq 0x1e5db(%rip), %rdi # 0x5f24d
leaq 0xd95c(%rip), %rdx # 0x4e5d5
leaq 0x1ea43(%rip), %rcx # 0x5f6c3
movl $0x2f7, %esi # imm = 0x2F7
xorl %eax, %eax
callq 0x1f9b0
|
gguf_get_key:
push rax
test rsi, rsi
js short loc_40C6B
mov rax, [rdi+10h]
sub rax, [rdi+8]
push 58h ; 'X'
pop rcx
cqo
idiv rcx
cmp rax, rsi
jle short loc_40C6B
add rdi, 8
call __ZNKSt6vectorI7gguf_kvSaIS0_EEixEm; std::vector<gguf_kv>::operator[](ulong)
mov rax, [rax]
pop rcx
retn
loc_40C6B:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKeyId0KeyIdGgu; "key_id >= 0 && key_id < gguf_get_n_kv(c"...
mov esi, 2F7h
xor eax, eax
call _ggml_abort
|
long long gguf_get_key(
long long a1,
long long 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
if ( a2 < 0 || (*(_QWORD *)(a1 + 16) - *(_QWORD *)(a1 + 8)) / 88LL <= a2 )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp",
759,
(long long)"GGML_ASSERT(%s) failed",
(long long)"key_id >= 0 && key_id < gguf_get_n_kv(ctx)",
a13,
a14,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
v14);
return *(_QWORD *)std::vector<gguf_kv>::operator[](a1 + 8, a2, (*(_QWORD *)(a1 + 16) - *(_QWORD *)(a1 + 8)) % 88LL);
}
|
gguf_get_key:
PUSH RAX
TEST RSI,RSI
JS 0x00140c6b
MOV RAX,qword ptr [RDI + 0x10]
SUB RAX,qword ptr [RDI + 0x8]
PUSH 0x58
POP RCX
CQO
IDIV RCX
CMP RAX,RSI
JLE 0x00140c6b
ADD RDI,0x8
CALL 0x0011e480
MOV RAX,qword ptr [RAX]
POP RCX
RET
LAB_00140c6b:
LEA RDI,[0x15f24d]
LEA RDX,[0x14e5d5]
LEA RCX,[0x15f6c3]
MOV ESI,0x2f7
XOR EAX,EAX
CALL 0x0011f9b0
|
int8 gguf_get_key(long param_1,ulong param_2)
{
int8 *puVar1;
if ((-1 < (long)param_2) &&
((long)param_2 < (*(long *)(param_1 + 0x10) - *(long *)(param_1 + 8)) / 0x58)) {
puVar1 = (int8 *)
std::vector<gguf_kv,std::allocator<gguf_kv>>::operator[]
((vector<gguf_kv,std::allocator<gguf_kv>> *)(param_1 + 8),param_2);
return *puVar1;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp",
0x2f7,"GGML_ASSERT(%s) failed","key_id >= 0 && key_id < gguf_get_n_kv(ctx)");
}
|
|
63,692
|
gguf_get_key
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp
|
const char * gguf_get_key(const struct gguf_context * ctx, int64_t key_id) {
GGML_ASSERT(key_id >= 0 && key_id < gguf_get_n_kv(ctx));
return ctx->kv[key_id].get_key().c_str();
}
|
O3
|
cpp
|
gguf_get_key:
testq %rsi, %rsi
js 0x3e0d0
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $0x2e8ba2e8ba2e8ba3, %rdx # imm = 0x2E8BA2E8BA2E8BA3
imulq %rcx, %rdx
cmpq %rsi, %rdx
jle 0x3e0d0
imulq $0x58, %rsi, %rcx
movq (%rax,%rcx), %rax
retq
pushq %rax
leaq 0x1f405(%rip), %rdi # 0x5d4dd
leaq 0xe586(%rip), %rdx # 0x4c665
leaq 0x1f86d(%rip), %rcx # 0x5d953
movl $0x2f7, %esi # imm = 0x2F7
xorl %eax, %eax
callq 0x17cd0
|
gguf_get_key:
test rsi, rsi
js short loc_3E0D0
mov rax, [rdi+8]
mov rcx, [rdi+10h]
sub rcx, rax
sar rcx, 3
mov rdx, 2E8BA2E8BA2E8BA3h
imul rdx, rcx
cmp rdx, rsi
jle short loc_3E0D0
imul rcx, rsi, 58h ; 'X'
mov rax, [rax+rcx]
retn
loc_3E0D0:
push rax
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKeyId0KeyIdGgu; "key_id >= 0 && key_id < gguf_get_n_kv(c"...
mov esi, 2F7h
xor eax, eax
call _ggml_abort
|
long long gguf_get_key(long long a1, long long a2, long long a3, long long a4, int a5, int a6)
{
long long v6; // rax
if ( a2 < 0 || (v6 = *(_QWORD *)(a1 + 8), 0x2E8BA2E8BA2E8BA3LL * ((*(_QWORD *)(a1 + 16) - v6) >> 3) <= a2) )
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp",
759,
(unsigned int)"GGML_ASSERT(%s) failed",
(unsigned int)"key_id >= 0 && key_id < gguf_get_n_kv(ctx)",
a5,
a6);
return *(_QWORD *)(v6 + 88 * a2);
}
|
gguf_get_key:
TEST RSI,RSI
JS 0x0013e0d0
MOV RAX,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RDI + 0x10]
SUB RCX,RAX
SAR RCX,0x3
MOV RDX,0x2e8ba2e8ba2e8ba3
IMUL RDX,RCX
CMP RDX,RSI
JLE 0x0013e0d0
IMUL RCX,RSI,0x58
MOV RAX,qword ptr [RAX + RCX*0x1]
RET
LAB_0013e0d0:
PUSH RAX
LEA RDI,[0x15d4dd]
LEA RDX,[0x14c665]
LEA RCX,[0x15d953]
MOV ESI,0x2f7
XOR EAX,EAX
CALL 0x00117cd0
|
int8
gguf_get_key(long param_1,long param_2,int8 param_3,int8 param_4,int8 param_5,
int8 param_6)
{
long in_RAX;
long lVar1;
if ((-1 < param_2) &&
(in_RAX = *(long *)(param_1 + 8),
lVar1 = (*(long *)(param_1 + 0x10) - in_RAX >> 3) * 0x2e8ba2e8ba2e8ba3,
lVar1 - param_2 != 0 && param_2 <= lVar1)) {
return *(int8 *)(in_RAX + param_2 * 0x58);
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp",
0x2f7,"GGML_ASSERT(%s) failed","key_id >= 0 && key_id < gguf_get_n_kv(ctx)",param_5,
param_6,in_RAX);
}
|
|
63,693
|
my_setwd
|
eloqsql/mysys/my_getwd.c
|
int my_setwd(const char *dir, myf MyFlags)
{
int res;
size_t length;
char *start, *pos;
DBUG_ENTER("my_setwd");
DBUG_PRINT("my",("dir: '%s' MyFlags %lu", dir, MyFlags));
start=(char *) dir;
if (! dir[0] || (dir[0] == FN_LIBCHAR && dir[1] == 0))
dir=FN_ROOTDIR;
if ((res=chdir((char*) dir)) != 0)
{
my_errno=errno;
if (MyFlags & MY_WME)
my_error(EE_SETWD,MYF(ME_BELL),start,errno);
}
else
{
if (test_if_hard_path(start))
{ /* Hard pathname */
pos= strmake(&curr_dir[0],start,(size_t) FN_REFLEN-1);
if (pos[-1] != FN_LIBCHAR)
{
length=(uint) (pos-(char*) curr_dir);
curr_dir[length]=FN_LIBCHAR; /* must end with '/' */
curr_dir[length+1]='\0';
}
}
else
curr_dir[0]='\0'; /* Don't save name */
}
DBUG_RETURN(res);
}
|
O0
|
c
|
my_setwd:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x2d0e2
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2d10c
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x2d117
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x2d117
leaq 0x4bf61(%rip), %rax # 0x79074
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x243d0
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x2d170
callq 0x24040
movl (%rax), %eax
movl %eax, -0x34(%rbp)
callq 0x25620
movl -0x34(%rbp), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
andq $0x10, %rax
cmpq $0x0, %rax
je 0x2d16e
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x24040
movq -0x40(%rbp), %rdx
movl (%rax), %ecx
movl $0x11, %edi
movl $0x4, %esi
movb $0x0, %al
callq 0x2c990
jmp 0x2d1e5
movq -0x28(%rbp), %rdi
callq 0x2d200
cmpl $0x0, %eax
je 0x2d1d9
movq -0x28(%rbp), %rsi
leaq 0x356637(%rip), %rdi # 0x3837c0
movl $0x1ff, %edx # imm = 0x1FF
callq 0x75890
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x2f, %eax
je 0x2d1d7
movq -0x30(%rbp), %rax
leaq 0x356611(%rip), %rcx # 0x3837c0
subq %rcx, %rax
movl %eax, %eax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
leaq 0x3565fd(%rip), %rax # 0x3837c0
movb $0x2f, (%rax,%rcx)
movq -0x20(%rbp), %rcx
leaq 0x3565ee(%rip), %rax # 0x3837c0
movb $0x0, 0x1(%rax,%rcx)
jmp 0x2d1e3
leaq 0x3565e0(%rip), %rax # 0x3837c0
movb $0x0, (%rax)
jmp 0x2d1e5
jmp 0x2d1e7
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_setwd:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
jmp short $+2
loc_2D0E2:
mov rax, [rbp+var_8]
mov [rbp+var_28], rax
mov rax, [rbp+var_8]
cmp byte ptr [rax], 0
jz short loc_2D10C
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
jnz short loc_2D117
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax+1]
cmp eax, 0
jnz short loc_2D117
loc_2D10C:
lea rax, unk_79074
mov [rbp+var_8], rax
loc_2D117:
mov rdi, [rbp+var_8]
call _chdir
mov [rbp+var_14], eax
cmp eax, 0
jz short loc_2D170
call ___errno_location
mov eax, [rax]
mov [rbp+var_34], eax
call _my_thread_var
mov ecx, [rbp+var_34]
mov [rax], ecx
mov rax, [rbp+var_10]
and rax, 10h
cmp rax, 0
jz short loc_2D16E
mov rax, [rbp+var_28]
mov [rbp+var_40], rax
call ___errno_location
mov rdx, [rbp+var_40]
mov ecx, [rax]
mov edi, 11h
mov esi, 4
mov al, 0
call my_error
loc_2D16E:
jmp short loc_2D1E5
loc_2D170:
mov rdi, [rbp+var_28]
call test_if_hard_path
cmp eax, 0
jz short loc_2D1D9
mov rsi, [rbp+var_28]
lea rdi, curr_dir
mov edx, 1FFh
call strmake
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax-1]
cmp eax, 2Fh ; '/'
jz short loc_2D1D7
mov rax, [rbp+var_30]
lea rcx, curr_dir
sub rax, rcx
mov eax, eax
mov [rbp+var_20], rax
mov rcx, [rbp+var_20]
lea rax, curr_dir
mov byte ptr [rax+rcx], 2Fh ; '/'
mov rcx, [rbp+var_20]
lea rax, curr_dir
mov byte ptr [rax+rcx+1], 0
loc_2D1D7:
jmp short loc_2D1E3
loc_2D1D9:
lea rax, curr_dir
mov byte ptr [rax], 0
loc_2D1E3:
jmp short $+2
loc_2D1E5:
jmp short $+2
loc_2D1E7:
mov eax, [rbp+var_14]
mov [rbp+var_44], eax
mov eax, [rbp+var_44]
add rsp, 50h
pop rbp
retn
|
long long my_setwd(_BYTE *a1, char a2)
{
unsigned int *v2; // rax
int v4; // [rsp+1Ch] [rbp-34h]
long long v5; // [rsp+20h] [rbp-30h]
unsigned int v6; // [rsp+3Ch] [rbp-14h]
void *v7; // [rsp+48h] [rbp-8h]
v7 = a1;
if ( !*a1 || *a1 == 47 && !a1[1] )
v7 = &unk_79074;
v6 = chdir(v7);
if ( v6 )
{
v4 = *(_DWORD *)__errno_location();
*(_DWORD *)my_thread_var() = v4;
if ( (a2 & 0x10) != 0 )
{
v2 = (unsigned int *)__errno_location();
my_error(0x11u, 4LL, a1, *v2);
}
}
else if ( (unsigned int)test_if_hard_path(a1) )
{
v5 = strmake(curr_dir, a1, 511LL);
if ( *(_BYTE *)(v5 - 1) != 47 )
{
curr_dir[(unsigned int)(v5 - (_QWORD)curr_dir)] = 47;
curr_dir[(unsigned int)(v5 - (_QWORD)curr_dir) + 1] = 0;
}
}
else
{
curr_dir[0] = 0;
}
return v6;
}
|
my_setwd:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
JMP 0x0012d0e2
LAB_0012d0e2:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x8]
CMP byte ptr [RAX],0x0
JZ 0x0012d10c
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
JNZ 0x0012d117
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x0
JNZ 0x0012d117
LAB_0012d10c:
LEA RAX,[0x179074]
MOV qword ptr [RBP + -0x8],RAX
LAB_0012d117:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001243d0
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JZ 0x0012d170
CALL 0x00124040
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x34],EAX
CALL 0x00125620
MOV ECX,dword ptr [RBP + -0x34]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x10]
AND RAX,0x10
CMP RAX,0x0
JZ 0x0012d16e
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x40],RAX
CALL 0x00124040
MOV RDX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RAX]
MOV EDI,0x11
MOV ESI,0x4
MOV AL,0x0
CALL 0x0012c990
LAB_0012d16e:
JMP 0x0012d1e5
LAB_0012d170:
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x0012d200
CMP EAX,0x0
JZ 0x0012d1d9
MOV RSI,qword ptr [RBP + -0x28]
LEA RDI,[0x4837c0]
MOV EDX,0x1ff
CALL 0x00175890
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX + -0x1]
CMP EAX,0x2f
JZ 0x0012d1d7
MOV RAX,qword ptr [RBP + -0x30]
LEA RCX,[0x4837c0]
SUB RAX,RCX
MOV EAX,EAX
MOV qword ptr [RBP + -0x20],RAX
MOV RCX,qword ptr [RBP + -0x20]
LEA RAX,[0x4837c0]
MOV byte ptr [RAX + RCX*0x1],0x2f
MOV RCX,qword ptr [RBP + -0x20]
LEA RAX,[0x4837c0]
MOV byte ptr [RAX + RCX*0x1 + 0x1],0x0
LAB_0012d1d7:
JMP 0x0012d1e3
LAB_0012d1d9:
LEA RAX,[0x4837c0]
MOV byte ptr [RAX],0x0
LAB_0012d1e3:
JMP 0x0012d1e5
LAB_0012d1e5:
JMP 0x0012d1e7
LAB_0012d1e7:
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x44],EAX
MOV EAX,dword ptr [RBP + -0x44]
ADD RSP,0x50
POP RBP
RET
|
int my_setwd(char *param_1,ulong param_2)
{
int iVar1;
int iVar2;
uint uVar3;
int *piVar4;
long lVar5;
char *local_10;
if ((*param_1 == '\0') || ((local_10 = param_1, *param_1 == '/' && (param_1[1] == '\0')))) {
local_10 = "/";
}
iVar1 = chdir(local_10);
if (iVar1 == 0) {
iVar2 = test_if_hard_path(param_1);
if (iVar2 == 0) {
curr_dir = 0;
}
else {
lVar5 = strmake(&curr_dir,param_1,0x1ff);
if (*(char *)(lVar5 + -1) != '/') {
uVar3 = (int)lVar5 - 0x4837c0;
(&curr_dir)[uVar3] = 0x2f;
(&DAT_004837c1)[uVar3] = 0;
}
}
}
else {
piVar4 = __errno_location();
iVar2 = *piVar4;
piVar4 = (int *)_my_thread_var();
*piVar4 = iVar2;
if ((param_2 & 0x10) != 0) {
piVar4 = __errno_location();
my_error(0x11,4,param_1,*piVar4);
}
}
return iVar1;
}
|
|
63,694
|
my_strnxfrm_unicode_full_bin_internal
|
eloqsql/strings/ctype-utf8.c
|
size_t
my_strnxfrm_unicode_full_bin_internal(CHARSET_INFO *cs,
uchar *dst, uchar *de, uint *nweights,
const uchar *src, const uchar *se)
{
my_wc_t UNINIT_VAR(wc);
uchar *dst0= dst;
DBUG_ASSERT(src || !se);
DBUG_ASSERT(cs->state & MY_CS_BINSORT);
for (; dst < de && *nweights; (*nweights)--)
{
int res;
if ((res= my_ci_mb_wc(cs, &wc, src, se)) <= 0)
break;
src+= res;
*dst++= (uchar) (wc >> 16);
if (dst < de)
{
*dst++= (uchar) ((wc >> 8) & 0xFF);
if (dst < de)
*dst++= (uchar) (wc & 0xFF);
}
}
return dst - dst0;
}
|
O0
|
c
|
my_strnxfrm_unicode_full_bin_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0xb3a82
jmp 0xb3a84
jmp 0xb3a86
jmp 0xb3a88
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x45(%rbp)
jae 0xb3aa4
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
setne %al
movb %al, -0x45(%rbp)
movb -0x45(%rbp), %al
testb $0x1, %al
jne 0xb3ab0
jmp 0xb3b70
movq -0x8(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq -0x38(%rbp), %rsi
callq *%rax
movl %eax, -0x44(%rbp)
cmpl $0x0, %eax
jg 0xb3ade
jmp 0xb3b70
movl -0x44(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xb3b5e
movq -0x38(%rbp), %rax
shrq $0x8, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xb3b5c
movq -0x38(%rbp), %rax
andq $0xff, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
jmp 0xb3b5e
jmp 0xb3b60
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
jmp 0xb3a88
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
subq %rcx, %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_strnxfrm_unicode_full_bin_internal:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_38]
mov [rbp+var_38], rax
mov rax, [rbp+var_10]
mov [rbp+var_40], rax
jmp short $+2
loc_B3A82:
jmp short $+2
loc_B3A84:
jmp short $+2
loc_B3A86:
jmp short $+2
loc_B3A88:
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_18]
mov [rbp+var_45], al
jnb short loc_B3AA4
mov rax, [rbp+var_20]
cmp dword ptr [rax], 0
setnz al
mov [rbp+var_45], al
loc_B3AA4:
mov al, [rbp+var_45]
test al, 1
jnz short loc_B3AB0
jmp loc_B3B70
loc_B3AB0:
mov rax, [rbp+var_8]
mov rax, [rax+0B8h]
mov rax, [rax+28h]
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_30]
lea rsi, [rbp+var_38]
call rax
mov [rbp+var_44], eax
cmp eax, 0
jg short loc_B3ADE
jmp loc_B3B70
loc_B3ADE:
mov ecx, [rbp+var_44]
mov rax, [rbp+var_28]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_28], rax
mov rax, [rbp+var_38]
shr rax, 10h
mov cl, al
mov rax, [rbp+var_10]
mov rdx, rax
add rdx, 1
mov [rbp+var_10], rdx
mov [rax], cl
mov rax, [rbp+var_10]
cmp rax, [rbp+var_18]
jnb short loc_B3B5E
mov rax, [rbp+var_38]
shr rax, 8
and rax, 0FFh
mov cl, al
mov rax, [rbp+var_10]
mov rdx, rax
add rdx, 1
mov [rbp+var_10], rdx
mov [rax], cl
mov rax, [rbp+var_10]
cmp rax, [rbp+var_18]
jnb short loc_B3B5C
mov rax, [rbp+var_38]
and rax, 0FFh
mov cl, al
mov rax, [rbp+var_10]
mov rdx, rax
add rdx, 1
mov [rbp+var_10], rdx
mov [rax], cl
loc_B3B5C:
jmp short $+2
loc_B3B5E:
jmp short $+2
loc_B3B60:
mov rax, [rbp+var_20]
mov ecx, [rax]
add ecx, 0FFFFFFFFh
mov [rax], ecx
jmp loc_B3A88
loc_B3B70:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_40]
sub rax, rcx
add rsp, 50h
pop rbp
retn
|
_BYTE * my_strnxfrm_unicode_full_bin_internal(
long long a1,
_BYTE *a2,
unsigned long long a3,
_DWORD *a4,
long long a5,
long long a6)
{
_BYTE *v6; // rax
_BYTE *v7; // rax
_BYTE *v8; // rax
bool v10; // [rsp+Bh] [rbp-45h]
int v11; // [rsp+Ch] [rbp-44h]
_BYTE v12[8]; // [rsp+18h] [rbp-38h] BYREF
long long v13; // [rsp+20h] [rbp-30h]
long long v14; // [rsp+28h] [rbp-28h]
_DWORD *v15; // [rsp+30h] [rbp-20h]
unsigned long long v16; // [rsp+38h] [rbp-18h]
_BYTE *v17; // [rsp+40h] [rbp-10h]
long long v18; // [rsp+48h] [rbp-8h]
v18 = a1;
v17 = a2;
v16 = a3;
v15 = a4;
v14 = a5;
v13 = a6;
while ( 1 )
{
v10 = 0;
if ( (unsigned long long)v17 < v16 )
v10 = *v15 != 0;
if ( !v10 )
break;
v11 = (*(long long ( **)(long long, _BYTE *, long long, long long))(*(_QWORD *)(v18 + 184) + 40LL))(
v18,
v12,
v14,
v13);
if ( v11 <= 0 )
break;
v14 += v11;
v6 = v17++;
*v6 = v12[2];
if ( (unsigned long long)v17 < v16 )
{
v7 = v17++;
*v7 = v12[1];
if ( (unsigned long long)v17 < v16 )
{
v8 = v17++;
*v8 = v12[0];
}
}
--*v15;
}
return (_BYTE *)(v17 - a2);
}
|
my_strnxfrm_unicode_full_bin_internal:
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 qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x40],RAX
JMP 0x001b3a82
LAB_001b3a82:
JMP 0x001b3a84
LAB_001b3a84:
JMP 0x001b3a86
LAB_001b3a86:
JMP 0x001b3a88
LAB_001b3a88:
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x18]
MOV byte ptr [RBP + -0x45],AL
JNC 0x001b3aa4
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX],0x0
SETNZ AL
MOV byte ptr [RBP + -0x45],AL
LAB_001b3aa4:
MOV AL,byte ptr [RBP + -0x45]
TEST AL,0x1
JNZ 0x001b3ab0
JMP 0x001b3b70
LAB_001b3ab0:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x28]
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
LEA RSI,[RBP + -0x38]
CALL RAX
MOV dword ptr [RBP + -0x44],EAX
CMP EAX,0x0
JG 0x001b3ade
JMP 0x001b3b70
LAB_001b3ade:
MOV ECX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + -0x28]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x38]
SHR RAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x10],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x18]
JNC 0x001b3b5e
MOV RAX,qword ptr [RBP + -0x38]
SHR RAX,0x8
AND RAX,0xff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x10],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x18]
JNC 0x001b3b5c
MOV RAX,qword ptr [RBP + -0x38]
AND RAX,0xff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x10],RDX
MOV byte ptr [RAX],CL
LAB_001b3b5c:
JMP 0x001b3b5e
LAB_001b3b5e:
JMP 0x001b3b60
LAB_001b3b60:
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX]
ADD ECX,-0x1
MOV dword ptr [RAX],ECX
JMP 0x001b3a88
LAB_001b3b70:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x40]
SUB RAX,RCX
ADD RSP,0x50
POP RBP
RET
|
long my_strnxfrm_unicode_full_bin_internal
(long param_1,int1 *param_2,int1 *param_3,int *param_4,long param_5,
int8 param_6)
{
int iVar1;
int1 *puVar2;
int1 *puVar3;
bool bVar4;
int1 local_40 [8];
int8 local_38;
long local_30;
int *local_28;
int1 *local_20;
int1 *local_18;
long local_10;
local_38 = param_6;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
bVar4 = false;
if (local_18 < local_20) {
bVar4 = *local_28 != 0;
}
if ((!bVar4) ||
(iVar1 = (**(code **)(*(long *)(local_10 + 0xb8) + 0x28))
(local_10,local_40,local_30,local_38), iVar1 < 1)) break;
local_30 = local_30 + iVar1;
puVar2 = local_18 + 1;
*local_18 = local_40[2];
if (puVar2 < local_20) {
puVar3 = local_18 + 2;
*puVar2 = local_40[1];
puVar2 = puVar3;
if (puVar3 < local_20) {
*puVar3 = local_40[0];
puVar2 = local_18 + 3;
}
}
local_18 = puVar2;
*local_28 = *local_28 + -1;
}
return (long)local_18 - (long)param_2;
}
|
|
63,695
|
find_var
|
bluesky950520[P]quickjs/quickjs.c
|
static int find_var(JSContext *ctx, JSFunctionDef *fd, JSAtom name)
{
JSVarDef *vd;
int i;
if (fd->vars_htab) {
i = find_var_htab(fd, name);
if (i == -1)
goto not_found;
vd = &fd->vars[i];
if (fd->vars[i].scope_level == 0)
return i;
}
for(i = fd->var_count; i-- > 0;) {
vd = &fd->vars[i];
if (vd->var_name == name)
if (vd->scope_level == 0)
return i;
}
not_found:
return find_arg(ctx, fd, name);
}
|
O2
|
c
|
find_var:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq 0x98(%rdi), %r15
testq %r15, %r15
je 0x54aba
movl %ebx, %edi
callq 0x51b05
movl %eax, %edi
movl 0xa4(%r14), %esi
pushq $0x5
popq %rcx
movl %esi, %eax
cltd
idivl %ecx
addl %esi, %eax
bsrl %eax, %ecx
notl %ecx
pushq $-0x1
popq %rdx
shrl %cl, %edx
pushq $0x1
popq %rcx
movl $0xffffffff, %r8d # imm = 0xFFFFFFFF
movl %edi, %eax
andl %edx, %eax
movl (%r15,%rax,4), %eax
cmpq %r8, %rax
je 0x54afb
movq 0x90(%r14), %r9
movq %rax, %r10
shlq $0x4, %r10
cmpl %ebx, (%r9,%r10)
je 0x54ac3
addl %ecx, %edi
incl %ecx
jmp 0x54a93
movl 0xa4(%r14), %esi
jmp 0x54ad2
movslq %eax, %rcx
shlq $0x4, %rcx
cmpl $0x0, 0x4(%r9,%rcx)
je 0x54b0e
movl %esi, %eax
shlq $0x4, %rax
addq $-0xc, %rax
testl %esi, %esi
jle 0x54afb
movq 0x90(%r14), %rcx
cmpl %ebx, -0x4(%rcx,%rax)
jne 0x54af3
cmpl $0x0, (%rcx,%rax)
je 0x54b0a
decl %esi
addq $-0x10, %rax
jmp 0x54adc
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x56492
decl %esi
movl %esi, %eax
popq %rbx
popq %r14
popq %r15
retq
|
find_var:
push r15
push r14
push rbx
mov ebx, esi
mov r14, rdi
mov r15, [rdi+98h]
test r15, r15
jz short loc_54ABA
mov edi, ebx
call hash_atom
mov edi, eax
mov esi, [r14+0A4h]
push 5
pop rcx
mov eax, esi
cdq
idiv ecx
add eax, esi
bsr ecx, eax
not ecx
push 0FFFFFFFFFFFFFFFFh
pop rdx
shr edx, cl
push 1
pop rcx
mov r8d, 0FFFFFFFFh
loc_54A93:
mov eax, edi
and eax, edx
mov eax, [r15+rax*4]
cmp rax, r8
jz short loc_54AFB
mov r9, [r14+90h]
mov r10, rax
shl r10, 4
cmp [r9+r10], ebx
jz short loc_54AC3
add edi, ecx
inc ecx
jmp short loc_54A93
loc_54ABA:
mov esi, [r14+0A4h]
jmp short loc_54AD2
loc_54AC3:
movsxd rcx, eax
shl rcx, 4
cmp dword ptr [r9+rcx+4], 0
jz short loc_54B0E
loc_54AD2:
mov eax, esi
shl rax, 4
add rax, 0FFFFFFFFFFFFFFF4h
loc_54ADC:
test esi, esi
jle short loc_54AFB
mov rcx, [r14+90h]
cmp [rcx+rax-4], ebx
jnz short loc_54AF3
cmp dword ptr [rcx+rax], 0
jz short loc_54B0A
loc_54AF3:
dec esi
add rax, 0FFFFFFFFFFFFFFF0h
jmp short loc_54ADC
loc_54AFB:
mov rdi, r14
mov esi, ebx
pop rbx
pop r14
pop r15
jmp find_arg
loc_54B0A:
dec esi
mov eax, esi
loc_54B0E:
pop rbx
pop r14
pop r15
retn
|
long long find_var(long long a1, unsigned int a2, long long a3, long long a4, long long a5)
{
long long v7; // r15
int v8; // edi
int v9; // esi
unsigned int v10; // ecx
long long result; // rax
long long v12; // r9
long long v13; // rax
v7 = *(_QWORD *)(a1 + 152);
if ( v7 )
{
v8 = hash_atom(a2);
v9 = *(_DWORD *)(a1 + 164);
_BitScanReverse(&v10, v9 + v9 / 5);
a3 = 0xFFFFFFFF >> ~(_BYTE)v10;
a4 = 1LL;
a5 = 0xFFFFFFFFLL;
while ( 1 )
{
result = *(unsigned int *)(v7 + 4LL * ((unsigned int)a3 & v8));
if ( result == 0xFFFFFFFFLL )
break;
v12 = *(_QWORD *)(a1 + 144);
if ( *(_DWORD *)(v12 + 16 * result) == a2 )
{
a4 = 16LL * (int)result;
if ( !*(_DWORD *)(v12 + a4 + 4) )
return result;
goto LABEL_8;
}
v8 += a4;
a4 = (unsigned int)(a4 + 1);
}
}
else
{
v9 = *(_DWORD *)(a1 + 164);
LABEL_8:
v13 = 16LL * (unsigned int)v9 - 12;
while ( v9 > 0 )
{
a4 = *(_QWORD *)(a1 + 144);
if ( *(_DWORD *)(a4 + v13 - 4) == a2 && !*(_DWORD *)(a4 + v13) )
return (unsigned int)(v9 - 1);
--v9;
v13 -= 16LL;
}
}
return find_arg(a1, a2, a3, a4, a5);
}
|
find_var:
PUSH R15
PUSH R14
PUSH RBX
MOV EBX,ESI
MOV R14,RDI
MOV R15,qword ptr [RDI + 0x98]
TEST R15,R15
JZ 0x00154aba
MOV EDI,EBX
CALL 0x00151b05
MOV EDI,EAX
MOV ESI,dword ptr [R14 + 0xa4]
PUSH 0x5
POP RCX
MOV EAX,ESI
CDQ
IDIV ECX
ADD EAX,ESI
BSR ECX,EAX
NOT ECX
PUSH -0x1
POP RDX
SHR EDX,CL
PUSH 0x1
POP RCX
MOV R8D,0xffffffff
LAB_00154a93:
MOV EAX,EDI
AND EAX,EDX
MOV EAX,dword ptr [R15 + RAX*0x4]
CMP RAX,R8
JZ 0x00154afb
MOV R9,qword ptr [R14 + 0x90]
MOV R10,RAX
SHL R10,0x4
CMP dword ptr [R9 + R10*0x1],EBX
JZ 0x00154ac3
ADD EDI,ECX
INC ECX
JMP 0x00154a93
LAB_00154aba:
MOV ESI,dword ptr [R14 + 0xa4]
JMP 0x00154ad2
LAB_00154ac3:
MOVSXD RCX,EAX
SHL RCX,0x4
CMP dword ptr [R9 + RCX*0x1 + 0x4],0x0
JZ 0x00154b0e
LAB_00154ad2:
MOV EAX,ESI
SHL RAX,0x4
ADD RAX,-0xc
LAB_00154adc:
TEST ESI,ESI
JLE 0x00154afb
MOV RCX,qword ptr [R14 + 0x90]
CMP dword ptr [RCX + RAX*0x1 + -0x4],EBX
JNZ 0x00154af3
CMP dword ptr [RCX + RAX*0x1],0x0
JZ 0x00154b0a
LAB_00154af3:
DEC ESI
ADD RAX,-0x10
JMP 0x00154adc
LAB_00154afb:
MOV RDI,R14
MOV ESI,EBX
POP RBX
POP R14
POP R15
JMP 0x00156492
LAB_00154b0a:
DEC ESI
MOV EAX,ESI
LAB_00154b0e:
POP RBX
POP R14
POP R15
RET
|
ulong find_var(long param_1,int param_2)
{
int iVar1;
uint uVar2;
uint uVar3;
long lVar4;
ulong uVar5;
int iVar6;
uint uVar7;
lVar4 = *(long *)(param_1 + 0x98);
if (lVar4 == 0) {
uVar7 = *(uint *)(param_1 + 0xa4);
LAB_00154ad2:
lVar4 = (ulong)uVar7 * 0x10 + -0xc;
for (; 0 < (int)uVar7; uVar7 = uVar7 - 1) {
if ((*(int *)(*(long *)(param_1 + 0x90) + -4 + lVar4) == param_2) &&
(*(int *)(*(long *)(param_1 + 0x90) + lVar4) == 0)) {
return (ulong)(uVar7 - 1);
}
lVar4 = lVar4 + -0x10;
}
}
else {
uVar2 = hash_atom(param_2);
uVar7 = *(uint *)(param_1 + 0xa4);
uVar3 = (int)uVar7 / 5 + uVar7;
iVar1 = 0x1f;
if (uVar3 != 0) {
for (; uVar3 >> iVar1 == 0; iVar1 = iVar1 + -1) {
}
}
iVar6 = 1;
while( true ) {
uVar3 = *(uint *)(lVar4 + (ulong)(uVar2 & 0xffffffffU >> (~(byte)iVar1 & 0x1f)) * 4);
uVar5 = (ulong)uVar3;
if (uVar5 == 0xffffffff) break;
if (*(int *)(*(long *)(param_1 + 0x90) + uVar5 * 0x10) == param_2) {
if (*(int *)(*(long *)(param_1 + 0x90) + 4 + (long)(int)uVar3 * 0x10) == 0) {
return uVar5;
}
goto LAB_00154ad2;
}
uVar2 = uVar2 + iVar6;
iVar6 = iVar6 + 1;
}
}
uVar5 = find_arg(param_1,param_2);
return uVar5;
}
|
|
63,696
|
coro::thread_pool::schedule_impl(std::__n4861::coroutine_handle<void>)
|
AlayaLite/build_O3/_deps/libcoro-src/src/thread_pool.cpp
|
auto thread_pool::schedule_impl(std::coroutine_handle<> handle) noexcept -> void
{
if (handle == nullptr || handle.done())
{
return;
}
{
std::scoped_lock lk{m_wait_mutex};
m_queue.emplace_back(handle);
m_wait_cv.notify_one();
}
}
|
O3
|
cpp
|
coro::thread_pool::schedule_impl(std::__n4861::coroutine_handle<void>):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, (%rsp)
testq %rsi, %rsi
je 0xc8b50
cmpq $0x0, (%rsi)
je 0xc8b50
movq %rdi, %rbx
leaq 0x68(%rdi), %r14
movq %r14, %rdi
callq 0x17370
testl %eax, %eax
jne 0xc8b58
leaq 0xd0(%rbx), %rdi
movq %rsp, %rsi
callq 0xc94d4
addq $0x90, %rbx
movq %rbx, %rdi
callq 0xc9522
movq %r14, %rdi
callq 0x17300
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %eax, %edi
callq 0x174d0
movq %rax, %rdi
callq 0x1f2c3
nop
|
_ZN4coro11thread_pool13schedule_implENSt7__n486116coroutine_handleIvEE:
push r14
push rbx
push rax
mov [rsp+18h+var_18], rsi
test rsi, rsi
jz short loc_C8B50
cmp qword ptr [rsi], 0
jz short loc_C8B50
mov rbx, rdi
lea r14, [rdi+68h]
mov rdi, r14
call _pthread_mutex_lock
test eax, eax
jnz short loc_C8B58
lea rdi, [rbx+0D0h]
mov rsi, rsp
call _ZNSt5dequeINSt7__n486116coroutine_handleIvEESaIS2_EE12emplace_backIJRS2_EEES6_DpOT_; std::deque<std::__n4861::coroutine_handle<void>>::emplace_back<std::__n4861::coroutine_handle<void>&>(std::__n4861::coroutine_handle<void>&)
add rbx, 90h
mov rdi, rbx; this
call _ZNSt3_V222condition_variable_any10notify_oneEv; std::_V2::condition_variable_any::notify_one(void)
mov rdi, r14
call _pthread_mutex_unlock
loc_C8B50:
add rsp, 8
pop rbx
pop r14
retn
loc_C8B58:
mov edi, eax; int
call __ZSt20__throw_system_errori; std::__throw_system_error(int)
mov rdi, rax
call __clang_call_terminate
|
void coro::thread_pool::schedule_impl(long long a1, _QWORD *a2)
{
int v2; // eax
_QWORD *v3; // [rsp+0h] [rbp-18h] BYREF
v3 = a2;
if ( a2 && *a2 )
{
v2 = pthread_mutex_lock(a1 + 104);
if ( v2 )
std::__throw_system_error(v2);
std::deque<std::__n4861::coroutine_handle<void>>::emplace_back<std::__n4861::coroutine_handle<void>&>(a1 + 208, &v3);
std::_V2::condition_variable_any::notify_one((std::_V2::condition_variable_any *)(a1 + 144));
pthread_mutex_unlock(a1 + 104);
}
}
|
schedule_impl:
PUSH R14
PUSH RBX
PUSH RAX
MOV qword ptr [RSP],RSI
TEST RSI,RSI
JZ 0x001c8b50
CMP qword ptr [RSI],0x0
JZ 0x001c8b50
MOV RBX,RDI
LEA R14,[RDI + 0x68]
MOV RDI,R14
CALL 0x00117370
TEST EAX,EAX
JNZ 0x001c8b58
LEA RDI,[RBX + 0xd0]
LAB_001c8b31:
MOV RSI,RSP
CALL 0x001c94d4
ADD RBX,0x90
MOV RDI,RBX
CALL 0x001c9522
MOV RDI,R14
CALL 0x00117300
LAB_001c8b50:
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_001c8b58:
MOV EDI,EAX
CALL 0x001174d0
LAB_001c8b5f:
MOV RDI,RAX
CALL 0x0011f2c3
|
/* coro::thread_pool::schedule_impl(std::__n4861::coroutine_handle<void>) */
void __thiscall coro::thread_pool::schedule_impl(thread_pool *this,long *param_2)
{
int iVar1;
int8 uVar2;
long *local_18;
if ((param_2 != (long *)0x0) && (*param_2 != 0)) {
local_18 = param_2;
iVar1 = pthread_mutex_lock((pthread_mutex_t *)(this + 0x68));
if (iVar1 != 0) {
uVar2 = std::__throw_system_error(iVar1);
/* catch(type#1 @ 00000000) { ... } // from try @ 001c8b31 with catch @ 001c8b5f
*/
/* WARNING: Subroutine does not return */
__clang_call_terminate(uVar2);
}
/* try { // try from 001c8b31 to 001c8b5e has its CatchHandler @ 001c8b5f */
std::
deque<std::__n4861::coroutine_handle<void>,std::allocator<std::__n4861::coroutine_handle<void>>>
::emplace_back<std::__n4861::coroutine_handle<void>&>
((deque<std::__n4861::coroutine_handle<void>,std::allocator<std::__n4861::coroutine_handle<void>>>
*)(this + 0xd0),(coroutine_handle *)&local_18);
std::_V2::condition_variable_any::notify_one((condition_variable_any *)(this + 0x90));
pthread_mutex_unlock((pthread_mutex_t *)(this + 0x68));
}
return;
}
|
|
63,697
|
JS_PromiseResult
|
bluesky950520[P]quickjs/quickjs.c
|
JSValue JS_PromiseResult(JSContext *ctx, JSValue promise)
{
JSPromiseData *s = JS_GetOpaque(promise, JS_CLASS_PROMISE);
if (!s)
return JS_UNDEFINED;
return JS_DupValue(ctx, s->promise_result);
}
|
O1
|
c
|
JS_PromiseResult:
movq %rsi, -0x8(%rsp)
cmpl $-0x1, %edx
jne 0x3627e
movq -0x8(%rsp), %rax
cmpw $0x31, 0x6(%rax)
jne 0x3627e
movq 0x30(%rax), %rcx
jmp 0x36280
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x3629f
movq 0x30(%rcx), %rax
movq 0x38(%rcx), %rdx
movq %rax, -0x8(%rsp)
cmpl $-0x9, %edx
jb 0x3629e
movq -0x8(%rsp), %rcx
incl (%rcx)
retq
movl $0x3, %edx
xorl %eax, %eax
retq
|
JS_PromiseResult:
mov [rsp+var_8], rsi
cmp edx, 0FFFFFFFFh
jnz short loc_3627E
mov rax, [rsp+var_8]
cmp word ptr [rax+6], 31h ; '1'
jnz short loc_3627E
mov rcx, [rax+30h]
jmp short loc_36280
loc_3627E:
xor ecx, ecx
loc_36280:
test rcx, rcx
jz short loc_3629F
mov rax, [rcx+30h]
mov rdx, [rcx+38h]
mov [rsp+var_8], rax
cmp edx, 0FFFFFFF7h
jb short locret_3629E
mov rcx, [rsp+var_8]
inc dword ptr [rcx]
locret_3629E:
retn
loc_3629F:
mov edx, 3
xor eax, eax
retn
|
long long JS_PromiseResult(long long a1, long long a2, int a3)
{
long long v3; // rcx
long long result; // rax
if ( a3 == -1 && *(_WORD *)(a2 + 6) == 49 )
v3 = *(_QWORD *)(a2 + 48);
else
v3 = 0LL;
if ( !v3 )
return 0LL;
result = *(_QWORD *)(v3 + 48);
if ( (unsigned int)*(_QWORD *)(v3 + 56) >= 0xFFFFFFF7 )
++**(_DWORD **)(v3 + 48);
return result;
}
|
JS_PromiseResult:
MOV qword ptr [RSP + -0x8],RSI
CMP EDX,-0x1
JNZ 0x0013627e
MOV RAX,qword ptr [RSP + -0x8]
CMP word ptr [RAX + 0x6],0x31
JNZ 0x0013627e
MOV RCX,qword ptr [RAX + 0x30]
JMP 0x00136280
LAB_0013627e:
XOR ECX,ECX
LAB_00136280:
TEST RCX,RCX
JZ 0x0013629f
MOV RAX,qword ptr [RCX + 0x30]
MOV RDX,qword ptr [RCX + 0x38]
MOV qword ptr [RSP + -0x8],RAX
CMP EDX,-0x9
JC 0x0013629e
MOV RCX,qword ptr [RSP + -0x8]
INC dword ptr [RCX]
LAB_0013629e:
RET
LAB_0013629f:
MOV EDX,0x3
XOR EAX,EAX
RET
|
int1 [16] JS_PromiseResult(int8 param_1,long param_2,int param_3)
{
int *piVar1;
int1 auVar2 [16];
long lVar3;
if ((param_3 == -1) && (*(short *)(param_2 + 6) == 0x31)) {
lVar3 = *(long *)(param_2 + 0x30);
}
else {
lVar3 = 0;
}
if (lVar3 != 0) {
piVar1 = *(int **)*(int1 (*) [16])(lVar3 + 0x30);
auVar2 = *(int1 (*) [16])(lVar3 + 0x30);
if (0xfffffff6 < (uint)*(int8 *)(lVar3 + 0x38)) {
*piVar1 = *piVar1 + 1;
}
return auVar2;
}
return ZEXT816(3) << 0x40;
}
|
|
63,698
|
JS_PromiseResult
|
bluesky950520[P]quickjs/quickjs.c
|
JSValue JS_PromiseResult(JSContext *ctx, JSValue promise)
{
JSPromiseData *s = JS_GetOpaque(promise, JS_CLASS_PROMISE);
if (!s)
return JS_UNDEFINED;
return JS_DupValue(ctx, s->promise_result);
}
|
O2
|
c
|
JS_PromiseResult:
movq %rdx, %rax
pushq $0x3
popq %rdx
cmpl $-0x1, %eax
jne 0x2f95e
cmpw $0x31, 0x6(%rsi)
jne 0x2f95e
movq 0x30(%rsi), %rcx
testq %rcx, %rcx
je 0x2f95e
movq 0x30(%rcx), %rax
movq 0x38(%rcx), %rdx
cmpl $-0x9, %edx
jb 0x2f960
incl (%rax)
retq
xorl %eax, %eax
retq
|
JS_PromiseResult:
mov rax, rdx
push 3
pop rdx
cmp eax, 0FFFFFFFFh
jnz short loc_2F95E
cmp word ptr [rsi+6], 31h ; '1'
jnz short loc_2F95E
mov rcx, [rsi+30h]
test rcx, rcx
jz short loc_2F95E
mov rax, [rcx+30h]
mov rdx, [rcx+38h]
cmp edx, 0FFFFFFF7h
jb short locret_2F960
inc dword ptr [rax]
retn
loc_2F95E:
xor eax, eax
locret_2F960:
retn
|
_DWORD * JS_PromiseResult(long long a1, long long a2, int a3)
{
long long v3; // rcx
_DWORD *result; // rax
if ( a3 != -1 )
return 0LL;
if ( *(_WORD *)(a2 + 6) != 49 )
return 0LL;
v3 = *(_QWORD *)(a2 + 48);
if ( !v3 )
return 0LL;
result = *(_DWORD **)(v3 + 48);
if ( (unsigned int)*(_QWORD *)(v3 + 56) >= 0xFFFFFFF7 )
++*result;
return result;
}
|
JS_PromiseResult:
MOV RAX,RDX
PUSH 0x3
POP RDX
CMP EAX,-0x1
JNZ 0x0012f95e
CMP word ptr [RSI + 0x6],0x31
JNZ 0x0012f95e
MOV RCX,qword ptr [RSI + 0x30]
TEST RCX,RCX
JZ 0x0012f95e
MOV RAX,qword ptr [RCX + 0x30]
MOV RDX,qword ptr [RCX + 0x38]
CMP EDX,-0x9
JC 0x0012f960
INC dword ptr [RAX]
RET
LAB_0012f95e:
XOR EAX,EAX
LAB_0012f960:
RET
|
int1 [16] JS_PromiseResult(int8 param_1,long param_2,int param_3)
{
long lVar1;
int *piVar2;
int1 auVar4 [16];
int8 uVar3;
uVar3 = 3;
if (((param_3 == -1) && (*(short *)(param_2 + 6) == 0x31)) &&
(lVar1 = *(long *)(param_2 + 0x30), lVar1 != 0)) {
piVar2 = *(int **)*(int1 (*) [16])(lVar1 + 0x30);
uVar3 = *(int8 *)(lVar1 + 0x38);
auVar4 = *(int1 (*) [16])(lVar1 + 0x30);
if (0xfffffff6 < (uint)uVar3) {
*piVar2 = *piVar2 + 1;
return auVar4;
}
}
else {
piVar2 = (int *)0x0;
}
auVar4._8_8_ = uVar3;
auVar4._0_8_ = piVar2;
return auVar4;
}
|
|
63,699
|
mbedtls_ecp_set_zero
|
msxemulator/build_O3/_deps/pico_sdk-src/lib/mbedtls/library/ecp.c
|
int mbedtls_ecp_set_zero(mbedtls_ecp_point *pt)
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
ECP_VALIDATE_RET(pt != NULL);
MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&pt->X, 1));
MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&pt->Y, 1));
MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&pt->Z, 0));
cleanup:
return ret;
}
|
O3
|
c
|
mbedtls_ecp_set_zero:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x7e18c
testl %eax, %eax
jne 0x844e0
leaq 0x18(%rbx), %rdi
movl $0x1, %esi
callq 0x7e18c
testl %eax, %eax
je 0x844e2
popq %rbx
retq
addq $0x30, %rbx
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x7e18c
|
mbedtls_ecp_set_zero:
push rbx
mov rbx, rdi
mov esi, 1
call mbedtls_mpi_lset
test eax, eax
jnz short loc_844E0
lea rdi, [rbx+18h]
mov esi, 1
call mbedtls_mpi_lset
test eax, eax
jz short loc_844E2
loc_844E0:
pop rbx
retn
loc_844E2:
add rbx, 30h ; '0'
mov rdi, rbx
xor esi, esi
pop rbx
jmp mbedtls_mpi_lset
|
long long mbedtls_ecp_set_zero(long long a1)
{
long long result; // rax
result = mbedtls_mpi_lset(a1, 1LL);
if ( !(_DWORD)result )
{
result = mbedtls_mpi_lset(a1 + 24, 1LL);
if ( !(_DWORD)result )
return mbedtls_mpi_lset(a1 + 48, 0LL);
}
return result;
}
|
mbedtls_ecp_set_zero:
PUSH RBX
MOV RBX,RDI
MOV ESI,0x1
CALL 0x0017e18c
TEST EAX,EAX
JNZ 0x001844e0
LEA RDI,[RBX + 0x18]
MOV ESI,0x1
CALL 0x0017e18c
TEST EAX,EAX
JZ 0x001844e2
LAB_001844e0:
POP RBX
RET
LAB_001844e2:
ADD RBX,0x30
MOV RDI,RBX
XOR ESI,ESI
POP RBX
JMP 0x0017e18c
|
void mbedtls_ecp_set_zero(long param_1)
{
int iVar1;
iVar1 = mbedtls_mpi_lset(param_1,1);
if (iVar1 == 0) {
iVar1 = mbedtls_mpi_lset(param_1 + 0x18,1);
if (iVar1 == 0) {
mbedtls_mpi_lset(param_1 + 0x30,0);
return;
}
}
return;
}
|
Subsets and Splits
C++ Functions Using STL
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++ STL Function Queries
Filters C++ code examples that use standard library containers and algorithms, helping identify common programming patterns and library usage in code generation tasks.