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,300 |
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 0x2e9bf
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 0x2e936
movl %ecx, %eax
addq %rbx, %rax
cmpq %r12, %rax
ja 0x2e9b5
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 0x2e91d
jmp 0x2e98c
movb (%r13), %dl
cmpl $0x1, %ecx
jne 0x2e958
movzbl %dl, %eax
cmpl $0x19, %eax
jle 0x2e96d
cmpl $0x26, %eax
jg 0x2e99d
cmpl $0x1a, %eax
je 0x2e9ad
cmpl $0x22, %eax
je 0x2e95c
jmp 0x2e981
testb %dl, %dl
je 0x2e97f
leaq 0x2(%rbx), %rax
cmpq %r12, %rax
ja 0x2e9b5
movb $0x5c, (%rbx)
movb %dl, 0x1(%rbx)
jmp 0x2e98c
testl %eax, %eax
je 0x2e9a9
cmpl $0xa, %eax
je 0x2e9b1
cmpl $0xd, %eax
jne 0x2e981
movb $0x72, %dl
jmp 0x2e95c
xorl %edx, %edx
leaq 0x1(%rbx), %rax
cmpq %r12, %rax
ja 0x2e9b5
movb %dl, (%rbx)
incq %r13
movq %rax, %rbx
cmpq %r15, %r13
jb 0x2e8ec
jmp 0x2e9bf
cmpl $0x27, %eax
je 0x2e95c
cmpl $0x5c, %eax
je 0x2e95c
jmp 0x2e981
movb $0x30, %dl
jmp 0x2e95c
movb $0x5a, %dl
jmp 0x2e95c
movb $0x6e, %dl
jmp 0x2e95c
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_2E9BF
mov r15, r8
mov r13, rcx
mov r14, rdi
mov rbx, [rbp+var_30]
add r12, rbx
add r15, rcx
loc_2E8EC:
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_2E936
mov eax, ecx
add rax, rbx
cmp rax, r12
ja loc_2E9B5
dec r13
mov rdx, r13
loc_2E91D:
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_2E91D
jmp short loc_2E98C
loc_2E936:
mov dl, [r13+0]
cmp ecx, 1
jnz short loc_2E958
movzx eax, dl
cmp eax, 19h
jle short loc_2E96D
cmp eax, 26h ; '&'
jg short loc_2E99D
cmp eax, 1Ah
jz short loc_2E9AD
cmp eax, 22h ; '"'
jz short loc_2E95C
jmp short loc_2E981
loc_2E958:
test dl, dl
jz short loc_2E97F
loc_2E95C:
lea rax, [rbx+2]
cmp rax, r12
ja short loc_2E9B5
mov byte ptr [rbx], 5Ch ; '\'
mov [rbx+1], dl
jmp short loc_2E98C
loc_2E96D:
test eax, eax
jz short loc_2E9A9
cmp eax, 0Ah
jz short loc_2E9B1
cmp eax, 0Dh
jnz short loc_2E981
mov dl, 72h ; 'r'
jmp short loc_2E95C
loc_2E97F:
xor edx, edx
loc_2E981:
lea rax, [rbx+1]
cmp rax, r12
ja short loc_2E9B5
mov [rbx], dl
loc_2E98C:
inc r13
mov rbx, rax
cmp r13, r15
jb loc_2E8EC
jmp short loc_2E9BF
loc_2E99D:
cmp eax, 27h ; '''
jz short loc_2E95C
cmp eax, 5Ch ; '\'
jz short loc_2E95C
jmp short loc_2E981
loc_2E9A9:
mov dl, 30h ; '0'
jmp short loc_2E95C
loc_2E9AD:
mov dl, 5Ah ; 'Z'
jmp short loc_2E95C
loc_2E9B1:
mov dl, 6Eh ; 'n'
jmp short loc_2E95C
loc_2E9B5:
mov rax, [rbp+var_38]
mov byte ptr [rax], 1
mov rax, rbx
loc_2E9BF:
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 0x0012e9bf
MOV R15,R8
MOV R13,RCX
MOV R14,RDI
MOV RBX,qword ptr [RBP + -0x30]
ADD R12,RBX
ADD R15,RCX
LAB_0012e8ec:
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 0x0012e936
MOV EAX,ECX
ADD RAX,RBX
CMP RAX,R12
JA 0x0012e9b5
DEC R13
MOV RDX,R13
LAB_0012e91d:
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 0x0012e91d
JMP 0x0012e98c
LAB_0012e936:
MOV DL,byte ptr [R13]
CMP ECX,0x1
JNZ 0x0012e958
MOVZX EAX,DL
CMP EAX,0x19
JLE 0x0012e96d
CMP EAX,0x26
JG 0x0012e99d
CMP EAX,0x1a
JZ 0x0012e9ad
CMP EAX,0x22
JZ 0x0012e95c
JMP 0x0012e981
LAB_0012e958:
TEST DL,DL
JZ 0x0012e97f
LAB_0012e95c:
LEA RAX,[RBX + 0x2]
CMP RAX,R12
JA 0x0012e9b5
MOV byte ptr [RBX],0x5c
MOV byte ptr [RBX + 0x1],DL
JMP 0x0012e98c
LAB_0012e96d:
TEST EAX,EAX
JZ 0x0012e9a9
CMP EAX,0xa
JZ 0x0012e9b1
CMP EAX,0xd
JNZ 0x0012e981
MOV DL,0x72
JMP 0x0012e95c
LAB_0012e97f:
XOR EDX,EDX
LAB_0012e981:
LEA RAX,[RBX + 0x1]
CMP RAX,R12
JA 0x0012e9b5
MOV byte ptr [RBX],DL
LAB_0012e98c:
INC R13
MOV RBX,RAX
CMP R13,R15
JC 0x0012e8ec
JMP 0x0012e9bf
LAB_0012e99d:
CMP EAX,0x27
JZ 0x0012e95c
CMP EAX,0x5c
JZ 0x0012e95c
JMP 0x0012e981
LAB_0012e9a9:
MOV DL,0x30
JMP 0x0012e95c
LAB_0012e9ad:
MOV DL,0x5a
JMP 0x0012e95c
LAB_0012e9b1:
MOV DL,0x6e
JMP 0x0012e95c
LAB_0012e9b5:
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],0x1
MOV RAX,RBX
LAB_0012e9bf:
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_0012e981;
bVar4 = 0x72;
}
}
else if (bVar4 < 0x27) {
if (bVar4 == 0x1a) {
bVar4 = 0x5a;
}
else if (bVar4 != 0x22) goto LAB_0012e981;
}
else if ((bVar4 != 0x27) && (bVar4 != 0x5c)) {
LAB_0012e981:
pbVar2 = pbVar6 + 1;
if (pbVar8 < pbVar2) goto LAB_0012e9b5;
*pbVar6 = bVar4;
goto LAB_0012e98c;
}
}
else if (bVar4 == 0) {
bVar4 = 0;
goto LAB_0012e981;
}
pbVar2 = pbVar6 + 2;
if (pbVar8 < pbVar2) goto LAB_0012e9b5;
*pbVar6 = 0x5c;
pbVar6[1] = bVar4;
}
else {
if (pbVar8 < pbVar6 + uVar3) {
LAB_0012e9b5:
*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_0012e98c:
param_4 = param_4 + 1;
pbVar6 = pbVar2;
} while (param_4 < pbVar9);
}
*pbVar2 = 0;
return (long)pbVar2 - (long)param_2;
}
|
|
63,301 |
LefDefParser::defiProp::print(_IO_FILE*) const
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiProp.cpp
|
void defiProp::print(FILE* f) const {
fprintf(f, "Prop type '%s'\n", propType());
if (hasString()) {
fprintf(f, " string '%s'\n", string());
}
if (hasNumber()) {
fprintf(f, " number %5.2f\n", number());
}
if (hasRange()) {
fprintf(f, " range %5.2f - %5.2f\n",
left(), right());
}
}
|
O3
|
cpp
|
LefDefParser::defiProp::print(_IO_FILE*) const:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdx
leaq 0x18f3a(%rip), %rsi # 0x45bbc
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7290
movq 0x18(%r14), %rdx
cmpb $0x0, (%rdx)
je 0x2cca6
leaq 0x18f30(%rip), %rsi # 0x45bcc
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7290
cmpb $0x0, 0x15(%r14)
je 0x2ccc4
movsd 0x38(%r14), %xmm0
leaq 0x18f21(%rip), %rsi # 0x45bdb
movq %rbx, %rdi
movb $0x1, %al
callq 0x7290
cmpb $0x0, 0x14(%r14)
je 0x2ccef
movsd 0x28(%r14), %xmm0
movsd 0x30(%r14), %xmm1
leaq 0x18f0d(%rip), %rsi # 0x45beb
movq %rbx, %rdi
movb $0x2, %al
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7290
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
_ZNK12LefDefParser8defiProp5printEP8_IO_FILE:
push r14
push rbx
push rax
mov rbx, rsi
mov r14, rdi
mov rdx, [rdi]
lea rsi, aPropTypeS; "Prop type '%s'\n"
mov rdi, rbx
xor eax, eax
call _fprintf
mov rdx, [r14+18h]
cmp byte ptr [rdx], 0
jz short loc_2CCA6
lea rsi, aStringS; " string '%s'\n"
mov rdi, rbx
xor eax, eax
call _fprintf
loc_2CCA6:
cmp byte ptr [r14+15h], 0
jz short loc_2CCC4
movsd xmm0, qword ptr [r14+38h]
lea rsi, aNumber52f; " number %5.2f\n"
mov rdi, rbx
mov al, 1
call _fprintf
loc_2CCC4:
cmp byte ptr [r14+14h], 0
jz short loc_2CCEF
movsd xmm0, qword ptr [r14+28h]
movsd xmm1, qword ptr [r14+30h]
lea rsi, aRange52f52f; " range %5.2f - %5.2f\n"
mov rdi, rbx
mov al, 2
add rsp, 8
pop rbx
pop r14
jmp _fprintf
loc_2CCEF:
add rsp, 8
pop rbx
pop r14
retn
|
long long LefDefParser::defiProp::print(long long a1, long long a2)
{
long long result; // rax
const char *v3; // rdx
result = fprintf(a2, "Prop type '%s'\n", *(const char **)a1);
v3 = *(const char **)(a1 + 24);
if ( *v3 )
result = fprintf(a2, " string '%s'\n", v3);
if ( *(_BYTE *)(a1 + 21) )
result = fprintf(a2, " number %5.2f\n", *(double *)(a1 + 56));
if ( *(_BYTE *)(a1 + 20) )
return fprintf(a2, " range %5.2f - %5.2f\n", *(double *)(a1 + 40), *(double *)(a1 + 48));
return result;
}
|
print:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
MOV RDX,qword ptr [RDI]
LEA RSI,[0x145bbc]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x00107290
MOV RDX,qword ptr [R14 + 0x18]
CMP byte ptr [RDX],0x0
JZ 0x0012cca6
LEA RSI,[0x145bcc]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x00107290
LAB_0012cca6:
CMP byte ptr [R14 + 0x15],0x0
JZ 0x0012ccc4
MOVSD XMM0,qword ptr [R14 + 0x38]
LEA RSI,[0x145bdb]
MOV RDI,RBX
MOV AL,0x1
CALL 0x00107290
LAB_0012ccc4:
CMP byte ptr [R14 + 0x14],0x0
JZ 0x0012ccef
MOVSD XMM0,qword ptr [R14 + 0x28]
MOVSD XMM1,qword ptr [R14 + 0x30]
LEA RSI,[0x145beb]
MOV RDI,RBX
MOV AL,0x2
ADD RSP,0x8
POP RBX
POP R14
JMP 0x00107290
LAB_0012ccef:
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* LefDefParser::defiProp::print(_IO_FILE*) const */
void __thiscall LefDefParser::defiProp::print(defiProp *this,_IO_FILE *param_1)
{
fprintf(param_1,"Prop type \'%s\'\n",*(int8 *)this);
if (**(char **)(this + 0x18) != '\0') {
fprintf(param_1," string \'%s\'\n");
}
if (this[0x15] != (defiProp)0x0) {
fprintf(param_1," number %5.2f\n",*(int8 *)(this + 0x38));
}
if (this[0x14] != (defiProp)0x0) {
fprintf(param_1," range %5.2f - %5.2f\n",*(int8 *)(this + 0x28),
*(int8 *)(this + 0x30));
return;
}
return;
}
|
|
63,302 |
minja::VariableExpr::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 (!context->contains(name)) {
return Value();
}
return context->at(name);
}
|
O3
|
cpp
|
minja::VariableExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %r12
addq $0x20, %r14
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x41a72
movq (%r12), %rax
movq %r12, %rdi
movq %r13, %rsi
callq *0x20(%rax)
movl %eax, %ebp
leaq 0x48(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x3ce3c
movq %r12, %rdi
callq 0x49a2a
movq -0x8(%r12), %rdi
testq %rdi, %rdi
je 0x592a9
callq 0x2ef66
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x592b8
callq 0x2ef66
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x592c7
callq 0x2ef66
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x592fd
movq 0x82cc0(%rip), %rax # 0xdbf98
cmpb $0x0, (%rax)
je 0x592e8
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x592f2
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x592fd
movq (%rdi), %rax
callq *0x18(%rax)
testb %bpl, %bpl
je 0x59394
movq (%r15), %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x41a72
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x18(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4e20c
leaq 0x48(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x3ce3c
movq %r14, %rdi
callq 0x49a2a
movq -0x8(%r14), %rdi
testq %rdi, %rdi
je 0x59355
callq 0x2ef66
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x59364
callq 0x2ef66
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x59373
callq 0x2ef66
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x593e7
movq 0x82c14(%rip), %rax # 0xdbf98
cmpb $0x0, (%rax)
je 0x593d2
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x593dc
leaq 0x40(%rbx), %r14
movq $0x0, 0x48(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
movb $0x0, 0x40(%rbx)
movq %r14, %rdi
movl $0x1, %esi
callq 0x3ce3c
movq %r14, %rdi
movl $0x1, %esi
callq 0x3ce3c
jmp 0x593e7
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x593e7
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x593fb
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3cdb0
movq %rbx, %rdi
callq 0x18ba0
|
_ZNK5minja12VariableExpr11do_evaluateERKSt10shared_ptrINS_7ContextEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov r15, rdx
mov r14, rsi
mov rbx, rdi
mov r12, [rdx]
add r14, 20h ; ' '
lea r13, [rsp+88h+var_80]
mov rdi, r13
mov rsi, r14
call _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::Value(std::string const&)
mov rax, [r12]
mov rdi, r12
mov rsi, r13
call qword ptr [rax+20h]
mov ebp, eax
lea r12, [rsp+88h+var_40]
mov rdi, r12
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r12
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [r12-8]
test rdi, rdi
jz short loc_592A9
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_592A9:
mov rdi, [rsp+88h+var_58]
test rdi, rdi
jz short loc_592B8
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_592B8:
mov rdi, [rsp+88h+var_68]
test rdi, rdi
jz short loc_592C7
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_592C7:
mov rdi, [rsp+88h+var_78]
test rdi, rdi
jz short loc_592FD
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_592E8
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_592F2
loc_592E8:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_592F2:
cmp eax, 1
jnz short loc_592FD
mov rax, [rdi]
call qword ptr [rax+18h]
loc_592FD:
test bpl, bpl
jz loc_59394
mov r15, [r15]
lea r12, [rsp+88h+var_80]
mov rdi, r12
mov rsi, r14
call _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::Value(std::string const&)
mov rax, [r15]
mov rdi, r15
mov rsi, r12
call qword ptr [rax+18h]
mov rdi, rbx; this
mov rsi, rax; minja::Value *
call _ZN5minja5ValueC2ERKS0_; minja::Value::Value(minja::Value const&)
lea r14, [rsp+88h+var_40]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [r14-8]
test rdi, rdi
jz short loc_59355
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_59355:
mov rdi, [rsp+88h+var_58]
test rdi, rdi
jz short loc_59364
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_59364:
mov rdi, [rsp+88h+var_68]
test rdi, rdi
jz short loc_59373
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_59373:
mov rdi, [rsp+88h+var_78]
test rdi, rdi
jz short loc_593E7
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_593D2
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_593DC
loc_59394:
lea r14, [rbx+40h]
mov qword ptr [rbx+48h], 0
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
movups xmmword ptr [rbx+10h], xmm0
movups xmmword ptr [rbx+20h], xmm0
movups xmmword ptr [rbx+30h], xmm0
mov byte ptr [rbx+40h], 0
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
jmp short loc_593E7
loc_593D2:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_593DC:
cmp eax, 1
jnz short loc_593E7
mov rax, [rdi]
call qword ptr [rax+18h]
loc_593E7:
mov rax, rbx
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short $+2
loc_593FB:
mov rbx, rax
lea rdi, [rsp+arg_0]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rdi, rbx
call __Unwind_Resume
|
minja::Value * minja::VariableExpr::do_evaluate(minja::Value *this, long long a2, long long *a3)
{
long long v5; // r12
char v6; // bp
long long v7; // rdi
signed __int32 v8; // eax
long long v9; // r15
const minja::Value *v10; // rax
long long v11; // rdi
signed __int32 v12; // eax
__int128 v14; // [rsp+8h] [rbp-80h] BYREF
volatile signed __int32 *v15; // [rsp+20h] [rbp-68h]
volatile signed __int32 *v16; // [rsp+30h] [rbp-58h]
volatile signed __int32 *v17; // [rsp+40h] [rbp-48h]
void **v18[8]; // [rsp+48h] [rbp-40h] BYREF
v5 = *a3;
minja::Value::Value(&v14);
v6 = (*(long long ( **)(long long, __int128 *))(*(_QWORD *)v5 + 32LL))(v5, &v14);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v18);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v18);
if ( v17 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v17);
if ( v16 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v16);
if ( v15 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v15);
v7 = *((_QWORD *)&v14 + 1);
if ( *((_QWORD *)&v14 + 1) )
{
if ( _libc_single_threaded )
{
v8 = *(_DWORD *)(*((_QWORD *)&v14 + 1) + 12LL);
*(_DWORD *)(*((_QWORD *)&v14 + 1) + 12LL) = v8 - 1;
}
else
{
v8 = _InterlockedExchangeAdd((volatile signed __int32 *)(*((_QWORD *)&v14 + 1) + 12LL), 0xFFFFFFFF);
}
if ( v8 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v7 + 24LL))(v7, 0LL);
}
if ( v6 )
{
v9 = *a3;
minja::Value::Value(&v14);
v10 = (const minja::Value *)(*(long long ( **)(long long, __int128 *))(*(_QWORD *)v9 + 24LL))(v9, &v14);
minja::Value::Value(this, v10);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v18);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v18);
if ( v17 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v17);
if ( v16 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v16);
if ( v15 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v15);
v11 = *((_QWORD *)&v14 + 1);
if ( *((_QWORD *)&v14 + 1) )
{
if ( _libc_single_threaded )
{
v12 = *(_DWORD *)(*((_QWORD *)&v14 + 1) + 12LL);
*(_DWORD *)(*((_QWORD *)&v14 + 1) + 12LL) = v12 - 1;
}
else
{
v12 = _InterlockedExchangeAdd((volatile signed __int32 *)(*((_QWORD *)&v14 + 1) + 12LL), 0xFFFFFFFF);
}
if ( v12 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v11 + 24LL))(v11, 0LL);
}
}
else
{
*((_QWORD *)this + 9) = 0LL;
*(_OWORD *)this = 0LL;
*((_OWORD *)this + 1) = 0LL;
*((_OWORD *)this + 2) = 0LL;
*((_OWORD *)this + 3) = 0LL;
*((_BYTE *)this + 64) = 0;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)this + 64);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)this + 64);
}
return this;
}
|
do_evaluate:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
MOV R12,qword ptr [RDX]
ADD R14,0x20
LEA R13,[RSP + 0x8]
MOV RDI,R13
MOV RSI,R14
CALL 0x00141a72
MOV RAX,qword ptr [R12]
LAB_00159278:
MOV RDI,R12
MOV RSI,R13
CALL qword ptr [RAX + 0x20]
LAB_00159281:
MOV EBP,EAX
LEA R12,[RSP + 0x48]
MOV RDI,R12
XOR ESI,ESI
CALL 0x0013ce3c
MOV RDI,R12
CALL 0x00149a2a
MOV RDI,qword ptr [R12 + -0x8]
TEST RDI,RDI
JZ 0x001592a9
CALL 0x0012ef66
LAB_001592a9:
MOV RDI,qword ptr [RSP + 0x30]
TEST RDI,RDI
JZ 0x001592b8
CALL 0x0012ef66
LAB_001592b8:
MOV RDI,qword ptr [RSP + 0x20]
TEST RDI,RDI
JZ 0x001592c7
CALL 0x0012ef66
LAB_001592c7:
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x001592fd
MOV RAX,qword ptr [0x001dbf98]
CMP byte ptr [RAX],0x0
JZ 0x001592e8
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x001592f2
LAB_001592e8:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_001592f2:
CMP EAX,0x1
JNZ 0x001592fd
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_001592fd:
TEST BPL,BPL
JZ 0x00159394
MOV R15,qword ptr [R15]
LEA R12,[RSP + 0x8]
MOV RDI,R12
MOV RSI,R14
CALL 0x00141a72
MOV RAX,qword ptr [R15]
LAB_0015931c:
MOV RDI,R15
MOV RSI,R12
CALL qword ptr [RAX + 0x18]
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0014e20c
LAB_00159330:
LEA R14,[RSP + 0x48]
MOV RDI,R14
XOR ESI,ESI
CALL 0x0013ce3c
MOV RDI,R14
CALL 0x00149a2a
MOV RDI,qword ptr [R14 + -0x8]
TEST RDI,RDI
JZ 0x00159355
CALL 0x0012ef66
LAB_00159355:
MOV RDI,qword ptr [RSP + 0x30]
TEST RDI,RDI
JZ 0x00159364
CALL 0x0012ef66
LAB_00159364:
MOV RDI,qword ptr [RSP + 0x20]
TEST RDI,RDI
JZ 0x00159373
CALL 0x0012ef66
LAB_00159373:
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x001593e7
MOV RAX,qword ptr [0x001dbf98]
CMP byte ptr [RAX],0x0
JZ 0x001593d2
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x001593dc
LAB_00159394:
LEA R14,[RBX + 0x40]
MOV qword ptr [RBX + 0x48],0x0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOVUPS xmmword ptr [RBX + 0x20],XMM0
MOVUPS xmmword ptr [RBX + 0x30],XMM0
MOV byte ptr [RBX + 0x40],0x0
MOV RDI,R14
MOV ESI,0x1
CALL 0x0013ce3c
MOV RDI,R14
MOV ESI,0x1
CALL 0x0013ce3c
JMP 0x001593e7
LAB_001593d2:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_001593dc:
CMP EAX,0x1
JNZ 0x001593e7
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_001593e7:
MOV RAX,RBX
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* minja::VariableExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const */
shared_ptr * minja::VariableExpr::do_evaluate(shared_ptr *param_1)
{
int *piVar1;
long *plVar2;
char cVar3;
int iVar4;
Value *pVVar5;
int8 *in_RDX;
long in_RSI;
bool bVar6;
Value local_80 [8];
long *local_78;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_68;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_58;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_48;
data local_40 [16];
plVar2 = (long *)*in_RDX;
Value::Value(local_80,(string *)(in_RSI + 0x20));
/* try { // try from 00159278 to 00159280 has its CatchHandler @ 001593fb */
cVar3 = (**(code **)(*plVar2 + 0x20))(plVar2,local_80);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_40,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_40);
if (local_48 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_48);
}
if (local_58 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_58);
}
if (local_68 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_68);
}
if (local_78 != (long *)0x0) {
if (*PTR___libc_single_threaded_001dbf98 == '\0') {
LOCK();
piVar1 = (int *)((long)local_78 + 0xc);
iVar4 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar4 = *(int *)((long)local_78 + 0xc);
*(int *)((long)local_78 + 0xc) = iVar4 + -1;
}
if (iVar4 == 1) {
(**(code **)(*local_78 + 0x18))();
}
}
if (cVar3 == '\0') {
bVar6 = (bool)((char)param_1 + '@');
*(int8 *)(param_1 + 0x48) = 0;
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
*(int8 *)(param_1 + 0x18) = 0;
*(int8 *)(param_1 + 0x20) = 0;
*(int8 *)(param_1 + 0x28) = 0;
*(int8 *)(param_1 + 0x30) = 0;
*(int8 *)(param_1 + 0x38) = 0;
param_1[0x40] = (shared_ptr)0x0;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar6);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar6);
}
else {
plVar2 = (long *)*in_RDX;
Value::Value(local_80,(string *)(in_RSI + 0x20));
/* try { // try from 0015931c to 0015932f has its CatchHandler @ 001593f9 */
pVVar5 = (Value *)(**(code **)(*plVar2 + 0x18))(plVar2,local_80);
Value::Value((Value *)param_1,pVVar5);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_40,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_40);
if (local_48 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_48);
}
if (local_58 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_58);
}
if (local_68 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_68);
}
if (local_78 != (long *)0x0) {
if (*PTR___libc_single_threaded_001dbf98 == '\0') {
LOCK();
piVar1 = (int *)((long)local_78 + 0xc);
iVar4 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar4 = *(int *)((long)local_78 + 0xc);
*(int *)((long)local_78 + 0xc) = iVar4 + -1;
}
if (iVar4 == 1) {
(**(code **)(*local_78 + 0x18))();
}
}
}
return param_1;
}
|
|
63,303 |
my_mb_wc_cp932
|
eloqsql/strings/ctype-cp932.c
|
static int
my_mb_wc_cp932(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e){
int hi;
if (s >= e)
return MY_CS_TOOSMALL;
if ((hi= s[0]) < 0x80) /* ASCII: [00-7F] -> [U+0000..U+007F] */
{
*pwc= hi;
return 1;
}
/* JIS-X-0201 Half width Katakana: [A1..DF] -> [U+FF61..U+FF9F] */
if (hi >= 0xA1 && hi <= 0xDF)
{
*pwc= cp932_to_unicode[hi];
return 1;
}
if (s + 2 > e)
return MY_CS_TOOSMALL2;
/* JIS-X-0208-MS [81..9F,E0..FC][40..7E,80..FC] */
if (!(pwc[0]= cp932_to_unicode[(hi << 8) + s[1]]))
return (iscp932head(hi) && iscp932tail(s[1])) ? -2 : MY_CS_ILSEQ;
return 2;
}
|
O3
|
c
|
my_mb_wc_cp932:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0xacb37
movzbl (%rdx), %edi
testb %dil, %dil
js 0xacb1d
movq %rdi, (%rsi)
jmp 0xacb32
leal 0x5f(%rdi), %eax
cmpb $0x3e, %al
ja 0xacb39
leaq 0x4db35(%rip), %rax # 0xfa660
movzwl (%rax,%rdi,2), %eax
movq %rax, (%rsi)
movl $0x1, %eax
popq %rbp
retq
leaq 0x2(%rdx), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %r8
ja 0xacb37
movzbl 0x1(%rdx), %eax
movl %edi, %ecx
shll $0x9, %ecx
leal (%rcx,%rax,2), %eax
leaq 0x4db06(%rip), %rcx # 0xfa660
movzwl (%rax,%rcx), %ecx
movq %rcx, (%rsi)
movl $0x2, %eax
testq %rcx, %rcx
jne 0xacb37
cmpb $-0x80, %dil
setne %al
cmpb $-0x60, %dil
setb %cl
andb %al, %cl
addb $0x20, %dil
cmpb $0x1d, %dil
setb %sil
orb %cl, %sil
xorl %eax, %eax
cmpb $0x1, %sil
jne 0xacb37
movb 0x1(%rdx), %cl
leal -0x40(%rcx), %edx
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
cmpb $0x3f, %dl
jb 0xacb37
movl $0x0, %eax
testb %cl, %cl
jns 0xacb37
xorl %eax, %eax
cmpb $-0x3, %cl
setae %al
leal -0x2(,%rax,2), %eax
jmp 0xacb37
|
my_mb_wc_cp932:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short loc_ACB37
movzx edi, byte ptr [rdx]
test dil, dil
js short loc_ACB1D
mov [rsi], rdi
jmp short loc_ACB32
loc_ACB1D:
lea eax, [rdi+5Fh]
cmp al, 3Eh ; '>'
ja short loc_ACB39
lea rax, cp932_to_unicode
movzx eax, word ptr [rax+rdi*2]
mov [rsi], rax
loc_ACB32:
mov eax, 1
loc_ACB37:
pop rbp
retn
loc_ACB39:
lea r8, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp r8, rcx
ja short loc_ACB37
movzx eax, byte ptr [rdx+1]
mov ecx, edi
shl ecx, 9
lea eax, [rcx+rax*2]
lea rcx, cp932_to_unicode
movzx ecx, word ptr [rax+rcx]
mov [rsi], rcx
mov eax, 2
test rcx, rcx
jnz short loc_ACB37
cmp dil, 80h
setnz al
cmp dil, 0A0h
setb cl
and cl, al
add dil, 20h ; ' '
cmp dil, 1Dh
setb sil
or sil, cl
xor eax, eax
cmp sil, 1
jnz short loc_ACB37
mov cl, [rdx+1]
lea edx, [rcx-40h]
mov eax, 0FFFFFFFEh
cmp dl, 3Fh ; '?'
jb short loc_ACB37
mov eax, 0
test cl, cl
jns short loc_ACB37
xor eax, eax
cmp cl, 0FDh
setnb al
lea eax, ds:0FFFFFFFFFFFFFFFEh[rax*2]
jmp loc_ACB37
|
long long my_mb_wc_cp932(long long a1, _QWORD *a2, unsigned __int8 *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rdi
long long v6; // rcx
char v7; // cl
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
v5 = *a3;
if ( (v5 & 0x80u) == 0LL )
{
*a2 = v5;
return 1LL;
}
if ( (unsigned __int8)(v5 + 95) <= 0x3Eu )
{
*a2 = cp932_to_unicode[v5];
return 1LL;
}
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
v6 = cp932_to_unicode[256 * (_DWORD)v5 + a3[1]];
*a2 = v6;
result = 2LL;
if ( !v6 )
{
result = 0LL;
if ( (_BYTE)v5 != 0x80 && (unsigned __int8)v5 < 0xA0u || (unsigned __int8)(v5 + 32) < 0x1Du )
{
v7 = a3[1];
result = 4294967294LL;
if ( (unsigned __int8)(v7 - 64) >= 0x3Fu )
{
result = 0LL;
if ( v7 < 0 )
return 2 * (unsigned int)((unsigned __int8)v7 >= 0xFDu) - 2;
}
}
}
}
}
return result;
}
|
my_mb_wc_cp932:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x001acb37
MOVZX EDI,byte ptr [RDX]
TEST DIL,DIL
JS 0x001acb1d
MOV qword ptr [RSI],RDI
JMP 0x001acb32
LAB_001acb1d:
LEA EAX,[RDI + 0x5f]
CMP AL,0x3e
JA 0x001acb39
LEA RAX,[0x1fa660]
MOVZX EAX,word ptr [RAX + RDI*0x2]
MOV qword ptr [RSI],RAX
LAB_001acb32:
MOV EAX,0x1
LAB_001acb37:
POP RBP
RET
LAB_001acb39:
LEA R8,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP R8,RCX
JA 0x001acb37
MOVZX EAX,byte ptr [RDX + 0x1]
MOV ECX,EDI
SHL ECX,0x9
LEA EAX,[RCX + RAX*0x2]
LEA RCX,[0x1fa660]
MOVZX ECX,word ptr [RAX + RCX*0x1]
MOV qword ptr [RSI],RCX
MOV EAX,0x2
TEST RCX,RCX
JNZ 0x001acb37
CMP DIL,0x80
SETNZ AL
CMP DIL,0xa0
SETC CL
AND CL,AL
ADD DIL,0x20
CMP DIL,0x1d
SETC SIL
OR SIL,CL
XOR EAX,EAX
CMP SIL,0x1
JNZ 0x001acb37
MOV CL,byte ptr [RDX + 0x1]
LEA EDX,[RCX + -0x40]
MOV EAX,0xfffffffe
CMP DL,0x3f
JC 0x001acb37
MOV EAX,0x0
TEST CL,CL
JNS 0x001acb37
XOR EAX,EAX
CMP CL,0xfd
SETNC AL
LEA EAX,[-0x2 + RAX*0x2]
JMP 0x001acb37
|
int my_mb_wc_cp932(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
byte bVar1;
ushort uVar2;
int iVar3;
iVar3 = -0x65;
if (param_3 < param_4) {
bVar1 = *param_3;
if ((char)bVar1 < '\0') {
if (0x3e < (byte)(bVar1 + 0x5f)) {
if (param_4 < param_3 + 2) {
return -0x66;
}
uVar2 = *(ushort *)(cp932_to_unicode + ((uint)bVar1 * 0x200 + (uint)param_3[1] * 2));
*param_2 = (ulong)uVar2;
if ((ulong)uVar2 != 0) {
return 2;
}
if (0x1c < (byte)(bVar1 + 0x20) && (0x9f < bVar1 || bVar1 == 0x80)) {
return 0;
}
bVar1 = param_3[1];
if ((byte)(bVar1 - 0x40) < 0x3f) {
return -2;
}
if (-1 < (char)bVar1) {
return 0;
}
return (uint)(0xfc < bVar1) * 2 + -2;
}
*param_2 = (ulong)*(ushort *)(cp932_to_unicode + (ulong)bVar1 * 2);
}
else {
*param_2 = (ulong)bVar1;
}
iVar3 = 1;
}
return iVar3;
}
|
|
63,304 |
unlink_from_queue
|
eloqsql/mysys/mf_keycache.c
|
static void unlink_from_queue(KEYCACHE_WQUEUE *wqueue,
struct st_my_thread_var *thread)
{
KEYCACHE_DBUG_PRINT("unlink_from_queue", ("thread %ld", (ulong) thread->id));
DBUG_ASSERT(thread->next && thread->prev);
if (thread->next == thread)
{
/* The queue contains only one member */
wqueue->last_thread= NULL;
}
else
{
/* Remove current element from list */
thread->next->prev= thread->prev;
*thread->prev= thread->next;
/* If first element, change list pointer to point to previous element */
if (wqueue->last_thread == thread)
wqueue->last_thread= STRUCT_PTR(struct st_my_thread_var, next,
thread->prev);
}
thread->next= NULL;
#ifdef DBUG_ASSERT_EXISTS
/*
This makes it easier to see it's not in a chain during debugging.
And some DBUG_ASSERT() rely on it.
*/
thread->prev= NULL;
#endif
}
|
O0
|
c
|
unlink_from_queue:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0xea67e
jmp 0xea680
jmp 0xea682
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0xea6a0
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
jmp 0xea6fe
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movq %rcx, 0x90(%rax)
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0xea6fc
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rcx
addq $-0x88, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0xea6fe
movq -0x10(%rbp), %rax
movq $0x0, 0x88(%rax)
popq %rbp
retq
nop
|
unlink_from_queue:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
jmp short $+2
loc_EA67E:
jmp short $+2
loc_EA680:
jmp short $+2
loc_EA682:
mov rax, [rbp+var_10]
mov rax, [rax+88h]
cmp rax, [rbp+var_10]
jnz short loc_EA6A0
mov rax, [rbp+var_8]
mov qword ptr [rax], 0
jmp short loc_EA6FE
loc_EA6A0:
mov rax, [rbp+var_10]
mov rcx, [rax+90h]
mov rax, [rbp+var_10]
mov rax, [rax+88h]
mov [rax+90h], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+88h]
mov rax, [rbp+var_10]
mov rax, [rax+90h]
mov [rax], rcx
mov rax, [rbp+var_8]
mov rax, [rax]
cmp rax, [rbp+var_10]
jnz short loc_EA6FC
mov rax, [rbp+var_10]
mov rcx, [rax+90h]
add rcx, 0FFFFFFFFFFFFFF78h
mov rax, [rbp+var_8]
mov [rax], rcx
loc_EA6FC:
jmp short $+2
loc_EA6FE:
mov rax, [rbp+var_10]
mov qword ptr [rax+88h], 0
pop rbp
retn
|
long long unlink_from_queue(_QWORD *a1, long long a2)
{
long long result; // rax
if ( *(_QWORD *)(a2 + 136) == a2 )
{
*a1 = 0LL;
}
else
{
*(_QWORD *)(*(_QWORD *)(a2 + 136) + 144LL) = *(_QWORD *)(a2 + 144);
**(_QWORD **)(a2 + 144) = *(_QWORD *)(a2 + 136);
if ( *a1 == a2 )
*a1 = *(_QWORD *)(a2 + 144) - 136LL;
}
result = a2;
*(_QWORD *)(a2 + 136) = 0LL;
return result;
}
|
unlink_from_queue:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
JMP 0x001ea67e
LAB_001ea67e:
JMP 0x001ea680
LAB_001ea680:
JMP 0x001ea682
LAB_001ea682:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x88]
CMP RAX,qword ptr [RBP + -0x10]
JNZ 0x001ea6a0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],0x0
JMP 0x001ea6fe
LAB_001ea6a0:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x90]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x88]
MOV qword ptr [RAX + 0x90],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x88]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x90]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
CMP RAX,qword ptr [RBP + -0x10]
JNZ 0x001ea6fc
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x90]
ADD RCX,-0x88
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],RCX
LAB_001ea6fc:
JMP 0x001ea6fe
LAB_001ea6fe:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x88],0x0
POP RBP
RET
|
void unlink_from_queue(long *param_1,long param_2)
{
if (*(long *)(param_2 + 0x88) == param_2) {
*param_1 = 0;
}
else {
*(int8 *)(*(long *)(param_2 + 0x88) + 0x90) = *(int8 *)(param_2 + 0x90);
**(int8 **)(param_2 + 0x90) = *(int8 *)(param_2 + 0x88);
if (*param_1 == param_2) {
*param_1 = *(long *)(param_2 + 0x90) + -0x88;
}
}
*(int8 *)(param_2 + 0x88) = 0;
return;
}
|
|
63,305 |
my_uca_init_one_contraction
|
eloqsql/strings/ctype-uca.c
|
static uint16 *
my_uca_init_one_contraction(MY_CONTRACTIONS *contractions,
my_wc_t *str, uint length, my_bool with_context)
{
int flag;
uint i;
my_uca_add_contraction_flag(contractions, str[0],
with_context ?
MY_UCA_PREVIOUS_CONTEXT_HEAD :
MY_UCA_CNT_HEAD);
for (i= 1, flag= MY_UCA_CNT_MID1; i < length - 1; i++, flag<<= 1)
my_uca_add_contraction_flag(contractions, str[i], flag);
my_uca_add_contraction_flag(contractions, str[i],
with_context ?
MY_UCA_PREVIOUS_CONTEXT_TAIL :
MY_UCA_CNT_TAIL);
/* Add new contraction to the contraction list */
return my_uca_add_contraction(contractions, str, length,
with_context)->weight;
}
|
O0
|
c
|
my_uca_init_one_contraction:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb %al, -0x15(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movsbl -0x15(%rbp), %ecx
movl $0x1, %edx
movl $0x40, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edx
callq 0x501c0
movl $0x1, -0x20(%rbp)
movl $0x4, -0x1c(%rbp)
movl -0x20(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jae 0x4f721
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
movl -0x1c(%rbp), %edx
callq 0x501c0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
shll %eax
movl %eax, -0x1c(%rbp)
jmp 0x4f6ea
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
movsbl -0x15(%rbp), %ecx
movl $0x2, %edx
movl $0x80, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edx
callq 0x501c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
movsbl -0x15(%rbp), %ecx
callq 0x501f0
addq $0x30, %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
|
my_uca_init_one_contraction:
push rbp
mov rbp, rsp
sub rsp, 20h
mov al, cl
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_15], al
mov rdi, [rbp+var_8]
mov rax, [rbp+var_10]
mov rsi, [rax]
movsx ecx, [rbp+var_15]
mov edx, 1
mov eax, 40h ; '@'
cmp ecx, 0
cmovnz edx, eax
call my_uca_add_contraction_flag
mov [rbp+var_20], 1
mov [rbp+var_1C], 4
loc_4F6EA:
mov eax, [rbp+var_20]
mov ecx, [rbp+var_14]
sub ecx, 1
cmp eax, ecx
jnb short loc_4F721
mov rdi, [rbp+var_8]
mov rax, [rbp+var_10]
mov ecx, [rbp+var_20]
mov rsi, [rax+rcx*8]
mov edx, [rbp+var_1C]
call my_uca_add_contraction_flag
mov eax, [rbp+var_20]
add eax, 1
mov [rbp+var_20], eax
mov eax, [rbp+var_1C]
shl eax, 1
mov [rbp+var_1C], eax
jmp short loc_4F6EA
loc_4F721:
mov rdi, [rbp+var_8]
mov rax, [rbp+var_10]
mov ecx, [rbp+var_20]
mov rsi, [rax+rcx*8]
movsx ecx, [rbp+var_15]
mov edx, 2
mov eax, 80h
cmp ecx, 0
cmovnz edx, eax
call my_uca_add_contraction_flag
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov eax, [rbp+var_14]
mov edx, eax
movsx ecx, [rbp+var_15]
call my_uca_add_contraction
add rax, 30h ; '0'
add rsp, 20h
pop rbp
retn
|
long long my_uca_init_one_contraction(long long a1, long long *a2, unsigned int a3, char a4)
{
long long v4; // rsi
long long v5; // rdx
long long v6; // rdx
unsigned int v8; // [rsp+0h] [rbp-20h]
unsigned int v9; // [rsp+4h] [rbp-1Ch]
v4 = *a2;
v5 = 1LL;
if ( a4 )
v5 = 64LL;
my_uca_add_contraction_flag(a1, v4, v5);
v8 = 1;
v9 = 4;
while ( v8 < a3 - 1 )
{
my_uca_add_contraction_flag(a1, a2[v8++], v9);
v9 *= 2;
}
v6 = 2LL;
if ( a4 )
v6 = 128LL;
my_uca_add_contraction_flag(a1, a2[v8], v6);
return my_uca_add_contraction(a1, a2, a3, (unsigned int)a4) + 48;
}
|
my_uca_init_one_contraction:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV AL,CL
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV byte ptr [RBP + -0x15],AL
MOV RDI,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX]
MOVSX ECX,byte ptr [RBP + -0x15]
MOV EDX,0x1
MOV EAX,0x40
CMP ECX,0x0
CMOVNZ EDX,EAX
CALL 0x001501c0
MOV dword ptr [RBP + -0x20],0x1
MOV dword ptr [RBP + -0x1c],0x4
LAB_0014f6ea:
MOV EAX,dword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x14]
SUB ECX,0x1
CMP EAX,ECX
JNC 0x0014f721
MOV RDI,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x20]
MOV RSI,qword ptr [RAX + RCX*0x8]
MOV EDX,dword ptr [RBP + -0x1c]
CALL 0x001501c0
MOV EAX,dword ptr [RBP + -0x20]
ADD EAX,0x1
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x1c]
SHL EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x0014f6ea
LAB_0014f721:
MOV RDI,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x20]
MOV RSI,qword ptr [RAX + RCX*0x8]
MOVSX ECX,byte ptr [RBP + -0x15]
MOV EDX,0x2
MOV EAX,0x80
CMP ECX,0x0
CMOVNZ EDX,EAX
CALL 0x001501c0
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x14]
MOV EDX,EAX
MOVSX ECX,byte ptr [RBP + -0x15]
CALL 0x001501f0
ADD RAX,0x30
ADD RSP,0x20
POP RBP
RET
|
long my_uca_init_one_contraction(int8 param_1,int8 *param_2,int param_3,char param_4)
{
long lVar1;
int8 uVar2;
uint local_28;
int local_24;
uVar2 = 1;
if (param_4 != '\0') {
uVar2 = 0x40;
}
my_uca_add_contraction_flag(param_1,*param_2,uVar2);
local_24 = 4;
for (local_28 = 1; local_28 < param_3 - 1U; local_28 = local_28 + 1) {
my_uca_add_contraction_flag(param_1,param_2[local_28],local_24);
local_24 = local_24 << 1;
}
uVar2 = 2;
if (param_4 != '\0') {
uVar2 = 0x80;
}
my_uca_add_contraction_flag(param_1,param_2[local_28],uVar2);
lVar1 = my_uca_add_contraction(param_1,param_2,param_3,(int)param_4);
return lVar1 + 0x30;
}
|
|
63,306 |
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;
}
|
O3
|
c
|
my_get_err_msg:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
leaq 0x2e7794(%rip), %r14 # 0x3887f0
xorl %eax, %eax
movq (%r14), %r14
testq %r14, %r14
je 0xa1092
cmpl %ebx, 0x14(%r14)
jb 0xa105e
cmpl %ebx, 0x10(%r14)
ja 0xa1090
movl %ebx, %edi
callq *0x8(%r14)
subl 0x10(%r14), %ebx
movq (%rax,%rbx,8), %rcx
testq %rcx, %rcx
je 0xa1090
xorl %eax, %eax
cmpb $0x0, (%rcx)
cmovneq %rcx, %rax
jmp 0xa1092
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
|
my_get_err_msg:
push rbp
mov rbp, rsp
push r14
push rbx
mov ebx, edi
lea r14, my_errmsgs_list
xor eax, eax
loc_A105E:
mov r14, [r14]
test r14, r14
jz short loc_A1092
cmp [r14+14h], ebx
jb short loc_A105E
cmp [r14+10h], ebx
ja short loc_A1090
mov edi, ebx
call qword ptr [r14+8]
sub ebx, [r14+10h]
mov rcx, [rax+rbx*8]
test rcx, rcx
jz short loc_A1090
xor eax, eax
cmp byte ptr [rcx], 0
cmovnz rax, rcx
jmp short loc_A1092
loc_A1090:
xor eax, eax
loc_A1092:
pop rbx
pop r14
pop rbp
retn
|
_BYTE * my_get_err_msg(unsigned int a1)
{
long long **v1; // r14
_BYTE *result; // rax
_BYTE *v3; // rcx
v1 = &my_errmsgs_list;
result = 0LL;
while ( 1 )
{
v1 = (long long **)*v1;
if ( !v1 )
break;
if ( *((_DWORD *)v1 + 5) >= a1 )
{
if ( *((_DWORD *)v1 + 4) > a1 )
return 0LL;
v3 = *(_BYTE **)(((long long ( *)(_QWORD))v1[1])(a1) + 8LL * (a1 - *((_DWORD *)v1 + 4)));
if ( !v3 )
return 0LL;
result = 0LL;
if ( *v3 )
return v3;
return result;
}
}
return result;
}
|
my_get_err_msg:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV EBX,EDI
LEA R14,[0x4887f0]
XOR EAX,EAX
LAB_001a105e:
MOV R14,qword ptr [R14]
TEST R14,R14
JZ 0x001a1092
CMP dword ptr [R14 + 0x14],EBX
JC 0x001a105e
CMP dword ptr [R14 + 0x10],EBX
JA 0x001a1090
MOV EDI,EBX
CALL qword ptr [R14 + 0x8]
SUB EBX,dword ptr [R14 + 0x10]
MOV RCX,qword ptr [RAX + RBX*0x8]
TEST RCX,RCX
JZ 0x001a1090
XOR EAX,EAX
CMP byte ptr [RCX],0x0
CMOVNZ RAX,RCX
JMP 0x001a1092
LAB_001a1090:
XOR EAX,EAX
LAB_001a1092:
POP RBX
POP R14
POP RBP
RET
|
char * my_get_err_msg(uint param_1)
{
char *pcVar1;
long lVar2;
int **ppuVar3;
ppuVar3 = &my_errmsgs_list;
do {
ppuVar3 = (int **)*ppuVar3;
if (ppuVar3 == (int **)0x0) {
return (char *)0x0;
}
} while (*(uint *)((long)ppuVar3 + 0x14) < param_1);
if (*(uint *)(ppuVar3 + 2) <= param_1) {
lVar2 = (*(code *)ppuVar3[1])(param_1);
pcVar1 = *(char **)(lVar2 + (ulong)(param_1 - *(int *)(ppuVar3 + 2)) * 8);
if (pcVar1 != (char *)0x0) {
if (*pcVar1 == '\0') {
return (char *)0x0;
}
return pcVar1;
}
}
return (char *)0x0;
}
|
|
63,307 |
YAML::Parser::HandleTagDirective(YAML::Token const&)
|
aimrt_mujoco_sim/_deps/yaml-cpp-src/src/parser.cpp
|
void Parser::HandleTagDirective(const Token& token) {
if (token.params.size() != 2)
throw ParserException(token.mark, ErrorMsg::TAG_DIRECTIVE_ARGS);
const std::string& handle = token.params[0];
const std::string& prefix = token.params[1];
if (m_pDirectives->tags.find(handle) != m_pDirectives->tags.end()) {
throw ParserException(token.mark, ErrorMsg::REPEATED_TAG_DIRECTIVE);
}
m_pDirectives->tags[handle] = prefix;
}
|
O3
|
cpp
|
YAML::Parser::HandleTagDirective(YAML::Token const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq 0x38(%rsi), %rbx
movq 0x40(%rsi), %rax
subq %rbx, %rax
cmpq $0x40, %rax
jne 0x63191
movq %rdi, %r15
movq 0x8(%rdi), %rdi
addq $0x10, %rdi
movq %rbx, %rsi
callq 0x2cba0
movq 0x8(%r15), %rdi
leaq 0x18(%rdi), %rcx
cmpq %rcx, %rax
jne 0x631fe
addq $0x10, %rdi
leaq 0x20(%rbx), %r14
movq %rbx, %rsi
callq 0x2c0e0
movq %rax, %rdi
movq %r14, %rsi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2d240
movl $0x40, %edi
callq 0x2c800
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x101981(%rip), %rsi # 0x164b2f
leaq 0x1019a8(%rip), %rdx # 0x164b5d
leaq 0x8(%rsp), %rdi
callq 0x2c610
addq $0x8, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x47336
leaq 0x1a6313(%rip), %rax # 0x2094f0
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1a632b(%rip), %rsi # 0x209518
leaq -0x2ac8(%rip), %rdx # 0x6072c
movq %rbx, %rdi
callq 0x2e0f0
jmp 0x63269
movl $0x40, %edi
callq 0x2c800
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x101943(%rip), %rsi # 0x164b5e
leaq 0x101952(%rip), %rdx # 0x164b74
leaq 0x8(%rsp), %rdi
callq 0x2c610
addq $0x8, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x47336
leaq 0x1a62a6(%rip), %rax # 0x2094f0
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1a62be(%rip), %rsi # 0x209518
leaq -0x2b35(%rip), %rdx # 0x6072c
movq %rbx, %rdi
callq 0x2e0f0
jmp 0x6326d
jmp 0x6328e
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x63287
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2d2d0
testb %bpl, %bpl
jne 0x63291
jmp 0x63299
movq %rax, %r14
movq %rbx, %rdi
callq 0x2cc80
movq %r14, %rdi
callq 0x2e220
nop
|
_ZN4YAML6Parser18HandleTagDirectiveERKNS_5TokenE:
push rbp
push r15
push r14
push rbx
sub rsp, 28h
mov r14, rsi
mov rbx, [rsi+38h]
mov rax, [rsi+40h]
sub rax, rbx
cmp rax, 40h ; '@'
jnz short loc_63191
mov r15, rdi
mov rdi, [rdi+8]
add rdi, 10h
mov rsi, rbx
call __ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_S5_ESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EE4findERS7_; std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::string>>>::find(std::string const&)
mov rdi, [r15+8]
lea rcx, [rdi+18h]
cmp rax, rcx
jnz loc_631FE
add rdi, 10h
lea r14, [rbx+20h]
mov rsi, rbx
call __ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_St4lessIS5_ESaISt4pairIKS5_S5_EEEixERS9_; std::map<std::string,std::string>::operator[](std::string const&)
mov rdi, rax
mov rsi, r14
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
jmp __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_assignERKS4_; std::string::_M_assign(std::string const&)
loc_63191:
mov edi, 40h ; '@'; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r15, [rsp+48h+var_30]
mov [r15-10h], r15
lea rsi, aTagDirectivesM; "TAG directives must have exactly two ar"...
lea rdx, aTagDirectivesM+2Eh; ""
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)
add r14, 8
mov bpl, 1
lea rdx, [rsp+48h+var_40]
mov rdi, rbx
mov rsi, r14
call _ZN4YAML9ExceptionC2ERKNS_4MarkERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; YAML::Exception::Exception(YAML::Mark const&,std::string const&)
lea rax, _ZTVN4YAML15ParserExceptionE; `vtable for'YAML::ParserException
add rax, 10h
mov [rbx], rax
xor ebp, ebp
lea rsi, _ZTIN4YAML15ParserExceptionE; lptinfo
lea rdx, _ZN4YAML9ExceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp short loc_63269
loc_631FE:
mov edi, 40h ; '@'; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r15, [rsp+48h+var_30]
mov [r15-10h], r15
lea rsi, aRepeatedTagDir; "repeated TAG directive"
lea rdx, aRepeatedTagDir+16h; ""
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)
add r14, 8
mov bpl, 1
lea rdx, [rsp+48h+var_40]
mov rdi, rbx
mov rsi, r14
call _ZN4YAML9ExceptionC2ERKNS_4MarkERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; YAML::Exception::Exception(YAML::Mark const&,std::string const&)
lea rax, _ZTVN4YAML15ParserExceptionE; `vtable for'YAML::ParserException
add rax, 10h
mov [rbx], rax
xor ebp, ebp
lea rsi, _ZTIN4YAML15ParserExceptionE; lptinfo
lea rdx, _ZN4YAML9ExceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_63269:
jmp short loc_6326D
jmp short loc_6328E
loc_6326D:
mov r14, rax
mov rdi, [rsp+48h+var_40]; void *
cmp rdi, r15
jz short loc_63287
mov rsi, [rsp+48h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_63287:
test bpl, bpl
jnz short loc_63291
jmp short loc_63299
loc_6328E:
mov r14, rax
loc_63291:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_63299:
mov rdi, r14
call __Unwind_Resume
|
long long YAML::Parser::HandleTagDirective(YAML::Parser *this, const YAML::Token *a2)
{
long long v2; // rbx
long long v3; // rax
long long v4; // rdi
long long v5; // rax
_QWORD *exception; // rbx
int v8; // ecx
int v9; // r8d
int v10; // r9d
_QWORD *v11; // rbx
int v12; // ecx
int v13; // r8d
int v14; // r9d
void *v15[2]; // [rsp+8h] [rbp-40h] BYREF
_QWORD v16[6]; // [rsp+18h] [rbp-30h] BYREF
v2 = *((_QWORD *)a2 + 7);
if ( *((_QWORD *)a2 + 8) - v2 != 64 )
{
exception = __cxa_allocate_exception(0x40uLL);
v15[0] = v16;
std::string::_M_construct<char const*>(v15, "TAG directives must have exactly two arguments", "");
YAML::Exception::Exception((_DWORD)exception, (_DWORD)a2 + 8, (unsigned int)v15, v8, v9, v10);
*exception = &`vtable for'YAML::ParserException + 2;
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'YAML::ParserException,
(void (*)(void *))YAML::Exception::~Exception);
}
v3 = std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::string>>>::find(
*((_QWORD *)this + 1) + 16LL,
*((_QWORD *)a2 + 7));
v4 = *((_QWORD *)this + 1);
if ( v3 != v4 + 24 )
{
v11 = __cxa_allocate_exception(0x40uLL);
v15[0] = v16;
std::string::_M_construct<char const*>(v15, "repeated TAG directive", "");
YAML::Exception::Exception((_DWORD)v11, (_DWORD)a2 + 8, (unsigned int)v15, v12, v13, v14);
*v11 = &`vtable for'YAML::ParserException + 2;
__cxa_throw(
v11,
(struct type_info *)&`typeinfo for'YAML::ParserException,
(void (*)(void *))YAML::Exception::~Exception);
}
v5 = std::map<std::string,std::string>::operator[](v4 + 16, v2);
return std::string::_M_assign(v5, v2 + 32);
}
|
HandleTagDirective:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV R14,RSI
MOV RBX,qword ptr [RSI + 0x38]
MOV RAX,qword ptr [RSI + 0x40]
SUB RAX,RBX
CMP RAX,0x40
JNZ 0x00163191
MOV R15,RDI
MOV RDI,qword ptr [RDI + 0x8]
ADD RDI,0x10
MOV RSI,RBX
CALL 0x0012cba0
MOV RDI,qword ptr [R15 + 0x8]
LEA RCX,[RDI + 0x18]
CMP RAX,RCX
JNZ 0x001631fe
ADD RDI,0x10
LEA R14,[RBX + 0x20]
MOV RSI,RBX
CALL 0x0012c0e0
MOV RDI,RAX
MOV RSI,R14
ADD RSP,0x28
POP RBX
POP R14
POP R15
POP RBP
JMP 0x0012d240
LAB_00163191:
MOV EDI,0x40
CALL 0x0012c800
MOV RBX,RAX
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
LAB_001631a7:
LEA RSI,[0x264b2f]
LEA RDX,[0x264b5d]
LEA RDI,[RSP + 0x8]
CALL 0x0012c610
ADD R14,0x8
MOV BPL,0x1
LAB_001631c6:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV RSI,R14
CALL 0x00147336
LEA RAX,[0x3094f0]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
XOR EBP,EBP
LEA RSI,[0x309518]
LEA RDX,[0x16072c]
MOV RDI,RBX
CALL 0x0012e0f0
LAB_001631fe:
MOV EDI,0x40
CALL 0x0012c800
MOV RBX,RAX
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
LAB_00163214:
LEA RSI,[0x264b5e]
LEA RDX,[0x264b74]
LEA RDI,[RSP + 0x8]
CALL 0x0012c610
ADD R14,0x8
MOV BPL,0x1
LAB_00163233:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV RSI,R14
CALL 0x00147336
LEA RAX,[0x3094f0]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
XOR EBP,EBP
LEA RSI,[0x309518]
LEA RDX,[0x16072c]
MOV RDI,RBX
CALL 0x0012e0f0
|
/* YAML::Parser::HandleTagDirective(YAML::Token const&) */
void __thiscall YAML::Parser::HandleTagDirective(Parser *this,Token *param_1)
{
string *psVar1;
long lVar2;
string *this_00;
Exception *pEVar3;
int1 *local_40 [2];
int1 local_30 [16];
psVar1 = *(string **)(param_1 + 0x38);
if (*(long *)(param_1 + 0x40) - (long)psVar1 != 0x40) {
pEVar3 = (Exception *)__cxa_allocate_exception(0x40);
local_40[0] = local_30;
/* try { // try from 001631a7 to 001631be has its CatchHandler @ 0016328e */
std::__cxx11::string::_M_construct<char_const*>
(local_40,"TAG directives must have exactly two arguments","");
/* try { // try from 001631c6 to 001631fb has its CatchHandler @ 0016326d */
Exception::Exception(pEVar3,(Mark *)(param_1 + 8),(string *)local_40);
*(int ***)pEVar3 = &PTR__BadInsert_00309500;
/* WARNING: Subroutine does not return */
__cxa_throw(pEVar3,&ParserException::typeinfo,BadInsert::~BadInsert);
}
lVar2 = std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::__cxx11::string>,std::_Select1st<std::pair<std::__cxx11::string_const,std::__cxx11::string>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
::find((_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::__cxx11::string>,std::_Select1st<std::pair<std::__cxx11::string_const,std::__cxx11::string>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
*)(*(long *)(this + 8) + 0x10),psVar1);
if (lVar2 == *(long *)(this + 8) + 0x18) {
this_00 = (string *)
std::
map<std::__cxx11::string,std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
::operator[]((map<std::__cxx11::string,std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
*)(*(long *)(this + 8) + 0x10),psVar1);
std::__cxx11::string::_M_assign(this_00,psVar1 + 0x20);
return;
}
pEVar3 = (Exception *)__cxa_allocate_exception(0x40);
local_40[0] = local_30;
/* try { // try from 00163214 to 0016322b has its CatchHandler @ 0016326b */
std::__cxx11::string::_M_construct<char_const*>(local_40,"repeated TAG directive","");
/* try { // try from 00163233 to 00163268 has its CatchHandler @ 00163269 */
Exception::Exception(pEVar3,(Mark *)(param_1 + 8),(string *)local_40);
*(int ***)pEVar3 = &PTR__BadInsert_00309500;
/* WARNING: Subroutine does not return */
__cxa_throw(pEVar3,&ParserException::typeinfo,BadInsert::~BadInsert);
}
|
|
63,308 |
mi_extra_keyflag
|
eloqsql/storage/myisam/mi_extra.c
|
static void mi_extra_keyflag(MI_INFO *info, enum ha_extra_function function)
{
uint idx;
for (idx= 0; idx< info->s->base.keys; idx++)
{
switch (function) {
case HA_EXTRA_CHANGE_KEY_TO_UNIQUE:
info->s->keyinfo[idx].flag|= HA_NOSAME;
break;
case HA_EXTRA_CHANGE_KEY_TO_DUP:
info->s->keyinfo[idx].flag&= ~(HA_NOSAME);
break;
default:
break;
}
}
}
|
O0
|
c
|
mi_extra_keyflag:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x180(%rcx), %eax
jae 0xadde7
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
subl $0x1e, %eax
je 0xadd8b
jmp 0xadd81
movl -0x14(%rbp), %eax
subl $0x1f, %eax
je 0xaddb0
jmp 0xaddd5
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x218(%rax), %rax
movl -0x10(%rbp), %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movzwl 0xa(%rax), %ecx
orl $0x1, %ecx
movw %cx, 0xa(%rax)
jmp 0xaddd7
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x218(%rax), %rax
movl -0x10(%rbp), %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movzwl 0xa(%rax), %ecx
andl $-0x2, %ecx
movw %cx, 0xa(%rax)
jmp 0xaddd7
jmp 0xaddd7
jmp 0xaddd9
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xadd62
popq %rbp
retq
nopl (%rax)
|
mi_extra_keyflag:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_10], 0
loc_ADD62:
mov eax, [rbp+var_10]
mov rcx, [rbp+var_8]
mov rcx, [rcx]
cmp eax, [rcx+180h]
jnb short loc_ADDE7
mov eax, [rbp+var_C]
mov [rbp+var_14], eax
sub eax, 1Eh
jz short loc_ADD8B
jmp short $+2
loc_ADD81:
mov eax, [rbp+var_14]
sub eax, 1Fh
jz short loc_ADDB0
jmp short loc_ADDD5
loc_ADD8B:
mov rax, [rbp+var_8]
mov rax, [rax]
mov rax, [rax+218h]
mov ecx, [rbp+var_10]
imul rcx, 70h ; 'p'
add rax, rcx
movzx ecx, word ptr [rax+0Ah]
or ecx, 1
mov [rax+0Ah], cx
jmp short loc_ADDD7
loc_ADDB0:
mov rax, [rbp+var_8]
mov rax, [rax]
mov rax, [rax+218h]
mov ecx, [rbp+var_10]
imul rcx, 70h ; 'p'
add rax, rcx
movzx ecx, word ptr [rax+0Ah]
and ecx, 0FFFFFFFEh
mov [rax+0Ah], cx
jmp short loc_ADDD7
loc_ADDD5:
jmp short $+2
loc_ADDD7:
jmp short $+2
loc_ADDD9:
mov eax, [rbp+var_10]
add eax, 1
mov [rbp+var_10], eax
jmp loc_ADD62
loc_ADDE7:
pop rbp
retn
|
long long mi_extra_keyflag(long long a1, int a2)
{
long long result; // rax
long long v3; // rax
long long v4; // rax
unsigned int i; // [rsp+4h] [rbp-10h]
for ( i = 0; ; ++i )
{
result = i;
if ( i >= *(_DWORD *)(*(_QWORD *)a1 + 384LL) )
break;
if ( a2 == 30 )
{
v3 = 112LL * i + *(_QWORD *)(*(_QWORD *)a1 + 536LL);
*(_WORD *)(v3 + 10) |= 1u;
}
else if ( a2 == 31 )
{
v4 = 112LL * i + *(_QWORD *)(*(_QWORD *)a1 + 536LL);
*(_WORD *)(v4 + 10) &= ~1u;
}
}
return result;
}
|
mi_extra_keyflag:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV dword ptr [RBP + -0x10],0x0
LAB_001add62:
MOV EAX,dword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RCX]
CMP EAX,dword ptr [RCX + 0x180]
JNC 0x001adde7
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x14],EAX
SUB EAX,0x1e
JZ 0x001add8b
JMP 0x001add81
LAB_001add81:
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,0x1f
JZ 0x001addb0
JMP 0x001addd5
LAB_001add8b:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV ECX,dword ptr [RBP + -0x10]
IMUL RCX,RCX,0x70
ADD RAX,RCX
MOVZX ECX,word ptr [RAX + 0xa]
OR ECX,0x1
MOV word ptr [RAX + 0xa],CX
JMP 0x001addd7
LAB_001addb0:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV ECX,dword ptr [RBP + -0x10]
IMUL RCX,RCX,0x70
ADD RAX,RCX
MOVZX ECX,word ptr [RAX + 0xa]
AND ECX,0xfffffffe
MOV word ptr [RAX + 0xa],CX
JMP 0x001addd7
LAB_001addd5:
JMP 0x001addd7
LAB_001addd7:
JMP 0x001addd9
LAB_001addd9:
MOV EAX,dword ptr [RBP + -0x10]
ADD EAX,0x1
MOV dword ptr [RBP + -0x10],EAX
JMP 0x001add62
LAB_001adde7:
POP RBP
RET
|
void mi_extra_keyflag(long *param_1,int param_2)
{
long lVar1;
int4 local_18;
for (local_18 = 0; local_18 < *(uint *)(*param_1 + 0x180); local_18 = local_18 + 1) {
if (param_2 == 0x1e) {
lVar1 = *(long *)(*param_1 + 0x218) + (ulong)local_18 * 0x70;
*(ushort *)(lVar1 + 10) = *(ushort *)(lVar1 + 10) | 1;
}
else if (param_2 == 0x1f) {
lVar1 = *(long *)(*param_1 + 0x218) + (ulong)local_18 * 0x70;
*(ushort *)(lVar1 + 10) = *(ushort *)(lVar1 + 10) & 0xfffe;
}
}
return;
}
|
|
63,309 |
ModbusSerialPort::close()
|
serhmarch[P]ModbusBridge/modbus/src/unix/ModbusSerialPort_unix.cpp
|
StatusCode ModbusSerialPort::close()
{
ModbusSerialPortPrivateUnix *d = d_unix(d_ptr);
if (d->serialPortIsOpen())
{
d->serialPortClose();
//setMessage(QString("Serial port '%1' is closed").arg(serialPortName()));
}
d->state = STATE_CLOSED;
return Status_Good;
}
|
O0
|
cpp
|
ModbusSerialPort::close():
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x228a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x253e0
testb $0x1, %al
jne 0x2525c
jmp 0x25265
movq -0x10(%rbp), %rdi
callq 0x254d0
movq -0x10(%rbp), %rax
movl $0xa, 0x8(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
_ZN16ModbusSerialPort5closeEv:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rdi, [rax+8]; ModbusPortPrivate *
call _Z6d_unixP17ModbusPortPrivate; d_unix(ModbusPortPrivate *)
mov [rbp+var_10], rax
mov rdi, [rbp+var_10]; this
call _ZNK27ModbusSerialPortPrivateUnix16serialPortIsOpenEv; ModbusSerialPortPrivateUnix::serialPortIsOpen(void)
test al, 1
jnz short loc_2525C
jmp short loc_25265
loc_2525C:
mov rdi, [rbp+var_10]; this
call _ZN27ModbusSerialPortPrivateUnix15serialPortCloseEv; ModbusSerialPortPrivateUnix::serialPortClose(void)
loc_25265:
mov rax, [rbp+var_10]
mov dword ptr [rax+8], 0Ah
xor eax, eax
add rsp, 10h
pop rbp
retn
|
long long ModbusSerialPort::close(ModbusPortPrivate **this)
{
ModbusPortPrivate *v2; // [rsp+0h] [rbp-10h]
v2 = d_unix(this[1]);
if ( (ModbusSerialPortPrivateUnix::serialPortIsOpen(v2) & 1) != 0 )
ModbusSerialPortPrivateUnix::serialPortClose(v2);
*((_DWORD *)v2 + 2) = 10;
return 0LL;
}
|
close:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x001228a0
MOV qword ptr [RBP + -0x10],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001253e0
TEST AL,0x1
JNZ 0x0012525c
JMP 0x00125265
LAB_0012525c:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001254d0
LAB_00125265:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x8],0xa
XOR EAX,EAX
ADD RSP,0x10
POP RBP
RET
|
/* ModbusSerialPort::close() */
int8 __thiscall ModbusSerialPort::close(ModbusSerialPort *this)
{
ModbusSerialPortPrivateUnix *this_00;
ulong uVar1;
this_00 = (ModbusSerialPortPrivateUnix *)d_unix(*(ModbusPortPrivate **)(this + 8));
uVar1 = ModbusSerialPortPrivateUnix::serialPortIsOpen(this_00);
if ((uVar1 & 1) != 0) {
ModbusSerialPortPrivateUnix::serialPortClose(this_00);
}
*(int4 *)(this_00 + 8) = 10;
return 0;
}
|
|
63,310 |
ModbusSerialPort::close()
|
serhmarch[P]ModbusBridge/modbus/src/unix/ModbusSerialPort_unix.cpp
|
StatusCode ModbusSerialPort::close()
{
ModbusSerialPortPrivateUnix *d = d_unix(d_ptr);
if (d->serialPortIsOpen())
{
d->serialPortClose();
//setMessage(QString("Serial port '%1' is closed").arg(serialPortName()));
}
d->state = STATE_CLOSED;
return Status_Good;
}
|
O3
|
cpp
|
ModbusSerialPort::close():
pushq %rbx
movq 0x8(%rdi), %rbx
movl 0x84(%rbx), %edi
cmpl $-0x1, %edi
je 0x165f1
callq 0x55a0
movl $0xffffffff, 0x84(%rbx) # imm = 0xFFFFFFFF
movl $0xa, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
retq
|
_ZN16ModbusSerialPort5closeEv:
push rbx
mov rbx, [rdi+8]
mov edi, [rbx+84h]
cmp edi, 0FFFFFFFFh
jz short loc_165F1
call _close
mov dword ptr [rbx+84h], 0FFFFFFFFh
loc_165F1:
mov dword ptr [rbx+8], 0Ah
xor eax, eax
pop rbx
retn
|
long long ModbusSerialPort::close(ModbusSerialPort *this)
{
long long v1; // rbx
long long v2; // rdi
v1 = *((_QWORD *)this + 1);
v2 = *(unsigned int *)(v1 + 132);
if ( (_DWORD)v2 != -1 )
{
close(v2);
*(_DWORD *)(v1 + 132) = -1;
}
*(_DWORD *)(v1 + 8) = 10;
return 0LL;
}
|
close:
PUSH RBX
MOV RBX,qword ptr [RDI + 0x8]
MOV EDI,dword ptr [RBX + 0x84]
CMP EDI,-0x1
JZ 0x001165f1
CALL 0x001055a0
MOV dword ptr [RBX + 0x84],0xffffffff
LAB_001165f1:
MOV dword ptr [RBX + 0x8],0xa
XOR EAX,EAX
POP RBX
RET
|
/* ModbusSerialPort::close() */
int8 __thiscall ModbusSerialPort::close(ModbusSerialPort *this)
{
long lVar1;
lVar1 = *(long *)(this + 8);
if (*(int *)(lVar1 + 0x84) != -1) {
::close(*(int *)(lVar1 + 0x84));
*(int4 *)(lVar1 + 0x84) = 0xffffffff;
}
*(int4 *)(lVar1 + 8) = 10;
return 0;
}
|
|
63,311 |
ftxui::separatorEmpty()
|
Andrewchistyakov[P]flashcards_lyc/build_O3/_deps/ftxui-src/src/ftxui/dom/separator.cpp
|
Element separatorEmpty() {
return std::make_shared<SeparatorAuto>(EMPTY);
}
|
O3
|
cpp
|
ftxui::separatorEmpty():
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x70, %edi
callq 0xb3e0
movq %rax, %rbx
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x8(%rbx)
leaq 0x332b1(%rip), %rax # 0x575f8
movq %rax, (%rbx)
movq %rbx, %r15
addq $0x10, %r15
movq %r15, %rdi
callq 0x23de0
leaq 0x332e8(%rip), %rax # 0x57648
movq %rax, 0x10(%rbx)
movl $0x5, 0x6c(%rbx)
movq %r15, (%r14)
movq %rbx, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x70, %esi
movq %rbx, %rdi
callq 0xb400
movq %r14, %rdi
callq 0xb780
|
_ZN5ftxui14separatorEmptyEv:
push r15
push r14
push rbx
mov r14, rdi
mov edi, 70h ; 'p'; unsigned __int64
call __Znwm; operator new(ulong)
mov rbx, rax
mov rax, 100000001h
mov [rbx+8], rax
lea rax, off_575F8
mov [rbx], rax
mov r15, rbx
add r15, 10h
mov rdi, r15; this
call _ZN5ftxui4NodeC2Ev; ftxui::Node::Node(void)
lea rax, off_57648
mov [rbx+10h], rax
mov dword ptr [rbx+6Ch], 5
mov [r14], r15
mov [r14+8], rbx
mov rax, r14
pop rbx
pop r14
pop r15
retn
mov r14, rax
mov esi, 70h ; 'p'; unsigned __int64
mov rdi, rbx; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rdi, r14
call __Unwind_Resume
|
ftxui * ftxui::separatorEmpty(ftxui *this)
{
long long v1; // rbx
v1 = operator new(0x70uLL);
*(_QWORD *)(v1 + 8) = 0x100000001LL;
*(_QWORD *)v1 = off_575F8;
ftxui::Node::Node((ftxui::Node *)(v1 + 16));
*(_QWORD *)(v1 + 16) = off_57648;
*(_DWORD *)(v1 + 108) = 5;
*(_QWORD *)this = v1 + 16;
*((_QWORD *)this + 1) = v1;
return this;
}
|
separatorEmpty:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RDI
MOV EDI,0x70
CALL 0x0010b3e0
MOV RBX,RAX
MOV RAX,0x100000001
MOV qword ptr [RBX + 0x8],RAX
LEA RAX,[0x1575f8]
MOV qword ptr [RBX],RAX
MOV R15,RBX
ADD R15,0x10
LAB_00124351:
MOV RDI,R15
CALL 0x00123de0
LAB_00124359:
LEA RAX,[0x157648]
MOV qword ptr [RBX + 0x10],RAX
MOV dword ptr [RBX + 0x6c],0x5
MOV qword ptr [R14],R15
MOV qword ptr [R14 + 0x8],RBX
MOV RAX,R14
POP RBX
POP R14
POP R15
RET
|
/* ftxui::separatorEmpty() */
ftxui * __thiscall ftxui::separatorEmpty(ftxui *this)
{
int8 *puVar1;
puVar1 = (int8 *)operator_new(0x70);
puVar1[1] = 0x100000001;
*puVar1 = &PTR___Sp_counted_ptr_inplace_001575f8;
/* try { // try from 00124351 to 00124358 has its CatchHandler @ 0012437b */
Node::Node((Node *)(puVar1 + 2));
puVar1[2] = &PTR__Node_00157648;
*(int4 *)((long)puVar1 + 0x6c) = 5;
*(Node **)this = (Node *)(puVar1 + 2);
*(int8 **)(this + 8) = puVar1;
return this;
}
|
|
63,312 |
httplib::detail::MultipartFormDataParser::MultipartFormDataParser()
|
nickolajgrishuk[P]metricz-cpp/build_O3/_deps/httplib-src/httplib.h
|
MultipartFormDataParser() = default;
|
O3
|
c
|
httplib::detail::MultipartFormDataParser::MultipartFormDataParser():
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
leaq 0x768e(%rip), %rsi # 0x2e314
leaq 0x7689(%rip), %rdx # 0x2e316
callq 0x10898
leaq 0x20(%rbx), %r14
leaq 0x30(%rbx), %r13
movq %r13, 0x20(%rbx)
leaq 0x776d(%rip), %rsi # 0x2e412
leaq 0x7768(%rip), %rdx # 0x2e414
movq %r14, %rdi
callq 0x10898
leaq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
movq %rax, 0x40(%rbx)
leaq 0x766f(%rip), %rsi # 0x2e336
leaq 0x766c(%rip), %rdx # 0x2e33a
callq 0x10898
leaq 0x70(%rbx), %rax
movq %rax, 0x60(%rbx)
xorl %eax, %eax
movq %rax, 0x68(%rbx)
movb %al, 0x70(%rbx)
leaq 0x90(%rbx), %rcx
movq %rcx, 0x80(%rbx)
movq %rax, 0x88(%rbx)
movb %al, 0x90(%rbx)
leaq 0xb0(%rbx), %rcx
movq %rcx, 0xa0(%rbx)
movq %rax, 0xa8(%rbx)
movb %al, 0xb0(%rbx)
movq %rax, 0xc0(%rbx)
movb %al, 0xc8(%rbx)
leaq 0xe0(%rbx), %rcx
movq %rcx, 0xd0(%rbx)
movq %rax, 0xd8(%rbx)
movb %al, 0xe0(%rbx)
leaq 0x100(%rbx), %rcx
movq %rcx, 0xf0(%rbx)
movq %rax, 0xf8(%rbx)
movb %al, 0x100(%rbx)
leaq 0x120(%rbx), %rcx
movq %rcx, 0x110(%rbx)
movq %rax, 0x118(%rbx)
movb %al, 0x120(%rbx)
leaq 0x140(%rbx), %rcx
movq %rcx, 0x130(%rbx)
movq %rax, 0x138(%rbx)
movb %al, 0x140(%rbx)
leaq 0x160(%rbx), %rcx
movq %rcx, 0x150(%rbx)
movq %rax, 0x158(%rbx)
movb %al, 0x160(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x170(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x26dd7
callq 0x8520
jmp 0x26dd7
movq %rax, %r15
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x26de4
callq 0x8520
movq %r15, %rdi
callq 0x8980
|
_ZN7httplib6detail23MultipartFormDataParserC2Ev:
push r15
push r14
push r13
push r12
push rbx
mov rbx, rdi
lea r12, [rdi+10h]
mov [rdi], r12
lea rsi, asc_2E314; "--"
lea rdx, asc_2E314+2; ""
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea r14, [rbx+20h]
lea r13, [rbx+30h]
mov [rbx+20h], r13
lea rsi, a0+3; "\r\n"
lea rdx, a0+5; ""
mov rdi, r14
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rdi, [rbx+40h]
lea rax, [rbx+50h]
mov [rbx+40h], rax
lea rsi, asc_2E336; "--\r\n"
lea rdx, asc_2E336+4; ""
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rax, [rbx+70h]
mov [rbx+60h], rax
xor eax, eax
mov [rbx+68h], rax
mov [rbx+70h], al
lea rcx, [rbx+90h]
mov [rbx+80h], rcx
mov [rbx+88h], rax
mov [rbx+90h], al
lea rcx, [rbx+0B0h]
mov [rbx+0A0h], rcx
mov [rbx+0A8h], rax
mov [rbx+0B0h], al
mov [rbx+0C0h], rax
mov [rbx+0C8h], al
lea rcx, [rbx+0E0h]
mov [rbx+0D0h], rcx
mov [rbx+0D8h], rax
mov [rbx+0E0h], al
lea rcx, [rbx+100h]
mov [rbx+0F0h], rcx
mov [rbx+0F8h], rax
mov [rbx+100h], al
lea rcx, [rbx+120h]
mov [rbx+110h], rcx
mov [rbx+118h], rax
mov [rbx+120h], al
lea rcx, [rbx+140h]
mov [rbx+130h], rcx
mov [rbx+138h], rax
mov [rbx+140h], al
lea rcx, [rbx+160h]
mov [rbx+150h], rcx
mov [rbx+158h], rax
mov [rbx+160h], al
xorps xmm0, xmm0
movups xmmword ptr [rbx+170h], xmm0
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov r15, rax
mov rdi, [r14]; void *
cmp rdi, r13
jz short loc_26DD7
call __ZdlPv; operator delete(void *)
jmp short loc_26DD7
mov r15, rax
loc_26DD7:
mov rdi, [rbx]; void *
cmp rdi, r12
jz short loc_26DE4
call __ZdlPv; operator delete(void *)
loc_26DE4:
mov rdi, r15
call __Unwind_Resume
|
long long httplib::detail::MultipartFormDataParser::MultipartFormDataParser(
httplib::detail::MultipartFormDataParser *this)
{
long long result; // rax
*(_QWORD *)this = (char *)this + 16;
std::string::_M_construct<char const*>((long long)this, "--", (long long)"");
*((_QWORD *)this + 4) = (char *)this + 48;
std::string::_M_construct<char const*>((long long)this + 32, "\r\n", (long long)"");
*((_QWORD *)this + 8) = (char *)this + 80;
std::string::_M_construct<char const*>((long long)this + 64, "--\r\n", (long long)"");
*((_QWORD *)this + 12) = (char *)this + 112;
result = 0LL;
*((_QWORD *)this + 13) = 0LL;
*((_BYTE *)this + 112) = 0;
*((_QWORD *)this + 16) = (char *)this + 144;
*((_QWORD *)this + 17) = 0LL;
*((_BYTE *)this + 144) = 0;
*((_QWORD *)this + 20) = (char *)this + 176;
*((_QWORD *)this + 21) = 0LL;
*((_BYTE *)this + 176) = 0;
*((_QWORD *)this + 24) = 0LL;
*((_BYTE *)this + 200) = 0;
*((_QWORD *)this + 26) = (char *)this + 224;
*((_QWORD *)this + 27) = 0LL;
*((_BYTE *)this + 224) = 0;
*((_QWORD *)this + 30) = (char *)this + 256;
*((_QWORD *)this + 31) = 0LL;
*((_BYTE *)this + 256) = 0;
*((_QWORD *)this + 34) = (char *)this + 288;
*((_QWORD *)this + 35) = 0LL;
*((_BYTE *)this + 288) = 0;
*((_QWORD *)this + 38) = (char *)this + 320;
*((_QWORD *)this + 39) = 0LL;
*((_BYTE *)this + 320) = 0;
*((_QWORD *)this + 42) = (char *)this + 352;
*((_QWORD *)this + 43) = 0LL;
*((_BYTE *)this + 352) = 0;
*((_OWORD *)this + 23) = 0LL;
return result;
}
|
MultipartFormDataParser:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV RBX,RDI
LEA R12,[RDI + 0x10]
MOV qword ptr [RDI],R12
LEA RSI,[0x12e314]
LEA RDX,[0x12e316]
CALL 0x00110898
LEA R14,[RBX + 0x20]
LEA R13,[RBX + 0x30]
MOV qword ptr [RBX + 0x20],R13
LAB_00126c9e:
LEA RSI,[0x12e412]
LEA RDX,[0x12e414]
MOV RDI,R14
CALL 0x00110898
LEA RDI,[RBX + 0x40]
LEA RAX,[RBX + 0x50]
MOV qword ptr [RBX + 0x40],RAX
LAB_00126cc0:
LEA RSI,[0x12e336]
LEA RDX,[0x12e33a]
CALL 0x00110898
LAB_00126cd3:
LEA RAX,[RBX + 0x70]
MOV qword ptr [RBX + 0x60],RAX
XOR EAX,EAX
MOV qword ptr [RBX + 0x68],RAX
MOV byte ptr [RBX + 0x70],AL
LEA RCX,[RBX + 0x90]
MOV qword ptr [RBX + 0x80],RCX
MOV qword ptr [RBX + 0x88],RAX
MOV byte ptr [RBX + 0x90],AL
LEA RCX,[RBX + 0xb0]
MOV qword ptr [RBX + 0xa0],RCX
MOV qword ptr [RBX + 0xa8],RAX
MOV byte ptr [RBX + 0xb0],AL
MOV qword ptr [RBX + 0xc0],RAX
MOV byte ptr [RBX + 0xc8],AL
LEA RCX,[RBX + 0xe0]
MOV qword ptr [RBX + 0xd0],RCX
MOV qword ptr [RBX + 0xd8],RAX
MOV byte ptr [RBX + 0xe0],AL
LEA RCX,[RBX + 0x100]
MOV qword ptr [RBX + 0xf0],RCX
MOV qword ptr [RBX + 0xf8],RAX
MOV byte ptr [RBX + 0x100],AL
LEA RCX,[RBX + 0x120]
MOV qword ptr [RBX + 0x110],RCX
MOV qword ptr [RBX + 0x118],RAX
MOV byte ptr [RBX + 0x120],AL
LEA RCX,[RBX + 0x140]
MOV qword ptr [RBX + 0x130],RCX
MOV qword ptr [RBX + 0x138],RAX
MOV byte ptr [RBX + 0x140],AL
LEA RCX,[RBX + 0x160]
MOV qword ptr [RBX + 0x150],RCX
MOV qword ptr [RBX + 0x158],RAX
MOV byte ptr [RBX + 0x160],AL
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x170],XMM0
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* httplib::detail::MultipartFormDataParser::MultipartFormDataParser() */
void __thiscall
httplib::detail::MultipartFormDataParser::MultipartFormDataParser(MultipartFormDataParser *this)
{
*(MultipartFormDataParser **)this = this + 0x10;
std::__cxx11::string::_M_construct<char_const*>(this,&DAT_0012e314,&DAT_0012e316);
*(MultipartFormDataParser **)(this + 0x20) = this + 0x30;
/* try { // try from 00126c9e to 00126cb3 has its CatchHandler @ 00126dd4 */
std::__cxx11::string::_M_construct<char_const*>(this + 0x20,&DAT_0012e412,&DAT_0012e414);
*(MultipartFormDataParser **)(this + 0x40) = this + 0x50;
/* try { // try from 00126cc0 to 00126cd2 has its CatchHandler @ 00126dc2 */
std::__cxx11::string::_M_construct<char_const*>(this + 0x40,&DAT_0012e336,&DAT_0012e33a);
*(MultipartFormDataParser **)(this + 0x60) = this + 0x70;
*(int8 *)(this + 0x68) = 0;
this[0x70] = (MultipartFormDataParser)0x0;
*(MultipartFormDataParser **)(this + 0x80) = this + 0x90;
*(int8 *)(this + 0x88) = 0;
this[0x90] = (MultipartFormDataParser)0x0;
*(MultipartFormDataParser **)(this + 0xa0) = this + 0xb0;
*(int8 *)(this + 0xa8) = 0;
this[0xb0] = (MultipartFormDataParser)0x0;
*(int8 *)(this + 0xc0) = 0;
this[200] = (MultipartFormDataParser)0x0;
*(MultipartFormDataParser **)(this + 0xd0) = this + 0xe0;
*(int8 *)(this + 0xd8) = 0;
this[0xe0] = (MultipartFormDataParser)0x0;
*(MultipartFormDataParser **)(this + 0xf0) = this + 0x100;
*(int8 *)(this + 0xf8) = 0;
this[0x100] = (MultipartFormDataParser)0x0;
*(MultipartFormDataParser **)(this + 0x110) = this + 0x120;
*(int8 *)(this + 0x118) = 0;
this[0x120] = (MultipartFormDataParser)0x0;
*(MultipartFormDataParser **)(this + 0x130) = this + 0x140;
*(int8 *)(this + 0x138) = 0;
this[0x140] = (MultipartFormDataParser)0x0;
*(MultipartFormDataParser **)(this + 0x150) = this + 0x160;
*(int8 *)(this + 0x158) = 0;
this[0x160] = (MultipartFormDataParser)0x0;
*(int8 *)(this + 0x170) = 0;
*(int8 *)(this + 0x178) = 0;
return;
}
|
|
63,313 |
nglog::operator<<(std::ostream&, nglog::Counter_t const&)
|
ng-log[P]ng-log/src/logging.cc
|
ostream& operator<<(ostream& os, const Counter_t&) {
#ifdef DISABLE_RTTI
LogMessage::LogStream* log = static_cast<LogMessage::LogStream*>(&os);
#else
auto* log = dynamic_cast<LogMessage::LogStream*>(&os);
#endif
CHECK(log && log == log->self())
<< "You must not use COUNTER with non-glog ostream";
os << log->ctr();
return os;
}
|
O0
|
cpp
|
nglog::operator<<(std::ostream&, nglog::Counter_t const&):
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
cmpq $0x0, %rax
je 0x11d8b
movq -0xa0(%rbp), %rdi
movq 0x6025e(%rip), %rsi # 0x71fd0
leaq 0x5f727(%rip), %rdx # 0x714a0
xorl %eax, %eax
movl %eax, %ecx
callq 0x9820
movq %rax, -0xa8(%rbp)
jmp 0x11d96
xorl %eax, %eax
movq %rax, -0xa8(%rbp)
jmp 0x11d96
movq -0xa8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movb $0x0, -0x81(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0xa9(%rbp)
je 0x11de4
movq -0x18(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1a360
movq %rax, %rcx
movq -0xb8(%rbp), %rax
cmpq %rcx, %rax
sete %al
movb %al, -0xa9(%rbp)
movb -0xa9(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x11df2
jmp 0x11e65
leaq 0x3c931(%rip), %rsi # 0x4e72a
leaq -0x80(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
movl $0x7c3, %edx # imm = 0x7C3
callq 0x15010
movq -0xc8(%rbp), %rdi
movb $0x1, -0x81(%rbp)
callq 0x10b40
movq %rax, %rdi
leaq 0x3c9ba(%rip), %rsi # 0x4e7e5
callq 0x96e0
movq %rax, -0xc0(%rbp)
jmp 0x11e39
movq -0xc0(%rbp), %rdi
leaq 0x3c9c7(%rip), %rsi # 0x4e80e
callq 0x96e0
movq %rax, -0xd0(%rbp)
jmp 0x11e55
movq -0xd0(%rbp), %rsi
leaq -0x19(%rbp), %rdi
callq 0x1a380
testb $0x1, -0x81(%rbp)
jne 0x11e70
jmp 0x11e96
leaq -0x80(%rbp), %rdi
callq 0x15080
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
testb $0x1, -0x81(%rbp)
jne 0x11ec6
jmp 0x11ed1
movq -0x8(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1a390
movq -0xd8(%rbp), %rdi
movq %rax, %rsi
callq 0x9d20
movq -0x8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x80(%rbp), %rdi
callq 0x15080
jmp 0x11ed1
jmp 0x11ed3
movq -0x90(%rbp), %rdi
callq 0x9cc0
movq %rax, %rdi
callq 0xc110
nopw (%rax,%rax)
|
_ZN5ngloglsERSoRKNS_9Counter_tE:
push rbp
mov rbp, rsp
sub rsp, 0E0h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov [rbp+lpsrc], rax
cmp rax, 0
jz short loc_11D8B
mov rdi, [rbp+lpsrc]; lpsrc
mov rsi, cs:lpstype; lpstype
lea rdx, _ZTIN5nglog10LogMessage9LogStreamE; lpdtype
xor eax, eax
mov ecx, eax; s2d
call ___dynamic_cast
mov [rbp+var_A8], rax
jmp short loc_11D96
loc_11D8B:
xor eax, eax
mov [rbp+var_A8], rax
jmp short $+2
loc_11D96:
mov rax, [rbp+var_A8]
mov [rbp+var_18], rax
mov rcx, [rbp+var_18]
mov [rbp+var_81], 0
xor eax, eax
cmp rcx, 0
mov [rbp+var_A9], al
jz short loc_11DE4
mov rax, [rbp+var_18]
mov [rbp+var_B8], rax
mov rdi, [rbp+var_18]; this
call _ZNK5nglog10LogMessage9LogStream4selfEv; nglog::LogMessage::LogStream::self(void)
mov rcx, rax
mov rax, [rbp+var_B8]
cmp rax, rcx
setz al
mov [rbp+var_A9], al
loc_11DE4:
mov al, [rbp+var_A9]
xor al, 0FFh
test al, 1
jnz short loc_11DF2
jmp short loc_11E65
loc_11DF2:
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdi, [rbp+var_80]; this
mov [rbp+var_C8], rdi
mov edx, 7C3h; int
call _ZN5nglog15LogMessageFatalC2EPKci; nglog::LogMessageFatal::LogMessageFatal(char const*,int)
mov rdi, [rbp+var_C8]; this
mov [rbp+var_81], 1
call _ZN5nglog10LogMessage6streamEv; nglog::LogMessage::stream(void)
mov rdi, rax
lea rsi, aCheckFailedLog; "Check failed: log && log == log->self()"...
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rbp+var_C0], rax
jmp short $+2
loc_11E39:
mov rdi, [rbp+var_C0]
lea rsi, aYouMustNotUseC; "You must not use COUNTER with non-glog "...
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rbp+var_D0], rax
jmp short $+2
loc_11E55:
mov rsi, [rbp+var_D0]
lea rdi, [rbp+var_19]
call _ZNK5nglog8internal17LogMessageVoidifyanERSo; nglog::internal::LogMessageVoidify::operator&(std::ostream &)
loc_11E65:
test [rbp+var_81], 1
jnz short loc_11E70
jmp short loc_11E96
loc_11E70:
lea rdi, [rbp+var_80]; this
call _ZN5nglog15LogMessageFatalD2Ev; nglog::LogMessageFatal::~LogMessageFatal()
mov rcx, rax
mov eax, edx
mov [rbp+var_90], rcx
mov [rbp+var_94], eax
test [rbp+var_81], 1
jnz short loc_11EC6
jmp short loc_11ED1
loc_11E96:
mov rax, [rbp+var_8]
mov [rbp+var_D8], rax
mov rdi, [rbp+var_18]; this
call _ZNK5nglog10LogMessage9LogStream3ctrEv; nglog::LogMessage::LogStream::ctr(void)
mov rdi, [rbp+var_D8]
mov rsi, rax
call __ZNSolsEl; std::ostream::operator<<(long)
mov rax, [rbp+var_8]
add rsp, 0E0h
pop rbp
retn
loc_11EC6:
lea rdi, [rbp+var_80]; this
call _ZN5nglog15LogMessageFatalD2Ev; nglog::LogMessageFatal::~LogMessageFatal()
jmp short $+2
loc_11ED1:
jmp short $+2
loc_11ED3:
mov rdi, [rbp+var_90]
call __Unwind_Resume
mov rdi, rax
call __clang_call_terminate
|
const void * nglog::operator<<(const void *a1, long long a2)
{
long long v2; // rax
long long v3; // rax
const void *v5; // [rsp+8h] [rbp-D8h]
long long v6; // [rsp+10h] [rbp-D0h]
long long v7; // [rsp+20h] [rbp-C0h]
bool v8; // [rsp+37h] [rbp-A9h]
nglog::LogMessage::LogStream *v9; // [rsp+38h] [rbp-A8h]
char v10; // [rsp+5Fh] [rbp-81h]
_BYTE v11[103]; // [rsp+60h] [rbp-80h] BYREF
char v12; // [rsp+C7h] [rbp-19h] BYREF
nglog::LogMessage::LogStream *v13; // [rsp+C8h] [rbp-18h]
long long v14; // [rsp+D0h] [rbp-10h]
const void *v15; // [rsp+D8h] [rbp-8h]
v15 = a1;
v14 = a2;
if ( a1 )
v9 = (nglog::LogMessage::LogStream *)__dynamic_cast(
a1,
(const struct __class_type_info *)&`typeinfo for'std::ostream,
(const struct __class_type_info *)&`typeinfo for'nglog::LogMessage::LogStream,
0LL);
else
v9 = 0LL;
v13 = v9;
v10 = 0;
v8 = 0;
if ( v9 )
v8 = v13 == (nglog::LogMessage::LogStream *)nglog::LogMessage::LogStream::self(v13);
if ( !v8 )
{
nglog::LogMessageFatal::LogMessageFatal(
(nglog::LogMessageFatal *)v11,
"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/logging.cc",
1987);
v10 = 1;
v2 = nglog::LogMessage::stream((nglog::LogMessage *)v11);
v7 = std::operator<<<std::char_traits<char>>(v2, "Check failed: log && log == log->self() ");
v6 = std::operator<<<std::char_traits<char>>(v7, "You must not use COUNTER with non-glog ostream");
nglog::internal::LogMessageVoidify::operator&(&v12, v6);
}
if ( (v10 & 1) != 0 )
nglog::LogMessageFatal::~LogMessageFatal((nglog::LogMessageFatal *)v11);
v5 = v15;
v3 = nglog::LogMessage::LogStream::ctr(v13);
std::ostream::operator<<(v5, v3);
return v15;
}
|
operator<<:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xe0
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0xa0],RAX
CMP RAX,0x0
JZ 0x00111d8b
MOV RDI,qword ptr [RBP + -0xa0]
MOV RSI,qword ptr [0x00171fd0]
LEA RDX,[0x1714a0]
XOR EAX,EAX
MOV ECX,EAX
CALL 0x00109820
MOV qword ptr [RBP + -0xa8],RAX
JMP 0x00111d96
LAB_00111d8b:
XOR EAX,EAX
MOV qword ptr [RBP + -0xa8],RAX
JMP 0x00111d96
LAB_00111d96:
MOV RAX,qword ptr [RBP + -0xa8]
MOV qword ptr [RBP + -0x18],RAX
MOV RCX,qword ptr [RBP + -0x18]
MOV byte ptr [RBP + -0x81],0x0
XOR EAX,EAX
CMP RCX,0x0
MOV byte ptr [RBP + -0xa9],AL
JZ 0x00111de4
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0xb8],RAX
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x0011a360
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0xb8]
CMP RAX,RCX
SETZ AL
MOV byte ptr [RBP + -0xa9],AL
LAB_00111de4:
MOV AL,byte ptr [RBP + -0xa9]
XOR AL,0xff
TEST AL,0x1
JNZ 0x00111df2
JMP 0x00111e65
LAB_00111df2:
LEA RSI,[0x14e72a]
LEA RDI,[RBP + -0x80]
MOV qword ptr [RBP + -0xc8],RDI
MOV EDX,0x7c3
CALL 0x00115010
MOV RDI,qword ptr [RBP + -0xc8]
MOV byte ptr [RBP + -0x81],0x1
CALL 0x00110b40
MOV RDI,RAX
LAB_00111e24:
LEA RSI,[0x14e7e5]
CALL 0x001096e0
MOV qword ptr [RBP + -0xc0],RAX
JMP 0x00111e39
LAB_00111e39:
MOV RDI,qword ptr [RBP + -0xc0]
LEA RSI,[0x14e80e]
CALL 0x001096e0
LAB_00111e4c:
MOV qword ptr [RBP + -0xd0],RAX
JMP 0x00111e55
LAB_00111e55:
MOV RSI,qword ptr [RBP + -0xd0]
LEA RDI,[RBP + -0x19]
CALL 0x0011a380
LAB_00111e65:
TEST byte ptr [RBP + -0x81],0x1
JNZ 0x00111e70
JMP 0x00111e96
LAB_00111e70:
LEA RDI,[RBP + -0x80]
CALL 0x00115080
LAB_00111e79:
MOV RCX,RAX
MOV EAX,EDX
MOV qword ptr [RBP + -0x90],RCX
MOV dword ptr [RBP + -0x94],EAX
TEST byte ptr [RBP + -0x81],0x1
JNZ 0x00111ec6
JMP 0x00111ed1
LAB_00111e96:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0xd8],RAX
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x0011a390
MOV RDI,qword ptr [RBP + -0xd8]
MOV RSI,RAX
CALL 0x00109d20
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0xe0
POP RBP
RET
LAB_00111ec6:
LEA RDI,[RBP + -0x80]
CALL 0x00115080
LAB_00111ecf:
JMP 0x00111ed1
LAB_00111ed1:
JMP 0x00111ed3
LAB_00111ed3:
MOV RDI,qword ptr [RBP + -0x90]
CALL 0x00109cc0
|
/* nglog::TEMPNAMEPLACEHOLDERVALUE(std::ostream&, nglog::Counter_t const&) */
ostream * nglog::operator<<(ostream *param_1,Counter_t *param_2)
{
LogStream *pLVar1;
ostream *poVar2;
int8 uVar3;
long lVar4;
bool bVar5;
LogStream *local_b0;
LogMessageFatal local_88 [103];
LogMessageVoidify local_21;
LogStream *local_20;
Counter_t *local_18;
ostream *local_10;
local_18 = param_2;
local_10 = param_1;
if (param_1 == (ostream *)0x0) {
local_b0 = (LogStream *)0x0;
}
else {
local_b0 = (LogStream *)
__dynamic_cast(param_1,PTR_typeinfo_00171fd0,&LogMessage::LogStream::typeinfo,0);
}
local_20 = local_b0;
bVar5 = false;
if (local_b0 != (LogStream *)0x0) {
pLVar1 = (LogStream *)LogMessage::LogStream::self(local_b0);
bVar5 = local_b0 == pLVar1;
}
poVar2 = local_10;
if (!bVar5) {
LogMessageFatal::LogMessageFatal
(local_88,"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/logging.cc",
0x7c3);
poVar2 = (ostream *)LogMessage::stream((LogMessage *)local_88);
/* try { // try from 00111e24 to 00111e4b has its CatchHandler @ 00111e79 */
poVar2 = std::operator<<(poVar2,"Check failed: log && log == log->self() ");
poVar2 = std::operator<<(poVar2,"You must not use COUNTER with non-glog ostream");
internal::LogMessageVoidify::operator&(&local_21,poVar2);
uVar3 = LogMessageFatal::~LogMessageFatal(local_88);
/* catch(type#1 @ 00000000) { ... } // from try @ 00111e24 with catch @ 00111e79
*/
if (!bVar5) {
/* try { // try from 00111ec6 to 00111ece has its CatchHandler @ 00111edf */
LogMessageFatal::~LogMessageFatal(local_88);
}
/* WARNING: Subroutine does not return */
_Unwind_Resume(uVar3);
}
lVar4 = LogMessage::LogStream::ctr(local_20);
std::ostream::operator<<(poVar2,lVar4);
return local_10;
}
|
|
63,314 |
nglog::operator<<(std::ostream&, nglog::Counter_t const&)
|
ng-log[P]ng-log/src/logging.cc
|
ostream& operator<<(ostream& os, const Counter_t&) {
#ifdef DISABLE_RTTI
LogMessage::LogStream* log = static_cast<LogMessage::LogStream*>(&os);
#else
auto* log = dynamic_cast<LogMessage::LogStream*>(&os);
#endif
CHECK(log && log == log->self())
<< "You must not use COUNTER with non-glog ostream";
os << log->ctr();
return os;
}
|
O2
|
cpp
|
nglog::operator<<(std::ostream&, nglog::Counter_t const&):
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq 0x23653(%rip), %rsi # 0x2dfc0
leaq 0x22b5c(%rip), %rdx # 0x2d4d0
xorl %ecx, %ecx
callq 0x7640
testq %rax, %rax
je 0xa99b
cmpq 0x50(%rax), %rax
jne 0xa99b
movq 0x48(%rax), %rsi
movq %rbx, %rdi
callq 0x7540
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
retq
leaq 0x13cb8(%rip), %rsi # 0x1e65a
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x7c3, %edx # imm = 0x7C3
callq 0xc66a
movl $0x7538, %edi # imm = 0x7538
addq 0x8(%rbx), %rdi
leaq 0x13d53(%rip), %rsi # 0x1e715
callq 0x7570
leaq 0x13d70(%rip), %rsi # 0x1e73e
movq %rax, %rdi
callq 0x7570
movq %rsp, %rdi
callq 0xc678
movq %rsp, %rdi
callq 0xc678
movq %rax, %rdi
callq 0x8df5
|
_ZN5ngloglsERSoRKNS_9Counter_tE:
push rbx
sub rsp, 60h
mov rbx, rdi
mov rsi, cs:lpstype; lpstype
lea rdx, _ZTIN5nglog10LogMessage9LogStreamE; lpdtype
xor ecx, ecx; s2d
call ___dynamic_cast
test rax, rax
jz short loc_A99B
cmp rax, [rax+50h]
jnz short loc_A99B
mov rsi, [rax+48h]
mov rdi, rbx
call __ZNSo9_M_insertIlEERSoT_; std::ostream::_M_insert<long>(long)
mov rax, rbx
add rsp, 60h
pop rbx
retn
loc_A99B:
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
mov rbx, rsp
mov rdi, rbx; this
mov edx, 7C3h; int
call _ZN5nglog15LogMessageFatalC2EPKci; nglog::LogMessageFatal::LogMessageFatal(char const*,int)
mov edi, 7538h
add rdi, [rbx+8]
lea rsi, aCheckFailedLog; "Check failed: log && log == log->self()"...
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
lea rsi, aYouMustNotUseC; "You must not use COUNTER with non-glog "...
mov rdi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rsp; this
call _ZN5nglog15LogMessageFatalD2Ev; nglog::LogMessageFatal::~LogMessageFatal()
mov rdi, rsp; this
call _ZN5nglog15LogMessageFatalD2Ev; nglog::LogMessageFatal::~LogMessageFatal()
mov rdi, rax
call __clang_call_terminate
|
const void * nglog::operator<<(const void *a1)
{
void **v1; // rax
long long v3; // rax
_QWORD v4[13]; // [rsp+0h] [rbp-68h] BYREF
v1 = (void **)__dynamic_cast(
a1,
(const struct __class_type_info *)&`typeinfo for'std::ostream,
(const struct __class_type_info *)&`typeinfo for'nglog::LogMessage::LogStream,
0LL);
if ( !v1 || v1 != v1[10] )
{
nglog::LogMessageFatal::LogMessageFatal(
(nglog::LogMessageFatal *)v4,
"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/logging.cc",
1987);
v3 = std::operator<<<std::char_traits<char>>(v4[1] + 30008LL, "Check failed: log && log == log->self() ");
std::operator<<<std::char_traits<char>>(v3, "You must not use COUNTER with non-glog ostream");
nglog::LogMessageFatal::~LogMessageFatal((nglog::LogMessageFatal *)v4);
}
std::ostream::_M_insert<long>(a1, v1[9]);
return a1;
}
|
operator<<:
PUSH RBX
SUB RSP,0x60
MOV RBX,RDI
MOV RSI,qword ptr [0x0012dfc0]
LEA RDX,[0x12d4d0]
XOR ECX,ECX
CALL 0x00107640
TEST RAX,RAX
JZ 0x0010a99b
CMP RAX,qword ptr [RAX + 0x50]
JNZ 0x0010a99b
MOV RSI,qword ptr [RAX + 0x48]
MOV RDI,RBX
CALL 0x00107540
MOV RAX,RBX
ADD RSP,0x60
POP RBX
RET
LAB_0010a99b:
LEA RSI,[0x11e65a]
MOV RBX,RSP
MOV RDI,RBX
MOV EDX,0x7c3
CALL 0x0010c66a
MOV EDI,0x7538
ADD RDI,qword ptr [RBX + 0x8]
LAB_0010a9bb:
LEA RSI,[0x11e715]
CALL 0x00107570
LEA RSI,[0x11e73e]
MOV RDI,RAX
CALL 0x00107570
LAB_0010a9d6:
MOV RDI,RSP
CALL 0x0010c678
LAB_0010a9de:
MOV RDI,RSP
CALL 0x0010c678
LAB_0010a9e6:
MOV RDI,RAX
CALL 0x00108df5
|
/* nglog::TEMPNAMEPLACEHOLDERVALUE(std::ostream&, nglog::Counter_t const&) */
ostream * nglog::operator<<(ostream *param_1,Counter_t *param_2)
{
long lVar1;
ostream *poVar2;
int8 uVar3;
LogMessageFatal aLStack_68 [8];
long local_60;
lVar1 = __dynamic_cast(param_1,PTR_typeinfo_0012dfc0,&LogMessage::LogStream::typeinfo,0);
if ((lVar1 != 0) && (lVar1 == *(long *)(lVar1 + 0x50))) {
std::ostream::_M_insert<long>((long)param_1);
return param_1;
}
LogMessageFatal::LogMessageFatal
(aLStack_68,"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/logging.cc",
0x7c3);
/* try { // try from 0010a9bb to 0010a9d5 has its CatchHandler @ 0010a9de */
poVar2 = std::operator<<((ostream *)(local_60 + 0x7538),"Check failed: log && log == log->self() "
);
std::operator<<(poVar2,"You must not use COUNTER with non-glog ostream");
LogMessageFatal::~LogMessageFatal(aLStack_68);
/* catch(type#1 @ 00000000) { ... } // from try @ 0010a9bb with catch @ 0010a9de
try { // try from 0010a9de to 0010a9e5 has its CatchHandler @ 0010a9e6 */
uVar3 = LogMessageFatal::~LogMessageFatal(aLStack_68);
/* catch(type#1 @ 00000000) { ... } // from try @ 0010a9de with catch @ 0010a9e6
*/
/* WARNING: Subroutine does not return */
__clang_call_terminate(uVar3);
}
|
|
63,315 |
ma_ll2str
|
eloqsql/libmariadb/libmariadb/ma_ll2str.c
|
char *ma_ll2str(long long val,char *dst,int radix)
{
char buffer[65];
register char *p;
long long_val;
if (radix < 0)
{
if (radix < -36 || radix > -2) return (char*) 0;
if (val < 0) {
*dst++ = '-';
val = 0ULL - val;
}
radix = -radix;
}
else
{
if (radix > 36 || radix < 2) return (char*) 0;
}
if (val == 0)
{
*dst++='0';
*dst='\0';
return dst;
}
p = &buffer[sizeof(buffer)-1];
*p = '\0';
while ((ulonglong) val > (ulonglong) LONG_MAX)
{
ulonglong quo=(ulonglong) val/(uint) radix;
uint rem= (uint) (val- quo* (uint) radix);
*--p = _dig_vec[rem];
val= quo;
}
long_val= (long) val;
while (long_val != 0)
{
long quo= long_val/radix;
*--p = _dig_vec[(uchar) (long_val - quo*radix)];
long_val= quo;
}
while ((*dst++ = *p++) != 0) ;
return dst-1;
}
|
O0
|
c
|
ma_ll2str:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x60(%rbp)
movq %rsi, -0x68(%rbp)
movl %edx, -0x6c(%rbp)
cmpl $0x0, -0x6c(%rbp)
jge 0x79fef
cmpl $-0x24, -0x6c(%rbp)
jl 0x79fb5
cmpl $-0x2, -0x6c(%rbp)
jle 0x79fc2
movq $0x0, -0x58(%rbp)
jmp 0x7a15a
cmpq $0x0, -0x60(%rbp)
jge 0x79fe5
movq -0x68(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x68(%rbp)
movb $0x2d, (%rax)
xorl %eax, %eax
subq -0x60(%rbp), %rax
movq %rax, -0x60(%rbp)
xorl %eax, %eax
subl -0x6c(%rbp), %eax
movl %eax, -0x6c(%rbp)
jmp 0x7a00a
cmpl $0x24, -0x6c(%rbp)
jg 0x79ffb
cmpl $0x2, -0x6c(%rbp)
jge 0x7a008
movq $0x0, -0x58(%rbp)
jmp 0x7a15a
jmp 0x7a00a
cmpq $0x0, -0x60(%rbp)
jne 0x7a037
movq -0x68(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x68(%rbp)
movb $0x30, (%rax)
movq -0x68(%rbp), %rax
movb $0x0, (%rax)
movq -0x68(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x7a15a
leaq -0x50(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movb $0x0, (%rax)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, -0x60(%rbp)
jbe 0x7a0b9
movq -0x60(%rbp), %rax
movl -0x6c(%rbp), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x88(%rbp)
movq -0x60(%rbp), %rax
movq -0x88(%rbp), %rcx
movl -0x6c(%rbp), %edx
imulq %rdx, %rcx
subq %rcx, %rax
movl %eax, -0x8c(%rbp)
movl -0x8c(%rbp), %eax
movl %eax, %ecx
leaq 0x1cfbd9(%rip), %rax # 0x249c70
movb (%rax,%rcx), %cl
movq -0x78(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x78(%rbp)
movb %cl, -0x1(%rax)
movq -0x88(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x7a04a
movq -0x60(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, -0x80(%rbp)
je 0x7a120
movq -0x80(%rbp), %rax
movslq -0x6c(%rbp), %rcx
cqto
idivq %rcx
movq %rax, -0x98(%rbp)
movq -0x80(%rbp), %rax
movq -0x98(%rbp), %rcx
movslq -0x6c(%rbp), %rdx
imulq %rdx, %rcx
subq %rcx, %rax
movzbl %al, %eax
movl %eax, %ecx
leaq 0x1cfb72(%rip), %rax # 0x249c70
movb (%rax,%rcx), %cl
movq -0x78(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x78(%rbp)
movb %cl, -0x1(%rax)
movq -0x98(%rbp), %rax
movq %rax, -0x80(%rbp)
jmp 0x7a0c1
jmp 0x7a122
movq -0x78(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x78(%rbp)
movb (%rax), %al
movq -0x68(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x68(%rbp)
movb %al, (%rcx)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x7a14e
jmp 0x7a122
movq -0x68(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x7a187
movq -0xa0(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
callq 0x382c0
nopl (%rax)
|
ma_ll2str:
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_60], rdi
mov [rbp+var_68], rsi
mov [rbp+var_6C], edx
cmp [rbp+var_6C], 0
jge short loc_79FEF
cmp [rbp+var_6C], 0FFFFFFDCh
jl short loc_79FB5
cmp [rbp+var_6C], 0FFFFFFFEh
jle short loc_79FC2
loc_79FB5:
mov [rbp+var_58], 0
jmp loc_7A15A
loc_79FC2:
cmp [rbp+var_60], 0
jge short loc_79FE5
mov rax, [rbp+var_68]
mov rcx, rax
add rcx, 1
mov [rbp+var_68], rcx
mov byte ptr [rax], 2Dh ; '-'
xor eax, eax
sub rax, [rbp+var_60]
mov [rbp+var_60], rax
loc_79FE5:
xor eax, eax
sub eax, [rbp+var_6C]
mov [rbp+var_6C], eax
jmp short loc_7A00A
loc_79FEF:
cmp [rbp+var_6C], 24h ; '$'
jg short loc_79FFB
cmp [rbp+var_6C], 2
jge short loc_7A008
loc_79FFB:
mov [rbp+var_58], 0
jmp loc_7A15A
loc_7A008:
jmp short $+2
loc_7A00A:
cmp [rbp+var_60], 0
jnz short loc_7A037
mov rax, [rbp+var_68]
mov rcx, rax
add rcx, 1
mov [rbp+var_68], rcx
mov byte ptr [rax], 30h ; '0'
mov rax, [rbp+var_68]
mov byte ptr [rax], 0
mov rax, [rbp+var_68]
mov [rbp+var_58], rax
jmp loc_7A15A
loc_7A037:
lea rax, [rbp+var_50]
add rax, 40h ; '@'
mov [rbp+var_78], rax
mov rax, [rbp+var_78]
mov byte ptr [rax], 0
loc_7A04A:
mov rax, 7FFFFFFFFFFFFFFFh
cmp [rbp+var_60], rax
jbe short loc_7A0B9
mov rax, [rbp+var_60]
mov ecx, [rbp+var_6C]
xor edx, edx
div rcx
mov [rbp+var_88], rax
mov rax, [rbp+var_60]
mov rcx, [rbp+var_88]
mov edx, [rbp+var_6C]
imul rcx, rdx
sub rax, rcx
mov [rbp+var_8C], eax
mov eax, [rbp+var_8C]
mov ecx, eax
lea rax, _dig_vec; "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
mov cl, [rax+rcx]
mov rax, [rbp+var_78]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_78], rdx
mov [rax-1], cl
mov rax, [rbp+var_88]
mov [rbp+var_60], rax
jmp short loc_7A04A
loc_7A0B9:
mov rax, [rbp+var_60]
mov [rbp+var_80], rax
loc_7A0C1:
cmp [rbp+var_80], 0
jz short loc_7A120
mov rax, [rbp+var_80]
movsxd rcx, [rbp+var_6C]
cqo
idiv rcx
mov [rbp+var_98], rax
mov rax, [rbp+var_80]
mov rcx, [rbp+var_98]
movsxd rdx, [rbp+var_6C]
imul rcx, rdx
sub rax, rcx
movzx eax, al
mov ecx, eax
lea rax, _dig_vec; "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
mov cl, [rax+rcx]
mov rax, [rbp+var_78]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_78], rdx
mov [rax-1], cl
mov rax, [rbp+var_98]
mov [rbp+var_80], rax
jmp short loc_7A0C1
loc_7A120:
jmp short $+2
loc_7A122:
mov rax, [rbp+var_78]
mov rcx, rax
add rcx, 1
mov [rbp+var_78], rcx
mov al, [rax]
mov rcx, [rbp+var_68]
mov rdx, rcx
add rdx, 1
mov [rbp+var_68], rdx
mov [rcx], al
movsx eax, al
cmp eax, 0
jz short loc_7A14E
jmp short loc_7A122
loc_7A14E:
mov rax, [rbp+var_68]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_58], rax
loc_7A15A:
mov rax, [rbp+var_58]
mov [rbp+var_A0], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_7A187
mov rax, [rbp+var_A0]
add rsp, 0A0h
pop rbp
retn
loc_7A187:
call ___stack_chk_fail
|
_BYTE * ma_ll2str(long long a1, _BYTE *a2, int a3)
{
_BYTE *v3; // rax
char *v4; // rax
char *v5; // rax
char *v6; // rax
_BYTE *v7; // rcx
signed long long i; // [rsp+20h] [rbp-80h]
char *v10; // [rsp+28h] [rbp-78h]
int v11; // [rsp+34h] [rbp-6Ch]
_BYTE *v12; // [rsp+38h] [rbp-68h]
_BYTE *v13; // [rsp+38h] [rbp-68h]
unsigned long long v14; // [rsp+40h] [rbp-60h]
char v16; // [rsp+90h] [rbp-10h] BYREF
unsigned long long v17; // [rsp+98h] [rbp-8h]
v17 = __readfsqword(0x28u);
v14 = a1;
v12 = a2;
v11 = a3;
if ( a3 >= 0 )
{
if ( a3 > 36 || a3 < 2 )
return 0LL;
}
else
{
if ( a3 < -36 || a3 > -2 )
return 0LL;
if ( a1 < 0 )
{
v12 = a2 + 1;
*a2 = 45;
v14 = -a1;
}
v11 = -a3;
}
if ( v14 )
{
v10 = &v16;
v16 = 0;
while ( v14 > 0x7FFFFFFFFFFFFFFFLL )
{
v4 = v10--;
*(v4 - 1) = dig_vec[v14 % (unsigned int)v11];
v14 /= (unsigned int)v11;
}
for ( i = v14; i; i /= v11 )
{
v5 = v10--;
*(v5 - 1) = dig_vec[(unsigned __int8)(i % v11)];
}
do
{
v6 = v10++;
LOBYTE(v6) = *v6;
v7 = v12++;
*v7 = (_BYTE)v6;
}
while ( (_BYTE)v6 );
return v12 - 1;
}
else
{
v3 = v12;
v13 = v12 + 1;
*v3 = 48;
*v13 = 0;
return v13;
}
}
|
ma_ll2str:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
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 dword ptr [RBP + -0x6c],EDX
CMP dword ptr [RBP + -0x6c],0x0
JGE 0x00179fef
CMP dword ptr [RBP + -0x6c],-0x24
JL 0x00179fb5
CMP dword ptr [RBP + -0x6c],-0x2
JLE 0x00179fc2
LAB_00179fb5:
MOV qword ptr [RBP + -0x58],0x0
JMP 0x0017a15a
LAB_00179fc2:
CMP qword ptr [RBP + -0x60],0x0
JGE 0x00179fe5
MOV RAX,qword ptr [RBP + -0x68]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x68],RCX
MOV byte ptr [RAX],0x2d
XOR EAX,EAX
SUB RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x60],RAX
LAB_00179fe5:
XOR EAX,EAX
SUB EAX,dword ptr [RBP + -0x6c]
MOV dword ptr [RBP + -0x6c],EAX
JMP 0x0017a00a
LAB_00179fef:
CMP dword ptr [RBP + -0x6c],0x24
JG 0x00179ffb
CMP dword ptr [RBP + -0x6c],0x2
JGE 0x0017a008
LAB_00179ffb:
MOV qword ptr [RBP + -0x58],0x0
JMP 0x0017a15a
LAB_0017a008:
JMP 0x0017a00a
LAB_0017a00a:
CMP qword ptr [RBP + -0x60],0x0
JNZ 0x0017a037
MOV RAX,qword ptr [RBP + -0x68]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x68],RCX
MOV byte ptr [RAX],0x30
MOV RAX,qword ptr [RBP + -0x68]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RBP + -0x58],RAX
JMP 0x0017a15a
LAB_0017a037:
LEA RAX,[RBP + -0x50]
ADD RAX,0x40
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x78]
MOV byte ptr [RAX],0x0
LAB_0017a04a:
MOV RAX,0x7fffffffffffffff
CMP qword ptr [RBP + -0x60],RAX
JBE 0x0017a0b9
MOV RAX,qword ptr [RBP + -0x60]
MOV ECX,dword ptr [RBP + -0x6c]
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x88]
MOV EDX,dword ptr [RBP + -0x6c]
IMUL RCX,RDX
SUB RAX,RCX
MOV dword ptr [RBP + -0x8c],EAX
MOV EAX,dword ptr [RBP + -0x8c]
MOV ECX,EAX
LEA RAX,[0x349c70]
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x78]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RBP + -0x78],RDX
MOV byte ptr [RAX + -0x1],CL
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RBP + -0x60],RAX
JMP 0x0017a04a
LAB_0017a0b9:
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x80],RAX
LAB_0017a0c1:
CMP qword ptr [RBP + -0x80],0x0
JZ 0x0017a120
MOV RAX,qword ptr [RBP + -0x80]
MOVSXD RCX,dword ptr [RBP + -0x6c]
CQO
IDIV RCX
MOV qword ptr [RBP + -0x98],RAX
MOV RAX,qword ptr [RBP + -0x80]
MOV RCX,qword ptr [RBP + -0x98]
MOVSXD RDX,dword ptr [RBP + -0x6c]
IMUL RCX,RDX
SUB RAX,RCX
MOVZX EAX,AL
MOV ECX,EAX
LEA RAX,[0x349c70]
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x78]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RBP + -0x78],RDX
MOV byte ptr [RAX + -0x1],CL
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x80],RAX
JMP 0x0017a0c1
LAB_0017a120:
JMP 0x0017a122
LAB_0017a122:
MOV RAX,qword ptr [RBP + -0x78]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x78],RCX
MOV AL,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x68]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x68],RDX
MOV byte ptr [RCX],AL
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x0017a14e
JMP 0x0017a122
LAB_0017a14e:
MOV RAX,qword ptr [RBP + -0x68]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x58],RAX
LAB_0017a15a:
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0xa0],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0017a187
MOV RAX,qword ptr [RBP + -0xa0]
ADD RSP,0xa0
POP RBP
RET
LAB_0017a187:
CALL 0x001382c0
|
char * ma_ll2str(ulong param_1,char *param_2,uint param_3)
{
char cVar1;
char *pcVar2;
long in_FS_OFFSET;
ulong local_88;
char *local_80;
uint local_74;
char *local_70;
ulong local_68;
char *local_60;
char local_19 [9];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_70 = param_2;
local_68 = param_1;
if ((int)param_3 < 0) {
if (((int)param_3 < -0x24) || (-2 < (int)param_3)) {
local_60 = (char *)0x0;
goto LAB_0017a15a;
}
if ((long)param_1 < 0) {
local_70 = param_2 + 1;
*param_2 = '-';
local_68 = -param_1;
}
local_74 = -param_3;
}
else if ((0x24 < (int)param_3) || (local_74 = param_3, (int)param_3 < 2)) {
local_60 = (char *)0x0;
goto LAB_0017a15a;
}
if (local_68 == 0) {
local_60 = local_70 + 1;
*local_70 = '0';
*local_60 = '\0';
}
else {
local_19[1] = 0;
local_80 = local_19 + 1;
while (0x7fffffffffffffff < local_68) {
local_80[-1] = _dig_vec[(int)local_68 - (int)(local_68 / local_74) * local_74];
local_80 = local_80 + -1;
local_68 = local_68 / local_74;
}
local_88 = local_68;
while (pcVar2 = local_70, local_88 != 0) {
local_80[-1] = _dig_vec[(byte)((char)local_88 -
(char)((long)local_88 / (long)(int)local_74) * (char)local_74)];
local_88 = (long)local_88 / (long)(int)local_74;
local_80 = local_80 + -1;
}
do {
local_70 = pcVar2;
cVar1 = *local_80;
*local_70 = cVar1;
local_80 = local_80 + 1;
pcVar2 = local_70 + 1;
} while (cVar1 != '\0');
local_60 = local_70;
}
LAB_0017a15a:
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_60;
}
|
|
63,316 |
innobase_get_at_most_n_mbchars(unsigned long, unsigned long, unsigned long, char const*)
|
eloqsql/storage/innobase/handler/ha_innodb.cc
|
ulint
innobase_get_at_most_n_mbchars(
/*===========================*/
ulint charset_id, /*!< in: character set id */
ulint prefix_len, /*!< in: prefix length in bytes of the index
(this has to be divided by mbmaxlen to get the
number of CHARACTERS n in the prefix) */
ulint data_len, /*!< in: length of the string in bytes */
const char* str) /*!< in: character string */
{
ulint char_length; /*!< character length in bytes */
ulint n_chars; /*!< number of characters in prefix */
CHARSET_INFO* charset; /*!< charset used in the field */
charset = get_charset((uint) charset_id, MYF(MY_WME));
ut_ad(charset);
ut_ad(charset->mbmaxlen);
/* Calculate how many characters at most the prefix index contains */
n_chars = prefix_len / charset->mbmaxlen;
/* If the charset is multi-byte, then we must find the length of the
first at most n chars in the string. If the string contains less
characters than n, then we return the length to the end of the last
character. */
if (charset->mbmaxlen > 1) {
/* charpos() returns the byte length of the first n_chars
characters, or a value bigger than the length of str, if
there were not enough full characters in str.
Why does the code below work:
Suppose that we are looking for n UTF-8 characters.
1) If the string is long enough, then the prefix contains at
least n complete UTF-8 characters + maybe some extra
characters + an incomplete UTF-8 character. No problem in
this case. The function returns the pointer to the
end of the nth character.
2) If the string is not long enough, then the string contains
the complete value of a column, that is, only complete UTF-8
characters, and we can store in the column prefix index the
whole string. */
char_length= charset->charpos(str, str + data_len, n_chars);
if (char_length > data_len) {
char_length = data_len;
}
} else if (data_len < prefix_len) {
char_length = data_len;
} else {
char_length = prefix_len;
}
return(char_length);
}
|
O0
|
cpp
|
innobase_get_at_most_n_mbchars(unsigned long, unsigned long, unsigned long, char const*):
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl %eax, %edi
movl $0x10, %esi
callq 0x1302840
movq %rax, -0x38(%rbp)
jmp 0x10bb83e
jmp 0x10bb840
jmp 0x10bb842
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movl 0x9c(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x1, 0x9c(%rax)
jbe 0x10bb897
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0xad05e0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x10bb895
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x10bb8b5
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x10bb8ab
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x10bb8b3
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x10bb8b5
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
|
_Z30innobase_get_at_most_n_mbcharsmmmPKc:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov rax, [rbp+var_8]
mov edi, eax
mov esi, 10h
call get_charset
mov [rbp+var_38], rax
jmp short $+2
loc_10BB83E:
jmp short $+2
loc_10BB840:
jmp short $+2
loc_10BB842:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_38]
mov ecx, [rcx+9Ch]
xor edx, edx
div rcx
mov [rbp+var_30], rax
mov rax, [rbp+var_38]
cmp dword ptr [rax+9Ch], 1
jbe short loc_10BB897
mov rdi, [rbp+var_38]; this
mov rsi, [rbp+var_20]; char *
mov rdx, [rbp+var_20]
add rdx, [rbp+var_18]; char *
mov rcx, [rbp+var_30]; unsigned __int64
call _ZNK15charset_info_st7charposEPKcS1_m; charset_info_st::charpos(char const*,char const*,ulong)
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
cmp rax, [rbp+var_18]
jbe short loc_10BB895
mov rax, [rbp+var_18]
mov [rbp+var_28], rax
loc_10BB895:
jmp short loc_10BB8B5
loc_10BB897:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_10]
jnb short loc_10BB8AB
mov rax, [rbp+var_18]
mov [rbp+var_28], rax
jmp short loc_10BB8B3
loc_10BB8AB:
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
loc_10BB8B3:
jmp short $+2
loc_10BB8B5:
mov rax, [rbp+var_28]
add rsp, 40h
pop rbp
retn
|
unsigned long long innobase_get_at_most_n_mbchars(
unsigned int a1,
unsigned long long a2,
unsigned long long a3,
const char *a4)
{
long long v4; // r8
long long v5; // r9
unsigned int *charset; // [rsp+8h] [rbp-38h]
unsigned long long v8; // [rsp+18h] [rbp-28h]
charset = (unsigned int *)get_charset(a1, 16LL);
if ( charset[39] <= 1 )
{
if ( a3 >= a2 )
return a2;
else
return a3;
}
else
{
v8 = charset_info_st::charpos((charset_info_st *)charset, a4, &a4[a3], a2 / charset[39], v4, v5);
if ( v8 > a3 )
return a3;
}
return v8;
}
|
hton_name:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x4]
MOV ECX,EAX
LEA RAX,[0x1e7d7d0]
MOV RAX,qword ptr [RAX + RCX*0x8]
POP RBP
RET
|
/* hton_name(handlerton const*) */
int8 hton_name(handlerton *param_1)
{
return *(int8 *)(hton2plugin + (ulong)*(uint *)(param_1 + 4) * 8);
}
|
|
63,317 |
auth_old_password
|
eloqsql/libmariadb/plugins/auth/old_password.c
|
static int auth_old_password(MYSQL_PLUGIN_VIO *vio, MYSQL *mysql)
{
uchar *pkt;
int pkt_len;
if (((MCPVIO_EXT *)vio)->mysql_change_user)
{
/*
in mysql_change_user() the client sends the first packet.
we use the old scramble.
*/
pkt= (uchar*)mysql->scramble_buff;
}
else
{
/* read the scramble */
if ((pkt_len= vio->read_packet(vio, &pkt)) < 0)
return CR_ERROR;
if (pkt_len != SCRAMBLE_LENGTH_323 + 1 &&
pkt_len != SCRAMBLE_LENGTH + 1)
return CR_SERVER_HANDSHAKE_ERR;
/* save it in MYSQL */
memmove(mysql->scramble_buff, pkt, pkt_len - 1);
mysql->scramble_buff[pkt_len - 1] = 0;
}
if (mysql && mysql->passwd[0])
{
char scrambled[SCRAMBLE_LENGTH_323 + 1];
ma_scramble_323(scrambled, (char*)pkt, mysql->passwd);
if (vio->write_packet(vio, (uchar*)scrambled, SCRAMBLE_LENGTH_323 + 1))
return CR_ERROR;
}
else
if (vio->write_packet(vio, 0, 0)) /* no password */
return CR_ERROR;
return CR_OK;
}
|
O0
|
c
|
auth_old_password:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, 0x48(%rax)
je 0x5b467
movq -0x28(%rbp), %rax
addq $0x48e, %rax # imm = 0x48E
movq %rax, -0x30(%rbp)
jmp 0x5b4d6
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq *%rax
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jge 0x5b48c
movl $0x0, -0x18(%rbp)
jmp 0x5b55a
cmpl $0x9, -0x34(%rbp)
je 0x5b4a4
cmpl $0x15, -0x34(%rbp)
je 0x5b4a4
movl $0x7dc, -0x18(%rbp) # imm = 0x7DC
jmp 0x5b55a
movq -0x28(%rbp), %rdi
addq $0x48e, %rdi # imm = 0x48E
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rdx
callq 0x14700
movq -0x28(%rbp), %rax
movl -0x34(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, 0x48e(%rax,%rcx)
cmpq $0x0, -0x28(%rbp)
je 0x5b52f
movq -0x28(%rbp), %rax
movq 0x2c0(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x5b52f
leaq -0x11(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rax
movq 0x2c0(%rax), %rdx
callq 0x62a20
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rdi
leaq -0x11(%rbp), %rsi
movl $0x9, %edx
callq *%rax
cmpl $0x0, %eax
je 0x5b52d
movl $0x0, -0x18(%rbp)
jmp 0x5b55a
jmp 0x5b553
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
xorl %edx, %edx
callq *%rax
cmpl $0x0, %eax
je 0x5b551
movl $0x0, -0x18(%rbp)
jmp 0x5b55a
jmp 0x5b553
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movl -0x18(%rbp), %eax
movl %eax, -0x38(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x5b57b
movl -0x38(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
callq 0x144c0
|
auth_old_password:
push rbp
mov rbp, rsp
sub rsp, 40h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_20], rdi
mov [rbp+var_28], rsi
mov rax, [rbp+var_20]
cmp byte ptr [rax+48h], 0
jz short loc_5B467
mov rax, [rbp+var_28]
add rax, 48Eh
mov [rbp+var_30], rax
jmp short loc_5B4D6
loc_5B467:
mov rax, [rbp+var_20]
mov rax, [rax]
mov rdi, [rbp+var_20]
lea rsi, [rbp+var_30]
call rax
mov [rbp+var_34], eax
cmp eax, 0
jge short loc_5B48C
mov [rbp+var_18], 0
jmp loc_5B55A
loc_5B48C:
cmp [rbp+var_34], 9
jz short loc_5B4A4
cmp [rbp+var_34], 15h
jz short loc_5B4A4
mov [rbp+var_18], 7DCh
jmp loc_5B55A
loc_5B4A4:
mov rdi, [rbp+var_28]
add rdi, 48Eh
mov rsi, [rbp+var_30]
mov eax, [rbp+var_34]
sub eax, 1
movsxd rdx, eax
call _memmove
mov rax, [rbp+var_28]
mov ecx, [rbp+var_34]
sub ecx, 1
movsxd rcx, ecx
mov byte ptr [rax+rcx+48Eh], 0
loc_5B4D6:
cmp [rbp+var_28], 0
jz short loc_5B52F
mov rax, [rbp+var_28]
mov rax, [rax+2C0h]
movsx eax, byte ptr [rax]
cmp eax, 0
jz short loc_5B52F
lea rdi, [rbp+var_11]
mov rsi, [rbp+var_30]
mov rax, [rbp+var_28]
mov rdx, [rax+2C0h]
call ma_scramble_323
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov rdi, [rbp+var_20]
lea rsi, [rbp+var_11]
mov edx, 9
call rax
cmp eax, 0
jz short loc_5B52D
mov [rbp+var_18], 0
jmp short loc_5B55A
loc_5B52D:
jmp short loc_5B553
loc_5B52F:
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov rdi, [rbp+var_20]
xor ecx, ecx
mov esi, ecx
xor edx, edx
call rax
cmp eax, 0
jz short loc_5B551
mov [rbp+var_18], 0
jmp short loc_5B55A
loc_5B551:
jmp short $+2
loc_5B553:
mov [rbp+var_18], 0FFFFFFFFh
loc_5B55A:
mov eax, [rbp+var_18]
mov [rbp+var_38], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_5B57B
mov eax, [rbp+var_38]
add rsp, 40h
pop rbp
retn
loc_5B57B:
call ___stack_chk_fail
|
long long auth_old_password(long long a1, long long a2)
{
int v3; // [rsp+Ch] [rbp-34h]
long long v4; // [rsp+10h] [rbp-30h] BYREF
long long v5; // [rsp+18h] [rbp-28h]
long long v6; // [rsp+20h] [rbp-20h]
_BYTE v8[9]; // [rsp+2Fh] [rbp-11h] BYREF
unsigned long long v9; // [rsp+38h] [rbp-8h]
v9 = __readfsqword(0x28u);
v6 = a1;
v5 = a2;
if ( *(_BYTE *)(a1 + 72) )
{
v4 = v5 + 1166;
LABEL_9:
if ( v5 && **(_BYTE **)(v5 + 704) )
{
ma_scramble_323(v8, v4, *(_QWORD *)(v5 + 704));
if ( (*(unsigned int ( **)(long long, _BYTE *, long long))(v6 + 8))(v6, v8, 9LL) )
return 0;
}
else if ( (*(unsigned int ( **)(long long, _QWORD, _QWORD))(v6 + 8))(v6, 0LL, 0LL) )
{
return 0;
}
return (unsigned int)-1;
}
v3 = (*(long long ( **)(long long, long long *))v6)(v6, &v4);
if ( v3 >= 0 )
{
if ( v3 == 9 || v3 == 21 )
{
memmove(v5 + 1166, v4, v3 - 1);
*(_BYTE *)(v5 + v3 - 1 + 1166) = 0;
goto LABEL_9;
}
return 2012;
}
else
{
return 0;
}
}
|
auth_old_password:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x20],RDI
MOV qword ptr [RBP + -0x28],RSI
MOV RAX,qword ptr [RBP + -0x20]
CMP byte ptr [RAX + 0x48],0x0
JZ 0x0015b467
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x48e
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0015b4d6
LAB_0015b467:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RBP + -0x20]
LEA RSI,[RBP + -0x30]
CALL RAX
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
JGE 0x0015b48c
MOV dword ptr [RBP + -0x18],0x0
JMP 0x0015b55a
LAB_0015b48c:
CMP dword ptr [RBP + -0x34],0x9
JZ 0x0015b4a4
CMP dword ptr [RBP + -0x34],0x15
JZ 0x0015b4a4
MOV dword ptr [RBP + -0x18],0x7dc
JMP 0x0015b55a
LAB_0015b4a4:
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x48e
MOV RSI,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RBP + -0x34]
SUB EAX,0x1
MOVSXD RDX,EAX
CALL 0x00114700
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RBP + -0x34]
SUB ECX,0x1
MOVSXD RCX,ECX
MOV byte ptr [RAX + RCX*0x1 + 0x48e],0x0
LAB_0015b4d6:
CMP qword ptr [RBP + -0x28],0x0
JZ 0x0015b52f
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x2c0]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JZ 0x0015b52f
LEA RDI,[RBP + -0x11]
MOV RSI,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RAX + 0x2c0]
CALL 0x00162a20
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RBP + -0x20]
LEA RSI,[RBP + -0x11]
MOV EDX,0x9
CALL RAX
CMP EAX,0x0
JZ 0x0015b52d
MOV dword ptr [RBP + -0x18],0x0
JMP 0x0015b55a
LAB_0015b52d:
JMP 0x0015b553
LAB_0015b52f:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RBP + -0x20]
XOR ECX,ECX
MOV ESI,ECX
XOR EDX,EDX
CALL RAX
CMP EAX,0x0
JZ 0x0015b551
MOV dword ptr [RBP + -0x18],0x0
JMP 0x0015b55a
LAB_0015b551:
JMP 0x0015b553
LAB_0015b553:
MOV dword ptr [RBP + -0x18],0xffffffff
LAB_0015b55a:
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x38],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0015b57b
MOV EAX,dword ptr [RBP + -0x38]
ADD RSP,0x40
POP RBP
RET
LAB_0015b57b:
CALL 0x001144c0
|
int4 auth_old_password(int8 *param_1,long param_2)
{
int iVar1;
long in_FS_OFFSET;
void *local_38;
long local_30;
int8 *local_28;
int4 local_20;
int1 local_19 [9];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_30 = param_2;
local_28 = param_1;
if (*(char *)(param_1 + 9) == '\0') {
iVar1 = (*(code *)*param_1)(param_1,&local_38);
if (iVar1 < 0) {
local_20 = 0;
goto LAB_0015b55a;
}
if ((iVar1 != 9) && (iVar1 != 0x15)) {
local_20 = 0x7dc;
goto LAB_0015b55a;
}
memmove((void *)(local_30 + 0x48e),local_38,(long)(iVar1 + -1));
*(int1 *)(local_30 + 0x48e + (long)(iVar1 + -1)) = 0;
}
else {
local_38 = (void *)(param_2 + 0x48e);
}
if ((local_30 == 0) || (**(char **)(local_30 + 0x2c0) == '\0')) {
iVar1 = (*(code *)local_28[1])(local_28,0,0);
if (iVar1 != 0) {
local_20 = 0;
goto LAB_0015b55a;
}
}
else {
ma_scramble_323(local_19,local_38,*(int8 *)(local_30 + 0x2c0));
iVar1 = (*(code *)local_28[1])(local_28,local_19,9);
if (iVar1 != 0) {
local_20 = 0;
goto LAB_0015b55a;
}
}
local_20 = 0xffffffff;
LAB_0015b55a:
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_20;
}
|
|
63,318 |
maria_ftparser_alloc_param
|
eloqsql/storage/maria/ma_ft_parser.c
|
MYSQL_FTPARSER_PARAM* maria_ftparser_alloc_param(MARIA_HA *info)
{
if (!info->ftparser_param)
{
/*
. info->ftparser_param can not be zero after the initialization,
because it always includes built-in fulltext parser. And built-in
parser can be called even if the table has no fulltext indexes and
no varchar/text fields.
ftb_find_relevance... parser (ftb_find_relevance_parse,
ftb_find_relevance_add_word) calls ftb_check_phrase... parser
(ftb_check_phrase_internal, ftb_phrase_add_word). Thus MAX_PARAM_NR=2.
*/
info->ftparser_param= (MYSQL_FTPARSER_PARAM *)
my_malloc(PSI_INSTRUMENT_ME, MAX_PARAM_NR * sizeof(MYSQL_FTPARSER_PARAM) *
info->s->ftkeys, MYF(MY_WME | MY_ZEROFILL));
init_alloc_root(PSI_INSTRUMENT_ME, &info->ft_memroot,
FTPARSER_MEMROOT_ALLOC_SIZE, 0, MYF(0));
}
return info->ftparser_param;
}
|
O3
|
c
|
maria_ftparser_alloc_param:
movq 0x368(%rdi), %rax
testq %rax, %rax
je 0x46762
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movl 0x748(%rax), %esi
shlq $0x7, %rsi
movl $0x30, %edx
xorl %edi, %edi
callq 0x9fdb1
movq %rax, 0x368(%rbx)
leaq 0x328(%rbx), %rsi
movl $0x10000, %edx # imm = 0x10000
xorl %edi, %edi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x9cb44
movq 0x368(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
maria_ftparser_alloc_param:
mov rax, [rdi+368h]
test rax, rax
jz short loc_46762
retn
loc_46762:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
mov rax, [rdi]
mov esi, [rax+748h]
shl rsi, 7
mov edx, 30h ; '0'
xor edi, edi
call my_malloc
mov [rbx+368h], rax
lea rsi, [rbx+328h]
mov edx, offset stru_10000
xor edi, edi
xor ecx, ecx
xor r8d, r8d
call init_alloc_root
mov rax, [rbx+368h]
add rsp, 8
pop rbx
pop rbp
retn
|
long long maria_ftparser_alloc_param(_QWORD *a1)
{
long long result; // rax
result = a1[109];
if ( !result )
{
a1[109] = my_malloc(0LL, (unsigned long long)*(unsigned int *)(*a1 + 1864LL) << 7, 48LL);
init_alloc_root(0LL, a1 + 101, &stru_10000, 0LL, 0LL);
return a1[109];
}
return result;
}
|
maria_ftparser_alloc_param:
MOV RAX,qword ptr [RDI + 0x368]
TEST RAX,RAX
JZ 0x00146762
RET
LAB_00146762:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RAX,qword ptr [RDI]
MOV ESI,dword ptr [RAX + 0x748]
SHL RSI,0x7
MOV EDX,0x30
XOR EDI,EDI
CALL 0x0019fdb1
MOV qword ptr [RBX + 0x368],RAX
LEA RSI,[RBX + 0x328]
MOV EDX,0x10000
XOR EDI,EDI
XOR ECX,ECX
XOR R8D,R8D
CALL 0x0019cb44
MOV RAX,qword ptr [RBX + 0x368]
ADD RSP,0x8
POP RBX
POP RBP
RET
|
long maria_ftparser_alloc_param(long *param_1)
{
long lVar1;
int8 in_R9;
long lVar2;
lVar2 = param_1[0x6d];
if (lVar2 != 0) {
return lVar2;
}
lVar1 = my_malloc(0,(ulong)*(uint *)(*param_1 + 0x748) << 7,0x30);
param_1[0x6d] = lVar1;
init_alloc_root(0,param_1 + 0x65,0x10000,0,0,in_R9,lVar2);
return param_1[0x6d];
}
|
|
63,319 |
fs_get_cache_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
monkey531[P]llama/common/common.cpp
|
std::string fs_get_cache_file(const std::string & filename) {
GGML_ASSERT(filename.find(DIRECTORY_SEPARATOR) == std::string::npos);
std::string cache_directory = fs_get_cache_directory();
const bool success = fs_create_directory_with_parents(cache_directory);
if (!success) {
throw std::runtime_error("failed to create cache directory: " + cache_directory);
}
return cache_directory + filename;
}
|
O3
|
cpp
|
fs_get_cache_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x2f, %esi
xorl %edx, %edx
callq 0x1ab30
cmpq $-0x1, %rax
jne 0x7485e
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x74470
movq %r15, %rdi
callq 0x74372
testb %al, %al
je 0x7487f
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x796b2
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x74850
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a8e0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7a28c(%rip), %rdi # 0xeeaf1
leaq 0x77487(%rip), %rdx # 0xebcf3
leaq 0x7a457(%rip), %rcx # 0xeecca
movl $0x378, %esi # imm = 0x378
xorl %eax, %eax
callq 0x1aeb0
movl $0x10, %edi
callq 0x1a430
movq %rax, %rbx
leaq 0x7a46f(%rip), %rsi # 0xeed02
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x54d11
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x1ae30
xorl %ebp, %ebp
movq 0xb7735(%rip), %rsi # 0x12bff0
movq 0xb769e(%rip), %rdx # 0x12bf60
movq %rbx, %rdi
callq 0x1af20
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x748e8
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1a8e0
testb %bpl, %bpl
jne 0x748f2
jmp 0x748ff
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a670
jmp 0x748ff
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7491a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a8e0
movq %r14, %rdi
callq 0x1afb0
|
_Z17fs_get_cache_fileRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp; int
push r15; int
push r14; int
push rbx; __int64
sub rsp, 48h
mov r14, rsi
mov rbx, rdi
mov rdi, rsi
mov esi, 2Fh ; '/'
xor edx, edx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEcm; std::string::find(char,ulong)
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_7485E
lea r15, [rsp+68h+var_60]
mov rdi, r15; int
call _Z22fs_get_cache_directoryB5cxx11v; fs_get_cache_directory(void)
mov rdi, r15
call _Z32fs_create_directory_with_parentsRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; fs_create_directory_with_parents(std::string const&)
test al, al
jz short loc_7487F
lea rsi, [rsp+68h+var_60]
mov rdi, rbx
mov rdx, r14
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EERKS8_SA_; std::operator+<char>(std::string const&,std::string const&)
lea rax, [rsp+68h+var_50]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_74850
mov rsi, [rsp+68h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_74850:
mov rax, rbx
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_7485E:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aFilenameFindDi; "filename.find(DIRECTORY_SEPARATOR) == s"...
mov esi, 378h
xor eax, eax
call _ggml_abort
loc_7487F:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aFailedToCreate; "failed to create cache directory: "
lea rdi, [rsp+68h+var_40]
lea rdx, [rsp+68h+var_60]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
mov bpl, 1
lea rsi, [rsp+68h+var_40]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+68h+var_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_748E8
mov rsi, [rsp+68h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_748E8:
test bpl, bpl
jnz short loc_748F2
jmp short loc_748FF
mov r14, rax
loc_748F2:
mov rdi, rbx; void *
call ___cxa_free_exception
jmp short loc_748FF
mov r14, rax
loc_748FF:
lea rax, [rsp+68h+var_50]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_7491A
mov rsi, [rsp+68h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7491A:
mov rdi, r14
call __Unwind_Resume
|
long long fs_get_cache_file(long long a1, long long a2)
{
void *exception; // rbx
int v4[4]; // [rsp+8h] [rbp-60h] BYREF
long long v5; // [rsp+18h] [rbp-50h] BYREF
_BYTE v6[16]; // [rsp+28h] [rbp-40h] BYREF
if ( std::string::find(a2, 47LL, 0LL) != -1 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",
888LL,
"GGML_ASSERT(%s) failed",
"filename.find(DIRECTORY_SEPARATOR) == std::string::npos");
LABEL_7:
exception = __cxa_allocate_exception(0x10uLL);
std::operator+<char>((long long)v6, (long long)"failed to create cache directory: ", v4);
std::runtime_error::runtime_error(exception, v6);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
fs_get_cache_directory[abi:cxx11]((long long)v4);
if ( !(unsigned __int8)fs_create_directory_with_parents(v4) )
goto LABEL_7;
std::operator+<char>(a1, v4, a2);
if ( *(long long **)v4 != &v5 )
operator delete(*(void **)v4, v5 + 1);
return a1;
}
|
fs_get_cache_file:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV R14,RSI
MOV RBX,RDI
MOV RDI,RSI
MOV ESI,0x2f
XOR EDX,EDX
CALL 0x0011ab30
CMP RAX,-0x1
JNZ 0x0017485e
LEA R15,[RSP + 0x8]
MOV RDI,R15
CALL 0x00174470
LAB_00174819:
MOV RDI,R15
CALL 0x00174372
TEST AL,AL
JZ 0x0017487f
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
MOV RDX,R14
CALL 0x001796b2
LAB_00174835:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00174850
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011a8e0
LAB_00174850:
MOV RAX,RBX
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0017485e:
LEA RDI,[0x1eeaf1]
LEA RDX,[0x1ebcf3]
LEA RCX,[0x1eecca]
MOV ESI,0x378
XOR EAX,EAX
CALL 0x0011aeb0
LAB_0017487f:
MOV EDI,0x10
CALL 0x0011a430
MOV RBX,RAX
LAB_0017488c:
LEA RSI,[0x1eed02]
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x8]
CALL 0x00154d11
MOV BPL,0x1
LAB_001748a5:
LEA RSI,[RSP + 0x28]
MOV RDI,RBX
CALL 0x0011ae30
XOR EBP,EBP
MOV RSI,qword ptr [0x0022bff0]
MOV RDX,qword ptr [0x0022bf60]
MOV RDI,RBX
CALL 0x0011af20
|
/* fs_get_cache_file(std::__cxx11::string const&) */
string * fs_get_cache_file(string *param_1)
{
char cVar1;
long lVar2;
runtime_error *this;
char in_SIL;
long *local_60 [2];
long local_50 [2];
string local_40 [32];
lVar2 = std::__cxx11::string::find(in_SIL,0x2f);
if (lVar2 != -1) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",0x378,
"GGML_ASSERT(%s) failed","filename.find(DIRECTORY_SEPARATOR) == std::string::npos");
}
fs_get_cache_directory_abi_cxx11_();
/* try { // try from 00174819 to 00174834 has its CatchHandler @ 001748fc */
cVar1 = fs_create_directory_with_parents((string *)local_60);
if (cVar1 != '\0') {
std::operator+(param_1,(string *)local_60);
if (local_60[0] != local_50) {
operator_delete(local_60[0],local_50[0] + 1);
}
return param_1;
}
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0017488c to 001748a1 has its CatchHandler @ 001748ef */
std::operator+((char *)local_40,(string *)"failed to create cache directory: ");
/* try { // try from 001748a5 to 001748c9 has its CatchHandler @ 001748ca */
std::runtime_error::runtime_error(this,local_40);
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_0022bff0,PTR__runtime_error_0022bf60);
}
|
|
63,320 |
my_instr_mb
|
eloqsql/strings/ctype-mb.c
|
uint my_instr_mb(CHARSET_INFO *cs,
const char *b, size_t b_length,
const char *s, size_t s_length,
my_match_t *match, uint nmatch)
{
register const char *end, *b0;
int res= 0;
if (s_length <= b_length)
{
if (!s_length)
{
if (nmatch)
{
match->beg= 0;
match->end= 0;
match->mb_len= 0;
}
return 1; /* Empty string is always found */
}
b0= b;
end= b+b_length-s_length+1;
while (b < end)
{
int mb_len;
if (!my_ci_strnncoll(cs, (const uchar *) b, s_length,
(const uchar *) s, s_length, 0))
{
if (nmatch)
{
match[0].beg= 0;
match[0].end= (uint) (b-b0);
match[0].mb_len= res;
if (nmatch > 1)
{
match[1].beg= match[0].end;
match[1].end= (uint)(match[0].end+s_length);
match[1].mb_len= 0; /* Not computed */
}
}
return 2;
}
mb_len= (mb_len= my_ismbchar(cs, b, end)) ? mb_len : 1;
b+= mb_len;
b_length-= mb_len;
res++;
}
}
return 0;
}
|
O0
|
c
|
my_instr_mb:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movl $0x0, -0x4c(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
ja 0x4008e
cmpq $0x0, -0x30(%rbp)
jne 0x3ff71
cmpl $0x0, 0x10(%rbp)
je 0x3ff65
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x8(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x40095
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
xorl %ecx, %ecx
subq -0x30(%rbp), %rcx
addq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x4008c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
xorl %r9d, %r9d
callq 0x400a0
cmpl $0x0, %eax
jne 0x4002d
cmpl $0x0, 0x10(%rbp)
je 0x40024
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movq -0x48(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x4c(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x8(%rax)
cmpl $0x1, 0x10(%rbp)
jbe 0x40022
movq -0x38(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x38(%rbp), %rax
movl 0x4(%rax), %eax
addq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x14(%rax)
jmp 0x40024
movl $0x2, -0x4(%rbp)
jmp 0x40095
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x3f030
movl %eax, -0x50(%rbp)
cmpl $0x0, %eax
je 0x4004e
movl -0x50(%rbp), %eax
movl %eax, -0x54(%rbp)
jmp 0x40058
movl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x40058
movl -0x54(%rbp), %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movslq -0x50(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x3ff92
jmp 0x4008e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
|
my_instr_mb:
push rbp
mov rbp, rsp
sub rsp, 60h
mov eax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_38], r9
mov [rbp+var_4C], 0
mov rax, [rbp+var_30]
cmp rax, [rbp+var_20]
ja loc_4008E
cmp [rbp+var_30], 0
jnz short loc_3FF71
cmp [rbp+arg_0], 0
jz short loc_3FF65
mov rax, [rbp+var_38]
mov dword ptr [rax], 0
mov rax, [rbp+var_38]
mov dword ptr [rax+4], 0
mov rax, [rbp+var_38]
mov dword ptr [rax+8], 0
loc_3FF65:
mov [rbp+var_4], 1
jmp loc_40095
loc_3FF71:
mov rax, [rbp+var_18]
mov [rbp+var_48], rax
mov rax, [rbp+var_18]
add rax, [rbp+var_20]
xor ecx, ecx
sub rcx, [rbp+var_30]
add rax, rcx
add rax, 1
mov [rbp+var_40], rax
loc_3FF92:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_40]
jnb loc_4008C
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_30]
mov rcx, [rbp+var_28]
mov r8, [rbp+var_30]
xor r9d, r9d
call my_ci_strnncoll
cmp eax, 0
jnz short loc_4002D
cmp [rbp+arg_0], 0
jz short loc_40024
mov rax, [rbp+var_38]
mov dword ptr [rax], 0
mov rax, [rbp+var_18]
mov rcx, [rbp+var_48]
sub rax, rcx
mov ecx, eax
mov rax, [rbp+var_38]
mov [rax+4], ecx
mov ecx, [rbp+var_4C]
mov rax, [rbp+var_38]
mov [rax+8], ecx
cmp [rbp+arg_0], 1
jbe short loc_40022
mov rax, [rbp+var_38]
mov ecx, [rax+4]
mov rax, [rbp+var_38]
mov [rax+0Ch], ecx
mov rax, [rbp+var_38]
mov eax, [rax+4]
add rax, [rbp+var_30]
mov ecx, eax
mov rax, [rbp+var_38]
mov [rax+10h], ecx
mov rax, [rbp+var_38]
mov dword ptr [rax+14h], 0
loc_40022:
jmp short $+2
loc_40024:
mov [rbp+var_4], 2
jmp short loc_40095
loc_4002D:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_40]
call my_ismbchar_0
mov [rbp+var_50], eax
cmp eax, 0
jz short loc_4004E
mov eax, [rbp+var_50]
mov [rbp+var_54], eax
jmp short loc_40058
loc_4004E:
mov eax, 1
mov [rbp+var_54], eax
jmp short $+2
loc_40058:
mov eax, [rbp+var_54]
mov [rbp+var_50], eax
mov ecx, [rbp+var_50]
mov rax, [rbp+var_18]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_18], rax
movsxd rcx, [rbp+var_50]
mov rax, [rbp+var_20]
sub rax, rcx
mov [rbp+var_20], rax
mov eax, [rbp+var_4C]
add eax, 1
mov [rbp+var_4C], eax
jmp loc_3FF92
loc_4008C:
jmp short $+2
loc_4008E:
mov [rbp+var_4], 0
loc_40095:
mov eax, [rbp+var_4]
add rsp, 60h
pop rbp
retn
|
long long my_instr_mb(
long long a1,
unsigned long long a2,
unsigned long long a3,
long long a4,
unsigned long long a5,
_DWORD *a6,
unsigned int a7)
{
int v8; // [rsp+Ch] [rbp-54h]
int v9; // [rsp+10h] [rbp-50h]
int v10; // [rsp+14h] [rbp-4Ch]
unsigned long long v11; // [rsp+20h] [rbp-40h]
unsigned long long v15; // [rsp+40h] [rbp-20h]
unsigned long long v16; // [rsp+48h] [rbp-18h]
v16 = a2;
v15 = a3;
v10 = 0;
if ( a5 > a3 )
return 0;
if ( a5 )
{
v11 = a3 + a2 - a5 + 1;
while ( v16 < v11 )
{
if ( !(unsigned int)my_ci_strnncoll(a1, v16, a5, a4, a5, 0LL) )
{
if ( a7 )
{
*a6 = 0;
a6[1] = v16 - a2;
a6[2] = v10;
if ( a7 > 1 )
{
a6[3] = a6[1];
a6[4] = a5 + a6[1];
a6[5] = 0;
}
}
return 2;
}
v9 = my_ismbchar_0(a1, v16, v11);
if ( v9 )
v8 = v9;
else
v8 = 1;
v16 += v8;
v15 -= v8;
++v10;
}
return 0;
}
if ( a7 )
{
*a6 = 0;
a6[1] = 0;
a6[2] = 0;
}
return 1;
}
|
my_instr_mb:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
MOV dword ptr [RBP + -0x4c],0x0
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x20]
JA 0x0014008e
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x0013ff71
CMP dword ptr [RBP + 0x10],0x0
JZ 0x0013ff65
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x4],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x8],0x0
LAB_0013ff65:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00140095
LAB_0013ff71:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,qword ptr [RBP + -0x20]
XOR ECX,ECX
SUB RCX,qword ptr [RBP + -0x30]
ADD RAX,RCX
ADD RAX,0x1
MOV qword ptr [RBP + -0x40],RAX
LAB_0013ff92:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x0014008c
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8,qword ptr [RBP + -0x30]
XOR R9D,R9D
CALL 0x001400a0
CMP EAX,0x0
JNZ 0x0014002d
CMP dword ptr [RBP + 0x10],0x0
JZ 0x00140024
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x48]
SUB RAX,RCX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x4],ECX
MOV ECX,dword ptr [RBP + -0x4c]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x8],ECX
CMP dword ptr [RBP + 0x10],0x1
JBE 0x00140022
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RAX + 0x4]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0xc],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX + 0x4]
ADD RAX,qword ptr [RBP + -0x30]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x14],0x0
LAB_00140022:
JMP 0x00140024
LAB_00140024:
MOV dword ptr [RBP + -0x4],0x2
JMP 0x00140095
LAB_0014002d:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x40]
CALL 0x0013f030
MOV dword ptr [RBP + -0x50],EAX
CMP EAX,0x0
JZ 0x0014004e
MOV EAX,dword ptr [RBP + -0x50]
MOV dword ptr [RBP + -0x54],EAX
JMP 0x00140058
LAB_0014004e:
MOV EAX,0x1
MOV dword ptr [RBP + -0x54],EAX
JMP 0x00140058
LAB_00140058:
MOV EAX,dword ptr [RBP + -0x54]
MOV dword ptr [RBP + -0x50],EAX
MOV ECX,dword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x18]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
MOVSXD RCX,dword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV EAX,dword ptr [RBP + -0x4c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x4c],EAX
JMP 0x0013ff92
LAB_0014008c:
JMP 0x0014008e
LAB_0014008e:
MOV dword ptr [RBP + -0x4],0x0
LAB_00140095:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x60
POP RBP
RET
|
int4
my_instr_mb(int8 param_1,ulong param_2,ulong param_3,int8 param_4,ulong param_5,
int4 *param_6,uint param_7)
{
int iVar1;
ulong uVar2;
int local_5c;
int local_54;
ulong local_20;
local_54 = 0;
if (param_5 <= param_3) {
if (param_5 == 0) {
if (param_7 != 0) {
*param_6 = 0;
param_6[1] = 0;
param_6[2] = 0;
}
return 1;
}
uVar2 = ((param_2 + param_3) - param_5) + 1;
for (local_20 = param_2; local_20 < uVar2; local_20 = local_20 + (long)local_5c) {
iVar1 = my_ci_strnncoll(param_1,local_20,param_5,param_4,param_5,0);
if (iVar1 == 0) {
if (param_7 != 0) {
*param_6 = 0;
param_6[1] = (int)local_20 - (int)param_2;
param_6[2] = local_54;
if (1 < param_7) {
param_6[3] = param_6[1];
param_6[4] = param_6[1] + (int)param_5;
param_6[5] = 0;
}
}
return 2;
}
local_5c = my_ismbchar(param_1,local_20,uVar2);
if (local_5c == 0) {
local_5c = 1;
}
local_54 = local_54 + 1;
}
}
return 0;
}
|
|
63,321 |
ma_hashtbl_insert
|
eloqsql/libmariadb/libmariadb/ma_hashtbl.c
|
my_bool ma_hashtbl_insert(MA_HASHTBL *info,const uchar *record)
{
int flag;
uint halfbuff,hash_nr,first_index,idx;
uchar *ptr_to_rec= NULL,*ptr_to_rec2= NULL;
MA_HASHTBL_LINK *data,*empty,*gpos= NULL,*gpos2 = NULL,*pos;
LINT_INIT(gpos); LINT_INIT(gpos2);
LINT_INIT(ptr_to_rec); LINT_INIT(ptr_to_rec2);
flag=0;
if (!(empty=(MA_HASHTBL_LINK*) ma_alloc_dynamic(&info->array)))
return(TRUE); /* No more memory */
info->current_record= NO_RECORD;
data=dynamic_element(&info->array,0,MA_HASHTBL_LINK*);
halfbuff= info->blength >> 1;
idx=first_index=info->records-halfbuff;
if (idx != info->records) /* If some records */
{
do
{
pos=data+idx;
hash_nr=rec_hashnr(info,pos->data);
if (flag == 0) /* First loop; Check if ok */
if (hash_mask(hash_nr,info->blength,info->records) != first_index)
break;
if (!(hash_nr & halfbuff))
{ /* Key will not move */
if (!(flag & LOWFIND))
{
if (flag & HIGHFIND)
{
flag=LOWFIND | HIGHFIND;
/* key shall be moved to the current empty position */
gpos=empty;
ptr_to_rec=pos->data;
empty=pos; /* This place is now free */
}
else
{
flag=LOWFIND | LOWUSED; /* key isn't changed */
gpos=pos;
ptr_to_rec=pos->data;
}
}
else
{
if (!(flag & LOWUSED))
{
/* Change link of previous LOW-key */
gpos->data=ptr_to_rec;
gpos->next=(uint) (pos-data);
flag= (flag & HIGHFIND) | (LOWFIND | LOWUSED);
}
gpos=pos;
ptr_to_rec=pos->data;
}
}
else
{ /* key will be moved */
if (!(flag & HIGHFIND))
{
flag= (flag & LOWFIND) | HIGHFIND;
/* key shall be moved to the last (empty) position */
gpos2 = empty; empty=pos;
ptr_to_rec2=pos->data;
}
else
{
if (!(flag & HIGHUSED))
{
/* Change link of previous hash-key and save */
gpos2->data=ptr_to_rec2;
gpos2->next=(uint) (pos-data);
flag= (flag & LOWFIND) | (HIGHFIND | HIGHUSED);
}
gpos2=pos;
ptr_to_rec2=pos->data;
}
}
}
while ((idx=pos->next) != NO_RECORD);
if ((flag & (LOWFIND | LOWUSED)) == LOWFIND)
{
gpos->data=ptr_to_rec;
gpos->next=NO_RECORD;
}
if ((flag & (HIGHFIND | HIGHUSED)) == HIGHFIND)
{
gpos2->data=ptr_to_rec2;
gpos2->next=NO_RECORD;
}
}
/* Check if we are at the empty position */
idx=hash_mask(rec_hashnr(info,record),info->blength,info->records+1);
pos=data+idx;
if (pos == empty)
{
pos->data=(uchar*) record;
pos->next=NO_RECORD;
}
else
{
/* Check if more records in same hash-nr family */
empty[0]=pos[0];
gpos=data+hash_rec_mask(info,pos,info->blength,info->records+1);
if (pos == gpos)
{
pos->data=(uchar*) record;
pos->next=(uint) (empty - data);
}
else
{
pos->data=(uchar*) record;
pos->next=NO_RECORD;
movelink(data,(uint) (pos-data),(uint) (gpos-data),(uint) (empty-data));
}
}
if (++info->records == info->blength)
info->blength+= info->blength;
return(0);
}
|
O3
|
c
|
ma_hashtbl_insert:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x18, %rdi
callq 0x3242e
testq %rax, %rax
je 0x32bab
movq %rax, %r13
movl $0xffffffff, 0x10(%rbx) # imm = 0xFFFFFFFF
movq 0x18(%rbx), %rcx
movl 0xc(%rbx), %edx
cmpl $0x2, %edx
movq %rbx, -0x70(%rbp)
movq %rcx, -0x68(%rbp)
movq %r14, -0x40(%rbp)
jb 0x32bba
movl 0x8(%rbx), %ebx
shrl %edx
subl %edx, %ebx
xorl %r12d, %r12d
movl %ebx, -0x74(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x60(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x58(%rbp)
movl %edx, %r14d
movq %r13, -0x30(%rbp)
movl %ebx, %r15d
shlq $0x4, %r15
movq 0x8(%rcx,%r15), %rdi
movq -0x70(%rbp), %r13
movq 0x30(%r13), %rax
testq %rax, %rax
je 0x32a66
leaq -0x34(%rbp), %rsi
xorl %edx, %edx
callq *%rax
movq %rax, %rdi
movl -0x34(%rbp), %esi
jmp 0x32a74
movl 0x4(%r13), %esi
movl %esi, -0x34(%rbp)
movl (%r13), %eax
addq %rax, %rdi
callq *0x40(%r13)
testl %r12d, %r12d
jne 0x32a9c
movl 0xc(%r13), %ecx
leal -0x1(%rcx), %edx
andl %eax, %edx
shrl %ecx
decl %ecx
andl %eax, %ecx
cmpl 0x8(%r13), %edx
cmovbl %edx, %ecx
cmpl -0x74(%rbp), %ecx
jne 0x32bb2
movq -0x68(%rbp), %rcx
addq %rcx, %r15
movl %r14d, %edx
testl %r14d, %eax
je 0x32ad1
testb $0x4, %r12b
jne 0x32b06
andl $0x1, %r12d
orl $0x4, %r12d
movq 0x8(%r15), %rax
movq %rax, -0x60(%rbp)
movq %r15, %r13
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x32b60
testb $0x1, %r12b
jne 0x32b34
andl $0x4, %r12d
movl %r12d, %eax
shrl %eax
addl $0x3, %eax
testl %r12d, %r12d
movq 0x8(%r15), %rsi
movq %rsi, -0x50(%rbp)
movq %r15, %r13
movq -0x30(%rbp), %rsi
cmoveq %rsi, %r13
cmoveq %r15, %rsi
movl %eax, %r12d
movq %rsi, -0x48(%rbp)
jmp 0x32b60
testb $0x8, %r12b
jne 0x32b22
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rsi
movq %rax, 0x8(%rsi)
movl %ebx, (%rsi)
andl $0x1, %r12d
orl $0xc, %r12d
movq 0x8(%r15), %rax
movq %rax, -0x60(%rbp)
movq -0x30(%rbp), %r13
movq %r15, -0x58(%rbp)
jmp 0x32b60
testb $0x2, %r12b
jne 0x32b50
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rsi
movq %rax, 0x8(%rsi)
movl %ebx, (%rsi)
andl $0x4, %r12d
orl $0x3, %r12d
movq 0x8(%r15), %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %r13
movq %r15, -0x48(%rbp)
movl (%r15), %ebx
cmpl $-0x1, %ebx
jne 0x32a36
movl %r12d, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x32b89
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rax, 0x8(%rcx)
movl $0xffffffff, (%rcx) # imm = 0xFFFFFFFF
andl $0xc, %r12d
cmpl $0x4, %r12d
movq -0x40(%rbp), %r14
jne 0x32bba
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rax, 0x8(%rcx)
movl $0xffffffff, (%rcx) # imm = 0xFFFFFFFF
jmp 0x32bba
movb $0x1, %al
jmp 0x32c9f
movq -0x30(%rbp), %r13
movq -0x40(%rbp), %r14
movq -0x70(%rbp), %r15
movq 0x30(%r15), %rax
testq %rax, %rax
je 0x32bde
leaq -0x78(%rbp), %r12
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq *%rax
movq %rax, %rdi
movl (%r12), %esi
jmp 0x32beb
movl 0x4(%r15), %esi
movl %esi, -0x78(%rbp)
movl (%r15), %edi
addq %r14, %rdi
callq *0x40(%r15)
movl 0x8(%r15), %ecx
movl 0xc(%r15), %ebx
incl %ecx
leal -0x1(%rbx), %edx
andl %eax, %edx
shrl %ebx
decl %ebx
andl %eax, %ebx
cmpl %ecx, %edx
cmovbl %edx, %ebx
movq %rbx, %r14
shlq $0x4, %r14
addq -0x68(%rbp), %r14
cmpq %r13, %r14
je 0x32c51
movups (%r14), %xmm0
movups %xmm0, (%r13)
movl 0x8(%r15), %ecx
movl 0xc(%r15), %edx
incl %ecx
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x328cc
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%r14)
cmpl %eax, %ebx
jne 0x32c62
subq -0x68(%rbp), %r13
shrq $0x4, %r13
movl %r13d, (%r14)
jmp 0x32c87
movq -0x40(%rbp), %rax
movq %rax, 0x8(%r14)
movl $0xffffffff, (%r14) # imm = 0xFFFFFFFF
jmp 0x32c87
movl $0xffffffff, (%r14) # imm = 0xFFFFFFFF
movq -0x68(%rbp), %rdx
subq %rdx, %r13
shrq $0x4, %r13
movl %eax, %ecx
shlq $0x4, %rcx
movl (%rdx,%rcx), %eax
cmpl %ebx, %eax
jne 0x32c74
addq %rcx, %rdx
movl %r13d, (%rdx)
movq -0x70(%rbp), %rcx
movl 0x8(%rcx), %eax
incl %eax
movl %eax, 0x8(%rcx)
cmpl 0xc(%rcx), %eax
jne 0x32c9d
addl %eax, %eax
movl %eax, 0xc(%rcx)
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
ma_hashtbl_insert:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov r14, rsi
mov rbx, rdi
add rdi, 18h
call ma_alloc_dynamic
test rax, rax
jz loc_32BAB
mov r13, rax
mov dword ptr [rbx+10h], 0FFFFFFFFh
mov rcx, [rbx+18h]
mov edx, [rbx+0Ch]
cmp edx, 2
mov [rbp+var_70], rbx
mov [rbp+var_68], rcx
mov [rbp+var_40], r14
jb loc_32BBA
mov ebx, [rbx+8]
shr edx, 1
sub ebx, edx
xor r12d, r12d
mov [rbp+var_74], ebx
mov [rbp+var_50], 0
mov [rbp+var_60], 0
mov [rbp+var_48], 0
mov [rbp+var_58], 0
loc_32A36:
mov r14d, edx
mov [rbp+var_30], r13
mov r15d, ebx
shl r15, 4
mov rdi, [rcx+r15+8]
mov r13, [rbp+var_70]
mov rax, [r13+30h]
test rax, rax
jz short loc_32A66
lea rsi, [rbp+var_34]
xor edx, edx
call rax
mov rdi, rax
mov esi, [rbp+var_34]
jmp short loc_32A74
loc_32A66:
mov esi, [r13+4]
mov [rbp+var_34], esi
mov eax, [r13+0]
add rdi, rax
loc_32A74:
call qword ptr [r13+40h]
test r12d, r12d
jnz short loc_32A9C
mov ecx, [r13+0Ch]
lea edx, [rcx-1]
and edx, eax
shr ecx, 1
dec ecx
and ecx, eax
cmp edx, [r13+8]
cmovb ecx, edx
cmp ecx, [rbp+var_74]
jnz loc_32BB2
loc_32A9C:
mov rcx, [rbp+var_68]
add r15, rcx
mov edx, r14d
test eax, r14d
jz short loc_32AD1
test r12b, 4
jnz short loc_32B06
and r12d, 1
or r12d, 4
mov rax, [r15+8]
mov [rbp+var_60], rax
mov r13, r15
mov rax, [rbp+var_30]
mov [rbp+var_58], rax
jmp loc_32B60
loc_32AD1:
test r12b, 1
jnz short loc_32B34
and r12d, 4
mov eax, r12d
shr eax, 1
add eax, 3
test r12d, r12d
mov rsi, [r15+8]
mov [rbp+var_50], rsi
mov r13, r15
mov rsi, [rbp+var_30]
cmovz r13, rsi
cmovz rsi, r15
mov r12d, eax
mov [rbp+var_48], rsi
jmp short loc_32B60
loc_32B06:
test r12b, 8
jnz short loc_32B22
mov rax, [rbp+var_60]
mov rsi, [rbp+var_58]
mov [rsi+8], rax
mov [rsi], ebx
and r12d, 1
or r12d, 0Ch
loc_32B22:
mov rax, [r15+8]
mov [rbp+var_60], rax
mov r13, [rbp+var_30]
mov [rbp+var_58], r15
jmp short loc_32B60
loc_32B34:
test r12b, 2
jnz short loc_32B50
mov rax, [rbp+var_50]
mov rsi, [rbp+var_48]
mov [rsi+8], rax
mov [rsi], ebx
and r12d, 4
or r12d, 3
loc_32B50:
mov rax, [r15+8]
mov [rbp+var_50], rax
mov r13, [rbp+var_30]
mov [rbp+var_48], r15
loc_32B60:
mov ebx, [r15]
cmp ebx, 0FFFFFFFFh
jnz loc_32A36
mov eax, r12d
and eax, 3
cmp eax, 1
jnz short loc_32B89
mov rax, [rbp+var_50]
mov rcx, [rbp+var_48]
mov [rcx+8], rax
mov dword ptr [rcx], 0FFFFFFFFh
loc_32B89:
and r12d, 0Ch
cmp r12d, 4
mov r14, [rbp+var_40]
jnz short loc_32BBA
mov rax, [rbp+var_60]
mov rcx, [rbp+var_58]
mov [rcx+8], rax
mov dword ptr [rcx], 0FFFFFFFFh
jmp short loc_32BBA
loc_32BAB:
mov al, 1
jmp loc_32C9F
loc_32BB2:
mov r13, [rbp+var_30]
mov r14, [rbp+var_40]
loc_32BBA:
mov r15, [rbp+var_70]
mov rax, [r15+30h]
test rax, rax
jz short loc_32BDE
lea r12, [rbp+var_78]
mov rdi, r14
mov rsi, r12
xor edx, edx
call rax
mov rdi, rax
mov esi, [r12]
jmp short loc_32BEB
loc_32BDE:
mov esi, [r15+4]
mov [rbp+var_78], esi
mov edi, [r15]
add rdi, r14
loc_32BEB:
call qword ptr [r15+40h]
mov ecx, [r15+8]
mov ebx, [r15+0Ch]
inc ecx
lea edx, [rbx-1]
and edx, eax
shr ebx, 1
dec ebx
and ebx, eax
cmp edx, ecx
cmovb ebx, edx
mov r14, rbx
shl r14, 4
add r14, [rbp+var_68]
cmp r14, r13
jz short loc_32C51
movups xmm0, xmmword ptr [r14]
movups xmmword ptr [r13+0], xmm0
mov ecx, [r15+8]
mov edx, [r15+0Ch]
inc ecx
mov rsi, [r14+8]
mov rdi, r15
call hash_rec_mask
mov rcx, [rbp+var_40]
mov [r14+8], rcx
cmp ebx, eax
jnz short loc_32C62
sub r13, [rbp+var_68]
shr r13, 4
mov [r14], r13d
jmp short loc_32C87
loc_32C51:
mov rax, [rbp+var_40]
mov [r14+8], rax
mov dword ptr [r14], 0FFFFFFFFh
jmp short loc_32C87
loc_32C62:
mov dword ptr [r14], 0FFFFFFFFh
mov rdx, [rbp+var_68]
sub r13, rdx
shr r13, 4
loc_32C74:
mov ecx, eax
shl rcx, 4
mov eax, [rdx+rcx]
cmp eax, ebx
jnz short loc_32C74
add rdx, rcx
mov [rdx], r13d
loc_32C87:
mov rcx, [rbp+var_70]
mov eax, [rcx+8]
inc eax
mov [rcx+8], eax
cmp eax, [rcx+0Ch]
jnz short loc_32C9D
add eax, eax
mov [rcx+0Ch], eax
loc_32C9D:
xor eax, eax
loc_32C9F:
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long ma_hashtbl_insert(unsigned int *a1, long long a2)
{
long long v2; // r14
long long v3; // rax
_OWORD *v4; // r13
long long v5; // rcx
unsigned int v6; // edx
unsigned int v7; // edx
unsigned int v8; // ebx
int v9; // r12d
unsigned int v10; // r14d
long long v11; // r15
long long v12; // rdi
long long ( *v13)(long long, unsigned int *, _QWORD); // rax
long long v14; // rdi
long long v15; // rsi
int v16; // eax
unsigned int v17; // ecx
unsigned int v18; // edx
int v19; // ecx
long long v20; // r15
unsigned int v21; // r12d
unsigned int *v22; // rsi
unsigned int *v23; // rsi
unsigned int *v24; // rsi
unsigned int *v25; // rcx
unsigned int *v26; // rcx
long long ( **v28)(long long, long long); // r15
long long ( *v29)(long long, unsigned int *, _QWORD); // rax
long long v30; // rdi
long long v31; // rsi
int v32; // eax
unsigned int v33; // ebx
unsigned int v34; // edx
long long v35; // rbx
long long v36; // r14
unsigned int v37; // eax
unsigned long long v38; // r13
long long v39; // rcx
unsigned int *v40; // rcx
int v41; // eax
unsigned int v42; // [rsp+8h] [rbp-78h] BYREF
unsigned int v43; // [rsp+Ch] [rbp-74h]
unsigned int *v44; // [rsp+10h] [rbp-70h]
long long v45; // [rsp+18h] [rbp-68h]
long long v46; // [rsp+20h] [rbp-60h]
unsigned int *v47; // [rsp+28h] [rbp-58h]
long long v48; // [rsp+30h] [rbp-50h]
unsigned int *v49; // [rsp+38h] [rbp-48h]
long long v50; // [rsp+40h] [rbp-40h]
unsigned int v51; // [rsp+4Ch] [rbp-34h] BYREF
_OWORD *v52; // [rsp+50h] [rbp-30h]
v2 = a2;
v3 = ma_alloc_dynamic((long long)(a1 + 6));
if ( !v3 )
return 1LL;
v4 = (_OWORD *)v3;
a1[4] = -1;
v5 = *((_QWORD *)a1 + 3);
v6 = a1[3];
v44 = a1;
v45 = v5;
v50 = a2;
if ( v6 >= 2 )
{
v7 = v6 >> 1;
v8 = a1[2] - v7;
v9 = 0;
v43 = v8;
v48 = 0LL;
v46 = 0LL;
v49 = 0LL;
v47 = 0LL;
do
{
v10 = v7;
v52 = v4;
v11 = 16LL * v8;
v12 = *(_QWORD *)(v5 + v11 + 8);
v13 = (long long ( *)(long long, unsigned int *, _QWORD))*((_QWORD *)v44 + 6);
if ( v13 )
{
v14 = v13(v12, &v51, 0LL);
v15 = v51;
}
else
{
v15 = v44[1];
v51 = v44[1];
v14 = *v44 + v12;
}
v16 = (*((long long ( **)(long long, long long))v44 + 8))(v14, v15);
if ( !v9 )
{
v17 = v44[3];
v18 = v16 & (v17 - 1);
v19 = v16 & ((v17 >> 1) - 1);
if ( v18 < v44[2] )
v19 = v18;
if ( v19 != v43 )
{
v4 = v52;
v2 = v50;
goto LABEL_31;
}
}
v5 = v45;
v20 = v45 + v11;
v7 = v10;
if ( (v10 & v16) != 0 )
{
if ( (v9 & 4) != 0 )
{
if ( (v9 & 8) == 0 )
{
v23 = v47;
*((_QWORD *)v47 + 1) = v46;
*v23 = v8;
v9 = v9 & 1 | 0xC;
}
v46 = *(_QWORD *)(v20 + 8);
v4 = v52;
v47 = (unsigned int *)v20;
}
else
{
v9 = v9 & 1 | 4;
v46 = *(_QWORD *)(v20 + 8);
v4 = (_OWORD *)v20;
v47 = (unsigned int *)v52;
}
}
else if ( (v9 & 1) != 0 )
{
if ( (v9 & 2) == 0 )
{
v24 = v49;
*((_QWORD *)v49 + 1) = v48;
*v24 = v8;
v9 = v9 & 4 | 3;
}
v48 = *(_QWORD *)(v20 + 8);
v4 = v52;
v49 = (unsigned int *)v20;
}
else
{
v21 = v9 & 4;
v48 = *(_QWORD *)(v20 + 8);
v4 = (_OWORD *)v20;
v22 = (unsigned int *)v52;
if ( !v21 )
{
v4 = v52;
v22 = (unsigned int *)v20;
}
v9 = (v21 >> 1) + 3;
v49 = v22;
}
v8 = *(_DWORD *)v20;
}
while ( *(_DWORD *)v20 != -1 );
if ( (v9 & 3) == 1 )
{
v25 = v49;
*((_QWORD *)v49 + 1) = v48;
*v25 = -1;
}
v2 = v50;
if ( (v9 & 0xC) == 4 )
{
v26 = v47;
*((_QWORD *)v47 + 1) = v46;
*v26 = -1;
}
}
LABEL_31:
v28 = (long long ( **)(long long, long long))v44;
v29 = (long long ( *)(long long, unsigned int *, _QWORD))*((_QWORD *)v44 + 6);
if ( v29 )
{
v30 = v29(v2, &v42, 0LL);
v31 = v42;
}
else
{
v31 = v44[1];
v42 = v44[1];
v30 = v2 + *v44;
}
v32 = v28[8](v30, v31);
v33 = *((_DWORD *)v28 + 3);
v34 = v32 & (v33 - 1);
v35 = v32 & ((v33 >> 1) - 1);
if ( v34 < *((_DWORD *)v28 + 2) + 1 )
v35 = v34;
v36 = v45 + 16 * v35;
if ( (_OWORD *)v36 == v4 )
{
*(_QWORD *)(v36 + 8) = v50;
*(_DWORD *)v36 = -1;
}
else
{
*v4 = *(_OWORD *)v36;
v37 = hash_rec_mask((unsigned int *)v28, *(_QWORD *)(v36 + 8), *((_DWORD *)v28 + 3), *((_DWORD *)v28 + 2) + 1);
*(_QWORD *)(v36 + 8) = v50;
if ( (_DWORD)v35 == v37 )
{
*(_DWORD *)v36 = ((unsigned long long)v4 - v45) >> 4;
}
else
{
*(_DWORD *)v36 = -1;
v38 = ((unsigned long long)v4 - v45) >> 4;
do
{
v39 = 16LL * v37;
v37 = *(_DWORD *)(v45 + v39);
}
while ( v37 != (_DWORD)v35 );
*(_DWORD *)(v39 + v45) = v38;
}
}
v40 = v44;
v41 = v44[2] + 1;
v44[2] = v41;
if ( v41 == v40[3] )
v40[3] = 2 * v41;
return 0LL;
}
|
ma_hashtbl_insert:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R14,RSI
MOV RBX,RDI
ADD RDI,0x18
CALL 0x0013242e
TEST RAX,RAX
JZ 0x00132bab
MOV R13,RAX
MOV dword ptr [RBX + 0x10],0xffffffff
MOV RCX,qword ptr [RBX + 0x18]
MOV EDX,dword ptr [RBX + 0xc]
CMP EDX,0x2
MOV qword ptr [RBP + -0x70],RBX
MOV qword ptr [RBP + -0x68],RCX
MOV qword ptr [RBP + -0x40],R14
JC 0x00132bba
MOV EBX,dword ptr [RBX + 0x8]
SHR EDX,0x1
SUB EBX,EDX
XOR R12D,R12D
MOV dword ptr [RBP + -0x74],EBX
MOV qword ptr [RBP + -0x50],0x0
MOV qword ptr [RBP + -0x60],0x0
MOV qword ptr [RBP + -0x48],0x0
MOV qword ptr [RBP + -0x58],0x0
LAB_00132a36:
MOV R14D,EDX
MOV qword ptr [RBP + -0x30],R13
MOV R15D,EBX
SHL R15,0x4
MOV RDI,qword ptr [RCX + R15*0x1 + 0x8]
MOV R13,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [R13 + 0x30]
TEST RAX,RAX
JZ 0x00132a66
LEA RSI,[RBP + -0x34]
XOR EDX,EDX
CALL RAX
MOV RDI,RAX
MOV ESI,dword ptr [RBP + -0x34]
JMP 0x00132a74
LAB_00132a66:
MOV ESI,dword ptr [R13 + 0x4]
MOV dword ptr [RBP + -0x34],ESI
MOV EAX,dword ptr [R13]
ADD RDI,RAX
LAB_00132a74:
CALL qword ptr [R13 + 0x40]
TEST R12D,R12D
JNZ 0x00132a9c
MOV ECX,dword ptr [R13 + 0xc]
LEA EDX,[RCX + -0x1]
AND EDX,EAX
SHR ECX,0x1
DEC ECX
AND ECX,EAX
CMP EDX,dword ptr [R13 + 0x8]
CMOVC ECX,EDX
CMP ECX,dword ptr [RBP + -0x74]
JNZ 0x00132bb2
LAB_00132a9c:
MOV RCX,qword ptr [RBP + -0x68]
ADD R15,RCX
MOV EDX,R14D
TEST EAX,R14D
JZ 0x00132ad1
TEST R12B,0x4
JNZ 0x00132b06
AND R12D,0x1
OR R12D,0x4
MOV RAX,qword ptr [R15 + 0x8]
MOV qword ptr [RBP + -0x60],RAX
MOV R13,R15
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x58],RAX
JMP 0x00132b60
LAB_00132ad1:
TEST R12B,0x1
JNZ 0x00132b34
AND R12D,0x4
MOV EAX,R12D
SHR EAX,0x1
ADD EAX,0x3
TEST R12D,R12D
MOV RSI,qword ptr [R15 + 0x8]
MOV qword ptr [RBP + -0x50],RSI
MOV R13,R15
MOV RSI,qword ptr [RBP + -0x30]
CMOVZ R13,RSI
CMOVZ RSI,R15
MOV R12D,EAX
MOV qword ptr [RBP + -0x48],RSI
JMP 0x00132b60
LAB_00132b06:
TEST R12B,0x8
JNZ 0x00132b22
MOV RAX,qword ptr [RBP + -0x60]
MOV RSI,qword ptr [RBP + -0x58]
MOV qword ptr [RSI + 0x8],RAX
MOV dword ptr [RSI],EBX
AND R12D,0x1
OR R12D,0xc
LAB_00132b22:
MOV RAX,qword ptr [R15 + 0x8]
MOV qword ptr [RBP + -0x60],RAX
MOV R13,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x58],R15
JMP 0x00132b60
LAB_00132b34:
TEST R12B,0x2
JNZ 0x00132b50
MOV RAX,qword ptr [RBP + -0x50]
MOV RSI,qword ptr [RBP + -0x48]
MOV qword ptr [RSI + 0x8],RAX
MOV dword ptr [RSI],EBX
AND R12D,0x4
OR R12D,0x3
LAB_00132b50:
MOV RAX,qword ptr [R15 + 0x8]
MOV qword ptr [RBP + -0x50],RAX
MOV R13,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x48],R15
LAB_00132b60:
MOV EBX,dword ptr [R15]
CMP EBX,-0x1
JNZ 0x00132a36
MOV EAX,R12D
AND EAX,0x3
CMP EAX,0x1
JNZ 0x00132b89
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RBP + -0x48]
MOV qword ptr [RCX + 0x8],RAX
MOV dword ptr [RCX],0xffffffff
LAB_00132b89:
AND R12D,0xc
CMP R12D,0x4
MOV R14,qword ptr [RBP + -0x40]
JNZ 0x00132bba
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x58]
MOV qword ptr [RCX + 0x8],RAX
MOV dword ptr [RCX],0xffffffff
JMP 0x00132bba
LAB_00132bab:
MOV AL,0x1
JMP 0x00132c9f
LAB_00132bb2:
MOV R13,qword ptr [RBP + -0x30]
MOV R14,qword ptr [RBP + -0x40]
LAB_00132bba:
MOV R15,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [R15 + 0x30]
TEST RAX,RAX
JZ 0x00132bde
LEA R12,[RBP + -0x78]
MOV RDI,R14
MOV RSI,R12
XOR EDX,EDX
CALL RAX
MOV RDI,RAX
MOV ESI,dword ptr [R12]
JMP 0x00132beb
LAB_00132bde:
MOV ESI,dword ptr [R15 + 0x4]
MOV dword ptr [RBP + -0x78],ESI
MOV EDI,dword ptr [R15]
ADD RDI,R14
LAB_00132beb:
CALL qword ptr [R15 + 0x40]
MOV ECX,dword ptr [R15 + 0x8]
MOV EBX,dword ptr [R15 + 0xc]
INC ECX
LEA EDX,[RBX + -0x1]
AND EDX,EAX
SHR EBX,0x1
DEC EBX
AND EBX,EAX
CMP EDX,ECX
CMOVC EBX,EDX
MOV R14,RBX
SHL R14,0x4
ADD R14,qword ptr [RBP + -0x68]
CMP R14,R13
JZ 0x00132c51
MOVUPS XMM0,xmmword ptr [R14]
MOVUPS xmmword ptr [R13],XMM0
MOV ECX,dword ptr [R15 + 0x8]
MOV EDX,dword ptr [R15 + 0xc]
INC ECX
MOV RSI,qword ptr [R14 + 0x8]
MOV RDI,R15
CALL 0x001328cc
MOV RCX,qword ptr [RBP + -0x40]
MOV qword ptr [R14 + 0x8],RCX
CMP EBX,EAX
JNZ 0x00132c62
SUB R13,qword ptr [RBP + -0x68]
SHR R13,0x4
MOV dword ptr [R14],R13D
JMP 0x00132c87
LAB_00132c51:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [R14 + 0x8],RAX
MOV dword ptr [R14],0xffffffff
JMP 0x00132c87
LAB_00132c62:
MOV dword ptr [R14],0xffffffff
MOV RDX,qword ptr [RBP + -0x68]
SUB R13,RDX
SHR R13,0x4
LAB_00132c74:
MOV ECX,EAX
SHL RCX,0x4
MOV EAX,dword ptr [RDX + RCX*0x1]
CMP EAX,EBX
JNZ 0x00132c74
ADD RDX,RCX
MOV dword ptr [RDX],R13D
LAB_00132c87:
MOV RCX,qword ptr [RBP + -0x70]
MOV EAX,dword ptr [RCX + 0x8]
INC EAX
MOV dword ptr [RCX + 0x8],EAX
CMP EAX,dword ptr [RCX + 0xc]
JNZ 0x00132c9d
ADD EAX,EAX
MOV dword ptr [RCX + 0xc],EAX
LAB_00132c9d:
XOR EAX,EAX
LAB_00132c9f:
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 ma_hashtbl_insert(uint *param_1,long param_2)
{
uint uVar1;
uint uVar2;
uint *puVar3;
long lVar4;
int8 uVar5;
ulong uVar6;
uint uVar7;
uint uVar8;
uint uVar9;
uint uVar10;
uint *puVar11;
uint *puVar12;
uint local_80;
uint local_7c;
uint *local_78;
long local_70;
int8 local_68;
uint *local_60;
int8 local_58;
uint *local_50;
long local_48;
uint local_3c;
uint *local_38;
puVar3 = (uint *)ma_alloc_dynamic(param_1 + 6);
if (puVar3 == (uint *)0x0) {
uVar5 = 1;
}
else {
param_1[4] = 0xffffffff;
local_70 = *(long *)(param_1 + 6);
local_78 = param_1;
local_48 = param_2;
if (1 < param_1[3]) {
uVar7 = param_1[3] >> 1;
uVar9 = param_1[2] - uVar7;
uVar10 = 0;
local_58 = 0;
local_68 = 0;
local_50 = (uint *)0x0;
local_60 = (uint *)0x0;
local_7c = uVar9;
do {
puVar12 = local_78;
lVar4 = *(long *)(local_70 + 8 + (ulong)uVar9 * 0x10);
local_38 = puVar3;
if (*(code **)(local_78 + 0xc) == (code *)0x0) {
local_3c = local_78[1];
lVar4 = lVar4 + (ulong)*local_78;
}
else {
lVar4 = (**(code **)(local_78 + 0xc))(lVar4,&local_3c,0);
}
uVar2 = (**(code **)(puVar12 + 0x10))(lVar4,local_3c);
if (uVar10 == 0) {
uVar8 = puVar12[3] - 1 & uVar2;
uVar1 = (puVar12[3] >> 1) - 1 & uVar2;
if (uVar8 < puVar12[2]) {
uVar1 = uVar8;
}
puVar3 = local_38;
if (uVar1 != local_7c) goto LAB_00132bba;
}
puVar12 = (uint *)((ulong)uVar9 * 0x10 + local_70);
puVar3 = puVar12;
if ((uVar2 & uVar7) == 0) {
if ((uVar10 & 1) == 0) {
uVar9 = uVar10 & 4;
uVar10 = (uVar9 >> 1) + 3;
local_58 = *(int8 *)(puVar12 + 2);
local_50 = local_38;
if (uVar9 == 0) {
puVar3 = local_38;
local_50 = puVar12;
}
}
else {
if ((uVar10 & 2) == 0) {
*(int8 *)(local_50 + 2) = local_58;
*local_50 = uVar9;
uVar10 = uVar10 & 4 | 3;
}
local_58 = *(int8 *)(puVar12 + 2);
puVar3 = local_38;
local_50 = puVar12;
}
}
else if ((uVar10 & 4) == 0) {
uVar10 = uVar10 & 1 | 4;
local_68 = *(int8 *)(puVar12 + 2);
local_60 = local_38;
}
else {
if ((uVar10 & 8) == 0) {
*(int8 *)(local_60 + 2) = local_68;
*local_60 = uVar9;
uVar10 = uVar10 & 1 | 0xc;
}
local_68 = *(int8 *)(puVar12 + 2);
puVar3 = local_38;
local_60 = puVar12;
}
uVar9 = *puVar12;
} while (uVar9 != 0xffffffff);
if ((uVar10 & 3) == 1) {
*(int8 *)(local_50 + 2) = local_58;
*local_50 = 0xffffffff;
}
if ((uVar10 & 0xc) == 4) {
*(int8 *)(local_60 + 2) = local_68;
*local_60 = 0xffffffff;
}
}
LAB_00132bba:
puVar12 = local_78;
if (*(code **)(local_78 + 0xc) == (code *)0x0) {
local_80 = local_78[1];
lVar4 = (ulong)*local_78 + local_48;
}
else {
lVar4 = (**(code **)(local_78 + 0xc))(local_48,&local_80,0);
}
uVar9 = (**(code **)(puVar12 + 0x10))(lVar4,local_80);
uVar10 = puVar12[3] - 1 & uVar9;
uVar9 = (puVar12[3] >> 1) - 1 & uVar9;
if (uVar10 < puVar12[2] + 1) {
uVar9 = uVar10;
}
puVar11 = (uint *)((ulong)uVar9 * 0x10 + local_70);
if (puVar11 == puVar3) {
*(long *)(puVar11 + 2) = local_48;
*puVar11 = 0xffffffff;
}
else {
uVar10 = puVar11[1];
uVar7 = puVar11[2];
uVar2 = puVar11[3];
*puVar3 = *puVar11;
puVar3[1] = uVar10;
puVar3[2] = uVar7;
puVar3[3] = uVar2;
uVar10 = hash_rec_mask(puVar12,*(int8 *)(puVar11 + 2),puVar12[3],puVar12[2] + 1);
*(long *)(puVar11 + 2) = local_48;
if (uVar9 == uVar10) {
*puVar11 = (uint)((ulong)((long)puVar3 - local_70) >> 4);
}
else {
*puVar11 = 0xffffffff;
do {
uVar6 = (ulong)uVar10;
uVar10 = *(uint *)(local_70 + uVar6 * 0x10);
} while (uVar10 != uVar9);
*(int *)(local_70 + uVar6 * 0x10) = (int)((ulong)((long)puVar3 - local_70) >> 4);
}
}
uVar9 = local_78[2] + 1;
local_78[2] = uVar9;
if (uVar9 == local_78[3]) {
local_78[3] = uVar9 * 2;
}
uVar5 = 0;
}
return uVar5;
}
|
|
63,322 |
mujoco::plugin::sdf::SdfDefault<mujoco::plugin::sdf::GearAttribute>::GetDefault(char const*, char const*)
|
aimrt_mujoco_sim/_deps/mujoco-src/plugin/sdf/sdf.h
|
mjtNum GetDefault(const char* name, const char* value) {
if (std::string(value).empty()) {
return default_[name];
}
try {
mjtNum num = std::stod(value);
return num;
} catch (const std::invalid_argument& e) {
mju_error("invalid attribute value for '%s'", name);
return 0;
}
}
|
O0
|
c
|
mujoco::plugin::sdf::SdfDefault<mujoco::plugin::sdf::GearAttribute>::GetDefault(char const*, char const*):
subq $0x118, %rsp # imm = 0x118
movq %rdi, 0x108(%rsp)
movq %rsi, 0x100(%rsp)
movq %rdx, 0xf8(%rsp)
movq 0x108(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0xf8(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0xd7(%rsp), %rdi
movq %rdi, 0x58(%rsp)
callq 0x19dd0
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
leaq 0xd8(%rsp), %rdi
callq 0x1c7d0
jmp 0x243e4
leaq 0xd8(%rsp), %rdi
callq 0x1a2b0
movb %al, 0x47(%rsp)
leaq 0xd8(%rsp), %rdi
callq 0x19e70
leaq 0xd7(%rsp), %rdi
callq 0x19de0
movb 0x47(%rsp), %al
testb $0x1, %al
jne 0x2441c
jmp 0x24517
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x100(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x9f(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x19dd0
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
leaq 0xa0(%rsp), %rdi
callq 0x1c7d0
jmp 0x2445e
movq 0x28(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x214e0
movq %rax, 0x20(%rsp)
jmp 0x24477
movq 0x20(%rsp), %rax
vmovsd (%rax), %xmm0
vmovsd %xmm0, 0x110(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x19e70
leaq 0x9f(%rsp), %rdi
callq 0x19de0
jmp 0x24642
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
leaq 0xd7(%rsp), %rdi
callq 0x19de0
jmp 0x24653
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
jmp 0x24505
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x19e70
leaq 0x9f(%rsp), %rdi
callq 0x19de0
jmp 0x24653
movq 0xf8(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x19dd0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x70(%rsp), %rdi
callq 0x1c7d0
jmp 0x24549
xorl %eax, %eax
movl %eax, %esi
leaq 0x70(%rsp), %rdi
callq 0x1a2c0
vmovsd %xmm0, 0x8(%rsp)
jmp 0x2455f
leaq 0x70(%rsp), %rdi
callq 0x19e70
leaq 0x6f(%rsp), %rdi
callq 0x19de0
vmovsd 0x8(%rsp), %xmm0
vmovsd %xmm0, 0x90(%rsp)
vmovsd 0x90(%rsp), %xmm0
vmovsd %xmm0, 0x110(%rsp)
jmp 0x24642
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
jmp 0x245cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x19e70
leaq 0x6f(%rsp), %rdi
callq 0x19de0
movl 0xc4(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x24653
movq 0xc8(%rsp), %rdi
callq 0x1a020
movq %rax, 0x60(%rsp)
movq 0x100(%rsp), %rsi
leaq 0xede1b(%rip), %rdi # 0x112423
xorl %eax, %eax
callq 0x1a2d0
jmp 0x24611
vxorps %xmm0, %xmm0, %xmm0
vmovsd %xmm0, 0x110(%rsp)
callq 0x1a050
jmp 0x24642
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
callq 0x1a050
jmp 0x24640
jmp 0x24653
vmovsd 0x110(%rsp), %xmm0
addq $0x118, %rsp # imm = 0x118
retq
movq 0xc8(%rsp), %rdi
callq 0x19e80
movq %rax, %rdi
callq 0x1d880
nopl (%rax,%rax)
|
_ZN6mujoco6plugin3sdf10SdfDefaultINS1_13GearAttributeEE10GetDefaultEPKcS6_:
sub rsp, 118h
mov [rsp+118h+var_10], rdi
mov [rsp+118h+var_18], rsi
mov [rsp+118h+var_20], rdx
mov rax, [rsp+118h+var_10]
mov [rsp+118h+var_D0], rax
mov rax, [rsp+118h+var_20]
mov [rsp+118h+var_C8], rax
lea rdi, [rsp+118h+var_41]
mov [rsp+118h+var_C0], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rsi, [rsp+118h+var_C8]
mov rdx, [rsp+118h+var_C0]
lea rdi, [rsp+118h+var_40]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_243E4:
lea rdi, [rsp+118h+var_40]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
mov [rsp+118h+var_D1], al
lea rdi, [rsp+118h+var_40]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+118h+var_41]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
mov al, [rsp+118h+var_D1]
test al, 1
jnz short loc_2441C
jmp loc_24517
loc_2441C:
mov rax, [rsp+118h+var_D0]
mov [rsp+118h+var_F0], rax
mov rax, [rsp+118h+var_18]
mov [rsp+118h+var_E8], rax
lea rdi, [rsp+118h+var_79]
mov [rsp+118h+var_E0], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rsi, [rsp+118h+var_E8]
mov rdx, [rsp+118h+var_E0]
lea rdi, [rsp+118h+var_78]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_2445E:
mov rdi, [rsp+118h+var_F0]
lea rsi, [rsp+118h+var_78]
call _ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEdSt4lessIS5_ESaISt4pairIKS5_dEEEixEOS5_; std::map<std::string,double>::operator[](std::string&&)
mov [rsp+118h+var_F8], rax
jmp short $+2
loc_24477:
mov rax, [rsp+118h+var_F8]
vmovsd xmm0, qword ptr [rax]
vmovsd [rsp+118h+var_8], xmm0
lea rdi, [rsp+118h+var_78]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+118h+var_79]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_24642
mov rcx, rax
mov eax, edx
mov [rsp+118h+var_50], rcx
mov [rsp+118h+var_54], eax
lea rdi, [rsp+118h+var_41]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_24653
mov rcx, rax
mov eax, edx
mov [rsp+118h+var_50], rcx
mov [rsp+118h+var_54], eax
jmp short loc_24505
mov rcx, rax
mov eax, edx
mov [rsp+118h+var_50], rcx
mov [rsp+118h+var_54], eax
lea rdi, [rsp+118h+var_78]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_24505:
lea rdi, [rsp+118h+var_79]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_24653
loc_24517:
mov rax, [rsp+118h+var_20]
mov [rsp+118h+var_108], rax
lea rdi, [rsp+118h+var_A9]
mov [rsp+118h+var_100], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rsi, [rsp+118h+var_108]
mov rdx, [rsp+118h+var_100]
lea rdi, [rsp+118h+var_A8]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_24549:
xor eax, eax
mov esi, eax
lea rdi, [rsp+118h+var_A8]
call __ZNSt7__cxx114stodERKNS_12basic_stringIcSt11char_traitsIcESaIcEEEPm; std::stod(std::string const&,ulong *)
vmovsd [rsp+118h+var_110], xmm0
jmp short $+2
loc_2455F:
lea rdi, [rsp+118h+var_A8]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+118h+var_A9]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
vmovsd xmm0, [rsp+118h+var_110]
vmovsd [rsp+118h+var_88], xmm0
vmovsd xmm0, [rsp+118h+var_88]
vmovsd [rsp+118h+var_8], xmm0
jmp loc_24642
mov rcx, rax
mov eax, edx
mov [rsp+118h+var_50], rcx
mov [rsp+118h+var_54], eax
jmp short loc_245CD
mov rcx, rax
mov eax, edx
mov [rsp+118h+var_50], rcx
mov [rsp+118h+var_54], eax
lea rdi, [rsp+118h+var_A8]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_245CD:
lea rdi, [rsp+118h+var_A9]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
mov eax, [rsp+118h+var_54]
mov ecx, 1
cmp eax, ecx
jnz short loc_24653
mov rdi, [rsp+118h+var_50]; void *
call ___cxa_begin_catch
mov [rsp+118h+var_B8], rax
mov rsi, [rsp+118h+var_18]
lea rdi, aInvalidAttribu; "invalid attribute value for '%s'"
xor eax, eax
call _mju_error
jmp short $+2
loc_24611:
vxorps xmm0, xmm0, xmm0
vmovsd [rsp+118h+var_8], xmm0
call ___cxa_end_catch
jmp short loc_24642
mov rcx, rax
mov eax, edx
mov [rsp+118h+var_50], rcx
mov [rsp+118h+var_54], eax
call ___cxa_end_catch
jmp short $+2
loc_24640:
jmp short loc_24653
loc_24642:
vmovsd xmm0, [rsp+118h+var_8]
add rsp, 118h
retn
loc_24653:
mov rdi, [rsp+118h+var_50]
call __Unwind_Resume
mov rdi, rax
call __clang_call_terminate
|
__int128 __usercall mujoco::plugin::sdf::SdfDefault<mujoco::plugin::sdf::GearAttribute>::GetDefault@<xmm0>(
long long a1@<rdi>,
long long a2@<rsi>,
long long a3@<rdx>,
__m128 _XMM0@<xmm0>)
{
__int128 result; // xmm0
long long v10; // [rsp+10h] [rbp-108h]
long long v11; // [rsp+30h] [rbp-E8h]
char v12; // [rsp+47h] [rbp-D1h]
char v14; // [rsp+6Fh] [rbp-A9h] BYREF
_BYTE v15[32]; // [rsp+70h] [rbp-A8h] BYREF
char v17; // [rsp+9Fh] [rbp-79h] BYREF
_BYTE v18[36]; // [rsp+A0h] [rbp-78h] BYREF
char v19; // [rsp+D7h] [rbp-41h] BYREF
_BYTE v20[32]; // [rsp+D8h] [rbp-40h] BYREF
long long v21; // [rsp+F8h] [rbp-20h]
long long v22; // [rsp+100h] [rbp-18h]
long long v23; // [rsp+108h] [rbp-10h]
v23 = a1;
v22 = a2;
v21 = a3;
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>((long long)v20, a3, (long long)&v19);
v12 = std::string::empty(v20);
std::string::~string(v20);
std::allocator<char>::~allocator(&v19);
if ( (v12 & 1) != 0 )
{
v11 = v22;
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>((long long)v18, v11, (long long)&v17);
_RAX = std::map<std::string,double>::operator[](a1, (long long)v18);
__asm
{
vmovsd xmm0, qword ptr [rax]
vmovsd [rsp+118h+var_8], xmm0
}
std::string::~string(v18);
std::allocator<char>::~allocator(&v17);
}
else
{
v10 = v21;
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>((long long)v15, v10, (long long)&v14);
*(double *)_XMM0.m128_u64 = std::stod(v15, 0LL);
__asm { vmovsd [rsp+118h+var_110], xmm0 }
std::string::~string(v15);
std::allocator<char>::~allocator(&v14);
__asm
{
vmovsd xmm0, [rsp+118h+var_110]
vmovsd [rsp+118h+var_88], xmm0
vmovsd xmm0, [rsp+118h+var_88]
vmovsd [rsp+118h+var_8], xmm0
}
}
__asm { vmovsd xmm0, [rsp+118h+var_8] }
return result;
}
|
GetDefault:
SUB RSP,0x118
MOV qword ptr [RSP + 0x108],RDI
MOV qword ptr [RSP + 0x100],RSI
MOV qword ptr [RSP + 0xf8],RDX
MOV RAX,qword ptr [RSP + 0x108]
MOV qword ptr [RSP + 0x48],RAX
MOV RAX,qword ptr [RSP + 0xf8]
MOV qword ptr [RSP + 0x50],RAX
LEA RDI,[RSP + 0xd7]
MOV qword ptr [RSP + 0x58],RDI
CALL 0x00119dd0
MOV RSI,qword ptr [RSP + 0x50]
MOV RDX,qword ptr [RSP + 0x58]
LAB_001243d5:
LEA RDI,[RSP + 0xd8]
CALL 0x0011c7d0
JMP 0x001243e4
LAB_001243e4:
LEA RDI,[RSP + 0xd8]
CALL 0x0011a2b0
MOV byte ptr [RSP + 0x47],AL
LEA RDI,[RSP + 0xd8]
CALL 0x00119e70
LEA RDI,[RSP + 0xd7]
CALL 0x00119de0
MOV AL,byte ptr [RSP + 0x47]
TEST AL,0x1
JNZ 0x0012441c
JMP 0x00124517
LAB_0012441c:
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x28],RAX
MOV RAX,qword ptr [RSP + 0x100]
MOV qword ptr [RSP + 0x30],RAX
LEA RDI,[RSP + 0x9f]
MOV qword ptr [RSP + 0x38],RDI
CALL 0x00119dd0
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x38]
LAB_0012444f:
LEA RDI,[RSP + 0xa0]
CALL 0x0011c7d0
JMP 0x0012445e
LAB_0012445e:
MOV RDI,qword ptr [RSP + 0x28]
LEA RSI,[RSP + 0xa0]
CALL 0x001214e0
MOV qword ptr [RSP + 0x20],RAX
JMP 0x00124477
LAB_00124477:
MOV RAX,qword ptr [RSP + 0x20]
VMOVSD XMM0,qword ptr [RAX]
VMOVSD qword ptr [RSP + 0x110],XMM0
LEA RDI,[RSP + 0xa0]
CALL 0x00119e70
LEA RDI,[RSP + 0x9f]
CALL 0x00119de0
JMP 0x00124642
LAB_00124517:
MOV RAX,qword ptr [RSP + 0xf8]
MOV qword ptr [RSP + 0x10],RAX
LEA RDI,[RSP + 0x6f]
MOV qword ptr [RSP + 0x18],RDI
CALL 0x00119dd0
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x18]
LAB_0012453d:
LEA RDI,[RSP + 0x70]
CALL 0x0011c7d0
JMP 0x00124549
LAB_00124549:
XOR EAX,EAX
MOV ESI,EAX
LEA RDI,[RSP + 0x70]
CALL 0x0011a2c0
LAB_00124557:
VMOVSD qword ptr [RSP + 0x8],XMM0
JMP 0x0012455f
LAB_0012455f:
LEA RDI,[RSP + 0x70]
CALL 0x00119e70
LEA RDI,[RSP + 0x6f]
CALL 0x00119de0
VMOVSD XMM0,qword ptr [RSP + 0x8]
VMOVSD qword ptr [RSP + 0x90],XMM0
VMOVSD XMM0,qword ptr [RSP + 0x90]
VMOVSD qword ptr [RSP + 0x110],XMM0
JMP 0x00124642
LAB_00124642:
VMOVSD XMM0,qword ptr [RSP + 0x110]
ADD RSP,0x118
RET
|
/* mujoco::plugin::sdf::SdfDefault<mujoco::plugin::sdf::GearAttribute>::GetDefault(char const*, char
const*) */
int8 __thiscall
mujoco::plugin::sdf::SdfDefault<mujoco::plugin::sdf::GearAttribute>::GetDefault
(SdfDefault<mujoco::plugin::sdf::GearAttribute> *this,char *param_1,char *param_2)
{
char *pcVar1;
char *pcVar2;
byte bVar3;
int8 *puVar4;
int8 uVar5;
allocator local_a9;
string local_a8 [47];
allocator local_79;
string local_78 [55];
allocator local_41;
string local_40 [32];
char *local_20;
char *local_18;
SdfDefault<mujoco::plugin::sdf::GearAttribute> *local_10;
int8 local_8;
local_20 = param_2;
local_18 = param_1;
local_10 = this;
std::allocator<char>::allocator();
/* try { // try from 001243d5 to 001243e1 has its CatchHandler @ 001244a8 */
std::__cxx11::string::string<std::allocator<char>>(local_40,param_2,&local_41);
bVar3 = std::__cxx11::string::empty();
std::__cxx11::string::~string(local_40);
std::allocator<char>::~allocator((allocator<char> *)&local_41);
pcVar2 = local_18;
pcVar1 = local_20;
if ((bVar3 & 1) == 0) {
std::allocator<char>::allocator();
/* try { // try from 0012453d to 00124546 has its CatchHandler @ 00124599 */
std::__cxx11::string::string<std::allocator<char>>(local_a8,pcVar1,&local_a9);
/* try { // try from 00124549 to 00124556 has its CatchHandler @ 001245af */
uVar5 = std::__cxx11::stod(local_a8,(ulong *)0x0);
std::__cxx11::string::~string(local_a8);
std::allocator<char>::~allocator((allocator<char> *)&local_a9);
local_8 = uVar5;
}
else {
std::allocator<char>::allocator();
/* try { // try from 0012444f to 0012445b has its CatchHandler @ 001244ce */
std::__cxx11::string::string<std::allocator<char>>(local_78,pcVar2,&local_79);
/* try { // try from 0012445e to 0012446f has its CatchHandler @ 001244e4 */
puVar4 = (int8 *)
std::
map<std::__cxx11::string,double,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,double>>>
::operator[]((map<std::__cxx11::string,double,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,double>>>
*)this,local_78);
local_8 = *puVar4;
std::__cxx11::string::~string(local_78);
std::allocator<char>::~allocator((allocator<char> *)&local_79);
}
return local_8;
}
|
|
63,323 |
mujoco::plugin::sdf::SdfDefault<mujoco::plugin::sdf::GearAttribute>::GetDefault(char const*, char const*)
|
aimrt_mujoco_sim/_deps/mujoco-src/plugin/sdf/sdf.h
|
mjtNum GetDefault(const char* name, const char* value) {
if (std::string(value).empty()) {
return default_[name];
}
try {
mjtNum num = std::stod(value);
return num;
} catch (const std::invalid_argument& e) {
mju_error("invalid attribute value for '%s'", name);
return 0;
}
}
|
O3
|
c
|
mujoco::plugin::sdf::SdfDefault<mujoco::plugin::sdf::GearAttribute>::GetDefault(char const*, char const*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r12
leaq 0x30(%rsp), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0xba4e
movq (%r12), %rdi
movq 0x8(%r12), %r12
leaq 0x20(%rsp), %r13
cmpq %r13, %rdi
je 0xeb2c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xa910
testq %r12, %r12
je 0xeb86
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r15, %rsi
callq 0xba4e
movq 0x10(%rsp), %r14
callq 0xaa90
movq %rax, %r15
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x30(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0xa900
cmpq %r14, (%r12)
je 0xebe0
movl (%r15), %eax
testl %eax, %eax
je 0xebab
cmpl $0x22, %eax
jne 0xebae
leaq 0x3bc9f(%rip), %rdi # 0x4a820
callq 0xaaa0
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movq %rbx, %rsi
callq 0xba4e
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0xcdee
vmovsd (%rax), %xmm0
jmp 0xebae
movl %ebp, (%r15)
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xebd1
movq 0x20(%rsp), %rsi
incq %rsi
vmovsd %xmm0, 0x8(%rsp)
callq 0xa910
vmovsd 0x8(%rsp), %xmm0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3bc39(%rip), %rdi # 0x4a820
callq 0xaab0
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xec0b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xa910
jmp 0xec0b
movq %rax, %r14
movq %r14, %rdi
callq 0xa950
movq %rdx, %r12
movq %rax, %r14
jmp 0xec41
movq %rdx, %r12
movq %rax, %r14
cmpl $0x0, (%r15)
jne 0xec2a
movl %ebp, (%r15)
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xec41
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xa910
cmpl $0x1, %r12d
jne 0xec0b
movq %r14, %rdi
callq 0xaac0
leaq 0x3bba9(%rip), %rdi # 0x4a7ff
movq %rbx, %rsi
xorl %eax, %eax
callq 0xaad0
callq 0xaae0
vxorps %xmm0, %xmm0, %xmm0
jmp 0xebd1
movq %rax, %r14
callq 0xaae0
jmp 0xec0b
movq %rax, %rdi
callq 0xcb19
|
_ZN6mujoco6plugin3sdf10SdfDefaultINS1_12NutAttributeEE10GetDefaultEPKcS6_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r15, rdx
mov rbx, rsi
mov r14, rdi
lea r12, [rsp+68h+var_58]
lea rdx, [rsp+68h+var_38]
mov rdi, r12
mov rsi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov rdi, [r12]; void *
mov r12, [r12+8]
lea r13, [rsp+68h+var_48]
cmp rdi, r13
jz short loc_EB2C
mov rsi, [rsp+68h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_EB2C:
test r12, r12
jz short loc_EB86
lea rdi, [rsp+68h+var_58]
lea rdx, [rsp+68h+var_61]
mov rsi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov r14, [rsp+68h+var_58]
call ___errno_location
mov r15, rax
mov ebp, [rax]
mov dword ptr [rax], 0
lea r12, [rsp+68h+var_38]
mov rdi, r14
mov rsi, r12
call _strtod
cmp [r12], r14
jz short loc_EBE0
mov eax, [r15]
test eax, eax
jz short loc_EBAB
cmp eax, 22h ; '"'
jnz short loc_EBAE
lea rdi, aStod; "stod"
call __ZSt20__throw_out_of_rangePKc; std::__throw_out_of_range(char const*)
loc_EB86:
lea rdi, [rsp+68h+var_58]
lea rdx, [rsp+68h+var_38]
mov rsi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rsi, [rsp+68h+var_58]
mov rdi, r14
call _ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEdSt4lessIS5_ESaISt4pairIKS5_dEEEixEOS5_; std::map<std::string,double>::operator[](std::string&&)
vmovsd xmm0, qword ptr [rax]
jmp short loc_EBAE
loc_EBAB:
mov [r15], ebp
loc_EBAE:
mov rdi, [rsp+68h+var_58]; void *
cmp rdi, r13
jz short loc_EBD1
mov rsi, [rsp+68h+var_48]
inc rsi; unsigned __int64
vmovsd [rsp+68h+var_60], xmm0
call __ZdlPvm; operator delete(void *,ulong)
vmovsd xmm0, [rsp+68h+var_60]
loc_EBD1:
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_EBE0:
lea rdi, aStod; "stod"
call __ZSt24__throw_invalid_argumentPKc; std::__throw_invalid_argument(char const*)
mov r14, rax
mov rdi, [rsp+68h+var_58]; void *
cmp rdi, r13
jz short loc_EC0B
mov rsi, [rsp+68h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_EC0B
mov r14, rax
loc_EC0B:
mov rdi, r14
call __Unwind_Resume
mov r12, rdx
mov r14, rax
jmp short loc_EC41
mov r12, rdx
mov r14, rax
cmp dword ptr [r15], 0
jnz short loc_EC2A
mov [r15], ebp
loc_EC2A:
mov rdi, [rsp+68h+var_58]; void *
cmp rdi, r13
jz short loc_EC41
mov rsi, [rsp+68h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_EC41:
cmp r12d, 1
jnz short loc_EC0B
mov rdi, r14; void *
call ___cxa_begin_catch
lea rdi, aInvalidAttribu; "invalid attribute value for '%s'"
mov rsi, rbx
xor eax, eax
call _mju_error
call ___cxa_end_catch
vxorps xmm0, xmm0, xmm0
jmp loc_EBD1
mov r14, rax
call ___cxa_end_catch
jmp short loc_EC0B
mov rdi, rax
call __clang_call_terminate
|
__m128 mujoco::plugin::sdf::SdfDefault<mujoco::plugin::sdf::NutAttribute>::GetDefault(
long long a1,
long long a2,
long long a3,
__m128 result)
{
void *v5; // r12
void *v6; // r14
int *v7; // r15
int v8; // ebp
long long v10; // r14
void *v12[2]; // [rsp+10h] [rbp-58h] BYREF
_QWORD v13[2]; // [rsp+20h] [rbp-48h] BYREF
void *v14; // [rsp+30h] [rbp-38h] BYREF
std::string::basic_string<std::allocator<char>>(v12, a3);
v5 = v12[1];
if ( v12[0] != v13 )
operator delete(v12[0], v13[0] + 1LL);
if ( v5 )
{
std::string::basic_string<std::allocator<char>>(v12, a3);
v6 = v12[0];
v7 = (int *)__errno_location();
v8 = *v7;
*v7 = 0;
strtod(v6, &v14);
if ( v14 == v6 )
{
v10 = std::__throw_invalid_argument("stod");
if ( v12[0] != v13 )
operator delete(v12[0], v13[0] + 1LL);
_Unwind_Resume(v10);
}
if ( *v7 )
{
if ( *v7 == 34 )
std::__throw_out_of_range("stod");
}
else
{
*v7 = v8;
}
}
else
{
std::string::basic_string<std::allocator<char>>(v12, a2);
_RAX = std::map<std::string,double>::operator[](a1, (long long)v12);
__asm { vmovsd xmm0, qword ptr [rax] }
}
if ( v12[0] != v13 )
{
__asm { vmovsd [rsp+68h+var_60], xmm0 }
operator delete(v12[0], v13[0] + 1LL);
__asm { vmovsd xmm0, [rsp+68h+var_60] }
}
return result;
}
|
GetDefault:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R15,RDX
MOV RBX,RSI
MOV R14,RDI
LEA R12,[RSP + 0x10]
LEA RDX,[RSP + 0x30]
MOV RDI,R12
MOV RSI,R15
CALL 0x0010ba4e
MOV RDI,qword ptr [R12]
MOV R12,qword ptr [R12 + 0x8]
LEA R13,[RSP + 0x20]
CMP RDI,R13
JZ 0x0010eb2c
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
CALL 0x0010a910
LAB_0010eb2c:
TEST R12,R12
JZ 0x0010eb86
LAB_0010eb31:
LEA RDI,[RSP + 0x10]
LEA RDX,[RSP + 0x7]
MOV RSI,R15
CALL 0x0010ba4e
MOV R14,qword ptr [RSP + 0x10]
CALL 0x0010aa90
MOV R15,RAX
MOV EBP,dword ptr [RAX]
MOV dword ptr [RAX],0x0
LEA R12,[RSP + 0x30]
MOV RDI,R14
MOV RSI,R12
CALL 0x0010a900
CMP qword ptr [R12],R14
JZ 0x0010ebe0
MOV EAX,dword ptr [R15]
TEST EAX,EAX
JZ 0x0010ebab
CMP EAX,0x22
JNZ 0x0010ebae
LAB_0010eb7a:
LEA RDI,[0x14a820]
CALL 0x0010aaa0
LAB_0010eb86:
LEA RDI,[RSP + 0x10]
LEA RDX,[RSP + 0x30]
MOV RSI,RBX
CALL 0x0010ba4e
LAB_0010eb98:
LEA RSI,[RSP + 0x10]
MOV RDI,R14
CALL 0x0010cdee
VMOVSD XMM0,qword ptr [RAX]
JMP 0x0010ebae
LAB_0010ebab:
MOV dword ptr [R15],EBP
LAB_0010ebae:
MOV RDI,qword ptr [RSP + 0x10]
CMP RDI,R13
JZ 0x0010ebd1
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
VMOVSD qword ptr [RSP + 0x8],XMM0
CALL 0x0010a910
VMOVSD XMM0,qword ptr [RSP + 0x8]
LAB_0010ebd1:
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0010ebe0:
LEA RDI,[0x14a820]
CALL 0x0010aab0
LAB_0010ebec:
MOV R14,RAX
MOV RDI,qword ptr [RSP + 0x10]
CMP RDI,R13
JZ 0x0010ec0b
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
CALL 0x0010a910
JMP 0x0010ec0b
LAB_0010ec0b:
MOV RDI,R14
CALL 0x0010a950
|
/* mujoco::plugin::sdf::SdfDefault<mujoco::plugin::sdf::NutAttribute>::GetDefault(char const*, char
const*) */
double __thiscall
mujoco::plugin::sdf::SdfDefault<mujoco::plugin::sdf::NutAttribute>::GetDefault
(SdfDefault<mujoco::plugin::sdf::NutAttribute> *this,char *param_1,char *param_2)
{
int iVar1;
int *piVar2;
double *pdVar3;
int8 uVar4;
allocator local_61;
double local_60;
map<std::__cxx11::string,double,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,double>>>
*local_58;
long local_50;
long local_48 [2];
map<std::__cxx11::string,double,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,double>>>
*local_38;
std::__cxx11::string::string<std::allocator<char>>
((string *)&local_58,param_2,(allocator *)&local_38);
if (local_58 !=
(map<std::__cxx11::string,double,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,double>>>
*)local_48) {
operator_delete(local_58,local_48[0] + 1);
}
if (local_50 != 0) {
/* try { // try from 0010eb31 to 0010eb42 has its CatchHandler @ 0010ec13 */
std::__cxx11::string::string<std::allocator<char>>((string *)&local_58,param_2,&local_61);
this = (SdfDefault<mujoco::plugin::sdf::NutAttribute> *)local_58;
piVar2 = __errno_location();
iVar1 = *piVar2;
*piVar2 = 0;
local_60 = strtod((char *)this,(char **)&local_38);
if (local_38 ==
(map<std::__cxx11::string,double,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,double>>>
*)this) {
/* try { // try from 0010ebe0 to 0010ebeb has its CatchHandler @ 0010ec1b */
uVar4 = std::__throw_invalid_argument("stod");
/* catch() { ... } // from try @ 0010eb98 with catch @ 0010ebec */
if (local_58 !=
(map<std::__cxx11::string,double,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,double>>>
*)local_48) {
operator_delete(local_58,local_48[0] + 1);
}
/* WARNING: Subroutine does not return */
_Unwind_Resume(uVar4);
}
if (*piVar2 == 0) {
*piVar2 = iVar1;
goto LAB_0010ebae;
}
if (*piVar2 != 0x22) goto LAB_0010ebae;
/* try { // try from 0010eb7a to 0010eb85 has its CatchHandler @ 0010ec1b */
std::__throw_out_of_range("stod");
}
/* try { // try from 0010eb86 to 0010eb97 has its CatchHandler @ 0010ec08 */
std::__cxx11::string::string<std::allocator<char>>
((string *)&local_58,param_1,(allocator *)&local_38);
/* try { // try from 0010eb98 to 0010eba4 has its CatchHandler @ 0010ebec */
pdVar3 = (double *)
std::
map<std::__cxx11::string,double,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,double>>>
::operator[]((map<std::__cxx11::string,double,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,double>>>
*)this,(string *)&local_58);
local_60 = *pdVar3;
LAB_0010ebae:
if (local_58 !=
(map<std::__cxx11::string,double,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,double>>>
*)local_48) {
operator_delete(local_58,local_48[0] + 1);
}
return local_60;
}
|
|
63,324 |
pagecache_unpin
|
eloqsql/storage/maria/ma_pagecache.c
|
void pagecache_unpin(PAGECACHE *pagecache,
PAGECACHE_FILE *file,
pgcache_page_no_t pageno,
LSN lsn)
{
PAGECACHE_BLOCK_LINK *block;
int page_st;
DBUG_ENTER("pagecache_unpin");
DBUG_PRINT("enter", ("fd: %u page: %lu",
(uint) file->file, (ulong) pageno));
pagecache_pthread_mutex_lock(&pagecache->cache_lock);
/*
As soon as we keep lock cache can be used, and we have lock bacause want
aunlock.
*/
DBUG_ASSERT(pagecache->can_be_used);
inc_counter_for_resize_op(pagecache);
/* See NOTE for pagecache_unlock about registering requests */
block= find_block(pagecache, file, pageno, 0, 0, 0, 0, FALSE, &page_st);
DBUG_ASSERT(block != 0);
DBUG_ASSERT(page_st == PAGE_READ);
/* we can't unpin such page without unlock */
DBUG_ASSERT((block->status & PCBLOCK_DIRECT_W) == 0);
if (lsn != LSN_IMPOSSIBLE)
check_and_set_lsn(pagecache, lsn, block);
/*
we can just unpin only with keeping read lock because:
a) we can't pin without any lock
b) we can't unpin keeping write lock
*/
if (make_lock_and_pin(pagecache, block,
PAGECACHE_LOCK_LEFT_READLOCKED,
PAGECACHE_UNPIN, FALSE))
DBUG_ASSERT(0); /* should not happend */
remove_reader(block);
/*
Link the block into the LRU chain if it's the last submitted request
for the block and block will not be pinned.
See NOTE for pagecache_unlock about registering requests
*/
unreg_request(pagecache, block, 1);
dec_counter_for_resize_op(pagecache);
pagecache_pthread_mutex_unlock(&pagecache->cache_lock);
DBUG_VOID_RETURN;
}
|
O0
|
c
|
pagecache_unpin:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0x63fea
movq -0x8(%rbp), %rdi
addq $0xc8, %rdi
leaq 0xbbd02(%rip), %rsi # 0x11fcfe
movl $0xcef, %edx # imm = 0xCEF
callq 0x62e90
jmp 0x64008
movq -0x8(%rbp), %rdi
callq 0x63240
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %r9d, %r9d
leaq -0x2c(%rbp), %rax
movl %r9d, %ecx
movl %r9d, %r8d
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x63260
movq %rax, -0x28(%rbp)
jmp 0x64049
jmp 0x6404b
jmp 0x6404d
jmp 0x6404f
jmp 0x64051
cmpq $0x0, -0x20(%rbp)
je 0x64069
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x63ab0
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x1, %edx
movl $0x3, %ecx
xorl %r8d, %r8d
callq 0x63c50
cmpb $0x0, %al
je 0x6408d
jmp 0x64089
jmp 0x6408b
jmp 0x6408d
movq -0x28(%rbp), %rdi
callq 0x63da0
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x1, %edx
callq 0x63df0
movq -0x8(%rbp), %rdi
callq 0x63f70
movq -0x8(%rbp), %rdi
addq $0xc8, %rdi
callq 0x62f00
jmp 0x640c3
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
|
pagecache_unpin:
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
jmp short $+2
loc_63FEA:
mov rdi, [rbp+var_8]
add rdi, 0C8h
lea rsi, aWorkspaceLlm4b_15; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 0CEFh
call inline_mysql_mutex_lock_8
jmp short $+2
loc_64008:
mov rdi, [rbp+var_8]
call inc_counter_for_resize_op
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
xor r9d, r9d
lea rax, [rbp+var_2C]
mov ecx, r9d
mov r8d, r9d
mov [rsp+50h+var_50], 0
mov [rsp+50h+var_48], 0
mov [rsp+50h+var_40], rax
call find_block
mov [rbp+var_28], rax
jmp short $+2
loc_64049:
jmp short $+2
loc_6404B:
jmp short $+2
loc_6404D:
jmp short $+2
loc_6404F:
jmp short $+2
loc_64051:
cmp [rbp+var_20], 0
jz short loc_64069
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
call check_and_set_lsn
loc_64069:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_28]
mov edx, 1
mov ecx, 3
xor r8d, r8d
call make_lock_and_pin
cmp al, 0
jz short loc_6408D
jmp short $+2
loc_64089:
jmp short $+2
loc_6408B:
jmp short $+2
loc_6408D:
mov rdi, [rbp+var_28]
call remove_reader
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_28]
mov edx, 1
call unreg_request
mov rdi, [rbp+var_8]
call dec_counter_for_resize_op
mov rdi, [rbp+var_8]
add rdi, 0C8h
call inline_mysql_mutex_unlock_8
jmp short $+2
loc_640C3:
add rsp, 50h
pop rbp
retn
|
long long pagecache_unpin(_QWORD *a1, long long a2, long long a3, long long a4)
{
int v5; // [rsp+24h] [rbp-2Ch] BYREF
long long block; // [rsp+28h] [rbp-28h]
long long v7; // [rsp+30h] [rbp-20h]
long long v8; // [rsp+38h] [rbp-18h]
long long v9; // [rsp+40h] [rbp-10h]
_QWORD *v10; // [rsp+48h] [rbp-8h]
v10 = a1;
v9 = a2;
v8 = a3;
v7 = a4;
inline_mysql_mutex_lock_8(
(long long)(a1 + 25),
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0xCEFu);
inc_counter_for_resize_op((long long)a1);
block = find_block((long long)a1, a2, v8, 0, 0, 0, 0, 0, &v5);
if ( v7 )
check_and_set_lsn((long long)v10, v7, block);
make_lock_and_pin((long long)v10, block, 1, 3, 0);
remove_reader(block);
unreg_request(v10, block, 1);
dec_counter_for_resize_op((long long)v10);
return inline_mysql_mutex_unlock_8((long long)(v10 + 25));
}
|
pagecache_unpin:
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
JMP 0x00163fea
LAB_00163fea:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc8
LEA RSI,[0x21fcfe]
MOV EDX,0xcef
CALL 0x00162e90
JMP 0x00164008
LAB_00164008:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00163240
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
XOR R9D,R9D
LEA RAX,[RBP + -0x2c]
MOV ECX,R9D
MOV R8D,R9D
MOV dword ptr [RSP],0x0
MOV dword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP + 0x10],RAX
CALL 0x00163260
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00164049
LAB_00164049:
JMP 0x0016404b
LAB_0016404b:
JMP 0x0016404d
LAB_0016404d:
JMP 0x0016404f
LAB_0016404f:
JMP 0x00164051
LAB_00164051:
CMP qword ptr [RBP + -0x20],0x0
JZ 0x00164069
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
CALL 0x00163ab0
LAB_00164069:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x28]
MOV EDX,0x1
MOV ECX,0x3
XOR R8D,R8D
CALL 0x00163c50
CMP AL,0x0
JZ 0x0016408d
JMP 0x00164089
LAB_00164089:
JMP 0x0016408b
LAB_0016408b:
JMP 0x0016408d
LAB_0016408d:
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x00163da0
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x28]
MOV EDX,0x1
CALL 0x00163df0
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00163f70
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc8
CALL 0x00162f00
JMP 0x001640c3
LAB_001640c3:
ADD RSP,0x50
POP RBP
RET
|
void pagecache_unpin(long param_1,int8 param_2,int8 param_3,long param_4)
{
int1 local_34 [4];
int8 local_30;
long local_28;
int8 local_20;
int8 local_18;
long local_10;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
inline_mysql_mutex_lock
(param_1 + 200,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0xcef);
inc_counter_for_resize_op(local_10);
local_30 = find_block(local_10,local_18,local_20,0,0,0,0,0,local_34);
if (local_28 != 0) {
check_and_set_lsn(local_10,local_28,local_30);
}
make_lock_and_pin(local_10,local_30,1,3,0);
remove_reader(local_30);
unreg_request(local_10,local_30,1);
dec_counter_for_resize_op(local_10);
inline_mysql_mutex_unlock(local_10 + 200);
return;
}
|
|
63,325 |
testing::internal::StreamingListener::UrlEncode[abi:cxx11](char const*)
|
AlayaLite/build_O3/_deps/googletest-src/googletest/src/gtest.cc
|
std::string StreamingListener::UrlEncode(const char* str) {
std::string result;
result.reserve(strlen(str) + 1);
for (char ch = *str; ch != '\0'; ch = *++str) {
switch (ch) {
case '%':
case '=':
case '&':
case '\n':
result.push_back('%');
result.append(String::FormatByte(static_cast<unsigned char>(ch)));
break;
default:
result.push_back(ch);
break;
}
}
return result;
}
|
O3
|
cpp
|
testing::internal::StreamingListener::UrlEncode[abi:cxx11](char const*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x114d0
leaq 0x1(%rax), %rsi
movq %rbx, %rdi
callq 0x33de4
leaq 0x18(%rsp), %r13
movabsq $0x2000006000000400, %rbp # imm = 0x2000006000000400
leaq 0x8(%rsp), %r15
movzbl (%r14), %r12d
cmpq $0x3d, %r12
ja 0x6e6c0
btq %r12, %rbp
jae 0x6e6bb
movq %rbx, %rdi
movl $0x25, %esi
callq 0x32f7c
movzbl %r12b, %esi
movq %r15, %rdi
callq 0x610e6
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x252d6
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x6e6cc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11120
jmp 0x6e6cc
testq %r12, %r12
je 0x6e6d1
movsbl %r12b, %esi
movq %rbx, %rdi
callq 0x32f7c
incq %r14
jmp 0x6e667
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6e703
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x6e706
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11120
jmp 0x6e706
jmp 0x6e703
movq %rax, %r14
movq (%rbx), %rdi
movq (%rsp), %rax
cmpq %rax, %rdi
je 0x6e71d
movq (%rax), %rsi
incq %rsi
callq 0x11120
movq %r14, %rdi
callq 0x11760
nop
|
_ZN7testing8internal17StreamingListener9UrlEncodeB5cxx11EPKc:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r14, rsi
mov rbx, rdi
lea rax, [rdi+10h]
mov [rsp+58h+var_58], rax
mov [rdi], rax
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rdi, rsi
call _strlen
lea rsi, [rax+1]
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
lea r13, [rsp+58h+var_40]
mov rbp, 2000006000000400h
lea r15, [rsp+58h+var_50]
loc_6E667:
movzx r12d, byte ptr [r14]
cmp r12, 3Dh ; '='
ja short loc_6E6C0
bt rbp, r12
jnb short loc_6E6BB
mov rdi, rbx
mov esi, 25h ; '%'
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
movzx esi, r12b
mov rdi, r15
call _ZN7testing8internal6String10FormatByteB5cxx11Eh; testing::internal::String::FormatByte(uchar)
mov rsi, [rsp+58h+var_50]
mov rdx, [rsp+58h+var_48]
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
mov rdi, [rsp+58h+var_50]; void *
cmp rdi, r13
jz short loc_6E6CC
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_6E6CC
loc_6E6BB:
test r12, r12
jz short loc_6E6D1
loc_6E6C0:
movsx esi, r12b
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
loc_6E6CC:
inc r14
jmp short loc_6E667
loc_6E6D1:
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_6E703
mov r14, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, r13
jz short loc_6E706
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_6E706
jmp short $+2
loc_6E703:
mov r14, rax
loc_6E706:
mov rdi, [rbx]; void *
mov rax, [rsp+0]
cmp rdi, rax
jz short loc_6E71D
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_6E71D:
mov rdi, r14
call __Unwind_Resume
|
long long testing::internal::StreamingListener::UrlEncode[abi:cxx11](long long a1, _BYTE *a2)
{
_BYTE *v2; // r14
long long v3; // rax
long long v4; // rbp
unsigned long long v5; // r12
void *v7[2]; // [rsp+8h] [rbp-50h] BYREF
long long v8; // [rsp+18h] [rbp-40h] BYREF
v2 = a2;
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v3 = strlen(a2);
std::string::reserve(a1, v3 + 1);
v4 = 0x2000006000000400LL;
while ( 1 )
{
v5 = (unsigned __int8)*v2;
if ( v5 > 0x3D )
goto LABEL_7;
if ( !_bittest64(&v4, v5) )
break;
std::string::push_back((_QWORD *)a1, 37);
testing::internal::String::FormatByte[abi:cxx11]((long long)v7, v5);
std::string::_M_append((_QWORD *)a1, (_BYTE *)v7[0], (long long)v7[1]);
if ( v7[0] != &v8 )
operator delete(v7[0], v8 + 1);
LABEL_8:
++v2;
}
if ( *v2 )
{
LABEL_7:
std::string::push_back((_QWORD *)a1, v5);
goto LABEL_8;
}
return a1;
}
|
UrlEncode[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,RSI
MOV RBX,RDI
LEA RAX,[RDI + 0x10]
MOV qword ptr [RSP],RAX
MOV qword ptr [RDI],RAX
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
MOV RDI,RSI
CALL 0x001114d0
LEA RSI,[RAX + 0x1]
LAB_0016e64b:
MOV RDI,RBX
CALL 0x00133de4
LEA R13,[RSP + 0x18]
MOV RBP,0x2000006000000400
LEA R15,[RSP + 0x8]
LAB_0016e667:
MOVZX R12D,byte ptr [R14]
CMP R12,0x3d
JA 0x0016e6c0
BT RBP,R12
JNC 0x0016e6bb
LAB_0016e677:
MOV RDI,RBX
MOV ESI,0x25
CALL 0x00132f7c
LAB_0016e684:
MOVZX ESI,R12B
MOV RDI,R15
CALL 0x001610e6
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
LAB_0016e69a:
MOV RDI,RBX
CALL 0x001252d6
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R13
JZ 0x0016e6cc
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00111120
JMP 0x0016e6cc
LAB_0016e6bb:
TEST R12,R12
JZ 0x0016e6d1
LAB_0016e6c0:
MOVSX ESI,R12B
MOV RDI,RBX
CALL 0x00132f7c
LAB_0016e6cc:
INC R14
JMP 0x0016e667
LAB_0016e6d1:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* testing::internal::StreamingListener::UrlEncode[abi:cxx11](char const*) */
StreamingListener * __thiscall
testing::internal::StreamingListener::UrlEncode_abi_cxx11_(StreamingListener *this,char *param_1)
{
size_t sVar1;
ulong uVar2;
long *local_50;
ulong local_48;
long local_40 [2];
*(StreamingListener **)this = this + 0x10;
*(int8 *)(this + 8) = 0;
this[0x10] = (StreamingListener)0x0;
sVar1 = strlen(param_1);
/* try { // try from 0016e64b to 0016e652 has its CatchHandler @ 0016e6e3 */
std::__cxx11::string::reserve((string *)this,sVar1 + 1);
do {
uVar2 = (ulong)(byte)*param_1;
if (uVar2 < 0x3e) {
if ((0x2000006000000400U >> (uVar2 & 0x3f) & 1) == 0) {
if (uVar2 == 0) {
return this;
}
goto LAB_0016e6c0;
}
/* try { // try from 0016e677 to 0016e683 has its CatchHandler @ 0016e703 */
std::__cxx11::string::push_back((string *)this,'%');
/* try { // try from 0016e684 to 0016e68f has its CatchHandler @ 0016e701 */
String::FormatByte_abi_cxx11_((uchar)&local_50);
/* try { // try from 0016e69a to 0016e6a1 has its CatchHandler @ 0016e6e5 */
std::__cxx11::string::_M_append((string *)this,(char *)local_50,local_48);
if (local_50 != local_40) {
operator_delete(local_50,local_40[0] + 1);
}
}
else {
LAB_0016e6c0:
/* try { // try from 0016e6c0 to 0016e6cb has its CatchHandler @ 0016e703 */
std::__cxx11::string::push_back((string *)this,*param_1);
}
param_1 = (char *)((byte *)param_1 + 1);
} while( true );
}
|
|
63,326 |
google::protobuf::(anonymous namespace)::ValidateSymbolName(google::protobuf::stringpiece_internal::StringPiece)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor_database.cc
|
bool ValidateSymbolName(StringPiece name) {
for (char c : name) {
// I don't trust ctype.h due to locales. :(
if (c != '.' && c != '_' && (c < '0' || c > '9') && (c < 'A' || c > 'Z') &&
(c < 'a' || c > 'z')) {
return false;
}
}
return true;
}
|
O0
|
cpp
|
google::protobuf::(anonymous namespace)::ValidateSymbolName(google::protobuf::stringpiece_internal::StringPiece):
subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x28(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x28fda0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x28fdb0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
je 0x2eca66
movq 0x10(%rsp), %rax
movb (%rax), %al
movb %al, 0x7(%rsp)
movsbl 0x7(%rsp), %eax
cmpl $0x2e, %eax
je 0x2eca54
movsbl 0x7(%rsp), %eax
cmpl $0x5f, %eax
je 0x2eca54
movsbl 0x7(%rsp), %eax
cmpl $0x30, %eax
jl 0x2eca25
movsbl 0x7(%rsp), %eax
cmpl $0x39, %eax
jle 0x2eca54
movsbl 0x7(%rsp), %eax
cmpl $0x41, %eax
jl 0x2eca39
movsbl 0x7(%rsp), %eax
cmpl $0x5a, %eax
jle 0x2eca54
movsbl 0x7(%rsp), %eax
cmpl $0x61, %eax
jl 0x2eca4d
movsbl 0x7(%rsp), %eax
cmpl $0x7a, %eax
jle 0x2eca54
movb $0x0, 0x37(%rsp)
jmp 0x2eca6b
jmp 0x2eca56
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2ec9e6
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
|
_ZN6google8protobuf12_GLOBAL__N_118ValidateSymbolNameENS0_20stringpiece_internal11StringPieceE:
sub rsp, 38h
mov [rsp+38h+var_18], rdi
mov [rsp+38h+var_10], rsi
lea rax, [rsp+38h+var_18]
mov [rsp+38h+var_20], rax
mov rdi, [rsp+38h+var_20]; this
call _ZNK6google8protobuf20stringpiece_internal11StringPiece5beginEv; google::protobuf::stringpiece_internal::StringPiece::begin(void)
mov [rsp+38h+var_28], rax
mov rdi, [rsp+38h+var_20]; this
call _ZNK6google8protobuf20stringpiece_internal11StringPiece3endEv; google::protobuf::stringpiece_internal::StringPiece::end(void)
mov [rsp+38h+var_30], rax
loc_2EC9E6:
mov rax, [rsp+38h+var_28]
cmp rax, [rsp+38h+var_30]
jz short loc_2ECA66
mov rax, [rsp+38h+var_28]
mov al, [rax]
mov [rsp+38h+var_31], al
movsx eax, [rsp+38h+var_31]
cmp eax, 2Eh ; '.'
jz short loc_2ECA54
movsx eax, [rsp+38h+var_31]
cmp eax, 5Fh ; '_'
jz short loc_2ECA54
movsx eax, [rsp+38h+var_31]
cmp eax, 30h ; '0'
jl short loc_2ECA25
movsx eax, [rsp+38h+var_31]
cmp eax, 39h ; '9'
jle short loc_2ECA54
loc_2ECA25:
movsx eax, [rsp+38h+var_31]
cmp eax, 41h ; 'A'
jl short loc_2ECA39
movsx eax, [rsp+38h+var_31]
cmp eax, 5Ah ; 'Z'
jle short loc_2ECA54
loc_2ECA39:
movsx eax, [rsp+38h+var_31]
cmp eax, 61h ; 'a'
jl short loc_2ECA4D
movsx eax, [rsp+38h+var_31]
cmp eax, 7Ah ; 'z'
jle short loc_2ECA54
loc_2ECA4D:
mov [rsp+38h+var_1], 0
jmp short loc_2ECA6B
loc_2ECA54:
jmp short $+2
loc_2ECA56:
mov rax, [rsp+38h+var_28]
add rax, 1
mov [rsp+38h+var_28], rax
jmp short loc_2EC9E6
loc_2ECA66:
mov [rsp+38h+var_1], 1
loc_2ECA6B:
mov al, [rsp+38h+var_1]
and al, 1
add rsp, 38h
retn
|
char google::protobuf::`anonymous namespace'::ValidateSymbolName(long long a1, long long a2)
{
char v3; // [rsp+7h] [rbp-31h]
long long v4; // [rsp+8h] [rbp-30h]
char *v5; // [rsp+10h] [rbp-28h]
_QWORD v6[2]; // [rsp+20h] [rbp-18h] BYREF
v6[0] = a1;
v6[1] = a2;
v5 = (char *)google::protobuf::stringpiece_internal::StringPiece::begin((google::protobuf::stringpiece_internal::StringPiece *)v6);
v4 = google::protobuf::stringpiece_internal::StringPiece::end((google::protobuf::stringpiece_internal::StringPiece *)v6);
while ( v5 != (char *)v4 )
{
v3 = *v5;
if ( *v5 != 46 && v3 != 95 && (v3 < 48 || v3 > 57) && (v3 < 65 || v3 > 90) && (v3 < 97 || v3 > 122) )
return 0;
++v5;
}
return 1;
}
|
ObjectWriter:
MOV qword ptr [RSP + -0x8],RDI
MOV RAX,qword ptr [RSP + -0x8]
LEA RCX,[0x5fd250]
ADD RCX,0x10
MOV qword ptr [RAX],RCX
MOV byte ptr [RAX + 0x8],0x1
RET
|
/* google::protobuf::util::converter::ObjectWriter::ObjectWriter() */
void __thiscall google::protobuf::util::converter::ObjectWriter::ObjectWriter(ObjectWriter *this)
{
*(int ***)this = &PTR__ObjectWriter_005fd260;
this[8] = (ObjectWriter)0x1;
return;
}
|
|
63,327 |
google::protobuf::compiler::CodeGeneratorRequest::_internal_mutable_compiler_version()
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/plugin.pb.h
|
inline ::PROTOBUF_NAMESPACE_ID::compiler::Version* CodeGeneratorRequest::_internal_mutable_compiler_version() {
_impl_._has_bits_[0] |= 0x00000002u;
if (_impl_.compiler_version_ == nullptr) {
auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::compiler::Version>(GetArenaForAllocation());
_impl_.compiler_version_ = p;
}
return _impl_.compiler_version_;
}
|
O0
|
c
|
google::protobuf::compiler::CodeGeneratorRequest::_internal_mutable_compiler_version():
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x20(%rsp), %rcx
movslq 0x1c(%rsp), %rdx
movl (%rcx,%rdx,4), %esi
orl $0x2, %esi
movl %esi, (%rcx,%rdx,4)
cmpq $0x0, 0x50(%rax)
jne 0x3d226
movq (%rsp), %rdi
callq 0x292e0
movq %rax, %rdi
callq 0x3d240
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq %rcx, 0x50(%rax)
movq (%rsp), %rax
movq 0x50(%rax), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
|
_ZN6google8protobuf8compiler20CodeGeneratorRequest34_internal_mutable_compiler_versionEv:
sub rsp, 28h
mov [rsp+28h+var_18], rdi
mov rax, [rsp+28h+var_18]
mov [rsp+28h+var_28], rax
mov rcx, rax
add rcx, 10h
mov [rsp+28h+var_8], rcx
mov [rsp+28h+var_C], 0
mov rcx, [rsp+28h+var_8]
movsxd rdx, [rsp+28h+var_C]
mov esi, [rcx+rdx*4]
or esi, 2
mov [rcx+rdx*4], esi
cmp qword ptr [rax+50h], 0
jnz short loc_3D226
mov rdi, [rsp+28h+var_28]; this
call _ZNK6google8protobuf11MessageLite21GetArenaForAllocationEv; google::protobuf::MessageLite::GetArenaForAllocation(void)
mov rdi, rax; int
call _ZN6google8protobuf11MessageLite18CreateMaybeMessageINS0_8compiler7VersionEEEPT_PNS0_5ArenaE; google::protobuf::MessageLite::CreateMaybeMessage<google::protobuf::compiler::Version>(google::protobuf::Arena *)
mov rcx, rax
mov rax, [rsp+28h+var_28]
mov [rsp+28h+var_20], rcx
mov rcx, [rsp+28h+var_20]
mov [rax+50h], rcx
loc_3D226:
mov rax, [rsp+28h+var_28]
mov rax, [rax+50h]
add rsp, 28h
retn
|
long long google::protobuf::compiler::CodeGeneratorRequest::_internal_mutable_compiler_version(
google::protobuf::compiler::CodeGeneratorRequest *this)
{
int ArenaForAllocation; // eax
*((_DWORD *)this + 4) |= 2u;
if ( !*((_QWORD *)this + 10) )
{
ArenaForAllocation = google::protobuf::MessageLite::GetArenaForAllocation(this);
*((_QWORD *)this + 10) = google::protobuf::MessageLite::CreateMaybeMessage<google::protobuf::compiler::Version>(ArenaForAllocation);
}
return *((_QWORD *)this + 10);
}
|
_internal_mutable_compiler_version:
SUB RSP,0x28
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP],RAX
MOV RCX,RAX
ADD RCX,0x10
MOV qword ptr [RSP + 0x20],RCX
MOV dword ptr [RSP + 0x1c],0x0
MOV RCX,qword ptr [RSP + 0x20]
MOVSXD RDX,dword ptr [RSP + 0x1c]
MOV ESI,dword ptr [RCX + RDX*0x4]
OR ESI,0x2
MOV dword ptr [RCX + RDX*0x4],ESI
CMP qword ptr [RAX + 0x50],0x0
JNZ 0x0013d226
MOV RDI,qword ptr [RSP]
CALL 0x001292e0
MOV RDI,RAX
CALL 0x0013d240
MOV RCX,RAX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x8],RCX
MOV RCX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX + 0x50],RCX
LAB_0013d226:
MOV RAX,qword ptr [RSP]
MOV RAX,qword ptr [RAX + 0x50]
ADD RSP,0x28
RET
|
/* google::protobuf::compiler::CodeGeneratorRequest::_internal_mutable_compiler_version() */
int8 __thiscall
google::protobuf::compiler::CodeGeneratorRequest::_internal_mutable_compiler_version
(CodeGeneratorRequest *this)
{
Arena *pAVar1;
Version *pVVar2;
*(uint *)(this + 0x10) = *(uint *)(this + 0x10) | 2;
if (*(long *)(this + 0x50) == 0) {
pAVar1 = (Arena *)MessageLite::GetArenaForAllocation((MessageLite *)this);
pVVar2 = MessageLite::CreateMaybeMessage<google::protobuf::compiler::Version>(pAVar1);
*(Version **)(this + 0x50) = pVVar2;
}
return *(int8 *)(this + 0x50);
}
|
|
63,328 |
my_well_formed_char_length_ucs2
|
eloqsql/strings/ctype-ucs2.c
|
static size_t
my_well_formed_char_length_ucs2(CHARSET_INFO *cs __attribute__((unused)),
const char *b, const char *e,
size_t nchars, MY_STRCOPY_STATUS *status)
{
size_t length= e - b;
if (nchars * 2 <= length)
{
status->m_well_formed_error_pos= NULL;
status->m_source_end_pos= b + (nchars * 2);
return nchars;
}
if (length % 2)
{
status->m_well_formed_error_pos= status->m_source_end_pos= e - 1;
}
else
{
status->m_well_formed_error_pos= NULL;
status->m_source_end_pos= e;
}
return length / 2;
}
|
O0
|
c
|
my_well_formed_char_length_ucs2:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
shlq %rax
cmpq -0x38(%rbp), %rax
ja 0x5c0af
movq -0x30(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
shlq %rax
addq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5c0f8
movq -0x38(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x5c0d6
movq -0x20(%rbp), %rcx
addq $-0x1, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x5c0ed
movq -0x30(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
shrq %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
|
my_well_formed_char_length_ucs2:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
sub rax, rcx
mov [rbp+var_38], rax
mov rax, [rbp+var_28]
shl rax, 1
cmp rax, [rbp+var_38]
ja short loc_5C0AF
mov rax, [rbp+var_30]
mov qword ptr [rax+8], 0
mov rcx, [rbp+var_18]
mov rax, [rbp+var_28]
shl rax, 1
add rcx, rax
mov rax, [rbp+var_30]
mov [rax], rcx
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
jmp short loc_5C0F8
loc_5C0AF:
mov rax, [rbp+var_38]
and rax, 1
cmp rax, 0
jz short loc_5C0D6
mov rcx, [rbp+var_20]
add rcx, 0FFFFFFFFFFFFFFFFh
mov rax, [rbp+var_30]
mov [rax], rcx
mov rax, [rbp+var_30]
mov [rax+8], rcx
jmp short loc_5C0ED
loc_5C0D6:
mov rax, [rbp+var_30]
mov qword ptr [rax+8], 0
mov rcx, [rbp+var_20]
mov rax, [rbp+var_30]
mov [rax], rcx
loc_5C0ED:
mov rax, [rbp+var_38]
shr rax, 1
mov [rbp+var_8], rax
loc_5C0F8:
mov rax, [rbp+var_8]
pop rbp
retn
|
unsigned long long my_well_formed_char_length_ucs2(long long a1, long long a2, long long a3, long long a4, _QWORD *a5)
{
unsigned long long v6; // [rsp+0h] [rbp-38h]
v6 = a3 - a2;
if ( 2 * a4 > (unsigned long long)(a3 - a2) )
{
if ( (v6 & 1) != 0 )
{
*a5 = a3 - 1;
a5[1] = a3 - 1;
}
else
{
a5[1] = 0LL;
*a5 = a3;
}
return v6 >> 1;
}
else
{
a5[1] = 0LL;
*a5 = 2 * a4 + a2;
return a4;
}
}
|
my_well_formed_char_length_ucs2:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
SUB RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x28]
SHL RAX,0x1
CMP RAX,qword ptr [RBP + -0x38]
JA 0x0015c0af
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x8],0x0
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x28]
SHL RAX,0x1
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0015c0f8
LAB_0015c0af:
MOV RAX,qword ptr [RBP + -0x38]
AND RAX,0x1
CMP RAX,0x0
JZ 0x0015c0d6
MOV RCX,qword ptr [RBP + -0x20]
ADD RCX,-0x1
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x0015c0ed
LAB_0015c0d6:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x8],0x0
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
LAB_0015c0ed:
MOV RAX,qword ptr [RBP + -0x38]
SHR RAX,0x1
MOV qword ptr [RBP + -0x8],RAX
LAB_0015c0f8:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
ulong my_well_formed_char_length_ucs2
(int8 param_1,long param_2,long param_3,ulong param_4,long *param_5)
{
ulong local_10;
local_10 = param_3 - param_2;
if (param_4 * 2 < local_10 || param_4 * 2 - local_10 == 0) {
param_5[1] = 0;
*param_5 = param_2 + param_4 * 2;
local_10 = param_4;
}
else {
if ((local_10 & 1) == 0) {
param_5[1] = 0;
*param_5 = param_3;
}
else {
*param_5 = param_3 + -1;
param_5[1] = param_3 + -1;
}
local_10 = local_10 >> 1;
}
return local_10;
}
|
|
63,329 |
my_well_formed_char_length_ucs2
|
eloqsql/strings/ctype-ucs2.c
|
static size_t
my_well_formed_char_length_ucs2(CHARSET_INFO *cs __attribute__((unused)),
const char *b, const char *e,
size_t nchars, MY_STRCOPY_STATUS *status)
{
size_t length= e - b;
if (nchars * 2 <= length)
{
status->m_well_formed_error_pos= NULL;
status->m_source_end_pos= b + (nchars * 2);
return nchars;
}
if (length % 2)
{
status->m_well_formed_error_pos= status->m_source_end_pos= e - 1;
}
else
{
status->m_well_formed_error_pos= NULL;
status->m_source_end_pos= e;
}
return length / 2;
}
|
O3
|
c
|
my_well_formed_char_length_ucs2:
pushq %rbp
movq %rsp, %rbp
movq %rcx, %rax
movq %rdx, %rcx
subq %rsi, %rcx
leaq (%rax,%rax), %rdi
cmpq %rcx, %rdi
jbe 0x4836b
movl %ecx, %eax
andl $0x1, %eax
movq %rax, %rsi
negq %rsi
leaq -0x1(%rdx), %rdi
andq %rdi, %rsi
testq %rax, %rax
cmoveq %rdx, %rdi
movq %rsi, 0x8(%r8)
movq %rdi, (%r8)
shrq %rcx
movq %rcx, %rax
jmp 0x48379
movq $0x0, 0x8(%r8)
addq %rdi, %rsi
movq %rsi, (%r8)
popq %rbp
retq
|
my_well_formed_char_length_ucs2:
push rbp
mov rbp, rsp
mov rax, rcx
mov rcx, rdx
sub rcx, rsi
lea rdi, [rax+rax]
cmp rdi, rcx
jbe short loc_4836B
mov eax, ecx
and eax, 1
mov rsi, rax
neg rsi
lea rdi, [rdx-1]
and rsi, rdi
test rax, rax
cmovz rdi, rdx
mov [r8+8], rsi
mov [r8], rdi
shr rcx, 1
mov rax, rcx
jmp short loc_48379
loc_4836B:
mov qword ptr [r8+8], 0
add rsi, rdi
mov [r8], rsi
loc_48379:
pop rbp
retn
|
unsigned long long my_well_formed_char_length_ucs2(
long long a1,
long long a2,
long long a3,
unsigned long long a4,
_QWORD *a5)
{
unsigned long long result; // rax
unsigned long long v6; // rcx
long long v7; // rdi
result = a4;
v6 = a3 - a2;
if ( 2 * result <= a3 - a2 )
{
a5[1] = 0LL;
*a5 = 2 * result + a2;
}
else
{
v7 = a3 - 1;
if ( (v6 & 1) == 0 )
v7 = a3;
a5[1] = (a3 - 1) & -(long long)(v6 & 1);
*a5 = v7;
return v6 >> 1;
}
return result;
}
|
my_well_formed_char_length_ucs2:
PUSH RBP
MOV RBP,RSP
MOV RAX,RCX
MOV RCX,RDX
SUB RCX,RSI
LEA RDI,[RAX + RAX*0x1]
CMP RDI,RCX
JBE 0x0014836b
MOV EAX,ECX
AND EAX,0x1
MOV RSI,RAX
NEG RSI
LEA RDI,[RDX + -0x1]
AND RSI,RDI
TEST RAX,RAX
CMOVZ RDI,RDX
MOV qword ptr [R8 + 0x8],RSI
MOV qword ptr [R8],RDI
SHR RCX,0x1
MOV RAX,RCX
JMP 0x00148379
LAB_0014836b:
MOV qword ptr [R8 + 0x8],0x0
ADD RSI,RDI
MOV qword ptr [R8],RSI
LAB_00148379:
POP RBP
RET
|
ulong my_well_formed_char_length_ucs2
(int8 param_1,long param_2,ulong param_3,ulong param_4,ulong *param_5)
{
ulong uVar1;
ulong uVar2;
ulong uVar3;
uVar2 = param_3 - param_2;
if (uVar2 < param_4 * 2) {
uVar1 = (ulong)((uint)uVar2 & 1);
uVar3 = param_3 - 1;
if (uVar1 == 0) {
uVar3 = param_3;
}
param_5[1] = -uVar1 & param_3 - 1;
*param_5 = uVar3;
param_4 = uVar2 >> 1;
}
else {
param_5[1] = 0;
*param_5 = param_2 + param_4 * 2;
}
return param_4;
}
|
|
63,330 |
my_strnxfrm_unicode_full_nopad_bin
|
eloqsql/strings/ctype-utf8.c
|
size_t
my_strnxfrm_unicode_full_nopad_bin(CHARSET_INFO *cs,
uchar *dst, size_t dstlen, uint nweights,
const uchar *src, size_t srclen, uint flags)
{
uchar *dst0= dst;
uchar *de= dst + dstlen;
dst+= my_strnxfrm_unicode_full_bin_internal(cs, dst, de, &nweights,
src, src + srclen);
DBUG_ASSERT(dst <= de); /* Safety */
if (dst < de && nweights && (flags & MY_STRXFRM_PAD_WITH_SPACE))
{
size_t len= de - dst;
set_if_smaller(len, nweights * 3);
memset(dst, 0x00, len);
dst+= len;
}
my_strxfrm_desc_and_reverse(dst0, dst, flags, 0);
if ((flags & MY_STRXFRM_PAD_TO_MAXLEN) && dst < de)
{
memset(dst, 0x00, de - dst);
dst= de;
}
return dst - dst0;
}
|
O0
|
c
|
my_strnxfrm_unicode_full_nopad_bin:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x28(%rbp), %r8
movq -0x28(%rbp), %r9
addq -0x30(%rbp), %r9
leaq -0x1c(%rbp), %rcx
callq 0xc3930
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xc3c51
movq -0x10(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0xc3cb1
cmpl $0x0, -0x1c(%rbp)
je 0xc3cb1
movl 0x10(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0xc3cb1
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
imull $0x3, -0x1c(%rbp), %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jbe 0xc3c94
imull $0x3, -0x1c(%rbp), %eax
movl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0xc3c96
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rdx
xorl %esi, %esi
callq 0x281c0
movq -0x48(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl 0x10(%rbp), %edx
xorl %ecx, %ecx
callq 0xa4e30
movl 0x10(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xc3cf8
movq -0x10(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0xc3cf8
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rdx
movq -0x10(%rbp), %rax
subq %rax, %rdx
xorl %esi, %esi
callq 0x281c0
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
subq %rcx, %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
|
my_strnxfrm_unicode_full_nopad_bin:
push rbp
mov rbp, rsp
sub rsp, 50h
mov eax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_10]
mov [rbp+var_38], rax
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_40]
mov r8, [rbp+var_28]
mov r9, [rbp+var_28]
add r9, [rbp+var_30]
lea rcx, [rbp+var_1C]
call my_strnxfrm_unicode_full_bin_internal
add rax, [rbp+var_10]
mov [rbp+var_10], rax
jmp short $+2
loc_C3C51:
mov rax, [rbp+var_10]
cmp rax, [rbp+var_40]
jnb short loc_C3CB1
cmp [rbp+var_1C], 0
jz short loc_C3CB1
mov eax, [rbp+arg_0]
and eax, 40h
cmp eax, 0
jz short loc_C3CB1
mov rax, [rbp+var_40]
mov rcx, [rbp+var_10]
sub rax, rcx
mov [rbp+var_48], rax
mov rax, [rbp+var_48]
imul ecx, [rbp+var_1C], 3
mov ecx, ecx
cmp rax, rcx
jbe short loc_C3C94
imul eax, [rbp+var_1C], 3
mov eax, eax
mov [rbp+var_48], rax
loc_C3C94:
jmp short $+2
loc_C3C96:
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_48]
xor esi, esi
call _memset
mov rax, [rbp+var_48]
add rax, [rbp+var_10]
mov [rbp+var_10], rax
loc_C3CB1:
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_10]
mov edx, [rbp+arg_0]
xor ecx, ecx
call my_strxfrm_desc_and_reverse
mov eax, [rbp+arg_0]
and eax, 80h
cmp eax, 0
jz short loc_C3CF8
mov rax, [rbp+var_10]
cmp rax, [rbp+var_40]
jnb short loc_C3CF8
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_40]
mov rax, [rbp+var_10]
sub rdx, rax
xor esi, esi
call _memset
mov rax, [rbp+var_40]
mov [rbp+var_10], rax
loc_C3CF8:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_38]
sub rax, rcx
add rsp, 50h
pop rbp
retn
|
signed long long my_strnxfrm_unicode_full_nopad_bin(
long long a1,
char *a2,
long long a3,
int a4,
long long a5,
long long a6,
unsigned int a7)
{
_BYTE *v7; // rax
unsigned long long v9; // [rsp+8h] [rbp-48h]
unsigned long long v10; // [rsp+10h] [rbp-40h]
int v11; // [rsp+34h] [rbp-1Ch] BYREF
long long v12; // [rsp+38h] [rbp-18h]
char *v13; // [rsp+40h] [rbp-10h]
long long v14; // [rsp+48h] [rbp-8h]
v14 = a1;
v13 = a2;
v12 = a3;
v11 = a4;
v10 = (unsigned long long)&a2[a3];
v7 = my_strnxfrm_unicode_full_bin_internal(a1, a2, (unsigned long long)&a2[a3], &v11, a5, a6 + a5);
v13 = &v7[(_QWORD)v13];
if ( (unsigned long long)v13 < v10 && v11 && (a7 & 0x40) != 0 )
{
v9 = v10 - (_QWORD)v13;
if ( v10 - (unsigned long long)v13 > (unsigned int)(3 * v11) )
v9 = (unsigned int)(3 * v11);
memset(v13, 0LL, v9);
v13 += v9;
}
my_strxfrm_desc_and_reverse(a2, (unsigned long long)v13, a7, 0);
if ( (a7 & 0x80) != 0 && (unsigned long long)v13 < v10 )
{
memset(v13, 0LL, v10 - (_QWORD)v13);
v13 = (char *)v10;
}
return v13 - a2;
}
|
my_strnxfrm_unicode_full_nopad_bin:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x40]
MOV R8,qword ptr [RBP + -0x28]
MOV R9,qword ptr [RBP + -0x28]
ADD R9,qword ptr [RBP + -0x30]
LEA RCX,[RBP + -0x1c]
CALL 0x001c3930
ADD RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001c3c51
LAB_001c3c51:
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x001c3cb1
CMP dword ptr [RBP + -0x1c],0x0
JZ 0x001c3cb1
MOV EAX,dword ptr [RBP + 0x10]
AND EAX,0x40
CMP EAX,0x0
JZ 0x001c3cb1
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x10]
SUB RAX,RCX
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x48]
IMUL ECX,dword ptr [RBP + -0x1c],0x3
MOV ECX,ECX
CMP RAX,RCX
JBE 0x001c3c94
IMUL EAX,dword ptr [RBP + -0x1c],0x3
MOV EAX,EAX
MOV qword ptr [RBP + -0x48],RAX
LAB_001c3c94:
JMP 0x001c3c96
LAB_001c3c96:
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x48]
XOR ESI,ESI
CALL 0x001281c0
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x10],RAX
LAB_001c3cb1:
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + 0x10]
XOR ECX,ECX
CALL 0x001a4e30
MOV EAX,dword ptr [RBP + 0x10]
AND EAX,0x80
CMP EAX,0x0
JZ 0x001c3cf8
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x001c3cf8
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x10]
SUB RDX,RAX
XOR ESI,ESI
CALL 0x001281c0
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x10],RAX
LAB_001c3cf8:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x38]
SUB RAX,RCX
ADD RSP,0x50
POP RBP
RET
|
long my_strnxfrm_unicode_full_nopad_bin
(int8 param_1,long param_2,long param_3,int param_4,long param_5,long param_6,
uint param_7)
{
void *pvVar1;
long lVar2;
size_t local_50;
int local_24;
long local_20;
void *local_18;
int8 local_10;
pvVar1 = (void *)(param_2 + param_3);
local_24 = param_4;
local_20 = param_3;
local_18 = (void *)param_2;
local_10 = param_1;
lVar2 = my_strnxfrm_unicode_full_bin_internal
(param_1,param_2,pvVar1,&local_24,param_5,param_5 + param_6);
local_18 = (void *)(lVar2 + (long)local_18);
if (((local_18 < pvVar1) && (local_24 != 0)) && ((param_7 & 0x40) != 0)) {
local_50 = (long)pvVar1 - (long)local_18;
if ((uint)(local_24 * 3) < local_50) {
local_50 = (size_t)(uint)(local_24 * 3);
}
memset(local_18,0,local_50);
local_18 = (void *)(local_50 + (long)local_18);
}
my_strxfrm_desc_and_reverse(param_2,local_18,param_7,0);
if (((param_7 & 0x80) != 0) && (local_18 < pvVar1)) {
memset(local_18,0,(long)pvVar1 - (long)local_18);
local_18 = pvVar1;
}
return (long)local_18 - param_2;
}
|
|
63,331 |
fmt::v11::basic_appender<char> fmt::v11::detail::write_significand<char, fmt::v11::basic_appender<char>, unsigned long, fmt::v11::detail::digit_grouping<char>>(fmt::v11::basic_appender<char>, unsigned long, int, int, fmt::v11::detail::digit_grouping<char> const&)
|
zkingston[P]unknot/build_O1/_deps/fmt-src/include/fmt/format.h
|
FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand,
int significand_size, int exponent,
const Grouping& grouping) -> OutputIt {
if (!grouping.has_separator()) {
out = write_significand<Char>(out, significand, significand_size);
return detail::fill_n(out, exponent, static_cast<Char>('0'));
}
auto buffer = memory_buffer();
write_significand<char>(appender(buffer), significand, significand_size);
detail::fill_n(appender(buffer), exponent, '0');
return grouping.apply(out, string_view(buffer.data(), buffer.size()));
}
|
O1
|
c
|
fmt::v11::basic_appender<char> fmt::v11::detail::write_significand<char, fmt::v11::basic_appender<char>, unsigned long, fmt::v11::detail::digit_grouping<char>>(fmt::v11::basic_appender<char>, unsigned long, int, int, fmt::v11::detail::digit_grouping<char> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movl %ecx, %ebp
movq %rdi, %rbx
cmpq $0x0, 0x28(%r8)
je 0x45aba
movq %r8, %r14
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %r15
movaps %xmm0, -0x20(%r15)
leaq -0x5e5f(%rip), %rax # 0x3fbfe
movq %rax, -0x8(%r15)
movq %r15, -0x20(%r15)
movq $0x1f4, -0x10(%r15) # imm = 0x1F4
movslq %edx, %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0x3f992
leaq 0xf(%rsp), %rdx
movb $0x30, (%rdx)
leaq 0x10(%rsp), %rdi
movl %ebp, %esi
callq 0x41b35
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x41f14
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x45add
callq 0xfc50
jmp 0x45add
movslq %edx, %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3f992
leaq 0x10(%rsp), %rdx
movb $0x30, (%rdx)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x41b35
movq %rax, %rbx
movq %rbx, %rax
addq $0x228, %rsp # imm = 0x228
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x45af0
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x45b02
callq 0xfc50
movq %rbx, %rdi
callq 0x101c0
|
_ZN3fmt3v116detail17write_significandIcNS0_14basic_appenderIcEEPKcNS1_14digit_groupingIcEEEET0_S9_T1_iiRKT2_:
push rbp
push r15
push r14
push rbx
sub rsp, 228h
mov ebp, ecx
mov rbx, rdi
cmp qword ptr [r8+28h], 0
jz short loc_45ABA
mov r14, r8
xorps xmm0, xmm0
lea r15, [rsp+248h+var_218]
movaps xmmword ptr [r15-20h], xmm0
lea rax, _ZN3fmt3v1119basic_memory_bufferIcLm500ENS0_6detail9allocatorIcEEE4growERNS2_6bufferIcEEm; fmt::v11::basic_memory_buffer<char,500ul,fmt::v11::detail::allocator<char>>::grow(fmt::v11::detail::buffer<char> &,ulong)
mov [r15-8], rax
mov [r15-20h], r15
mov qword ptr [r15-10h], 1F4h
movsxd rdx, edx
add rdx, rsi
lea rdi, [rsp+248h+var_238]
call _ZN3fmt3v116detail6bufferIcE6appendIcEEvPKT_S7_; fmt::v11::detail::buffer<char>::append<char>(char const*,char const*)
lea rdx, [rsp+248h+var_239]
mov byte ptr [rdx], 30h ; '0'
lea rdi, [rsp+248h+var_238]
mov esi, ebp
call _ZN3fmt3v116detail6fill_nINS0_14basic_appenderIcEEicEET_S5_T0_RKT1_; fmt::v11::detail::fill_n<fmt::v11::basic_appender<char>,int,char>(fmt::v11::basic_appender<char>,int,char const&)
mov rdx, [rsp+248h+var_238]
mov rcx, [rsp+248h+var_230]
mov rdi, r14
mov rsi, rbx
call _ZNK3fmt3v116detail14digit_groupingIcE5applyINS0_14basic_appenderIcEEcEET_S7_NS0_17basic_string_viewIT0_EE; fmt::v11::detail::digit_grouping<char>::apply<fmt::v11::basic_appender<char>,char>(fmt::v11::basic_appender<char>,fmt::v11::basic_string_view<char>)
mov rbx, rax
mov rdi, [rsp+248h+var_238]
cmp rdi, r15
jz short loc_45ADD
call _free
jmp short loc_45ADD
loc_45ABA:
movsxd rdx, edx
add rdx, rsi
mov rdi, rbx
call _ZN3fmt3v116detail6bufferIcE6appendIcEEvPKT_S7_; fmt::v11::detail::buffer<char>::append<char>(char const*,char const*)
lea rdx, [rsp+248h+var_238]
mov byte ptr [rdx], 30h ; '0'
mov rdi, rbx
mov esi, ebp
call _ZN3fmt3v116detail6fill_nINS0_14basic_appenderIcEEicEET_S5_T0_RKT1_; fmt::v11::detail::fill_n<fmt::v11::basic_appender<char>,int,char>(fmt::v11::basic_appender<char>,int,char const&)
mov rbx, rax
loc_45ADD:
mov rax, rbx
add rsp, 228h
pop rbx
pop r14
pop r15
pop rbp
retn
jmp short $+2
loc_45AF0:
mov rbx, rax
mov rdi, [rsp+arg_8]
cmp rdi, r15
jz short loc_45B02
call _free
loc_45B02:
mov rdi, rbx
call __Unwind_Resume
|
long long * fmt::v11::detail::write_significand<char,fmt::v11::basic_appender<char>,char const*,fmt::v11::detail::digit_grouping<char>>(
long long *a1,
long long a2,
int a3,
int a4,
long long a5)
{
long long v7; // rbx
char v9; // [rsp+Fh] [rbp-239h] BYREF
__int128 v10; // [rsp+10h] [rbp-238h] BYREF
long long v11; // [rsp+20h] [rbp-228h]
long long ( *v12)(long long *, unsigned long long); // [rsp+28h] [rbp-220h]
_BYTE v13[536]; // [rsp+30h] [rbp-218h] BYREF
if ( *(_QWORD *)(a5 + 40) )
{
v10 = 0LL;
v12 = fmt::v11::basic_memory_buffer<char,500ul,fmt::v11::detail::allocator<char>>::grow;
*(_QWORD *)&v10 = v13;
v11 = 500LL;
fmt::v11::detail::buffer<char>::append<char>((long long)&v10, a2, a2 + a3);
v9 = 48;
fmt::v11::detail::fill_n<fmt::v11::basic_appender<char>,int,char>((long long *)&v10, a4, &v9);
v7 = fmt::v11::detail::digit_grouping<char>::apply<fmt::v11::basic_appender<char>,char>(
(unsigned __int8 **)a5,
(long long)a1,
v10,
SDWORD2(v10));
if ( (_BYTE *)v10 != v13 )
free(v10);
}
else
{
fmt::v11::detail::buffer<char>::append<char>((long long)a1, a2, a2 + a3);
LOBYTE(v10) = 48;
return fmt::v11::detail::fill_n<fmt::v11::basic_appender<char>,int,char>(a1, a4, (char *)&v10);
}
return (long long *)v7;
}
|
write_significand<char,fmt::v11::basic_appender<char>,char_const*,fmt::v11::detail::digit_grouping<char>>:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x228
MOV EBP,ECX
MOV RBX,RDI
CMP qword ptr [R8 + 0x28],0x0
JZ 0x00145aba
MOV R14,R8
XORPS XMM0,XMM0
LEA R15,[RSP + 0x30]
MOVAPS xmmword ptr [R15 + -0x20],XMM0
LEA RAX,[0x13fbfe]
MOV qword ptr [R15 + -0x8],RAX
MOV qword ptr [R15 + -0x20],R15
MOV qword ptr [R15 + -0x10],0x1f4
MOVSXD RDX,EDX
ADD RDX,RSI
LAB_00145a73:
LEA RDI,[RSP + 0x10]
CALL 0x0013f992
LEA RDX,[RSP + 0xf]
MOV byte ptr [RDX],0x30
LAB_00145a85:
LEA RDI,[RSP + 0x10]
MOV ESI,EBP
CALL 0x00141b35
MOV RDX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x18]
LAB_00145a9b:
MOV RDI,R14
MOV RSI,RBX
CALL 0x00141f14
LAB_00145aa6:
MOV RBX,RAX
MOV RDI,qword ptr [RSP + 0x10]
CMP RDI,R15
JZ 0x00145add
CALL 0x0010fc50
JMP 0x00145add
LAB_00145aba:
MOVSXD RDX,EDX
ADD RDX,RSI
MOV RDI,RBX
CALL 0x0013f992
LEA RDX,[RSP + 0x10]
MOV byte ptr [RDX],0x30
MOV RDI,RBX
MOV ESI,EBP
CALL 0x00141b35
MOV RBX,RAX
LAB_00145add:
MOV RAX,RBX
ADD RSP,0x228
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* fmt::v11::basic_appender<char> fmt::v11::detail::write_significand<char,
fmt::v11::basic_appender<char>, char const*, fmt::v11::detail::digit_grouping<char>
>(fmt::v11::basic_appender<char>, char const*, int, int, fmt::v11::detail::digit_grouping<char>
const&) */
int8
fmt::v11::detail::
write_significand<char,fmt::v11::basic_appender<char>,char_const*,fmt::v11::detail::digit_grouping<char>>
(buffer<char> *param_1,char *param_2,int param_3,int4 param_4,long param_5)
{
int8 uVar1;
int1 *local_238;
int8 uStack_230;
int8 local_228;
code *local_220;
int1 local_218 [504];
if (*(long *)(param_5 + 0x28) == 0) {
buffer<char>::append<char>(param_1,param_2,param_2 + param_3);
local_238 = (int1 *)CONCAT71(local_238._1_7_,0x30);
uVar1 = fill_n<fmt::v11::basic_appender<char>,int,char>(param_1,param_4);
}
else {
uStack_230 = 0;
local_220 = basic_memory_buffer<char,500ul,fmt::v11::detail::allocator<char>>::grow;
local_228 = 500;
/* try { // try from 00145a73 to 00145a7c has its CatchHandler @ 00145af0 */
local_238 = local_218;
buffer<char>::append<char>((buffer<char> *)&local_238,param_2,param_2 + param_3);
/* try { // try from 00145a85 to 00145a90 has its CatchHandler @ 00145aee */
fill_n<fmt::v11::basic_appender<char>,int,char>(&local_238,param_4);
/* try { // try from 00145a9b to 00145aa5 has its CatchHandler @ 00145af0 */
uVar1 = digit_grouping<char>::apply<fmt::v11::basic_appender<char>,char>
(param_5,param_1,local_238,uStack_230);
if (local_238 != local_218) {
free(local_238);
}
}
return uVar1;
}
|
|
63,332 |
LefDefParser::lefiLayer::parseLayerEnclosure(int)
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiLayer.cpp
|
void
lefiLayer::parseLayerEnclosure(int index)
{
char *wrkingStr = strdup(values_[index]);
char *value;
char msg[1024];
int overh = 0, width = 0, except = 0, length = 0;
char *enclRule = 0;
double overhang1 = 0, overhang2 = 0, minWidth = 0, cutWithin = 0, minLength = 0;
if (strcmp(type(), "CUT") != 0) {
/*
sprintf(msg, "ERROR (LEFPARS-1331): The property LEF57_ENCLOSURE with value %s is for TYPE CUT only.\nThe current layer has the TYPE %s.\nUpdate the property of your lef file with the correct syntax or remove this property from your lef file.\n",
values_[index], type());
lefiError(msg);
*/
sprintf(msg, "The property LEF57_ENCLOSURE with value %s is for TYPE CUT only.\nThe current layer has the TYPE %s.\nUpdate the property of your lef file with the correct syntax or remove this property from your lef file.\n",
values_[index], type());
lefError(1331, msg);
free(wrkingStr);
return;
}
value = strtok(wrkingStr, " ");
if (strcmp(value, "ENCLOSURE") != 0) { // Unknown value
/*
sprintf(msg, "ERROR (LEFPARS-1330): Incorrect syntax defined for property LEF57_ENCLOSURE: %s\nCorrect syntax is \"ENCLOSURE [ABOVE|BELOW] overhang1 overhang2\n\t[WIDTH minWidth [EXCEPTEXTRACUT cutWithin]\n\t|LENGTH minLength] ;\"\n", values_[index]);
lefiError(msg);
*/
sprintf(msg, "Incorrect syntax defined for property LEF57_ENCLOSURE: %s\nCorrect syntax is \"ENCLOSURE [ABOVE|BELOW] overhang1 overhang2\n\t[WIDTH minWidth [EXCEPTEXTRACUT cutWithin]\n\t|LENGTH minLength] ;\"\n", values_[index]);
lefError(1330, msg);
free(wrkingStr);
return;
}
value = strtok(NULL, " ");
while (strcmp(value, ";") != 0) {
if (strcmp(value, "CUTCLASS") == 0) {
// This is 58 syntax but is not in OA data model. Skip the parsing
free(wrkingStr);
return;
} else if ((strcmp(value, "ABOVE") == 0) || (strcmp(value, "BELOW") == 0)) {
// Parse the rest of the property value lefData->first and if it has the syntax
// ENCLOSURE [ABOVE | BELOW] overhang1 overhang2
// [WIDTH minWidth [EXCEPTEXTRACUT cutWithin]
// |LENGTH minLength]
if (overh) {
/*
sprintf(msg, "ERROR (LEFPARS-1330): Incorrect syntax defined for property LEF57_ENCLOSURE: %s\nCorrect syntax is \"ENCLOSURE [ABOVE|BELOW] overhang1 overhang2\n\t[WIDTH minWidth [EXCEPTEXTRACUT cutWithin]\n\t|LENGTH minLength] ;\"\n", values_[index]);
lefiError(msg);
*/
sprintf(msg, "Incorrect syntax defined for property LEF57_ENCLOSURE: %s\nCorrect syntax is \"ENCLOSURE [ABOVE|BELOW] overhang1 overhang2\n\t[WIDTH minWidth [EXCEPTEXTRACUT cutWithin]\n\t|LENGTH minLength] ;\"\n", values_[index]);
lefError(1330, msg);
free(wrkingStr);
if (enclRule)
free(enclRule);
return;
}
enclRule = strdup(value);
value = strtok(NULL, " ");
} else if (strcmp(value, "WIDTH") == 0) {
if ((!overh)) {
/*
sprintf(msg, "ERROR (LEFPARS-1330): Incorrect syntax defined for property LEF57_ENCLOSURE: %s\nCorrect syntax is \"ENCLOSURE [ABOVE|BELOW] overhang1 overhang2\n\t[WIDTH minWidth [EXCEPTEXTRACUT cutWithin]\n\t|LENGTH minLength] ;\"\n", values_[index]);
lefiError(msg);
*/
sprintf(msg, "Incorrect syntax defined for property LEF57_ENCLOSURE: %s\nCorrect syntax is \"ENCLOSURE [ABOVE|BELOW] overhang1 overhang2\n\t[WIDTH minWidth [EXCEPTEXTRACUT cutWithin]\n\t|LENGTH minLength] ;\"\n", values_[index]);
lefError(1330, msg);
free(wrkingStr);
if (enclRule)
free(enclRule);
return;
}
minWidth = strtod(strtok(NULL, " "), 0);
value = strtok(NULL, " ");
width = 1;
if (strcmp(value, "EXCEPTEXTRACUT") == 0) { // continue with WIDTH
except = 1;
value = strtok(NULL, " ");
cutWithin = strtod(value, 0);
value = strtok(NULL, " ");
if (strcmp(value, "NOSHAREDEDGE") == 0) {
// 5.8 syntax but not in OA data model
free(wrkingStr);
if (enclRule)
free(enclRule);
return;
}
}
} else if (strcmp(value, "LENGTH") == 0) {
if (width || (!overh)) {
/*
sprintf(msg, "ERROR (LEFPARS-1330): Incorrect syntax defined for property LEF57_ENCLOSURE: %s\nCorrect syntax is \"ENCLOSURE [ABOVE|BELOW] overhang1 overhang2\n\t[WIDTH minWidth [EXCEPTEXTRACUT cutWithin\n\t|LENGTH minLength] ;\"\n", values_[index]);
lefiError(msg);
*/
sprintf(msg, "Incorrect syntax defined for property LEF57_ENCLOSURE: %s\nCorrect syntax is \"ENCLOSURE [ABOVE|BELOW] overhang1 overhang2\n\t[WIDTH minWidth [EXCEPTEXTRACUT cutWithin\n\t|LENGTH minLength] ;\"\n", values_[index]);
lefError(1330, msg);
free(wrkingStr);
if (enclRule)
free(enclRule);
return;
}
minLength = strtod(strtok(NULL, " "), 0);
value = strtok(NULL, " ");
length = 1;
} else {
if (overh == 1) { // Already has overhang value
/*
sprintf(msg, "ERROR (LEFPARS-1330): Incorrect syntax defined for property LEF57_ENCLOSURE: %s\nCorrect syntax is \"ENCLOSURE [ABOVE|BELOW] overhang1 overhang2\n\t[WIDTH minWidth [EXCEPTEXTRACUT cutWithin]\n\t|LENGTH minLength] ;\"\n", values_[index]);
lefiError(msg);
*/
sprintf(msg, "Incorrect syntax defined for property LEF57_ENCLOSURE: %s\nCorrect syntax is \"ENCLOSURE [ABOVE|BELOW] overhang1 overhang2\n\t[WIDTH minWidth [EXCEPTEXTRACUT cutWithin]\n\t|LENGTH minLength] ;\"\n", values_[index]);
lefError(1330, msg);
free(wrkingStr);
if (enclRule)
free(enclRule);
return;
}
overhang1 = strtod(value, 0);
overhang2 = strtod(strtok(NULL, " "), 0);
overh = 1; // set the flag on
value = strtok(NULL, " ");
}
}
if (!overh) {
/*
sprintf(msg, "ERROR (LEFPARS-1330): Incorrect syntax defined for property LEF57_ENCLOSURE: %s\nCorrect syntax is \"ENCLOSURE [ABOVE|BELOW] overhang1 overhang2\n\t[WIDTH minWidth [EXCEPTEXTRACUT cutWithin]\n\t|LENGTH minLength] ;\"\n", values_[index]);
*/
sprintf(msg, "Incorrect syntax defined for property LEF57_ENCLOSURE: %s\nCorrect syntax is \"ENCLOSURE [ABOVE|BELOW] overhang1 overhang2\n\t[WIDTH minWidth [EXCEPTEXTRACUT cutWithin]\n\t|LENGTH minLength] ;\"\n", values_[index]);
lefError(1330, msg);
} else {
addEnclosure(enclRule, overhang1, overhang2);
if (width) {
addEnclosureWidth(minWidth);
if (except)
addEnclosureExceptEC(cutWithin);
}
if (length)
addEnclosureLength(minLength);
}
if (enclRule)
free(enclRule);
free(wrkingStr);
return;
}
|
O3
|
cpp
|
LefDefParser::lefiLayer::parseLayerEnclosure(int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x458, %rsp # imm = 0x458
movq %rdi, %r15
movq 0x360(%rdi), %rax
movslq %esi, %rbp
movq (%rax,%rbp,8), %r14
movq %r14, %rdi
callq 0x2380
movq %rax, %rbx
movq 0x10(%r15), %r12
leaq 0x30f59(%rip), %rsi # 0x4f4d9
movq %r12, %rdi
callq 0x22b0
testl %eax, %eax
je 0x1e5b2
leaq 0x30da7(%rip), %rsi # 0x4f33a
leaq 0x50(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x2050
movl $0x533, %edi # imm = 0x533
movq %r15, %rsi
jmp 0x1e5fd
leaq 0x31748(%rip), %rsi # 0x4fd01
movq %rbx, %rdi
callq 0x2300
leaq 0x2da00(%rip), %rsi # 0x4bfc8
movq %rax, %rdi
callq 0x22b0
testl %eax, %eax
je 0x1e61c
movq 0x360(%r15), %rax
movq (%rax,%rbp,8), %rdx
leaq 0x30e22(%rip), %rsi # 0x4f408
leaq 0x50(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
movl $0x532, %edi # imm = 0x532
movq %r14, %rsi
callq 0x2453a
movq %rbx, %rdi
callq 0x2240
addq $0x458, %rsp # imm = 0x458
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, 0x8(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rsp)
movb $0x1, %al
movq %rax, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
leaq 0x316c0(%rip), %r12 # 0x4fd01
xorl %ebx, %ebx
movq $0x0, 0x10(%rsp)
movsd %xmm0, 0x38(%rsp)
movsd %xmm0, 0x48(%rsp)
movsd %xmm0, 0x28(%rsp)
movsd %xmm0, 0x18(%rsp)
xorl %r13d, %r13d
xorl %edi, %edi
movq %r12, %rsi
callq 0x2300
movq %rax, %r14
cmpb $0x3b, (%r14)
jne 0x1e685
cmpb $0x0, 0x1(%r14)
je 0x1e89a
movq %r14, %rdi
leaq 0x30e36(%rip), %rsi # 0x4f4c5
callq 0x22b0
testl %eax, %eax
je 0x1e834
movq %r14, %rdi
leaq 0x3402c(%rip), %rsi # 0x526d2
callq 0x22b0
testl %eax, %eax
je 0x1e78a
movq %r14, %rdi
leaq 0x3401f(%rip), %rsi # 0x526dc
callq 0x22b0
testl %eax, %eax
je 0x1e78a
movq %r14, %rdi
leaq 0x2dcd6(%rip), %rsi # 0x4c3aa
callq 0x22b0
testl %eax, %eax
jne 0x1e7a6
testl %ebx, %ebx
je 0x1e84f
xorl %edi, %edi
movq %r12, %rsi
callq 0x2300
movq %rax, %rdi
xorl %esi, %esi
callq 0x2170
movsd %xmm0, 0x48(%rsp)
xorl %edi, %edi
movq %r12, %rsi
callq 0x2300
movq %rax, %r14
movq %rax, %rdi
leaq 0x30db4(%rip), %rsi # 0x4f4ce
callq 0x22b0
movl $0x1, %ebx
movl $0x1, %r13d
testl %eax, %eax
jne 0x1e674
xorl %edi, %edi
movq %r12, %rsi
callq 0x2300
movq %rax, %rdi
xorl %esi, %esi
callq 0x2170
movsd %xmm0, 0x28(%rsp)
xorl %edi, %edi
movq %r12, %rsi
callq 0x2300
movq %rax, %r14
movq %rax, %rdi
leaq 0x30d7a(%rip), %rsi # 0x4f4dd
callq 0x22b0
movl $0x1, %ebx
movl $0x1, %r13d
movl $0x1, %ecx
movq %rcx, 0x30(%rsp)
testl %eax, %eax
jne 0x1e674
jmp 0x1e969
testl %ebx, %ebx
jne 0x1e84f
movq %r14, %rdi
callq 0x2380
movq %rax, 0x10(%rsp)
xorl %ebx, %ebx
jmp 0x1e667
movq %r14, %rdi
leaq 0x33eb0(%rip), %rsi # 0x52660
callq 0x22b0
testl %eax, %eax
je 0x1e7f6
cmpl $0x1, %ebx
je 0x1e84f
movq %r14, %rdi
xorl %esi, %esi
callq 0x2170
movsd %xmm0, 0x40(%rsp)
xorl %edi, %edi
movq %r12, %rsi
callq 0x2300
movq %rax, %rdi
xorl %esi, %esi
callq 0x2170
movsd %xmm0, 0x38(%rsp)
movl $0x1, %ebx
jmp 0x1e667
testl %ebx, %ebx
je 0x1e986
testl %r13d, %r13d
jne 0x1e986
movq $0x0, 0x20(%rsp)
xorl %edi, %edi
movq %r12, %rsi
callq 0x2300
movq %rax, %rdi
xorl %esi, %esi
callq 0x2170
movsd %xmm0, 0x18(%rsp)
movl $0x1, %ebx
jmp 0x1e664
movq 0x8(%rsp), %rdi
addq $0x458, %rsp # imm = 0x458
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2240
movq 0x360(%r15), %rax
movq (%rax,%rbp,8), %rdx
leaq 0x30ba7(%rip), %rsi # 0x4f408
leaq 0x50(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
movl $0x532, %edi # imm = 0x532
movq %r14, %rsi
callq 0x2453a
movq 0x8(%rsp), %rdi
callq 0x2240
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
jne 0x1e605
jmp 0x1e60a
testl %ebx, %ebx
je 0x1e91b
movq %r15, %rdi
movq 0x10(%rsp), %r14
movq %r14, %rsi
movsd 0x40(%rsp), %xmm0
movsd 0x38(%rsp), %xmm1
callq 0x1c57c
testl %r13d, %r13d
movq 0x8(%rsp), %rbx
je 0x1e8f8
movq 0x4d8(%r15), %rcx
movslq 0x4b8(%r15), %rax
movsd 0x48(%rsp), %xmm0
movsd %xmm0, -0x8(%rcx,%rax,8)
cmpl $0x0, 0x30(%rsp)
je 0x1e8f8
movq 0x4e0(%r15), %rcx
movsd 0x28(%rsp), %xmm0
movsd %xmm0, -0x8(%rcx,%rax,8)
testb $0x1, 0x20(%rsp)
jne 0x1e953
movq 0x4e8(%r15), %rax
movslq 0x4b8(%r15), %rcx
movsd 0x18(%rsp), %xmm0
movsd %xmm0, -0x8(%rax,%rcx,8)
jmp 0x1e953
movq 0x360(%r15), %rax
movq (%rax,%rbp,8), %rdx
leaq 0x30adb(%rip), %rsi # 0x4f408
leaq 0x50(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
movl $0x532, %edi # imm = 0x532
movq %r14, %rsi
callq 0x2453a
movq 0x8(%rsp), %rbx
movq 0x10(%rsp), %r14
testq %r14, %r14
je 0x1e602
movq %r14, %rdi
callq 0x2240
jmp 0x1e602
movq 0x8(%rsp), %rdi
callq 0x2240
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
jne 0x1e839
jmp 0x1e60a
movq 0x360(%r15), %rax
movq (%rax,%rbp,8), %rdx
leaq 0x30b52(%rip), %rsi # 0x4f4ea
jmp 0x1e861
nop
|
_ZN12LefDefParser9lefiLayer19parseLayerEnclosureEi:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 458h
mov r15, rdi
mov rax, [rdi+360h]
movsxd rbp, esi
mov r14, [rax+rbp*8]
mov rdi, r14
call _strdup
mov rbx, rax
mov r12, [r15+10h]
lea rsi, aExceptextracut_0+0Bh; "CUT"
mov rdi, r12
call _strcmp
test eax, eax
jz short loc_1E5B2
lea rsi, aThePropertyLef_2; "The property LEF57_ENCLOSURE with value"...
lea r15, [rsp+488h+var_438]
mov rdi, r15
mov rdx, r14
mov rcx, r12
xor eax, eax
call _sprintf
mov edi, 533h
mov rsi, r15
jmp short loc_1E5FD
loc_1E5B2:
lea rsi, asc_4FCFD+4; " "
mov rdi, rbx
call _strtok
lea rsi, aLayerSEnclosur+9; "ENCLOSURE"
mov rdi, rax
call _strcmp
test eax, eax
jz short loc_1E61C
mov rax, [r15+360h]
mov rdx, [rax+rbp*8]
lea rsi, aIncorrectSynta_16; "Incorrect syntax defined for property L"...
lea r14, [rsp+488h+var_438]
mov rdi, r14
xor eax, eax
call _sprintf
mov edi, (offset stru_520.st_size+2); this
mov rsi, r14; int
loc_1E5FD:
call _ZN12LefDefParser8lefErrorEiPKc; LefDefParser::lefError(int,char const*)
loc_1E602:
mov rdi, rbx
loc_1E605:
call _free
loc_1E60A:
add rsp, 458h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1E61C:
mov [rsp+488h+var_480], rbx
xorps xmm0, xmm0
movsd [rsp+488h+var_448], xmm0
mov al, 1
mov [rsp+488h+var_468], rax
mov [rsp+488h+var_458], 0
lea r12, asc_4FCFD+4; " "
xor ebx, ebx
mov [rsp+488h+var_478], 0
movsd [rsp+488h+var_450], xmm0
movsd [rsp+488h+var_440], xmm0
movsd [rsp+488h+var_460], xmm0
movsd [rsp+488h+var_470], xmm0
loc_1E664:
xor r13d, r13d
loc_1E667:
xor edi, edi
mov rsi, r12
call _strtok
mov r14, rax
loc_1E674:
cmp byte ptr [r14], 3Bh ; ';'
jnz short loc_1E685
cmp byte ptr [r14+1], 0
jz loc_1E89A
loc_1E685:
mov rdi, r14
lea rsi, aCutclass; "CUTCLASS"
call _strcmp
test eax, eax
jz loc_1E834
mov rdi, r14
lea rsi, aFromabove+4; "ABOVE"
call _strcmp
test eax, eax
jz loc_1E78A
mov rdi, r14
lea rsi, aFrombelow+4; "BELOW"
call _strcmp
test eax, eax
jz loc_1E78A
mov rdi, r14
lea rsi, aWidth+1; "WIDTH"
call _strcmp
test eax, eax
jnz loc_1E7A6
test ebx, ebx
jz loc_1E84F
xor edi, edi
mov rsi, r12
call _strtok
mov rdi, rax
xor esi, esi
call _strtod
movsd [rsp+488h+var_440], xmm0
xor edi, edi
mov rsi, r12
call _strtok
mov r14, rax
mov rdi, rax
lea rsi, aExceptextracut_0; "EXCEPTEXTRACUT"
call _strcmp
mov ebx, 1
mov r13d, 1
test eax, eax
jnz loc_1E674
xor edi, edi
mov rsi, r12
call _strtok
mov rdi, rax
xor esi, esi
call _strtod
movsd [rsp+488h+var_460], xmm0
xor edi, edi
mov rsi, r12
call _strtok
mov r14, rax
mov rdi, rax
lea rsi, aNosharededge; "NOSHAREDEDGE"
call _strcmp
mov ebx, 1
mov r13d, 1
mov ecx, 1
mov [rsp+488h+var_458], rcx
test eax, eax
jnz loc_1E674
jmp loc_1E969
loc_1E78A:
test ebx, ebx
jnz loc_1E84F
mov rdi, r14
call _strdup
mov [rsp+488h+var_478], rax
xor ebx, ebx
jmp loc_1E667
loc_1E7A6:
mov rdi, r14
lea rsi, aDiagminedgelen+0Bh; "LENGTH"
call _strcmp
test eax, eax
jz short loc_1E7F6
cmp ebx, 1
jz loc_1E84F
mov rdi, r14
xor esi, esi
call _strtod
movsd [rsp+488h+var_448], xmm0
xor edi, edi
mov rsi, r12
call _strtok
mov rdi, rax
xor esi, esi
call _strtod
movsd [rsp+488h+var_450], xmm0
mov ebx, 1
jmp loc_1E667
loc_1E7F6:
test ebx, ebx
jz loc_1E986
test r13d, r13d
jnz loc_1E986
mov [rsp+488h+var_468], 0
xor edi, edi
mov rsi, r12
call _strtok
mov rdi, rax
xor esi, esi
call _strtod
movsd [rsp+488h+var_470], xmm0
mov ebx, 1
jmp loc_1E664
loc_1E834:
mov rdi, [rsp+488h+var_480]
loc_1E839:
add rsp, 458h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _free
loc_1E84F:
mov rax, [r15+360h]
mov rdx, [rax+rbp*8]
lea rsi, aIncorrectSynta_16; "Incorrect syntax defined for property L"...
loc_1E861:
lea r14, [rsp+488h+var_438]
mov rdi, r14
xor eax, eax
call _sprintf
mov edi, (offset stru_520.st_size+2); this
mov rsi, r14; int
call _ZN12LefDefParser8lefErrorEiPKc; LefDefParser::lefError(int,char const*)
mov rdi, [rsp+488h+var_480]
call _free
mov rdi, [rsp+488h+var_478]
test rdi, rdi
jnz loc_1E605
jmp loc_1E60A
loc_1E89A:
test ebx, ebx
jz short loc_1E91B
mov rdi, r15; this
mov r14, [rsp+488h+var_478]
mov rsi, r14; char *
movsd xmm0, [rsp+488h+var_448]; double
movsd xmm1, [rsp+488h+var_450]; double
call _ZN12LefDefParser9lefiLayer12addEnclosureEPcdd; LefDefParser::lefiLayer::addEnclosure(char *,double,double)
test r13d, r13d
mov rbx, [rsp+488h+var_480]
jz short loc_1E8F8
mov rcx, [r15+4D8h]
movsxd rax, dword ptr [r15+4B8h]
movsd xmm0, [rsp+488h+var_440]
movsd qword ptr [rcx+rax*8-8], xmm0
cmp dword ptr [rsp+488h+var_458], 0
jz short loc_1E8F8
mov rcx, [r15+4E0h]
movsd xmm0, [rsp+488h+var_460]
movsd qword ptr [rcx+rax*8-8], xmm0
loc_1E8F8:
test byte ptr [rsp+488h+var_468], 1
jnz short loc_1E953
mov rax, [r15+4E8h]
movsxd rcx, dword ptr [r15+4B8h]
movsd xmm0, [rsp+488h+var_470]
movsd qword ptr [rax+rcx*8-8], xmm0
jmp short loc_1E953
loc_1E91B:
mov rax, [r15+360h]
mov rdx, [rax+rbp*8]
lea rsi, aIncorrectSynta_16; "Incorrect syntax defined for property L"...
lea r14, [rsp+488h+var_438]
mov rdi, r14
xor eax, eax
call _sprintf
mov edi, (offset stru_520.st_size+2); this
mov rsi, r14; int
call _ZN12LefDefParser8lefErrorEiPKc; LefDefParser::lefError(int,char const*)
mov rbx, [rsp+488h+var_480]
mov r14, [rsp+488h+var_478]
loc_1E953:
test r14, r14
jz loc_1E602
mov rdi, r14
call _free
jmp loc_1E602
loc_1E969:
mov rdi, [rsp+488h+var_480]
call _free
mov rdi, [rsp+488h+var_478]
test rdi, rdi
jnz loc_1E839
jmp loc_1E60A
loc_1E986:
mov rax, [r15+360h]
mov rdx, [rax+rbp*8]
lea rsi, aIncorrectSynta_17; "Incorrect syntax defined for property L"...
jmp loc_1E861
|
long long LefDefParser::lefiLayer::parseLayerEnclosure(LefDefParser::lefiLayer *this, int a2)
{
const char *v2; // r14
long long v3; // rbx
const char *v4; // r12
const char *v5; // rdx
LefDefParser *v6; // rdi
long long v7; // rax
long long v8; // rdi
long long result; // rax
int v10; // ebx
int v11; // r13d
_BYTE *v12; // r14
long long v13; // rax
long long v14; // rax
long long v15; // rax
long long v16; // rax
char *v17; // rdi
long long v18; // rdx
const char *v19; // rsi
const char *v20; // rdx
char *v21; // r14
long long v22; // rax
const char *v23; // rdx
long long v24; // [rsp+8h] [rbp-480h]
char *v25; // [rsp+10h] [rbp-478h]
double v26; // [rsp+18h] [rbp-470h]
char v27; // [rsp+20h] [rbp-468h]
double v28; // [rsp+28h] [rbp-460h]
int v29; // [rsp+30h] [rbp-458h]
double v30; // [rsp+38h] [rbp-450h]
double v31; // [rsp+40h] [rbp-448h]
double v32; // [rsp+48h] [rbp-440h]
int v33[270]; // [rsp+50h] [rbp-438h] BYREF
v2 = *(const char **)(*((_QWORD *)this + 108) + 8LL * a2);
v3 = strdup(v2);
v4 = (const char *)*((_QWORD *)this + 2);
if ( (unsigned int)strcmp(v4, "CUT") )
{
sprintf(
v33,
"The property LEF57_ENCLOSURE with value %s is for TYPE CUT only.\n"
"The current layer has the TYPE %s.\n"
"Update the property of your lef file with the correct syntax or remove this property from your lef file.\n",
v2,
v4);
v6 = (LefDefParser *)(&stru_520 + 19);
LABEL_5:
LefDefParser::lefError(v6, (int)v33, v5);
LABEL_6:
v8 = v3;
return free(v8);
}
v7 = strtok(v3, " ");
if ( (unsigned int)strcmp(v7, "ENCLOSURE") )
{
sprintf(
v33,
"Incorrect syntax defined for property LEF57_ENCLOSURE: %s\n"
"Correct syntax is \"ENCLOSURE [ABOVE|BELOW] overhang1 overhang2\n"
"\t[WIDTH minWidth [EXCEPTEXTRACUT cutWithin]\n"
"\t|LENGTH minLength] ;\"\n",
*(const char **)(*((_QWORD *)this + 108) + 8LL * a2));
v6 = (LefDefParser *)((char *)&stru_520.st_size + 2);
goto LABEL_5;
}
v24 = v3;
v31 = 0.0;
v27 = 1;
v29 = 0;
v10 = 0;
v25 = 0LL;
v30 = 0.0;
v32 = 0.0;
v28 = 0.0;
v26 = 0.0;
LABEL_9:
v11 = 0;
LABEL_10:
v12 = (_BYTE *)strtok(0LL, " ");
while ( 1 )
{
if ( *v12 == 59 && !v12[1] )
{
if ( v10 )
{
v21 = v25;
LefDefParser::lefiLayer::addEnclosure(this, v25, v31, v30);
v3 = v24;
if ( v11 )
{
v22 = *((int *)this + 302);
*(double *)(*((_QWORD *)this + 155) + 8 * v22 - 8) = v32;
if ( v29 )
*(double *)(*((_QWORD *)this + 156) + 8 * v22 - 8) = v28;
}
if ( (v27 & 1) == 0 )
*(double *)(*((_QWORD *)this + 157) + 8LL * *((int *)this + 302) - 8) = v26;
}
else
{
sprintf(
v33,
"Incorrect syntax defined for property LEF57_ENCLOSURE: %s\n"
"Correct syntax is \"ENCLOSURE [ABOVE|BELOW] overhang1 overhang2\n"
"\t[WIDTH minWidth [EXCEPTEXTRACUT cutWithin]\n"
"\t|LENGTH minLength] ;\"\n",
*(const char **)(*((_QWORD *)this + 108) + 8LL * a2));
LefDefParser::lefError((LefDefParser *)((char *)&stru_520.st_size + 2), (int)v33, v23);
v3 = v24;
v21 = v25;
}
if ( v21 )
free(v21);
goto LABEL_6;
}
if ( !(unsigned int)strcmp(v12, "CUTCLASS") )
{
v17 = (char *)v24;
return free(v17);
}
if ( !(unsigned int)strcmp(v12, "ABOVE") || !(unsigned int)strcmp(v12, "BELOW") )
{
if ( !v10 )
{
v25 = (char *)strdup(v12);
v10 = 0;
goto LABEL_10;
}
goto LABEL_31;
}
if ( (unsigned int)strcmp(v12, "WIDTH") )
{
if ( !(unsigned int)strcmp(v12, "LENGTH") )
{
if ( v10 && !v11 )
{
v27 = 0;
v16 = strtok(0LL, " ");
v26 = strtod(v16, 0LL);
v10 = 1;
goto LABEL_9;
}
v18 = *(_QWORD *)(*((_QWORD *)this + 108) + 8LL * a2);
v19 = "Incorrect syntax defined for property LEF57_ENCLOSURE: %s\n"
"Correct syntax is \"ENCLOSURE [ABOVE|BELOW] overhang1 overhang2\n"
"\t[WIDTH minWidth [EXCEPTEXTRACUT cutWithin\n"
"\t|LENGTH minLength] ;\"\n";
LABEL_32:
sprintf(v33, v19, v18);
LefDefParser::lefError((LefDefParser *)((char *)&stru_520.st_size + 2), (int)v33, v20);
result = free(v24);
v8 = (long long)v25;
if ( !v25 )
return result;
return free(v8);
}
if ( v10 != 1 )
{
v31 = strtod(v12, 0LL);
v15 = strtok(0LL, " ");
v30 = strtod(v15, 0LL);
v10 = 1;
goto LABEL_10;
}
LABEL_31:
v18 = *(_QWORD *)(*((_QWORD *)this + 108) + 8LL * a2);
v19 = "Incorrect syntax defined for property LEF57_ENCLOSURE: %s\n"
"Correct syntax is \"ENCLOSURE [ABOVE|BELOW] overhang1 overhang2\n"
"\t[WIDTH minWidth [EXCEPTEXTRACUT cutWithin]\n"
"\t|LENGTH minLength] ;\"\n";
goto LABEL_32;
}
if ( !v10 )
goto LABEL_31;
v13 = strtok(0LL, " ");
v32 = strtod(v13, 0LL);
v12 = (_BYTE *)strtok(0LL, " ");
v10 = 1;
v11 = 1;
if ( !(unsigned int)strcmp(v12, "EXCEPTEXTRACUT") )
{
v14 = strtok(0LL, " ");
v28 = strtod(v14, 0LL);
v12 = (_BYTE *)strtok(0LL, " ");
v10 = 1;
v11 = 1;
v29 = 1;
if ( !(unsigned int)strcmp(v12, "NOSHAREDEDGE") )
break;
}
}
result = free(v24);
v17 = v25;
if ( v25 )
return free(v17);
return result;
}
|
parseLayerEnclosure:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x458
MOV R15,RDI
MOV RAX,qword ptr [RDI + 0x360]
MOVSXD RBP,ESI
MOV R14,qword ptr [RAX + RBP*0x8]
MOV RDI,R14
CALL 0x00102380
MOV RBX,RAX
MOV R12,qword ptr [R15 + 0x10]
LEA RSI,[0x14f4d9]
MOV RDI,R12
CALL 0x001022b0
TEST EAX,EAX
JZ 0x0011e5b2
LEA RSI,[0x14f33a]
LEA R15,[RSP + 0x50]
MOV RDI,R15
MOV RDX,R14
MOV RCX,R12
XOR EAX,EAX
CALL 0x00102050
MOV EDI,0x533
MOV RSI,R15
JMP 0x0011e5fd
LAB_0011e5b2:
LEA RSI,[0x14fd01]
MOV RDI,RBX
CALL 0x00102300
LEA RSI,[0x14bfc8]
MOV RDI,RAX
CALL 0x001022b0
TEST EAX,EAX
JZ 0x0011e61c
MOV RAX,qword ptr [R15 + 0x360]
MOV RDX,qword ptr [RAX + RBP*0x8]
LEA RSI,[0x14f408]
LEA R14,[RSP + 0x50]
MOV RDI,R14
XOR EAX,EAX
CALL 0x00102050
MOV EDI,0x532
MOV RSI,R14
LAB_0011e5fd:
CALL 0x0012453a
LAB_0011e602:
MOV RDI,RBX
LAB_0011e605:
CALL 0x00102240
LAB_0011e60a:
ADD RSP,0x458
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0011e61c:
MOV qword ptr [RSP + 0x8],RBX
XORPS XMM0,XMM0
MOVSD qword ptr [RSP + 0x40],XMM0
MOV AL,0x1
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x30],0x0
LEA R12,[0x14fd01]
XOR EBX,EBX
MOV qword ptr [RSP + 0x10],0x0
MOVSD qword ptr [RSP + 0x38],XMM0
MOVSD qword ptr [RSP + 0x48],XMM0
MOVSD qword ptr [RSP + 0x28],XMM0
MOVSD qword ptr [RSP + 0x18],XMM0
LAB_0011e664:
XOR R13D,R13D
LAB_0011e667:
XOR EDI,EDI
MOV RSI,R12
CALL 0x00102300
MOV R14,RAX
LAB_0011e674:
CMP byte ptr [R14],0x3b
JNZ 0x0011e685
CMP byte ptr [R14 + 0x1],0x0
JZ 0x0011e89a
LAB_0011e685:
MOV RDI,R14
LEA RSI,[0x14f4c5]
CALL 0x001022b0
TEST EAX,EAX
JZ 0x0011e834
MOV RDI,R14
LEA RSI,[0x1526d2]
CALL 0x001022b0
TEST EAX,EAX
JZ 0x0011e78a
MOV RDI,R14
LEA RSI,[0x1526dc]
CALL 0x001022b0
TEST EAX,EAX
JZ 0x0011e78a
MOV RDI,R14
LEA RSI,[0x14c3aa]
CALL 0x001022b0
TEST EAX,EAX
JNZ 0x0011e7a6
TEST EBX,EBX
JZ 0x0011e84f
XOR EDI,EDI
MOV RSI,R12
CALL 0x00102300
MOV RDI,RAX
XOR ESI,ESI
CALL 0x00102170
MOVSD qword ptr [RSP + 0x48],XMM0
XOR EDI,EDI
MOV RSI,R12
CALL 0x00102300
MOV R14,RAX
MOV RDI,RAX
LEA RSI,[0x14f4ce]
CALL 0x001022b0
MOV EBX,0x1
MOV R13D,0x1
TEST EAX,EAX
JNZ 0x0011e674
XOR EDI,EDI
MOV RSI,R12
CALL 0x00102300
MOV RDI,RAX
XOR ESI,ESI
CALL 0x00102170
MOVSD qword ptr [RSP + 0x28],XMM0
XOR EDI,EDI
MOV RSI,R12
CALL 0x00102300
MOV R14,RAX
MOV RDI,RAX
LEA RSI,[0x14f4dd]
CALL 0x001022b0
MOV EBX,0x1
MOV R13D,0x1
MOV ECX,0x1
MOV qword ptr [RSP + 0x30],RCX
TEST EAX,EAX
JNZ 0x0011e674
JMP 0x0011e969
LAB_0011e78a:
TEST EBX,EBX
JNZ 0x0011e84f
MOV RDI,R14
CALL 0x00102380
MOV qword ptr [RSP + 0x10],RAX
XOR EBX,EBX
JMP 0x0011e667
LAB_0011e7a6:
MOV RDI,R14
LEA RSI,[0x152660]
CALL 0x001022b0
TEST EAX,EAX
JZ 0x0011e7f6
CMP EBX,0x1
JZ 0x0011e84f
MOV RDI,R14
XOR ESI,ESI
CALL 0x00102170
MOVSD qword ptr [RSP + 0x40],XMM0
XOR EDI,EDI
MOV RSI,R12
CALL 0x00102300
MOV RDI,RAX
XOR ESI,ESI
CALL 0x00102170
MOVSD qword ptr [RSP + 0x38],XMM0
MOV EBX,0x1
JMP 0x0011e667
LAB_0011e7f6:
TEST EBX,EBX
JZ 0x0011e986
TEST R13D,R13D
JNZ 0x0011e986
MOV qword ptr [RSP + 0x20],0x0
XOR EDI,EDI
MOV RSI,R12
CALL 0x00102300
MOV RDI,RAX
XOR ESI,ESI
CALL 0x00102170
MOVSD qword ptr [RSP + 0x18],XMM0
MOV EBX,0x1
JMP 0x0011e664
LAB_0011e834:
MOV RDI,qword ptr [RSP + 0x8]
LAB_0011e839:
ADD RSP,0x458
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00102240
LAB_0011e84f:
MOV RAX,qword ptr [R15 + 0x360]
MOV RDX,qword ptr [RAX + RBP*0x8]
LEA RSI,[0x14f408]
LAB_0011e861:
LEA R14,[RSP + 0x50]
MOV RDI,R14
XOR EAX,EAX
CALL 0x00102050
MOV EDI,0x532
MOV RSI,R14
CALL 0x0012453a
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x00102240
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JNZ 0x0011e605
JMP 0x0011e60a
LAB_0011e89a:
TEST EBX,EBX
JZ 0x0011e91b
MOV RDI,R15
MOV R14,qword ptr [RSP + 0x10]
MOV RSI,R14
MOVSD XMM0,qword ptr [RSP + 0x40]
MOVSD XMM1,qword ptr [RSP + 0x38]
CALL 0x0011c57c
TEST R13D,R13D
MOV RBX,qword ptr [RSP + 0x8]
JZ 0x0011e8f8
MOV RCX,qword ptr [R15 + 0x4d8]
MOVSXD RAX,dword ptr [R15 + 0x4b8]
MOVSD XMM0,qword ptr [RSP + 0x48]
MOVSD qword ptr [RCX + RAX*0x8 + -0x8],XMM0
CMP dword ptr [RSP + 0x30],0x0
JZ 0x0011e8f8
MOV RCX,qword ptr [R15 + 0x4e0]
MOVSD XMM0,qword ptr [RSP + 0x28]
MOVSD qword ptr [RCX + RAX*0x8 + -0x8],XMM0
LAB_0011e8f8:
TEST byte ptr [RSP + 0x20],0x1
JNZ 0x0011e953
MOV RAX,qword ptr [R15 + 0x4e8]
MOVSXD RCX,dword ptr [R15 + 0x4b8]
MOVSD XMM0,qword ptr [RSP + 0x18]
MOVSD qword ptr [RAX + RCX*0x8 + -0x8],XMM0
JMP 0x0011e953
LAB_0011e91b:
MOV RAX,qword ptr [R15 + 0x360]
MOV RDX,qword ptr [RAX + RBP*0x8]
LEA RSI,[0x14f408]
LEA R14,[RSP + 0x50]
MOV RDI,R14
XOR EAX,EAX
CALL 0x00102050
MOV EDI,0x532
MOV RSI,R14
CALL 0x0012453a
MOV RBX,qword ptr [RSP + 0x8]
MOV R14,qword ptr [RSP + 0x10]
LAB_0011e953:
TEST R14,R14
JZ 0x0011e602
MOV RDI,R14
CALL 0x00102240
JMP 0x0011e602
LAB_0011e969:
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x00102240
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JNZ 0x0011e839
JMP 0x0011e60a
LAB_0011e986:
MOV RAX,qword ptr [R15 + 0x360]
MOV RDX,qword ptr [RAX + RBP*0x8]
LEA RSI,[0x14f4ea]
JMP 0x0011e861
|
/* LefDefParser::lefiLayer::parseLayerEnclosure(int) */
void __thiscall LefDefParser::lefiLayer::parseLayerEnclosure(lefiLayer *this,int param_1)
{
char *__s1;
bool bVar1;
bool bVar2;
bool bVar3;
bool bVar4;
int iVar5;
char *__s;
char *pcVar6;
int8 uVar7;
long lVar8;
char *local_478;
double local_470;
double local_460;
double local_450;
double local_448;
double local_440;
char local_438 [1032];
lVar8 = (long)param_1;
pcVar6 = *(char **)(*(long *)(this + 0x360) + lVar8 * 8);
__s = strdup(pcVar6);
__s1 = *(char **)(this + 0x10);
iVar5 = strcmp(__s1,"CUT");
if (iVar5 == 0) {
pcVar6 = strtok(__s," ");
iVar5 = strcmp(pcVar6,"ENCLOSURE");
if (iVar5 == 0) {
local_448 = 0.0;
bVar4 = true;
bVar3 = false;
bVar1 = false;
local_478 = (char *)0x0;
local_450 = 0.0;
local_440 = 0.0;
local_460 = 0.0;
local_470 = 0.0;
do {
bVar2 = false;
LAB_0011e667:
pcVar6 = strtok((char *)0x0," ");
while( true ) {
if ((*pcVar6 == ';') && (pcVar6[1] == '\0')) {
if (bVar1) {
addEnclosure(this,local_478,local_448,local_450);
if (bVar2) {
iVar5 = *(int *)(this + 0x4b8);
*(double *)(*(long *)(this + 0x4d8) + -8 + (long)iVar5 * 8) = local_440;
if (bVar3) {
*(double *)(*(long *)(this + 0x4e0) + -8 + (long)iVar5 * 8) = local_460;
}
}
if (!bVar4) {
*(double *)(*(long *)(this + 0x4e8) + -8 + (long)*(int *)(this + 0x4b8) * 8) =
local_470;
}
}
else {
sprintf(local_438,
"Incorrect syntax defined for property LEF57_ENCLOSURE: %s\nCorrect syntax is \"ENCLOSURE [ABOVE|BELOW] overhang1 overhang2\n\t[WIDTH minWidth [EXCEPTEXTRACUT cutWithin]\n\t|LENGTH minLength] ;\"\n"
,*(int8 *)(*(long *)(this + 0x360) + lVar8 * 8));
lefError(0x532,local_438);
}
if (local_478 != (char *)0x0) {
free(local_478);
}
goto LAB_0011e605;
}
iVar5 = strcmp(pcVar6,"CUTCLASS");
if (iVar5 == 0) goto LAB_0011e839;
iVar5 = strcmp(pcVar6,"ABOVE");
if ((iVar5 == 0) || (iVar5 = strcmp(pcVar6,"BELOW"), iVar5 == 0)) {
if (bVar1) goto LAB_0011e84f;
local_478 = strdup(pcVar6);
bVar1 = false;
goto LAB_0011e667;
}
iVar5 = strcmp(pcVar6,"WIDTH");
if (iVar5 != 0) break;
if (!bVar1) goto LAB_0011e84f;
pcVar6 = strtok((char *)0x0," ");
local_440 = strtod(pcVar6,(char **)0x0);
pcVar6 = strtok((char *)0x0," ");
iVar5 = strcmp(pcVar6,"EXCEPTEXTRACUT");
bVar1 = true;
bVar2 = true;
if (iVar5 == 0) {
pcVar6 = strtok((char *)0x0," ");
local_460 = strtod(pcVar6,(char **)0x0);
pcVar6 = strtok((char *)0x0," ");
iVar5 = strcmp(pcVar6,"NOSHAREDEDGE");
bVar1 = true;
bVar2 = true;
bVar3 = true;
if (iVar5 == 0) {
free(__s);
__s = local_478;
if (local_478 == (char *)0x0) {
return;
}
LAB_0011e839:
free(__s);
return;
}
}
}
iVar5 = strcmp(pcVar6,"LENGTH");
if (iVar5 != 0) {
if (bVar1) {
LAB_0011e84f:
uVar7 = *(int8 *)(*(long *)(this + 0x360) + lVar8 * 8);
pcVar6 =
"Incorrect syntax defined for property LEF57_ENCLOSURE: %s\nCorrect syntax is \"ENCLOSURE [ABOVE|BELOW] overhang1 overhang2\n\t[WIDTH minWidth [EXCEPTEXTRACUT cutWithin]\n\t|LENGTH minLength] ;\"\n"
;
goto LAB_0011e861;
}
local_448 = strtod(pcVar6,(char **)0x0);
pcVar6 = strtok((char *)0x0," ");
local_450 = strtod(pcVar6,(char **)0x0);
bVar1 = true;
goto LAB_0011e667;
}
if ((!bVar1) || (bVar2)) goto LAB_0011e986;
bVar4 = false;
pcVar6 = strtok((char *)0x0," ");
local_470 = strtod(pcVar6,(char **)0x0);
bVar1 = true;
} while( true );
}
sprintf(local_438,
"Incorrect syntax defined for property LEF57_ENCLOSURE: %s\nCorrect syntax is \"ENCLOSURE [ABOVE|BELOW] overhang1 overhang2\n\t[WIDTH minWidth [EXCEPTEXTRACUT cutWithin]\n\t|LENGTH minLength] ;\"\n"
,*(int8 *)(*(long *)(this + 0x360) + lVar8 * 8));
iVar5 = 0x532;
}
else {
sprintf(local_438,
"The property LEF57_ENCLOSURE with value %s is for TYPE CUT only.\nThe current layer has the TYPE %s.\nUpdate the property of your lef file with the correct syntax or remove this property from your lef file.\n"
,pcVar6,__s1);
iVar5 = 0x533;
}
lefError(iVar5,local_438);
LAB_0011e605:
free(__s);
return;
LAB_0011e986:
uVar7 = *(int8 *)(*(long *)(this + 0x360) + lVar8 * 8);
pcVar6 =
"Incorrect syntax defined for property LEF57_ENCLOSURE: %s\nCorrect syntax is \"ENCLOSURE [ABOVE|BELOW] overhang1 overhang2\n\t[WIDTH minWidth [EXCEPTEXTRACUT cutWithin\n\t|LENGTH minLength] ;\"\n"
;
LAB_0011e861:
sprintf(local_438,pcVar6,uVar7);
lefError(0x532,local_438);
free(__s);
__s = local_478;
if (local_478 == (char *)0x0) {
return;
}
goto LAB_0011e605;
}
|
|
63,333 |
bc_put_atom
|
bluesky950520[P]quickjs/quickjs.c
|
static int bc_put_atom(BCWriterState *s, JSAtom atom)
{
uint32_t v;
if (__JS_AtomIsTaggedInt(atom)) {
v = (__JS_AtomToUInt32(atom) << 1) | 1;
} else {
if (bc_atom_to_idx(s, &v, atom))
return -1;
v <<= 1;
}
bc_put_leb128(s, v);
return 0;
}
|
O0
|
c
|
bc_put_atom:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movl 0x4(%rsp), %edi
callq 0x360c0
cmpl $0x0, %eax
je 0x7935e
movl 0x4(%rsp), %edi
callq 0x360e0
shll %eax
orl $0x1, %eax
movl %eax, (%rsp)
jmp 0x79386
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %edx
movq %rsp, %rsi
callq 0x79870
cmpl $0x0, %eax
je 0x7937e
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x7939b
movl (%rsp), %eax
shll %eax
movl %eax, (%rsp)
movq 0x8(%rsp), %rdi
movl (%rsp), %esi
callq 0x78730
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
|
bc_put_atom:
sub rsp, 18h
mov [rsp+18h+var_10], rdi
mov [rsp+18h+var_14], esi
mov edi, [rsp+18h+var_14]
call __JS_AtomIsTaggedInt
cmp eax, 0
jz short loc_7935E
mov edi, [rsp+18h+var_14]
call __JS_AtomToUInt32
shl eax, 1
or eax, 1
mov [rsp+18h+var_18], eax
jmp short loc_79386
loc_7935E:
mov rdi, [rsp+18h+var_10]
mov edx, [rsp+18h+var_14]
mov rsi, rsp
call bc_atom_to_idx
cmp eax, 0
jz short loc_7937E
mov [rsp+18h+var_4], 0FFFFFFFFh
jmp short loc_7939B
loc_7937E:
mov eax, [rsp+18h+var_18]
shl eax, 1
mov [rsp+18h+var_18], eax
loc_79386:
mov rdi, [rsp+18h+var_10]
mov esi, [rsp+18h+var_18]
call bc_put_leb128
mov [rsp+18h+var_4], 0
loc_7939B:
mov eax, [rsp+18h+var_4]
add rsp, 18h
retn
|
long long bc_put_atom(long long a1, int a2)
{
unsigned int v3; // [rsp+0h] [rbp-18h] BYREF
unsigned int v4; // [rsp+4h] [rbp-14h]
long long v5; // [rsp+8h] [rbp-10h]
v5 = a1;
v4 = a2;
if ( _JS_AtomIsTaggedInt(a2) )
{
v3 = (2 * _JS_AtomToUInt32(v4)) | 1;
LABEL_6:
bc_put_leb128(v5, v3);
return 0;
}
if ( !(unsigned int)bc_atom_to_idx(v5, &v3, v4) )
{
v3 *= 2;
goto LABEL_6;
}
return (unsigned int)-1;
}
|
bc_put_atom:
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDI
MOV dword ptr [RSP + 0x4],ESI
MOV EDI,dword ptr [RSP + 0x4]
CALL 0x001360c0
CMP EAX,0x0
JZ 0x0017935e
MOV EDI,dword ptr [RSP + 0x4]
CALL 0x001360e0
SHL EAX,0x1
OR EAX,0x1
MOV dword ptr [RSP],EAX
JMP 0x00179386
LAB_0017935e:
MOV RDI,qword ptr [RSP + 0x8]
MOV EDX,dword ptr [RSP + 0x4]
MOV RSI,RSP
CALL 0x00179870
CMP EAX,0x0
JZ 0x0017937e
MOV dword ptr [RSP + 0x14],0xffffffff
JMP 0x0017939b
LAB_0017937e:
MOV EAX,dword ptr [RSP]
SHL EAX,0x1
MOV dword ptr [RSP],EAX
LAB_00179386:
MOV RDI,qword ptr [RSP + 0x8]
MOV ESI,dword ptr [RSP]
CALL 0x00178730
MOV dword ptr [RSP + 0x14],0x0
LAB_0017939b:
MOV EAX,dword ptr [RSP + 0x14]
ADD RSP,0x18
RET
|
int4 bc_put_atom(int8 param_1,int4 param_2)
{
int iVar1;
uint local_18;
int4 local_14;
int8 local_10;
local_14 = param_2;
local_10 = param_1;
iVar1 = __JS_AtomIsTaggedInt(param_2);
if (iVar1 == 0) {
iVar1 = bc_atom_to_idx(local_10,&local_18,local_14);
if (iVar1 != 0) {
return 0xffffffff;
}
local_18 = local_18 << 1;
}
else {
iVar1 = __JS_AtomToUInt32(local_14);
local_18 = iVar1 << 1 | 1;
}
bc_put_leb128(local_10,local_18);
return 0;
}
|
|
63,334 |
bc_put_atom
|
bluesky950520[P]quickjs/quickjs.c
|
static int bc_put_atom(BCWriterState *s, JSAtom atom)
{
uint32_t v;
if (__JS_AtomIsTaggedInt(atom)) {
v = (__JS_AtomToUInt32(atom) << 1) | 1;
} else {
if (bc_atom_to_idx(s, &v, atom))
return -1;
v <<= 1;
}
bc_put_leb128(s, v);
return 0;
}
|
O1
|
c
|
bc_put_atom:
pushq %rbx
subq $0x10, %rsp
movl %esi, %edx
movq %rdi, %rbx
testl %esi, %esi
js 0x45833
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x4589b
testl %eax, %eax
je 0x4583c
addq $0x10, %rsp
popq %rbx
retq
leal 0x1(,%rdx,2), %esi
jmp 0x45842
movl 0xc(%rsp), %esi
addl %esi, %esi
movl %esi, 0xc(%rsp)
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x45854
|
bc_put_atom:
push rbx
sub rsp, 10h
mov edx, esi
mov rbx, rdi
test esi, esi
js short loc_45833
lea rsi, [rsp+18h+var_C]
mov rdi, rbx
call bc_atom_to_idx
test eax, eax
jz short loc_4583C
add rsp, 10h
pop rbx
retn
loc_45833:
lea esi, ds:1[rdx*2]
jmp short loc_45842
loc_4583C:
mov esi, [rsp+18h+var_C]
add esi, esi
loc_45842:
mov [rsp+18h+var_C], esi
add rbx, 8
mov rdi, rbx
add rsp, 10h
pop rbx
jmp short $+2
|
long long bc_put_atom(long long a1, int a2)
{
long long result; // rax
long long v3; // rsi
_DWORD v4[3]; // [rsp+Ch] [rbp-Ch] BYREF
if ( a2 < 0 )
{
v3 = (unsigned int)(2 * a2 + 1);
return dbuf_put_leb128(a1 + 8, v3);
}
result = bc_atom_to_idx(a1, v4, (unsigned int)a2);
if ( !(_DWORD)result )
{
v3 = (unsigned int)(2 * v4[0]);
return dbuf_put_leb128(a1 + 8, v3);
}
return result;
}
| |||
63,335 |
my_strntoull10rnd_8bit
|
eloqsql/strings/ctype-simple.c
|
ulonglong
my_strntoull10rnd_8bit(CHARSET_INFO *cs __attribute__((unused)),
const char *str, size_t length, int unsigned_flag,
char **endptr, int *error)
{
const char *dot, *end9, *beg, *end= str + length;
ulonglong ull;
ulong ul;
uchar ch;
int shift= 0, digits= 0, negative, addon;
/* Skip leading spaces and tabs */
for ( ; str < end && my_isspace(&my_charset_latin1, *str) ; )
str++;
if (str >= end)
goto ret_edom;
if ((negative= (*str == '-')) || *str=='+') /* optional sign */
{
if (++str == end)
goto ret_edom;
}
beg= str;
end9= (str + 9) > end ? end : (str + 9);
/* Accumulate small number into ulong, for performance purposes */
for (ul= 0 ; str < end9 && (ch= (uchar) (*str - '0')) < 10; str++)
{
ul= ul * 10 + ch;
}
if (str >= end) /* Small number without dots and expanents */
{
*endptr= (char*) str;
if (negative)
{
if (unsigned_flag)
{
*error= ul ? MY_ERRNO_ERANGE : 0;
return 0;
}
else
{
*error= 0;
return (ulonglong) (longlong) -(long) ul;
}
}
else
{
*error=0;
return (ulonglong) ul;
}
}
digits= (int) (str - beg);
/* Continue to accumulate into ulonglong */
for (dot= NULL, ull= ul; str < end; str++)
{
if ((ch= (uchar) (*str - '0')) < 10)
{
if (ull < CUTOFF || (ull == CUTOFF && ch <= CUTLIM))
{
ull= ull * 10 + ch;
digits++;
continue;
}
/*
Adding the next digit would overflow.
Remember the next digit in "addon", for rounding.
Scan all digits with an optional single dot.
*/
if (ull == CUTOFF)
{
ull= ULONGLONG_MAX;
addon= 1;
str++;
}
else
addon= (*str >= '5');
if (!dot)
{
for ( ; str < end && (ch= (uchar) (*str - '0')) < 10; shift++, str++);
if (str < end && *str == '.')
{
str++;
for ( ; str < end && (ch= (uchar) (*str - '0')) < 10; str++);
}
}
else
{
shift= (int) (dot - str);
for ( ; str < end && (ch= (uchar) (*str - '0')) < 10; str++);
}
goto exp;
}
if (*str == '.')
{
if (dot)
{
/* The second dot character */
addon= 0;
goto exp;
}
else
{
dot= str + 1;
}
continue;
}
/* Unknown character, exit the loop */
break;
}
shift= dot ? (int)(dot - str) : 0; /* Right shift */
addon= 0;
exp: /* [ E [ <sign> ] <unsigned integer> ] */
if (!digits)
{
str= beg;
goto ret_edom;
}
if (str < end && (*str == 'e' || *str == 'E'))
{
str++;
if (str < end)
{
int negative_exp, exponent;
if ((negative_exp= (*str == '-')) || *str=='+')
{
if (++str == end)
{
str-= 2; /* 'e-' or 'e+' not followed by digits */
goto ret_sign;
}
}
if (shift > 0 && !negative_exp)
goto ret_too_big;
for (exponent= 0 ; str < end && (ch= (uchar) (*str - '0')) < 10; str++)
{
if (negative_exp)
{
if (exponent - shift > DIGITS_IN_ULONGLONG)
goto ret_zero;
}
else
{
if (exponent + shift > DIGITS_IN_ULONGLONG)
goto ret_too_big;
}
exponent= exponent * 10 + ch;
}
shift+= negative_exp ? -exponent : exponent;
}
else
str--; /* 'e' not followed by digits */
}
if (shift == 0) /* No shift, check addon digit */
{
if (addon)
{
if (ull == ULONGLONG_MAX)
goto ret_too_big;
ull++;
}
goto ret_sign;
}
if (shift < 0) /* Right shift */
{
ulonglong d, r;
if (-shift >= DIGITS_IN_ULONGLONG)
goto ret_zero; /* Exponent is a big negative number, return 0 */
d= d10[-shift];
r= (ull % d) * 2;
ull /= d;
if (r >= d)
ull++;
goto ret_sign;
}
if (shift > DIGITS_IN_ULONGLONG) /* Huge left shift */
{
if (!ull)
goto ret_sign;
goto ret_too_big;
}
for ( ; shift > 0; shift--, ull*= 10) /* Left shift */
{
if (ull > CUTOFF)
goto ret_too_big; /* Overflow, number too big */
}
ret_sign:
*endptr= (char*) str;
if (!unsigned_flag)
{
if (negative)
{
if (ull >= (ulonglong) LONGLONG_MIN)
{
if (ull != (ulonglong) LONGLONG_MIN)
*error= MY_ERRNO_ERANGE;
return (ulonglong) LONGLONG_MIN;
}
*error= 0;
return (ulonglong) -(longlong) ull;
}
else
{
if (ull > (ulonglong) LONGLONG_MAX)
{
*error= MY_ERRNO_ERANGE;
return (ulonglong) LONGLONG_MAX;
}
*error= 0;
return ull;
}
}
/* Unsigned number */
if (negative && ull)
{
*error= MY_ERRNO_ERANGE;
return 0;
}
*error= 0;
return ull;
ret_zero:
*endptr= (char*) str;
*error= 0;
return 0;
ret_edom:
*endptr= (char*) str;
*error= MY_ERRNO_EDOM;
return 0;
ret_too_big:
*endptr= (char*) str;
*error= MY_ERRNO_ERANGE;
return unsigned_flag ?
ULONGLONG_MAX :
negative ? (ulonglong) LONGLONG_MIN : (ulonglong) LONGLONG_MAX;
}
|
O3
|
c
|
my_strntoull10rnd_8bit:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdx, %rdx
jle 0xb6373
leaq (%rsi,%rdx), %r11
leaq 0x2f5e67(%rip), %rax # 0x3abf20
movq 0x40(%rax), %rax
decq %rdx
movzbl (%rsi), %r10d
testb $0x8, 0x1(%rax,%r10)
je 0xb60dc
incq %rsi
decq %rdx
cmpq %r11, %rsi
jb 0xb60c0
jmp 0xb6373
cmpl $0x2b, %r10d
je 0xb60e8
cmpl $0x2d, %r10d
jne 0xb60f4
testq %rdx, %rdx
je 0xb61cb
incq %rsi
leaq 0x9(%rsi), %rax
cmpq %r11, %rax
cmovaq %r11, %rax
xorl %edi, %edi
movq %rsi, %r14
cmpq %rax, %rsi
jae 0xb6127
movb (%r14), %dl
addb $-0x30, %dl
cmpb $0x9, %dl
ja 0xb6127
leaq (%rdi,%rdi,4), %rdi
movzbl %dl, %edx
leaq (%rdx,%rdi,2), %rdi
incq %r14
cmpq %rax, %r14
jb 0xb6109
cmpq %r11, %r14
jae 0xb61a1
movabsq $0x1999999999999999, %r15 # imm = 0x1999999999999999
movl %r14d, %r12d
subl %esi, %r12d
xorl %ebx, %ebx
movl %r14d, %r13d
movb (%r14), %al
leal -0x30(%rax), %edx
cmpb $0x9, %dl
ja 0xb6170
cmpq %r15, %rdi
jb 0xb6160
jne 0xb61e0
cmpb $0x5, %dl
ja 0xb61e0
leaq (%rdi,%rdi,4), %rax
movzbl %dl, %edx
leaq (%rdx,%rax,2), %rdi
incl %r12d
jmp 0xb617d
cmpb $0x2e, %al
jne 0xb6188
testq %rbx, %rbx
jne 0xb61d3
leaq 0x1(%r14), %rbx
incq %r14
incl %r13d
cmpq %r11, %r14
jb 0xb6141
movl %ebx, %eax
subl %r14d, %eax
xorl %r13d, %r13d
testq %rbx, %rbx
cmovel %r13d, %eax
movl %eax, %ebx
movq %rdi, %rax
jmp 0xb629e
movq %r14, (%r8)
cmpl $0x2d, %r10d
jne 0xb6456
testl %ecx, %ecx
je 0xb6442
xorl %eax, %eax
testq %rdi, %rdi
movl $0x22, %ecx
cmovel %eax, %ecx
movl %ecx, (%r9)
jmp 0xb637d
movq %r11, %rsi
jmp 0xb6373
xorl %ebx, %ebx
movq %rdi, %rax
xorl %r13d, %r13d
jmp 0xb629e
movl %ecx, -0x30(%rbp)
cmpb $0x35, %al
setae %al
movl %eax, -0x2c(%rbp)
xorl %ecx, %ecx
cmpq %r15, %rdi
movq $-0x1, %rax
cmovneq %rdi, %rax
sete %cl
movl -0x2c(%rbp), %edx
orb %cl, %dl
movl %edx, -0x2c(%rbp)
movq %rcx, %rdx
movq %r15, %rcx
leaq (%r14,%rdx), %r15
testq %rbx, %rbx
je 0xb6250
xorl %edx, %edx
cmpq %rcx, %rdi
sete %dl
subl %edx, %ebx
subl %r13d, %ebx
cmpq %r11, %r15
movl -0x30(%rbp), %ecx
jae 0xb628d
movl -0x2c(%rbp), %r13d
movb (%r15), %dl
addb $-0x30, %dl
cmpb $0x9, %dl
ja 0xb6241
incq %r15
cmpq %r11, %r15
jb 0xb622e
movq %r15, %r14
movabsq $0x1999999999999999, %r15 # imm = 0x1999999999999999
jmp 0xb629e
xorl %ebx, %ebx
cmpq %r11, %r15
movl -0x30(%rbp), %ecx
jae 0xb628d
leaq (%r14,%rdx), %rdi
xorl %ebx, %ebx
leaq (%rdx,%rbx), %r15
movb (%r14,%r15), %r15b
leal -0x30(%r15), %r13d
cmpb $0x9, %r13b
ja 0xb6499
leaq (%rbx,%rdi), %r15
incq %r15
incq %rbx
cmpq %r11, %r15
jb 0xb6260
addq %rbx, %rdi
movq %rdi, %r14
jmp 0xb6290
movq %r15, %r14
movabsq $0x1999999999999999, %r15 # imm = 0x1999999999999999
movl -0x2c(%rbp), %r13d
testl %r12d, %r12d
je 0xb6373
cmpq %r11, %r14
jae 0xb635c
movzbl (%r14), %edx
orl $0x20, %edx
cmpl $0x65, %edx
jne 0xb635c
leaq 0x1(%r14), %rsi
cmpq %r11, %rsi
jae 0xb635c
movzbl (%rsi), %edi
cmpl $0x2d, %edi
je 0xb62da
cmpl $0x2b, %edi
jne 0xb62e7
leaq 0x2(%r14), %rsi
cmpq %r11, %rsi
je 0xb63c6
testl %ebx, %ebx
jle 0xb62f5
cmpb $0x2d, %dil
jne 0xb63ce
xorl %r14d, %r14d
cmpq %r11, %rsi
jae 0xb6348
xorl %r14d, %r14d
movb (%rsi), %dl
addb $-0x30, %dl
cmpb $0x9, %dl
ja 0xb6348
movq %r15, %r12
cmpb $0x2d, %dil
jne 0xb6324
movl %r14d, %r15d
subl %ebx, %r15d
cmpl $0x14, %r15d
jle 0xb6332
jmp 0xb63a5
leal (%r14,%rbx), %r15d
cmpl $0x14, %r15d
jg 0xb63ce
movzbl %dl, %edx
leal (%r14,%r14,4), %r14d
leal (%rdx,%r14,2), %r14d
incq %rsi
cmpq %r11, %rsi
movq %r12, %r15
jb 0xb6300
movl %r14d, %edx
negl %edx
cmpb $0x2d, %dil
cmovnel %r14d, %edx
addl %ebx, %edx
movl %edx, %ebx
movq %rsi, %r14
testl %ebx, %ebx
je 0xb638d
js 0xb639d
cmpl $0x14, %ebx
jbe 0xb63b1
testq %rax, %rax
jne 0xb63cb
xorl %edi, %edi
jmp 0xb6419
movq %rsi, (%r8)
movl $0x21, (%r9)
xorl %edi, %edi
movq %rdi, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testb %r13b, %r13b
je 0xb63c6
cmpq $-0x1, %rax
je 0xb63cb
incq %rax
jmp 0xb63c6
cmpl $-0x13, %ebx
jae 0xb63fa
movq %r14, %rsi
movq %rsi, (%r8)
movl $0x0, (%r9)
jmp 0xb637d
incl %ebx
cmpq %r15, %rax
ja 0xb63cb
addq %rax, %rax
leaq (%rax,%rax,4), %rax
decl %ebx
cmpl $0x1, %ebx
jg 0xb63b3
movq %rax, %rdi
jmp 0xb6419
movq %r14, %rsi
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
leaq -0x1(%rax), %rdx
cmpl $0x2d, %r10d
movq %rsi, (%r8)
movl $0x22, (%r9)
cmoveq %rax, %rdx
xorl %edi, %edi
negl %ecx
sbbq %rdi, %rdi
orq %rdx, %rdi
jmp 0xb637f
negl %ebx
leaq 0x16f74d(%rip), %rdx # 0x225b50
movq (%rdx,%rbx,8), %rsi
xorl %edx, %edx
divq %rsi
movq %rax, %rdi
addq %rdx, %rdx
cmpq %rsi, %rdx
sbbq $-0x1, %rdi
movq %r14, (%r8)
testl %ecx, %ecx
je 0xb6437
cmpl $0x2d, %r10d
jne 0xb6456
testq %rdi, %rdi
je 0xb6456
movl $0x22, (%r9)
jmp 0xb637d
cmpl $0x2d, %r10d
jne 0xb6451
testq %rdi, %rdi
js 0xb6462
movl $0x0, (%r9)
negq %rdi
jmp 0xb637f
testq %rdi, %rdi
js 0xb6480
movl $0x0, (%r9)
jmp 0xb637f
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
negq %rdi
jo 0xb6478
movl $0x22, (%r9)
movq %rax, %rdi
jmp 0xb637f
movl $0x22, (%r9)
movabsq $-0x8000000000000000, %rdi # imm = 0x8000000000000000
decq %rdi
jmp 0xb637f
cmpb $0x2e, %r15b
movl -0x2c(%rbp), %r13d
jne 0xb64d6
leaq (%rbx,%rdi), %rdx
incq %rdx
movabsq $0x1999999999999999, %r15 # imm = 0x1999999999999999
movq %rdx, %r14
cmpq %r11, %rdx
jae 0xb629e
movb (%r14), %dil
addb $-0x30, %dil
leaq 0x1(%r14), %rdx
cmpb $0xa, %dil
jb 0xb64b4
jmp 0xb629e
addq %rbx, %rdi
movq %rdi, %r14
jmp 0xb6244
|
my_strntoull10rnd_8bit:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
test rdx, rdx
jle loc_B6373
lea r11, [rsi+rdx]
lea rax, my_charset_latin1
mov rax, [rax+40h]
dec rdx
loc_B60C0:
movzx r10d, byte ptr [rsi]
test byte ptr [rax+r10+1], 8
jz short loc_B60DC
inc rsi
dec rdx
cmp rsi, r11
jb short loc_B60C0
jmp loc_B6373
loc_B60DC:
cmp r10d, 2Bh ; '+'
jz short loc_B60E8
cmp r10d, 2Dh ; '-'
jnz short loc_B60F4
loc_B60E8:
test rdx, rdx
jz loc_B61CB
inc rsi
loc_B60F4:
lea rax, [rsi+9]
cmp rax, r11
cmova rax, r11
xor edi, edi
mov r14, rsi
cmp rsi, rax
jnb short loc_B6127
loc_B6109:
mov dl, [r14]
add dl, 0D0h
cmp dl, 9
ja short loc_B6127
lea rdi, [rdi+rdi*4]
movzx edx, dl
lea rdi, [rdx+rdi*2]
inc r14
cmp r14, rax
jb short loc_B6109
loc_B6127:
cmp r14, r11
jnb short loc_B61A1
mov r15, 1999999999999999h
mov r12d, r14d
sub r12d, esi
xor ebx, ebx
mov r13d, r14d
loc_B6141:
mov al, [r14]
lea edx, [rax-30h]
cmp dl, 9
ja short loc_B6170
cmp rdi, r15
jb short loc_B6160
jnz loc_B61E0
cmp dl, 5
ja loc_B61E0
loc_B6160:
lea rax, [rdi+rdi*4]
movzx edx, dl
lea rdi, [rdx+rax*2]
inc r12d
jmp short loc_B617D
loc_B6170:
cmp al, 2Eh ; '.'
jnz short loc_B6188
test rbx, rbx
jnz short loc_B61D3
lea rbx, [r14+1]
loc_B617D:
inc r14
inc r13d
cmp r14, r11
jb short loc_B6141
loc_B6188:
mov eax, ebx
sub eax, r14d
xor r13d, r13d
test rbx, rbx
cmovz eax, r13d
mov ebx, eax
mov rax, rdi
jmp loc_B629E
loc_B61A1:
mov [r8], r14
cmp r10d, 2Dh ; '-'
jnz loc_B6456
test ecx, ecx
jz loc_B6442
xor eax, eax
test rdi, rdi
mov ecx, 22h ; '"'
cmovz ecx, eax
mov [r9], ecx
jmp loc_B637D
loc_B61CB:
mov rsi, r11
jmp loc_B6373
loc_B61D3:
xor ebx, ebx
mov rax, rdi
xor r13d, r13d
jmp loc_B629E
loc_B61E0:
mov [rbp+var_30], ecx
cmp al, 35h ; '5'
setnb al
mov [rbp+var_2C], eax
xor ecx, ecx
cmp rdi, r15
mov rax, 0FFFFFFFFFFFFFFFFh
cmovnz rax, rdi
setz cl
mov edx, [rbp+var_2C]
or dl, cl
mov [rbp+var_2C], edx
mov rdx, rcx
mov rcx, r15
lea r15, [r14+rdx]
test rbx, rbx
jz short loc_B6250
xor edx, edx
cmp rdi, rcx
setz dl
sub ebx, edx
sub ebx, r13d
cmp r15, r11
mov ecx, [rbp+var_30]
jnb short loc_B628D
mov r13d, [rbp+var_2C]
loc_B622E:
mov dl, [r15]
add dl, 0D0h
cmp dl, 9
ja short loc_B6241
inc r15
cmp r15, r11
jb short loc_B622E
loc_B6241:
mov r14, r15
loc_B6244:
mov r15, 1999999999999999h
jmp short loc_B629E
loc_B6250:
xor ebx, ebx
cmp r15, r11
mov ecx, [rbp+var_30]
jnb short loc_B628D
lea rdi, [r14+rdx]
xor ebx, ebx
loc_B6260:
lea r15, [rdx+rbx]
mov r15b, [r14+r15]
lea r13d, [r15-30h]
cmp r13b, 9
ja loc_B6499
lea r15, [rbx+rdi]
inc r15
inc rbx
cmp r15, r11
jb short loc_B6260
add rdi, rbx
mov r14, rdi
jmp short loc_B6290
loc_B628D:
mov r14, r15
loc_B6290:
mov r15, 1999999999999999h
mov r13d, [rbp+var_2C]
loc_B629E:
test r12d, r12d
jz loc_B6373
cmp r14, r11
jnb loc_B635C
movzx edx, byte ptr [r14]
or edx, 20h
cmp edx, 65h ; 'e'
jnz loc_B635C
lea rsi, [r14+1]
cmp rsi, r11
jnb loc_B635C
movzx edi, byte ptr [rsi]
cmp edi, 2Dh ; '-'
jz short loc_B62DA
cmp edi, 2Bh ; '+'
jnz short loc_B62E7
loc_B62DA:
lea rsi, [r14+2]
cmp rsi, r11
jz loc_B63C6
loc_B62E7:
test ebx, ebx
jle short loc_B62F5
cmp dil, 2Dh ; '-'
jnz loc_B63CE
loc_B62F5:
xor r14d, r14d
cmp rsi, r11
jnb short loc_B6348
xor r14d, r14d
loc_B6300:
mov dl, [rsi]
add dl, 0D0h
cmp dl, 9
ja short loc_B6348
mov r12, r15
cmp dil, 2Dh ; '-'
jnz short loc_B6324
mov r15d, r14d
sub r15d, ebx
cmp r15d, 14h
jle short loc_B6332
jmp loc_B63A5
loc_B6324:
lea r15d, [r14+rbx]
cmp r15d, 14h
jg loc_B63CE
loc_B6332:
movzx edx, dl
lea r14d, [r14+r14*4]
lea r14d, [rdx+r14*2]
inc rsi
cmp rsi, r11
mov r15, r12
jb short loc_B6300
loc_B6348:
mov edx, r14d
neg edx
cmp dil, 2Dh ; '-'
cmovnz edx, r14d
add edx, ebx
mov ebx, edx
mov r14, rsi
loc_B635C:
test ebx, ebx
jz short loc_B638D
js short loc_B639D
cmp ebx, 14h
jbe short loc_B63B1
test rax, rax
jnz short loc_B63CB
xor edi, edi
jmp loc_B6419
loc_B6373:
mov [r8], rsi
mov dword ptr [r9], 21h ; '!'
loc_B637D:
xor edi, edi
loc_B637F:
mov rax, rdi
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_B638D:
test r13b, r13b
jz short loc_B63C6
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_B63CB
inc rax
jmp short loc_B63C6
loc_B639D:
cmp ebx, 0FFFFFFEDh
jnb short loc_B63FA
mov rsi, r14
loc_B63A5:
mov [r8], rsi
mov dword ptr [r9], 0
jmp short loc_B637D
loc_B63B1:
inc ebx
loc_B63B3:
cmp rax, r15
ja short loc_B63CB
add rax, rax
lea rax, [rax+rax*4]
dec ebx
cmp ebx, 1
jg short loc_B63B3
loc_B63C6:
mov rdi, rax
jmp short loc_B6419
loc_B63CB:
mov rsi, r14
loc_B63CE:
mov rax, 8000000000000000h
lea rdx, [rax-1]
cmp r10d, 2Dh ; '-'
mov [r8], rsi
mov dword ptr [r9], 22h ; '"'
cmovz rdx, rax
xor edi, edi
neg ecx
sbb rdi, rdi
or rdi, rdx
jmp short loc_B637F
loc_B63FA:
neg ebx
lea rdx, d10
mov rsi, [rdx+rbx*8]
xor edx, edx
div rsi
mov rdi, rax
add rdx, rdx
cmp rdx, rsi
sbb rdi, 0FFFFFFFFFFFFFFFFh
loc_B6419:
mov [r8], r14
test ecx, ecx
jz short loc_B6437
cmp r10d, 2Dh ; '-'
jnz short loc_B6456
test rdi, rdi
jz short loc_B6456
mov dword ptr [r9], 22h ; '"'
jmp loc_B637D
loc_B6437:
cmp r10d, 2Dh ; '-'
jnz short loc_B6451
test rdi, rdi
js short loc_B6462
loc_B6442:
mov dword ptr [r9], 0
neg rdi
jmp loc_B637F
loc_B6451:
test rdi, rdi
js short loc_B6480
loc_B6456:
mov dword ptr [r9], 0
jmp loc_B637F
loc_B6462:
mov rax, 8000000000000000h
neg rdi
jo short loc_B6478
mov dword ptr [r9], 22h ; '"'
loc_B6478:
mov rdi, rax
jmp loc_B637F
loc_B6480:
mov dword ptr [r9], 22h ; '"'
mov rdi, 8000000000000000h
dec rdi
jmp loc_B637F
loc_B6499:
cmp r15b, 2Eh ; '.'
mov r13d, [rbp+var_2C]
jnz short loc_B64D6
lea rdx, [rbx+rdi]
inc rdx
mov r15, 1999999999999999h
loc_B64B4:
mov r14, rdx
cmp rdx, r11
jnb loc_B629E
mov dil, [r14]
add dil, 0D0h
lea rdx, [r14+1]
cmp dil, 0Ah
jb short loc_B64B4
jmp loc_B629E
loc_B64D6:
add rdi, rbx
mov r14, rdi
jmp loc_B6244
|
long long my_strntoull10rnd_8bit(
long long a1,
unsigned __int8 *a2,
long long a3,
int a4,
unsigned __int8 **a5,
int *a6)
{
unsigned long long v6; // r11
long long v7; // rdx
long long v8; // r10
unsigned __int8 *v9; // rax
long long v10; // rdi
unsigned __int8 *i; // r14
unsigned __int8 v12; // dl
int v13; // r12d
_BYTE *v14; // rbx
int v15; // r13d
unsigned __int8 v16; // al
unsigned __int8 v17; // dl
int v18; // eax
bool v19; // r13
unsigned long long v20; // rax
int v21; // ecx
long long v22; // rcx
long long v23; // rdx
unsigned __int8 *v24; // r15
unsigned __int8 *v25; // rdi
char v26; // r15
unsigned long long v27; // r15
unsigned __int8 *v28; // rsi
int v29; // edi
int v30; // r14d
unsigned __int8 v31; // dl
int v32; // edx
int v34; // ebx
unsigned long long v35; // rdx
unsigned long long v36; // rsi
unsigned __int8 *v37; // rdx
unsigned __int8 v38; // di
int v39; // [rsp+0h] [rbp-30h]
bool v40; // [rsp+4h] [rbp-2Ch]
bool v41; // [rsp+4h] [rbp-2Ch]
if ( a3 <= 0 )
goto LABEL_76;
v6 = (unsigned long long)&a2[a3];
v7 = a3 - 1;
while ( 1 )
{
v8 = *a2;
if ( (*(_BYTE *)(*(_QWORD *)&my_charset_latin1[16] + v8 + 1) & 8) == 0 )
break;
++a2;
--v7;
if ( (unsigned long long)a2 >= v6 )
goto LABEL_76;
}
if ( (_DWORD)v8 == 43 || (_DWORD)v8 == 45 )
{
if ( !v7 )
{
a2 = (unsigned __int8 *)v6;
goto LABEL_76;
}
++a2;
}
v9 = a2 + 9;
if ( (unsigned long long)(a2 + 9) > v6 )
v9 = (unsigned __int8 *)v6;
v10 = 0LL;
for ( i = a2; i < v9; ++i )
{
v12 = *i - 48;
if ( v12 > 9u )
break;
v10 = v12 + 10 * v10;
}
if ( (unsigned long long)i >= v6 )
{
*a5 = i;
if ( (_DWORD)v8 != 45 )
goto LABEL_102;
if ( a4 )
{
v21 = 34;
if ( !v10 )
v21 = 0;
*a6 = v21;
return 0LL;
}
goto LABEL_100;
}
v13 = (_DWORD)i - (_DWORD)a2;
v14 = 0LL;
v15 = (int)i;
while ( 1 )
{
v16 = *i;
v17 = *i - 48;
if ( v17 <= 9u )
break;
if ( v16 != 46 )
goto LABEL_26;
if ( v14 )
{
LODWORD(v14) = 0;
v20 = v10;
v19 = 0;
goto LABEL_51;
}
v14 = i + 1;
LABEL_25:
++i;
++v15;
if ( (unsigned long long)i >= v6 )
{
LABEL_26:
v18 = (_DWORD)v14 - (_DWORD)i;
v19 = 0;
if ( !v14 )
v18 = 0;
LODWORD(v14) = v18;
v20 = v10;
goto LABEL_51;
}
}
if ( (unsigned long long)v10 < 0x1999999999999999LL || v10 == 0x1999999999999999LL && v17 <= 5u )
{
v10 = v17 + 10 * v10;
++v13;
goto LABEL_25;
}
v39 = a4;
v40 = v16 >= 0x35u;
v22 = 0LL;
v20 = -1LL;
if ( v10 != 0x1999999999999999LL )
v20 = v10;
LOBYTE(v22) = v10 == 0x1999999999999999LL;
v41 = v10 == 0x1999999999999999LL || v40;
v23 = v22;
v24 = &i[v22];
if ( v14 )
{
LODWORD(v14) = (_DWORD)v14 - (v10 == 0x1999999999999999LL) - v15;
a4 = v39;
if ( (unsigned long long)v24 < v6 )
{
v19 = v41;
do
{
if ( (unsigned __int8)(*v24 - 48) > 9u )
break;
++v24;
}
while ( (unsigned long long)v24 < v6 );
i = v24;
goto LABEL_51;
}
LABEL_49:
i = v24;
LABEL_50:
v19 = v41;
}
else
{
LODWORD(v14) = 0;
a4 = v39;
if ( (unsigned long long)v24 >= v6 )
goto LABEL_49;
v25 = &i[v23];
v14 = 0LL;
while ( 1 )
{
v26 = v14[v23 + (_QWORD)i];
if ( (unsigned __int8)(v26 - 48) > 9u )
break;
v27 = (unsigned long long)&v25[(_QWORD)v14++ + 1];
if ( v27 >= v6 )
{
i = &v25[(_QWORD)v14];
goto LABEL_50;
}
}
v19 = v41;
if ( v26 == 46 )
{
v37 = &v25[(_QWORD)v14 + 1];
do
{
i = v37;
if ( (unsigned long long)v37 >= v6 )
break;
v38 = *v37++ - 48;
}
while ( v38 < 0xAu );
}
else
{
i = &v25[(_QWORD)v14];
}
}
LABEL_51:
if ( !v13 )
{
LABEL_76:
*a5 = a2;
*a6 = 33;
return 0LL;
}
if ( (unsigned long long)i >= v6 )
goto LABEL_71;
if ( (*i | 0x20) != 0x65 )
goto LABEL_71;
v28 = i + 1;
if ( (unsigned long long)(i + 1) >= v6 )
goto LABEL_71;
v29 = *v28;
if ( v29 == 45 || v29 == 43 )
{
v28 = i + 2;
if ( i + 2 == (unsigned __int8 *)v6 )
{
LABEL_88:
v10 = v20;
LABEL_94:
*a5 = i;
if ( a4 )
{
if ( (_DWORD)v8 == 45 && v10 )
{
*a6 = 34;
return 0LL;
}
LABEL_102:
*a6 = 0;
return v10;
}
if ( (_DWORD)v8 != 45 )
{
if ( v10 < 0 )
{
*a6 = 34;
return 0x7FFFFFFFFFFFFFFFLL;
}
goto LABEL_102;
}
if ( v10 < 0 )
{
if ( !__OFSUB__(-v10, 1LL) )
*a6 = 34;
return 0x8000000000000000LL;
}
LABEL_100:
*a6 = 0;
return -v10;
}
}
if ( (int)v14 > 0 && (_BYTE)v29 != 45 )
goto LABEL_90;
v30 = 0;
if ( (unsigned long long)v28 < v6 )
{
v30 = 0;
do
{
v31 = *v28 - 48;
if ( v31 > 9u )
break;
if ( (_BYTE)v29 == 45 )
{
if ( v30 - (int)v14 > 20 )
goto LABEL_84;
}
else if ( v30 + (int)v14 > 20 )
{
goto LABEL_90;
}
v30 = v31 + 10 * v30;
++v28;
}
while ( (unsigned long long)v28 < v6 );
}
v32 = -v30;
if ( (_BYTE)v29 != 45 )
v32 = v30;
LODWORD(v14) = (_DWORD)v14 + v32;
i = v28;
LABEL_71:
if ( !(_DWORD)v14 )
{
if ( v19 )
{
if ( v20 == -1LL )
goto LABEL_89;
++v20;
}
goto LABEL_88;
}
if ( (int)v14 < 0 )
{
if ( (unsigned int)v14 < 0xFFFFFFED )
{
v28 = i;
LABEL_84:
*a5 = v28;
*a6 = 0;
return 0LL;
}
v36 = d10[-(int)v14];
v10 = v20 / v36 - ((2 * (v20 % v36) < v36) - 1LL);
goto LABEL_94;
}
if ( (unsigned int)v14 <= 0x14 )
{
v34 = (_DWORD)v14 + 1;
while ( v20 <= 0x1999999999999999LL )
{
v20 *= 10LL;
if ( --v34 <= 1 )
goto LABEL_88;
}
}
else if ( !v20 )
{
v10 = 0LL;
goto LABEL_94;
}
LABEL_89:
v28 = i;
LABEL_90:
v35 = 0x7FFFFFFFFFFFFFFFLL;
*a5 = v28;
*a6 = 34;
if ( (_DWORD)v8 == 45 )
v35 = 0x8000000000000000LL;
return v35 | -(long long)(a4 != 0);
}
|
my_strntoull10rnd_8bit:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
TEST RDX,RDX
JLE 0x001b6373
LEA R11,[RSI + RDX*0x1]
LEA RAX,[0x4abf20]
MOV RAX,qword ptr [RAX + 0x40]
DEC RDX
LAB_001b60c0:
MOVZX R10D,byte ptr [RSI]
TEST byte ptr [RAX + R10*0x1 + 0x1],0x8
JZ 0x001b60dc
INC RSI
DEC RDX
CMP RSI,R11
JC 0x001b60c0
JMP 0x001b6373
LAB_001b60dc:
CMP R10D,0x2b
JZ 0x001b60e8
CMP R10D,0x2d
JNZ 0x001b60f4
LAB_001b60e8:
TEST RDX,RDX
JZ 0x001b61cb
INC RSI
LAB_001b60f4:
LEA RAX,[RSI + 0x9]
CMP RAX,R11
CMOVA RAX,R11
XOR EDI,EDI
MOV R14,RSI
CMP RSI,RAX
JNC 0x001b6127
LAB_001b6109:
MOV DL,byte ptr [R14]
ADD DL,0xd0
CMP DL,0x9
JA 0x001b6127
LEA RDI,[RDI + RDI*0x4]
MOVZX EDX,DL
LEA RDI,[RDX + RDI*0x2]
INC R14
CMP R14,RAX
JC 0x001b6109
LAB_001b6127:
CMP R14,R11
JNC 0x001b61a1
MOV R15,0x1999999999999999
MOV R12D,R14D
SUB R12D,ESI
XOR EBX,EBX
MOV R13D,R14D
LAB_001b6141:
MOV AL,byte ptr [R14]
LEA EDX,[RAX + -0x30]
CMP DL,0x9
JA 0x001b6170
CMP RDI,R15
JC 0x001b6160
JNZ 0x001b61e0
CMP DL,0x5
JA 0x001b61e0
LAB_001b6160:
LEA RAX,[RDI + RDI*0x4]
MOVZX EDX,DL
LEA RDI,[RDX + RAX*0x2]
INC R12D
JMP 0x001b617d
LAB_001b6170:
CMP AL,0x2e
JNZ 0x001b6188
TEST RBX,RBX
JNZ 0x001b61d3
LEA RBX,[R14 + 0x1]
LAB_001b617d:
INC R14
INC R13D
CMP R14,R11
JC 0x001b6141
LAB_001b6188:
MOV EAX,EBX
SUB EAX,R14D
XOR R13D,R13D
TEST RBX,RBX
CMOVZ EAX,R13D
MOV EBX,EAX
MOV RAX,RDI
JMP 0x001b629e
LAB_001b61a1:
MOV qword ptr [R8],R14
CMP R10D,0x2d
JNZ 0x001b6456
TEST ECX,ECX
JZ 0x001b6442
XOR EAX,EAX
TEST RDI,RDI
MOV ECX,0x22
CMOVZ ECX,EAX
MOV dword ptr [R9],ECX
JMP 0x001b637d
LAB_001b61cb:
MOV RSI,R11
JMP 0x001b6373
LAB_001b61d3:
XOR EBX,EBX
MOV RAX,RDI
XOR R13D,R13D
JMP 0x001b629e
LAB_001b61e0:
MOV dword ptr [RBP + -0x30],ECX
CMP AL,0x35
SETNC AL
MOV dword ptr [RBP + -0x2c],EAX
XOR ECX,ECX
CMP RDI,R15
MOV RAX,-0x1
CMOVNZ RAX,RDI
SETZ CL
MOV EDX,dword ptr [RBP + -0x2c]
OR DL,CL
MOV dword ptr [RBP + -0x2c],EDX
MOV RDX,RCX
MOV RCX,R15
LEA R15,[R14 + RDX*0x1]
TEST RBX,RBX
JZ 0x001b6250
XOR EDX,EDX
CMP RDI,RCX
SETZ DL
SUB EBX,EDX
SUB EBX,R13D
CMP R15,R11
MOV ECX,dword ptr [RBP + -0x30]
JNC 0x001b628d
MOV R13D,dword ptr [RBP + -0x2c]
LAB_001b622e:
MOV DL,byte ptr [R15]
ADD DL,0xd0
CMP DL,0x9
JA 0x001b6241
INC R15
CMP R15,R11
JC 0x001b622e
LAB_001b6241:
MOV R14,R15
LAB_001b6244:
MOV R15,0x1999999999999999
JMP 0x001b629e
LAB_001b6250:
XOR EBX,EBX
CMP R15,R11
MOV ECX,dword ptr [RBP + -0x30]
JNC 0x001b628d
LEA RDI,[R14 + RDX*0x1]
XOR EBX,EBX
LAB_001b6260:
LEA R15,[RDX + RBX*0x1]
MOV R15B,byte ptr [R14 + R15*0x1]
LEA R13D,[R15 + -0x30]
CMP R13B,0x9
JA 0x001b6499
LEA R15,[RBX + RDI*0x1]
INC R15
INC RBX
CMP R15,R11
JC 0x001b6260
ADD RDI,RBX
MOV R14,RDI
JMP 0x001b6290
LAB_001b628d:
MOV R14,R15
LAB_001b6290:
MOV R15,0x1999999999999999
MOV R13D,dword ptr [RBP + -0x2c]
LAB_001b629e:
TEST R12D,R12D
JZ 0x001b6373
CMP R14,R11
JNC 0x001b635c
MOVZX EDX,byte ptr [R14]
OR EDX,0x20
CMP EDX,0x65
JNZ 0x001b635c
LEA RSI,[R14 + 0x1]
CMP RSI,R11
JNC 0x001b635c
MOVZX EDI,byte ptr [RSI]
CMP EDI,0x2d
JZ 0x001b62da
CMP EDI,0x2b
JNZ 0x001b62e7
LAB_001b62da:
LEA RSI,[R14 + 0x2]
CMP RSI,R11
JZ 0x001b63c6
LAB_001b62e7:
TEST EBX,EBX
JLE 0x001b62f5
CMP DIL,0x2d
JNZ 0x001b63ce
LAB_001b62f5:
XOR R14D,R14D
CMP RSI,R11
JNC 0x001b6348
XOR R14D,R14D
LAB_001b6300:
MOV DL,byte ptr [RSI]
ADD DL,0xd0
CMP DL,0x9
JA 0x001b6348
MOV R12,R15
CMP DIL,0x2d
JNZ 0x001b6324
MOV R15D,R14D
SUB R15D,EBX
CMP R15D,0x14
JLE 0x001b6332
JMP 0x001b63a5
LAB_001b6324:
LEA R15D,[R14 + RBX*0x1]
CMP R15D,0x14
JG 0x001b63ce
LAB_001b6332:
MOVZX EDX,DL
LEA R14D,[R14 + R14*0x4]
LEA R14D,[RDX + R14*0x2]
INC RSI
CMP RSI,R11
MOV R15,R12
JC 0x001b6300
LAB_001b6348:
MOV EDX,R14D
NEG EDX
CMP DIL,0x2d
CMOVNZ EDX,R14D
ADD EDX,EBX
MOV EBX,EDX
MOV R14,RSI
LAB_001b635c:
TEST EBX,EBX
JZ 0x001b638d
JS 0x001b639d
CMP EBX,0x14
JBE 0x001b63b1
TEST RAX,RAX
JNZ 0x001b63cb
XOR EDI,EDI
JMP 0x001b6419
LAB_001b6373:
MOV qword ptr [R8],RSI
MOV dword ptr [R9],0x21
LAB_001b637d:
XOR EDI,EDI
LAB_001b637f:
MOV RAX,RDI
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001b638d:
TEST R13B,R13B
JZ 0x001b63c6
CMP RAX,-0x1
JZ 0x001b63cb
INC RAX
JMP 0x001b63c6
LAB_001b639d:
CMP EBX,-0x13
JNC 0x001b63fa
MOV RSI,R14
LAB_001b63a5:
MOV qword ptr [R8],RSI
MOV dword ptr [R9],0x0
JMP 0x001b637d
LAB_001b63b1:
INC EBX
LAB_001b63b3:
CMP RAX,R15
JA 0x001b63cb
ADD RAX,RAX
LEA RAX,[RAX + RAX*0x4]
DEC EBX
CMP EBX,0x1
JG 0x001b63b3
LAB_001b63c6:
MOV RDI,RAX
JMP 0x001b6419
LAB_001b63cb:
MOV RSI,R14
LAB_001b63ce:
MOV RAX,-0x8000000000000000
LEA RDX,[RAX + -0x1]
CMP R10D,0x2d
MOV qword ptr [R8],RSI
MOV dword ptr [R9],0x22
CMOVZ RDX,RAX
XOR EDI,EDI
NEG ECX
SBB RDI,RDI
OR RDI,RDX
JMP 0x001b637f
LAB_001b63fa:
NEG EBX
LEA RDX,[0x325b50]
MOV RSI,qword ptr [RDX + RBX*0x8]
XOR EDX,EDX
DIV RSI
MOV RDI,RAX
ADD RDX,RDX
CMP RDX,RSI
SBB RDI,-0x1
LAB_001b6419:
MOV qword ptr [R8],R14
TEST ECX,ECX
JZ 0x001b6437
CMP R10D,0x2d
JNZ 0x001b6456
TEST RDI,RDI
JZ 0x001b6456
MOV dword ptr [R9],0x22
JMP 0x001b637d
LAB_001b6437:
CMP R10D,0x2d
JNZ 0x001b6451
TEST RDI,RDI
JS 0x001b6462
LAB_001b6442:
MOV dword ptr [R9],0x0
NEG RDI
JMP 0x001b637f
LAB_001b6451:
TEST RDI,RDI
JS 0x001b6480
LAB_001b6456:
MOV dword ptr [R9],0x0
JMP 0x001b637f
LAB_001b6462:
MOV RAX,-0x8000000000000000
NEG RDI
JO 0x001b6478
MOV dword ptr [R9],0x22
LAB_001b6478:
MOV RDI,RAX
JMP 0x001b637f
LAB_001b6480:
MOV dword ptr [R9],0x22
MOV RDI,-0x8000000000000000
DEC RDI
JMP 0x001b637f
LAB_001b6499:
CMP R15B,0x2e
MOV R13D,dword ptr [RBP + -0x2c]
JNZ 0x001b64d6
LEA RDX,[RBX + RDI*0x1]
INC RDX
MOV R15,0x1999999999999999
LAB_001b64b4:
MOV R14,RDX
CMP RDX,R11
JNC 0x001b629e
MOV DIL,byte ptr [R14]
ADD DIL,0xd0
LEA RDX,[R14 + 0x1]
CMP DIL,0xa
JC 0x001b64b4
JMP 0x001b629e
LAB_001b64d6:
ADD RDI,RBX
MOV R14,RDI
JMP 0x001b6244
|
ulong my_strntoull10rnd_8bit
(int8 param_1,byte *param_2,long param_3,int param_4,ulong *param_5,
int4 *param_6)
{
byte *pbVar1;
byte bVar2;
byte bVar3;
long lVar4;
uint uVar5;
byte *pbVar6;
int4 uVar7;
ulong uVar8;
byte bVar9;
int iVar10;
ulong uVar11;
ulong uVar12;
byte *pbVar13;
ulong uVar14;
int iVar15;
byte *pbVar16;
byte *pbVar17;
bool bVar18;
if (param_3 < 1) {
LAB_001b6373:
*param_5 = (ulong)param_2;
*param_6 = 0x21;
return 0;
}
pbVar1 = param_2 + param_3;
param_3 = param_3 + -1;
pbVar13 = param_2;
while (bVar3 = *pbVar13, (PTR_ctype_latin1_004abf60[(ulong)bVar3 + 1] & 8) != 0) {
param_2 = pbVar13 + 1;
param_3 = param_3 + -1;
pbVar13 = param_2;
if (pbVar1 <= param_2) goto LAB_001b6373;
}
if ((bVar3 == 0x2b) || (bVar3 == 0x2d)) {
param_2 = pbVar1;
if (param_3 == 0) goto LAB_001b6373;
pbVar13 = pbVar13 + 1;
}
pbVar6 = pbVar13 + 9;
if (pbVar1 < pbVar13 + 9) {
pbVar6 = pbVar1;
}
uVar11 = 0;
for (pbVar16 = pbVar13; (pbVar16 < pbVar6 && ((byte)(*pbVar16 - 0x30) < 10));
pbVar16 = pbVar16 + 1) {
uVar11 = (ulong)(byte)(*pbVar16 - 0x30) + uVar11 * 10;
}
if (pbVar1 <= pbVar16) {
*param_5 = (ulong)pbVar16;
if (bVar3 == 0x2d) {
if (param_4 != 0) {
uVar7 = 0x22;
if (uVar11 == 0) {
uVar7 = 0;
}
*param_6 = uVar7;
return 0;
}
goto LAB_001b6442;
}
goto LAB_001b6456;
}
iVar15 = (int)pbVar16 - (int)pbVar13;
pbVar6 = (byte *)0x0;
uVar12 = (ulong)pbVar16 & 0xffffffff;
uVar14 = uVar11;
LAB_001b6141:
bVar2 = *pbVar16;
bVar9 = bVar2 - 0x30;
if (9 < bVar9) {
if (bVar2 != 0x2e) goto LAB_001b6188;
if (pbVar6 == (byte *)0x0) {
pbVar6 = pbVar16 + 1;
goto LAB_001b617d;
}
uVar12 = 0;
bVar18 = false;
uVar11 = uVar14;
pbVar17 = pbVar16;
goto LAB_001b629e;
}
if ((uVar14 < 0x1999999999999999) || ((uVar14 == 0x1999999999999999 && (bVar9 < 6))))
goto LAB_001b6160;
bVar18 = uVar14 == 0x1999999999999999;
uVar11 = 0xffffffffffffffff;
if (!bVar18) {
uVar11 = uVar14;
}
uVar8 = (ulong)bVar18;
bVar18 = 0x34 < bVar2 || bVar18;
pbVar17 = pbVar16 + uVar8;
if (pbVar6 != (byte *)0x0) {
uVar12 = (ulong)(((int)pbVar6 - (uint)(uVar14 == 0x1999999999999999)) - (int)uVar12);
for (; (pbVar17 < pbVar1 && ((byte)(*pbVar17 - 0x30) < 10)); pbVar17 = pbVar17 + 1) {
}
goto LAB_001b629e;
}
uVar12 = 0;
if (pbVar1 <= pbVar17) goto LAB_001b629e;
uVar12 = 0;
goto LAB_001b6260;
while (lVar4 = uVar12 + uVar8, uVar12 = uVar12 + 1, pbVar16 + lVar4 + 1 < pbVar1) {
LAB_001b6260:
if (9 < (byte)(pbVar16[uVar8 + uVar12] - 0x30)) {
if (pbVar16[uVar8 + uVar12] != 0x2e) {
pbVar17 = pbVar16 + uVar12 + uVar8;
goto LAB_001b629e;
}
pbVar17 = pbVar16 + uVar12 + uVar8;
goto LAB_001b64b4;
}
}
pbVar17 = pbVar16 + uVar12 + uVar8;
goto LAB_001b629e;
LAB_001b6160:
uVar14 = (ulong)bVar9 + uVar14 * 10;
iVar15 = iVar15 + 1;
LAB_001b617d:
pbVar16 = pbVar16 + 1;
uVar12 = (ulong)((int)uVar12 + 1);
if (pbVar1 <= pbVar16) goto LAB_001b6188;
goto LAB_001b6141;
LAB_001b6188:
uVar5 = (int)pbVar6 - (int)pbVar16;
bVar18 = false;
if (pbVar6 == (byte *)0x0) {
uVar5 = 0;
}
uVar12 = (ulong)uVar5;
uVar11 = uVar14;
pbVar17 = pbVar16;
goto LAB_001b629e;
while ((byte)(*pbVar17 - 0x30) < 10) {
LAB_001b64b4:
pbVar17 = pbVar17 + 1;
if (pbVar1 <= pbVar17) break;
}
LAB_001b629e:
uVar5 = (uint)uVar12;
param_2 = pbVar13;
if (iVar15 == 0) goto LAB_001b6373;
if (((pbVar17 < pbVar1) && ((*pbVar17 | 0x20) == 0x65)) &&
(pbVar13 = pbVar17 + 1, pbVar13 < pbVar1)) {
bVar2 = *pbVar13;
if (((bVar2 != 0x2d) && (bVar2 != 0x2b)) || (pbVar13 = pbVar17 + 2, pbVar13 != pbVar1)) {
if ((0 < (int)uVar5) && (bVar2 != 0x2d)) goto LAB_001b63ce;
iVar15 = 0;
if (pbVar13 < pbVar1) {
iVar15 = 0;
do {
if (9 < (byte)(*pbVar13 - 0x30)) break;
if (bVar2 == 0x2d) {
if (0x14 < (int)(iVar15 - uVar5)) goto LAB_001b63a5;
}
else if (0x14 < (int)(iVar15 + uVar5)) goto LAB_001b63ce;
iVar15 = (uint)(byte)(*pbVar13 - 0x30) + iVar15 * 10;
pbVar13 = pbVar13 + 1;
} while (pbVar13 < pbVar1);
}
iVar10 = -iVar15;
if (bVar2 != 0x2d) {
iVar10 = iVar15;
}
uVar5 = iVar10 + uVar5;
pbVar17 = pbVar13;
goto LAB_001b635c;
}
}
else {
LAB_001b635c:
pbVar13 = pbVar17;
pbVar17 = pbVar13;
if (uVar5 == 0) {
if (bVar18) {
if (uVar11 == 0xffffffffffffffff) goto LAB_001b63ce;
uVar11 = uVar11 + 1;
}
}
else if ((int)uVar5 < 0) {
if (uVar5 < 0xffffffed) {
LAB_001b63a5:
*param_5 = (ulong)pbVar13;
*param_6 = 0;
return 0;
}
uVar14 = *(ulong *)(d10 + (ulong)-uVar5 * 8);
uVar11 = (uVar11 / uVar14 + 1) - (ulong)((uVar11 % uVar14) * 2 < uVar14);
}
else if (uVar5 < 0x15) {
iVar15 = uVar5 + 1;
do {
if (0x1999999999999999 < uVar11) goto LAB_001b63ce;
uVar11 = uVar11 * 10;
iVar15 = iVar15 + -1;
} while (1 < iVar15);
}
else {
if (uVar11 != 0) {
LAB_001b63ce:
uVar11 = 0x7fffffffffffffff;
*param_5 = (ulong)pbVar13;
*param_6 = 0x22;
if (bVar3 == 0x2d) {
uVar11 = 0x8000000000000000;
}
return -(ulong)(param_4 != 0) | uVar11;
}
uVar11 = 0;
}
}
*param_5 = (ulong)pbVar17;
if (param_4 == 0) {
if (bVar3 == 0x2d) {
if ((long)uVar11 < 0) {
*param_6 = 0x22;
return 0x8000000000000000;
}
LAB_001b6442:
*param_6 = 0;
return -uVar11;
}
if ((long)uVar11 < 0) {
*param_6 = 0x22;
return 0x7fffffffffffffff;
}
}
else if ((bVar3 == 0x2d) && (uVar11 != 0)) {
*param_6 = 0x22;
return 0;
}
LAB_001b6456:
*param_6 = 0;
return uVar11;
}
|
|
63,336 |
ModbusObject::~ModbusObject()
|
serhmarch[P]ModbusBridge/modbus/src/ModbusObject.cpp
|
ModbusObject::~ModbusObject()
{
for (ModbusObjectPrivate::const_iterator it = d_ptr->begin(); it != d_ptr->end(); it++)
{
for (void *ptr : it->second)
{
delete reinterpret_cast<ModbusSlotBase<void>*>(ptr);
}
}
delete d_ptr;
}
|
O2
|
cpp
|
ModbusObject::~ModbusObject():
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x14464(%rip), %rax # 0x1c430
movq %rax, (%rdi)
movq 0x8(%rdi), %r14
addq $0x38, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x8001
leaq 0x10(%r14), %r15
movq %r15, %r12
movq (%r12), %r12
cmpq %r15, %r12
je 0x7fd7
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0x7fe6
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x7fe6
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x801b
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
_ZN12ModbusObjectD2Ev:
push r15; Alternative name is 'ModbusObject::~ModbusObject()'
push r14
push r12
push rbx
push rax
mov rbx, rdi
lea rax, off_1C430
mov [rdi], rax
mov r14, [rdi+8]
add r14, 38h ; '8'
loc_7FD7:
mov r14, [r14]
test r14, r14
jz short loc_8001
lea r15, [r14+10h]
mov r12, r15
loc_7FE6:
mov r12, [r12]
cmp r12, r15
jz short loc_7FD7
mov rdi, [r12+10h]
test rdi, rdi
jz short loc_7FE6
mov rax, [rdi]
call qword ptr [rax+8]
jmp short loc_7FE6
loc_8001:
mov rdi, [rbx+8]
test rdi, rdi
jz short loc_801B
mov rax, [rdi]
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
jmp qword ptr [rax+8]
loc_801B:
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
|
void ModbusObject::~ModbusObject(ModbusObject *this)
{
_QWORD *v2; // r14
_QWORD *v3; // r12
long long v4; // rdi
long long v5; // rdi
*(_QWORD *)this = off_1C430;
v2 = (_QWORD *)(*((_QWORD *)this + 1) + 56LL);
while ( 1 )
{
v2 = (_QWORD *)*v2;
if ( !v2 )
break;
v3 = v2 + 2;
while ( 1 )
{
v3 = (_QWORD *)*v3;
if ( v3 == v2 + 2 )
break;
v4 = v3[2];
if ( v4 )
(*(void ( **)(long long))(*(_QWORD *)v4 + 8LL))(v4);
}
}
v5 = *((_QWORD *)this + 1);
if ( v5 )
(*(void ( **)(long long))(*(_QWORD *)v5 + 8LL))(v5);
}
|
~ModbusObject:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA RAX,[0x11c430]
MOV qword ptr [RDI],RAX
MOV R14,qword ptr [RDI + 0x8]
ADD R14,0x38
LAB_00107fd7:
MOV R14,qword ptr [R14]
TEST R14,R14
JZ 0x00108001
LEA R15,[R14 + 0x10]
MOV R12,R15
LAB_00107fe6:
MOV R12,qword ptr [R12]
CMP R12,R15
JZ 0x00107fd7
MOV RDI,qword ptr [R12 + 0x10]
TEST RDI,RDI
JZ 0x00107fe6
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
JMP 0x00107fe6
LAB_00108001:
MOV RDI,qword ptr [RBX + 0x8]
TEST RDI,RDI
JZ 0x0010801b
MOV RAX,qword ptr [RDI]
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
JMP qword ptr [RAX + 0x8]
LAB_0010801b:
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* ModbusObject::~ModbusObject() */
void __thiscall ModbusObject::~ModbusObject(ModbusObject *this)
{
long *plVar1;
long *plVar2;
*(int ***)this = &PTR__ModbusObject_0011c430;
plVar2 = (long *)(*(long *)(this + 8) + 0x38);
while (plVar2 = (long *)*plVar2, plVar2 != (long *)0x0) {
plVar1 = plVar2 + 2;
while (plVar1 = (long *)*plVar1, plVar1 != plVar2 + 2) {
if ((long *)plVar1[2] != (long *)0x0) {
(**(code **)(*(long *)plVar1[2] + 8))();
}
}
}
if (*(long **)(this + 8) != (long *)0x0) {
/* WARNING: Could not recover jumptable at 0x00108018. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(**(long **)(this + 8) + 8))();
return;
}
return;
}
|
|
63,337 |
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 0x64c32
jmp 0x64c34
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x51(%rbp)
jae 0x64c64
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x40(%rbp), %rcx
leaq -0x30(%rbp), %rsi
callq 0x64a60
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x64c6d
jmp 0x64cc7
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x699f0
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 0x64a90
movl %eax, %ecx
movl -0x58(%rbp), %eax
cmpl %ecx, %eax
je 0x64ca0
jmp 0x64cc7
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 0x64c34
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_64C32:
jmp short $+2
loc_64C34:
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_51], al
jnb short loc_64C64
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_64C64:
mov al, [rbp+var_51]
test al, 1
jnz short loc_64C6D
jmp short loc_64CC7
loc_64C6D:
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_64CA0
jmp short loc_64CC7
loc_64CA0:
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_64C34
loc_64CC7:
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 0x00164c32
LAB_00164c32:
JMP 0x00164c34
LAB_00164c34:
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x51],AL
JNC 0x00164c64
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x40]
LEA RSI,[RBP + -0x30]
CALL 0x00164a60
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
SETG AL
MOV byte ptr [RBP + -0x51],AL
LAB_00164c64:
MOV AL,byte ptr [RBP + -0x51]
TEST AL,0x1
JNZ 0x00164c6d
JMP 0x00164cc7
LAB_00164c6d:
MOV RDI,qword ptr [RBP + -0x50]
LEA RSI,[RBP + -0x30]
CALL 0x001699f0
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 0x00164a90
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x58]
CMP EAX,ECX
JZ 0x00164ca0
JMP 0x00164cc7
LAB_00164ca0:
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 0x00164c34
LAB_00164cc7:
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,338 |
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::vector<char, std::allocator<char>>>>>::lexer(nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::vector<char, std::allocator<char>>>>&&, bool)
|
monkey531[P]llama/common/./json.hpp
|
explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false) noexcept
: ia(std::move(adapter))
, ignore_comments(ignore_comments_)
, decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
{}
|
O0
|
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::vector<char, std::allocator<char>>>>>::lexer(nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::vector<char, std::allocator<char>>>>&&, bool):
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movb 0x17(%rsp), %cl
andb $0x1, %cl
movb %cl, 0x10(%rax)
callq 0xa0ba0
movq 0x8(%rsp), %rdi
movl %eax, 0x14(%rdi)
movb $0x0, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
movq $0x0, 0x30(%rdi)
addq $0x38, %rdi
movq %rdi, (%rsp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x59540
movq (%rsp), %rdi
callq 0xa5380
movq 0x8(%rsp), %rdi
addq $0x50, %rdi
callq 0x595c0
movq 0x8(%rsp), %rax
leaq 0x4335(%rip), %rcx # 0x2084a2
movq %rcx, 0x70(%rax)
movq $0x0, 0x78(%rax)
movq $0x0, 0x80(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x88(%rax)
callq 0x204fc0
movb %al, %cl
movq 0x8(%rsp), %rax
movsbl %cl, %ecx
movl %ecx, 0x90(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
|
_ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcS5_IcSA_EEEEEEC2EOSN_b:
sub rsp, 28h
mov al, dl
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_10], rsi
and al, 1
mov [rsp+28h+var_11], al
mov rax, [rsp+28h+var_8]
mov [rsp+28h+var_20], rax
mov rcx, [rsp+28h+var_10]
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
mov cl, [rsp+28h+var_11]
and cl, 1
mov [rax+10h], cl
call _ZNSt11char_traitsIcE3eofEv; std::char_traits<char>::eof(void)
mov rdi, [rsp+28h+var_20]
mov [rdi+14h], eax
mov byte ptr [rdi+18h], 0
mov qword ptr [rdi+20h], 0
mov qword ptr [rdi+28h], 0
mov qword ptr [rdi+30h], 0
add rdi, 38h ; '8'
mov [rsp+28h+var_28], rdi
xor esi, esi
mov edx, 18h
call _memset
mov rdi, [rsp+28h+var_28]
call _ZNSt6vectorIcSaIcEEC2Ev; std::vector<char>::vector(void)
mov rdi, [rsp+28h+var_20]
add rdi, 50h ; 'P'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string(void)
mov rax, [rsp+28h+var_20]
lea rcx, aTestArgParserT_1+46h; ""
mov [rax+70h], rcx
mov qword ptr [rax+78h], 0
mov qword ptr [rax+80h], 0
xorps xmm0, xmm0
movsd qword ptr [rax+88h], xmm0
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcS5_IcSA_EEEEEE17get_decimal_pointEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::vector<char>>>>::get_decimal_point(void)
mov cl, al
mov rax, [rsp+28h+var_20]
movsx ecx, cl
mov [rax+90h], ecx
add rsp, 28h
retn
|
long long nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::vector<char>>>>::lexer(
long long a1,
_QWORD *a2,
char a3)
{
char decimal_point; // cl
long long result; // rax
*(_QWORD *)a1 = *a2;
*(_QWORD *)(a1 + 8) = a2[1];
*(_BYTE *)(a1 + 16) = a3 & 1;
*(_DWORD *)(a1 + 20) = std::char_traits<char>::eof();
*(_BYTE *)(a1 + 24) = 0;
*(_QWORD *)(a1 + 32) = 0LL;
*(_QWORD *)(a1 + 40) = 0LL;
*(_QWORD *)(a1 + 48) = 0LL;
memset(a1 + 56, 0LL, 24LL);
std::vector<char>::vector(a1 + 56);
std::string::basic_string(a1 + 80);
*(_QWORD *)(a1 + 112) = "";
*(_QWORD *)(a1 + 120) = 0LL;
*(_QWORD *)(a1 + 128) = 0LL;
*(_QWORD *)(a1 + 136) = 0LL;
decimal_point = 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::vector<char>>>>::get_decimal_point();
result = a1;
*(_DWORD *)(a1 + 144) = decimal_point;
return result;
}
| |||
63,339 |
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::vector<char, std::allocator<char>>>>>::lexer(nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::vector<char, std::allocator<char>>>>&&, bool)
|
monkey531[P]llama/common/./json.hpp
|
explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false) noexcept
: ia(std::move(adapter))
, ignore_comments(ignore_comments_)
, decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
{}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::vector<char, std::allocator<char>>>>>::lexer(nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::vector<char, std::allocator<char>>>>&&, bool):
pushq %rbx
movq %rdi, %rbx
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
movb %dl, 0x10(%rdi)
movl $0xffffffff, 0x14(%rdi) # imm = 0xFFFFFFFF
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x60(%rdi), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movq %rcx, 0x50(%rdi)
movq %rax, 0x58(%rdi)
movb %al, 0x60(%rdi)
leaq 0x77ba(%rip), %rcx # 0xebdf2
movq %rcx, 0x70(%rdi)
movups %xmm0, 0x78(%rdi)
movq %rax, 0x88(%rdi)
callq 0x1b080
movq (%rax), %rax
testq %rax, %rax
je 0xe4659
movsbl (%rax), %eax
jmp 0xe465e
movl $0x2e, %eax
movl %eax, 0x90(%rbx)
popq %rbx
retq
|
_ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEEC2EOSM_b:
push rbx
mov rbx, rdi
movups xmm0, xmmword ptr [rsi]
movups xmmword ptr [rdi], xmm0
mov [rdi+10h], dl
mov dword ptr [rdi+14h], 0FFFFFFFFh
xor eax, eax
mov [rdi+18h], al
lea rcx, [rdi+60h]
xorps xmm0, xmm0
movups xmmword ptr [rdi+20h], xmm0
movups xmmword ptr [rdi+30h], xmm0
movups xmmword ptr [rdi+40h], xmm0
mov [rdi+50h], rcx
mov [rdi+58h], rax
mov [rdi+60h], al
lea rcx, aErrorWhileHand_0+34h; ""
mov [rdi+70h], rcx
movups xmmword ptr [rdi+78h], xmm0
mov [rdi+88h], rax
call _localeconv
mov rax, [rax]
test rax, rax
jz short loc_E4659
movsx eax, byte ptr [rax]
jmp short loc_E465E
loc_E4659:
mov eax, 2Eh ; '.'
loc_E465E:
mov [rbx+90h], eax
pop rbx
retn
|
long long nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::lexer(
long long a1,
_OWORD *a2,
char a3)
{
char *v3; // rax
long long result; // rax
*(_OWORD *)a1 = *a2;
*(_BYTE *)(a1 + 16) = a3;
*(_DWORD *)(a1 + 20) = -1;
*(_BYTE *)(a1 + 24) = 0;
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
*(_OWORD *)(a1 + 64) = 0LL;
*(_QWORD *)(a1 + 80) = a1 + 96;
*(_QWORD *)(a1 + 88) = 0LL;
*(_BYTE *)(a1 + 96) = 0;
*(_QWORD *)(a1 + 112) = "";
*(_OWORD *)(a1 + 120) = 0LL;
*(_QWORD *)(a1 + 136) = 0LL;
v3 = *(char **)localeconv(a1);
if ( v3 )
result = (unsigned int)*v3;
else
result = 46LL;
*(_DWORD *)(a1 + 144) = result;
return result;
}
|
lexer:
PUSH RBX
MOV RBX,RDI
MOVUPS XMM0,xmmword ptr [RSI]
MOVUPS xmmword ptr [RDI],XMM0
MOV byte ptr [RDI + 0x10],DL
MOV dword ptr [RDI + 0x14],0xffffffff
XOR EAX,EAX
MOV byte ptr [RDI + 0x18],AL
LEA RCX,[RDI + 0x60]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOVUPS xmmword ptr [RDI + 0x30],XMM0
MOVUPS xmmword ptr [RDI + 0x40],XMM0
MOV qword ptr [RDI + 0x50],RCX
MOV qword ptr [RDI + 0x58],RAX
MOV byte ptr [RDI + 0x60],AL
LEA RCX,[0x1ebdf2]
MOV qword ptr [RDI + 0x70],RCX
MOVUPS xmmword ptr [RDI + 0x78],XMM0
MOV qword ptr [RDI + 0x88],RAX
CALL 0x0011b080
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x001e4659
MOVSX EAX,byte ptr [RAX]
JMP 0x001e465e
LAB_001e4659:
MOV EAX,0x2e
LAB_001e465e:
MOV dword ptr [RBX + 0x90],EAX
POP RBX
RET
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > >
>::lexer(nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > >&&, bool) */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::lexer(lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*this,iterator_input_adapter *param_1,bool param_2)
{
int8 uVar1;
int iVar2;
lconv *plVar3;
uVar1 = *(int8 *)(param_1 + 8);
*(int8 *)this = *(int8 *)param_1;
*(int8 *)(this + 8) = uVar1;
this[0x10] = (lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
)param_2;
*(int4 *)(this + 0x14) = 0xffffffff;
this[0x18] = (lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
)0x0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
*(lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
**)(this + 0x50) = this + 0x60;
*(int8 *)(this + 0x58) = 0;
this[0x60] = (lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
)0x0;
*(char **)(this + 0x70) = "";
*(int8 *)(this + 0x78) = 0;
*(int8 *)(this + 0x80) = 0;
*(int8 *)(this + 0x88) = 0;
plVar3 = localeconv();
if (plVar3->decimal_point == (char *)0x0) {
iVar2 = 0x2e;
}
else {
iVar2 = (int)*plVar3->decimal_point;
}
*(int *)(this + 0x90) = iVar2;
return;
}
|
|
63,340 |
get_hash_link
|
eloqsql/mysys/mf_keycache.c
|
static HASH_LINK *get_hash_link(SIMPLE_KEY_CACHE_CB *keycache,
int file, my_off_t filepos)
{
reg1 HASH_LINK *hash_link, **start;
#if defined(KEYCACHE_DEBUG)
int cnt;
#endif
KEYCACHE_DBUG_PRINT("get_hash_link", ("fd: %u pos: %lu",
(uint) file,(ulong) filepos));
restart:
/*
Find the bucket in the hash table for the pair (file, filepos);
start contains the head of the bucket list,
hash_link points to the first member of the list
*/
hash_link= *(start= &keycache->hash_root[KEYCACHE_HASH(file, filepos)]);
#if defined(KEYCACHE_DEBUG)
cnt= 0;
#endif
/* Look for an element for the pair (file, filepos) in the bucket chain */
while (hash_link &&
(hash_link->diskpos != filepos || hash_link->file != file))
{
hash_link= hash_link->next;
#if defined(KEYCACHE_DEBUG)
cnt++;
if (! (cnt <= keycache->hash_links_used))
{
int i;
for (i=0, hash_link= *start ;
i < cnt ; i++, hash_link= hash_link->next)
{
KEYCACHE_DBUG_PRINT("get_hash_link", ("fd: %u pos: %lu",
(uint) hash_link->file,(ulong) hash_link->diskpos));
}
}
KEYCACHE_DBUG_ASSERT(cnt <= keycache->hash_links_used);
#endif
}
if (! hash_link)
{
/* There is no hash link in the hash table for the pair (file, filepos) */
if (keycache->free_hash_list)
{
hash_link= keycache->free_hash_list;
keycache->free_hash_list= hash_link->next;
}
else if (keycache->hash_links_used < keycache->hash_links)
{
hash_link= &keycache->hash_link_root[keycache->hash_links_used++];
}
else
{
/* Wait for a free hash link */
struct st_my_thread_var *thread= my_thread_var;
KEYCACHE_PAGE page;
KEYCACHE_DBUG_PRINT("get_hash_link", ("waiting"));
page.file= file;
page.filepos= filepos;
thread->keycache_link= (void *) &page;
link_into_queue(&keycache->waiting_for_hash_link, thread);
KEYCACHE_DBUG_PRINT("get_hash_link: wait",
("suspend thread %ld", (ulong) thread->id));
keycache_pthread_cond_wait(&thread->suspend,
&keycache->cache_lock);
thread->keycache_link= NULL;
goto restart;
}
hash_link->file= file;
hash_link->diskpos= filepos;
link_hash(start, hash_link);
}
/* Register the request for the page */
hash_link->requests++;
return hash_link;
}
|
O0
|
c
|
get_hash_link:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0xe4bf5
jmp 0xe4bf7
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x18(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movslq -0xc(%rbp), %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movl 0x164(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq -0x8(%rbp), %rdx
movl 0x38(%rdx), %edx
subl $0x1, %edx
movl %edx, %edx
andq %rdx, %rcx
movq %rcx, %rsi
shlq $0x3, %rsi
movq %rax, %rdx
addq %rsi, %rdx
movq %rdx, -0x28(%rbp)
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x49(%rbp)
je 0xe4c90
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rcx
movb $0x1, %al
cmpq -0x18(%rbp), %rcx
movb %al, -0x4a(%rbp)
jne 0xe4c8a
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0xc(%rbp), %eax
setne %al
movb %al, -0x4a(%rbp)
movb -0x4a(%rbp), %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0xe4c99
jmp 0xe4ca6
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xe4c5b
cmpq $0x0, -0x20(%rbp)
jne 0xe4dba
movq -0x8(%rbp), %rax
cmpq $0x0, 0x90(%rax)
je 0xe4ce5
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x90(%rax)
jmp 0xe4d97
movq -0x8(%rbp), %rax
movl 0x44(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x40(%rcx), %eax
jge 0xe4d1f
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x8(%rbp), %rdx
movl 0x44(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x44(%rdx)
movslq %ecx, %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0xe4d95
callq 0xf6050
movq %rax, -0x30(%rbp)
jmp 0xe4d2a
movl -0xc(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
leaq -0x40(%rbp), %rcx
movq %rcx, 0xa8(%rax)
movq -0x8(%rbp), %rdi
addq $0x118, %rdi # imm = 0x118
movq -0x30(%rbp), %rsi
callq 0xe4f90
jmp 0xe4d5d
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
addq $0xc0, %rsi
leaq 0x6f2a0(%rip), %rdx # 0x154017
movl $0x71e, %ecx # imm = 0x71E
callq 0xe4b70
movq -0x30(%rbp), %rax
movq $0x0, 0xa8(%rax)
jmp 0xe4bf7
jmp 0xe4d97
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xe52c0
movq -0x20(%rbp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
get_hash_link_0:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
jmp short $+2
loc_E4BF5:
jmp short $+2
loc_E4BF7:
mov rax, [rbp+var_8]
mov rax, [rax+80h]
mov [rbp+var_48], rax
mov rax, [rbp+var_18]
mov rcx, [rbp+var_8]
mov ecx, [rcx+18h]
xor edx, edx
div rcx
movsxd rcx, [rbp+var_C]
add rax, rcx
mov rcx, [rbp+var_8]
mov ecx, [rcx+164h]
xor edx, edx
div rcx
mov rcx, rax
mov rax, [rbp+var_48]
mov rdx, [rbp+var_8]
mov edx, [rdx+38h]
sub edx, 1
mov edx, edx
and rcx, rdx
mov rsi, rcx
shl rsi, 3
mov rdx, rax
add rdx, rsi
mov [rbp+var_28], rdx
mov rax, [rax+rcx*8]
mov [rbp+var_20], rax
loc_E4C5B:
xor eax, eax
cmp [rbp+var_20], 0
mov [rbp+var_49], al
jz short loc_E4C90
mov rax, [rbp+var_20]
mov rcx, [rax+20h]
mov al, 1
cmp rcx, [rbp+var_18]
mov [rbp+var_4A], al
jnz short loc_E4C8A
mov rax, [rbp+var_20]
mov eax, [rax+18h]
cmp eax, [rbp+var_C]
setnz al
mov [rbp+var_4A], al
loc_E4C8A:
mov al, [rbp+var_4A]
mov [rbp+var_49], al
loc_E4C90:
mov al, [rbp+var_49]
test al, 1
jnz short loc_E4C99
jmp short loc_E4CA6
loc_E4C99:
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_20], rax
jmp short loc_E4C5B
loc_E4CA6:
cmp [rbp+var_20], 0
jnz loc_E4DBA
mov rax, [rbp+var_8]
cmp qword ptr [rax+90h], 0
jz short loc_E4CE5
mov rax, [rbp+var_8]
mov rax, [rax+90h]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov rcx, [rax]
mov rax, [rbp+var_8]
mov [rax+90h], rcx
jmp loc_E4D97
loc_E4CE5:
mov rax, [rbp+var_8]
mov eax, [rax+44h]
mov rcx, [rbp+var_8]
cmp eax, [rcx+40h]
jge short loc_E4D1F
mov rax, [rbp+var_8]
mov rax, [rax+88h]
mov rdx, [rbp+var_8]
mov ecx, [rdx+44h]
mov esi, ecx
add esi, 1
mov [rdx+44h], esi
movsxd rcx, ecx
imul rcx, 30h ; '0'
add rax, rcx
mov [rbp+var_20], rax
jmp short loc_E4D95
loc_E4D1F:
call _my_thread_var
mov [rbp+var_30], rax
jmp short $+2
loc_E4D2A:
mov eax, [rbp+var_C]
mov [rbp+var_40], eax
mov rax, [rbp+var_18]
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
lea rcx, [rbp+var_40]
mov [rax+0A8h], rcx
mov rdi, [rbp+var_8]
add rdi, 118h
mov rsi, [rbp+var_30]
call link_into_queue
jmp short $+2
loc_E4D5D:
mov rdi, [rbp+var_30]
add rdi, 8
mov rsi, [rbp+var_8]
add rsi, 0C0h
lea rdx, aWorkspaceLlm4b_36; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 71Eh
call inline_mysql_cond_wait_4
mov rax, [rbp+var_30]
mov qword ptr [rax+0A8h], 0
jmp loc_E4BF7
loc_E4D95:
jmp short $+2
loc_E4D97:
mov ecx, [rbp+var_C]
mov rax, [rbp+var_20]
mov [rax+18h], ecx
mov rcx, [rbp+var_18]
mov rax, [rbp+var_20]
mov [rax+20h], rcx
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_20]
call link_hash_0
loc_E4DBA:
mov rax, [rbp+var_20]
mov ecx, [rax+28h]
add ecx, 1
mov [rax+28h], ecx
mov rax, [rbp+var_20]
add rsp, 50h
pop rbp
retn
|
long long * get_hash_link_0(long long a1, int a2, unsigned long long a3)
{
const char *v3; // rsi
long long v4; // rax
int v5; // ecx
bool v7; // [rsp+6h] [rbp-4Ah]
bool v8; // [rsp+7h] [rbp-49h]
int v9; // [rsp+10h] [rbp-40h] BYREF
unsigned long long v10; // [rsp+18h] [rbp-38h]
long long v11; // [rsp+20h] [rbp-30h]
const char *v12; // [rsp+28h] [rbp-28h]
long long *i; // [rsp+30h] [rbp-20h]
unsigned long long v14; // [rsp+38h] [rbp-18h]
int v15; // [rsp+44h] [rbp-Ch]
long long v16; // [rsp+48h] [rbp-8h]
v16 = a1;
v15 = a2;
v14 = a3;
while ( 1 )
{
v3 = (const char *)(8
* ((unsigned int)(*(_DWORD *)(v16 + 56) - 1) & ((v15 + v14 / *(unsigned int *)(v16 + 24))
/ *(unsigned int *)(v16 + 356))));
v12 = &v3[*(_QWORD *)(v16 + 128)];
for ( i = *(long long **)v12; ; i = (long long *)*i )
{
v8 = 0;
if ( i )
{
v7 = 1;
if ( i[4] == v14 )
v7 = *((_DWORD *)i + 6) != v15;
v8 = v7;
}
if ( !v8 )
break;
}
if ( i )
break;
if ( *(_QWORD *)(v16 + 144) )
{
i = *(long long **)(v16 + 144);
*(_QWORD *)(v16 + 144) = *i;
LABEL_15:
*((_DWORD *)i + 6) = v15;
i[4] = v14;
link_hash_0(v12, i);
break;
}
if ( *(_DWORD *)(v16 + 68) < *(_DWORD *)(v16 + 64) )
{
v4 = *(_QWORD *)(v16 + 136);
v5 = *(_DWORD *)(v16 + 68);
*(_DWORD *)(v16 + 68) = v5 + 1;
i = (long long *)(48LL * v5 + v4);
goto LABEL_15;
}
v11 = my_thread_var(a1, v3);
v9 = v15;
v10 = v14;
*(_QWORD *)(v11 + 168) = &v9;
link_into_queue(v16 + 280, v11);
a1 = v11 + 8;
inline_mysql_cond_wait_4(
v11 + 8,
v16 + 192,
(long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c",
0x71Eu);
*(_QWORD *)(v11 + 168) = 0LL;
}
++*((_DWORD *)i + 10);
return i;
}
|
get_hash_link:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
JMP 0x001e4bf5
LAB_001e4bf5:
JMP 0x001e4bf7
LAB_001e4bf7:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x80]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX + 0x18]
XOR EDX,EDX
DIV RCX
MOVSXD RCX,dword ptr [RBP + -0xc]
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX + 0x164]
XOR EDX,EDX
DIV RCX
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x8]
MOV EDX,dword ptr [RDX + 0x38]
SUB EDX,0x1
MOV EDX,EDX
AND RCX,RDX
MOV RSI,RCX
SHL RSI,0x3
MOV RDX,RAX
ADD RDX,RSI
MOV qword ptr [RBP + -0x28],RDX
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x20],RAX
LAB_001e4c5b:
XOR EAX,EAX
CMP qword ptr [RBP + -0x20],0x0
MOV byte ptr [RBP + -0x49],AL
JZ 0x001e4c90
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX + 0x20]
MOV AL,0x1
CMP RCX,qword ptr [RBP + -0x18]
MOV byte ptr [RBP + -0x4a],AL
JNZ 0x001e4c8a
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x18]
CMP EAX,dword ptr [RBP + -0xc]
SETNZ AL
MOV byte ptr [RBP + -0x4a],AL
LAB_001e4c8a:
MOV AL,byte ptr [RBP + -0x4a]
MOV byte ptr [RBP + -0x49],AL
LAB_001e4c90:
MOV AL,byte ptr [RBP + -0x49]
TEST AL,0x1
JNZ 0x001e4c99
JMP 0x001e4ca6
LAB_001e4c99:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001e4c5b
LAB_001e4ca6:
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x001e4dba
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x90],0x0
JZ 0x001e4ce5
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x90]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x90],RCX
JMP 0x001e4d97
LAB_001e4ce5:
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x44]
MOV RCX,qword ptr [RBP + -0x8]
CMP EAX,dword ptr [RCX + 0x40]
JGE 0x001e4d1f
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x88]
MOV RDX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RDX + 0x44]
MOV ESI,ECX
ADD ESI,0x1
MOV dword ptr [RDX + 0x44],ESI
MOVSXD RCX,ECX
IMUL RCX,RCX,0x30
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001e4d95
LAB_001e4d1f:
CALL 0x001f6050
MOV qword ptr [RBP + -0x30],RAX
JMP 0x001e4d2a
LAB_001e4d2a:
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x40],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
LEA RCX,[RBP + -0x40]
MOV qword ptr [RAX + 0xa8],RCX
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x118
MOV RSI,qword ptr [RBP + -0x30]
CALL 0x001e4f90
JMP 0x001e4d5d
LAB_001e4d5d:
MOV RDI,qword ptr [RBP + -0x30]
ADD RDI,0x8
MOV RSI,qword ptr [RBP + -0x8]
ADD RSI,0xc0
LEA RDX,[0x254017]
MOV ECX,0x71e
CALL 0x001e4b70
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0xa8],0x0
JMP 0x001e4bf7
LAB_001e4d95:
JMP 0x001e4d97
LAB_001e4d97:
MOV ECX,dword ptr [RBP + -0xc]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x18],ECX
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x20],RCX
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x001e52c0
LAB_001e4dba:
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x28]
ADD ECX,0x1
MOV dword ptr [RAX + 0x28],ECX
MOV RAX,qword ptr [RBP + -0x20]
ADD RSP,0x50
POP RBP
RET
|
int8 * get_hash_link(long param_1,int param_2,ulong param_3)
{
int iVar1;
ulong uVar2;
bool bVar3;
int local_48 [2];
ulong local_40;
long local_38;
long local_30;
int8 *local_28;
ulong local_20;
int local_14;
long local_10;
local_20 = param_3;
local_14 = param_2;
local_10 = param_1;
while( true ) {
uVar2 = (local_20 / *(uint *)(local_10 + 0x18) + (long)local_14) /
(ulong)*(uint *)(local_10 + 0x164) & (ulong)(*(int *)(local_10 + 0x38) - 1);
local_30 = *(long *)(local_10 + 0x80) + uVar2 * 8;
local_28 = *(int8 **)(*(long *)(local_10 + 0x80) + uVar2 * 8);
while( true ) {
bVar3 = false;
if ((local_28 != (int8 *)0x0) && (bVar3 = true, local_28[4] == local_20)) {
bVar3 = *(int *)(local_28 + 3) != local_14;
}
if (!bVar3) break;
local_28 = (int8 *)*local_28;
}
if (local_28 != (int8 *)0x0) goto LAB_001e4dba;
if (*(long *)(local_10 + 0x90) != 0) break;
if (*(int *)(local_10 + 0x44) < *(int *)(local_10 + 0x40)) {
iVar1 = *(int *)(local_10 + 0x44);
*(int *)(local_10 + 0x44) = iVar1 + 1;
local_28 = (int8 *)(*(long *)(local_10 + 0x88) + (long)iVar1 * 0x30);
LAB_001e4d97:
*(int *)(local_28 + 3) = local_14;
local_28[4] = local_20;
link_hash(local_30,local_28);
LAB_001e4dba:
*(int *)(local_28 + 5) = *(int *)(local_28 + 5) + 1;
return local_28;
}
local_38 = _my_thread_var();
local_48[0] = local_14;
local_40 = local_20;
*(int **)(local_38 + 0xa8) = local_48;
link_into_queue(local_10 + 0x118,local_38);
inline_mysql_cond_wait
(local_38 + 8,local_10 + 0xc0,
"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c",0x71e);
*(int8 *)(local_38 + 0xa8) = 0;
}
local_28 = *(int8 **)(local_10 + 0x90);
*(int8 *)(local_10 + 0x90) = *local_28;
goto LAB_001e4d97;
}
|
|
63,341 |
google::protobuf::util::status_internal::Status::ToString[abi:cxx11]() const
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/stubs/status.cc
|
std::string Status::ToString() const {
if (error_code_ == StatusCode::kOk) {
return "OK";
} else {
if (error_message_.empty()) {
return StatusCodeToString(error_code_);
} else {
return StatusCodeToString(error_code_) + ":" + error_message_;
}
}
}
|
O0
|
cpp
|
google::protobuf::util::status_internal::Status::ToString[abi:cxx11]() const:
subq $0x98, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpl $0x0, (%rax)
jne 0x25632
leaq 0x87(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x13760
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x1c6ef3(%rip), %rsi # 0x1ec4ec
callq 0x135f0
jmp 0x25600
leaq 0x87(%rsp), %rdi
callq 0x134d0
jmp 0x256ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x87(%rsp), %rdi
callq 0x134d0
jmp 0x256fb
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
callq 0x147f0
testb $0x1, %al
jne 0x25646
jmp 0x2565c
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movl (%rax), %esi
callq 0x25710
jmp 0x256ee
movq 0x28(%rsp), %rax
movl (%rax), %esi
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x25710
movq 0x8(%rsp), %rsi
leaq 0x1c8563(%rip), %rdx # 0x1edbe1
leaq 0x50(%rsp), %rdi
callq 0x191c0
jmp 0x2568a
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rdx
addq $0x8, %rdx
leaq 0x50(%rsp), %rsi
callq 0x26650
jmp 0x256a4
leaq 0x50(%rsp), %rdi
callq 0x13290
leaq 0x30(%rsp), %rdi
callq 0x13290
jmp 0x256ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x256e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x13290
leaq 0x30(%rsp), %rdi
callq 0x13290
jmp 0x256fb
movq 0x20(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x78(%rsp), %rdi
callq 0x13750
nopw %cs:(%rax,%rax)
|
_ZNK6google8protobuf4util15status_internal6Status8ToStringB5cxx11Ev:
sub rsp, 98h
mov [rsp+98h+var_80], rdi
mov rax, rdi
mov [rsp+98h+var_78], rax
mov [rsp+98h+var_8], rdi
mov [rsp+98h+var_10], rsi
mov rax, [rsp+98h+var_10]
mov [rsp+98h+var_70], rax
cmp dword ptr [rax], 0
jnz short loc_25632
lea rdi, [rsp+98h+var_11]
mov [rsp+98h+var_88], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdi, [rsp+98h+var_80]
mov rdx, [rsp+98h+var_88]
lea rsi, unk_1EC4EC
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1EPKcRKS3_; std::string::basic_string(char const*,std::allocator<char> const&)
jmp short $+2
loc_25600:
lea rdi, [rsp+98h+var_11]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_256EE
mov rcx, rax
mov eax, edx
mov [rsp+arg_70], rcx
mov [rsp+arg_6C], eax
lea rdi, [rsp+arg_7F]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_256FB
loc_25632:
mov rdi, [rsp+98h+var_70]
add rdi, 8
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
test al, 1
jnz short loc_25646
jmp short loc_2565C
loc_25646:
mov rdi, [rsp+98h+var_80]
mov rax, [rsp+98h+var_70]
mov esi, [rax]
call _ZN6google8protobuf4util15status_internal12_GLOBAL__N_118StatusCodeToStringB5cxx11ENS2_10StatusCodeE; google::protobuf::util::status_internal::`anonymous namespace'::StatusCodeToString(google::protobuf::util::status_internal::StatusCode)
jmp loc_256EE
loc_2565C:
mov rax, [rsp+98h+var_70]
mov esi, [rax]
lea rdi, [rsp+98h+var_68]
mov [rsp+98h+var_90], rdi
call _ZN6google8protobuf4util15status_internal12_GLOBAL__N_118StatusCodeToStringB5cxx11ENS2_10StatusCodeE; google::protobuf::util::status_internal::`anonymous namespace'::StatusCodeToString(google::protobuf::util::status_internal::StatusCode)
mov rsi, [rsp+98h+var_90]
lea rdx, asc_1EDBE0+1; ":"
lea rdi, [rsp+98h+var_48]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
jmp short $+2
loc_2568A:
mov rdi, [rsp+98h+var_80]
mov rdx, [rsp+98h+var_70]
add rdx, 8
lea rsi, [rsp+98h+var_48]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_RKS8_; std::operator+<char>(std::string&&,std::string const&)
jmp short $+2
loc_256A4:
lea rdi, [rsp+98h+var_48]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+98h+var_68]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_256EE
mov rcx, rax
mov eax, edx
mov [rsp+arg_70], rcx
mov [rsp+arg_6C], eax
jmp short loc_256E2
mov rcx, rax
mov eax, edx
mov [rsp+arg_70], rcx
mov [rsp+arg_6C], eax
lea rdi, [rsp+arg_48]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_256E2:
lea rdi, [rsp+arg_28]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_256FB
loc_256EE:
mov rax, [rsp+98h+var_78]
add rsp, 98h
retn
loc_256FB:
mov rdi, [rsp+arg_70]
call __Unwind_Resume
|
ToString[abi:cxx11]:
SUB RSP,0x98
MOV qword ptr [RSP + 0x18],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x90],RDI
MOV qword ptr [RSP + 0x88],RSI
MOV RAX,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0x28],RAX
CMP dword ptr [RAX],0x0
JNZ 0x00125632
LEA RDI,[RSP + 0x87]
MOV qword ptr [RSP + 0x10],RDI
CALL 0x00113760
MOV RDI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x10]
LAB_001255f2:
LEA RSI,[0x2ec4ec]
CALL 0x001135f0
LAB_001255fe:
JMP 0x00125600
LAB_00125600:
LEA RDI,[RSP + 0x87]
CALL 0x001134d0
JMP 0x001256ee
LAB_00125632:
MOV RDI,qword ptr [RSP + 0x28]
ADD RDI,0x8
CALL 0x001147f0
TEST AL,0x1
JNZ 0x00125646
JMP 0x0012565c
LAB_00125646:
MOV RDI,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RSP + 0x28]
MOV ESI,dword ptr [RAX]
CALL 0x00125710
JMP 0x001256ee
LAB_0012565c:
MOV RAX,qword ptr [RSP + 0x28]
MOV ESI,dword ptr [RAX]
LEA RDI,[RSP + 0x30]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x00125710
MOV RSI,qword ptr [RSP + 0x8]
LAB_00125677:
LEA RDX,[0x2edbe1]
LEA RDI,[RSP + 0x50]
CALL 0x001191c0
JMP 0x0012568a
LAB_0012568a:
MOV RDI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x28]
ADD RDX,0x8
LAB_00125698:
LEA RSI,[RSP + 0x50]
CALL 0x00126650
LAB_001256a2:
JMP 0x001256a4
LAB_001256a4:
LEA RDI,[RSP + 0x50]
CALL 0x00113290
LEA RDI,[RSP + 0x30]
CALL 0x00113290
JMP 0x001256ee
LAB_001256ee:
MOV RAX,qword ptr [RSP + 0x20]
ADD RSP,0x98
RET
|
/* google::protobuf::util::status_internal::Status::ToString[abi:cxx11]() const */
string * google::protobuf::util::status_internal::Status::ToString_abi_cxx11_(void)
{
ulong uVar1;
int *in_RSI;
string *in_RDI;
_anonymous_namespace_ local_68 [32];
string local_48 [55];
allocator local_11 [17];
if (*in_RSI == 0) {
std::allocator<char>::allocator();
/* try { // try from 001255f2 to 001255fd has its CatchHandler @ 00125612 */
std::__cxx11::string::string(in_RDI,"OK",local_11);
std::allocator<char>::~allocator((allocator<char> *)local_11);
}
else {
uVar1 = std::__cxx11::string::empty((string *)(in_RSI + 2));
if ((uVar1 & 1) == 0) {
(anonymous_namespace)::StatusCodeToString_abi_cxx11_(local_68,*in_RSI);
/* try { // try from 00125677 to 00125687 has its CatchHandler @ 001256ba */
std::operator+(local_48,(char *)local_68);
/* try { // try from 00125698 to 001256a1 has its CatchHandler @ 001256ca */
std::operator+(in_RDI,local_48);
std::__cxx11::string::~string(local_48);
std::__cxx11::string::~string((string *)local_68);
}
else {
(anonymous_namespace)::StatusCodeToString_abi_cxx11_((_anonymous_namespace_ *)in_RDI,*in_RSI);
}
}
return in_RDI;
}
|
||
63,342 |
myisam_log_command
|
eloqsql/storage/myisam/mi_log.c
|
void _myisam_log_command(enum myisam_log_commands command, MI_INFO *info,
const uchar *buffert, uint length, int result)
{
uchar buff[9];
int error,old_errno;
ulong pid=(ulong) GETPID();
old_errno=my_errno;
buff[0]=(char) command;
mi_int2store(buff+1,info->dfile);
mi_int4store(buff+3,pid);
mi_int2store(buff+7,result);
mysql_mutex_lock(&THR_LOCK_myisam);
error=my_lock(myisam_log_file,F_WRLCK,0L,F_TO_EOF,MYF(MY_SEEK_NOT_DONE));
(void) mysql_file_write(myisam_log_file, buff, sizeof(buff), MYF(0));
if (buffert)
(void) mysql_file_write(myisam_log_file, buffert, length, MYF(0));
if (!error)
error=my_lock(myisam_log_file,F_UNLCK,0L,F_TO_EOF,MYF(MY_SEEK_NOT_DONE));
mysql_mutex_unlock(&THR_LOCK_myisam);
my_errno=old_errno;
}
|
O3
|
c
|
myisam_log_command:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, -0x40(%rbp)
movq %rdx, %r12
movq %rsi, %r15
movl %r8d, %r14d
movl %edi, %r13d
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
cmpl $0x1, 0x371956(%rip) # 0x3a66d8
jne 0x34d8d
movq 0x371945(%rip), %rbx # 0x3a66d0
jmp 0x34d95
callq 0x5c550
movq %rax, %rbx
callq 0x5c086
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movb %r13b, -0x39(%rbp)
movl 0x1c0(%r15), %eax
movb %al, -0x37(%rbp)
movb %ah, -0x38(%rbp)
movb %bl, -0x33(%rbp)
movb %bh, -0x34(%rbp)
movl %ebx, %eax
shrl $0x10, %eax
movb %al, -0x35(%rbp)
shrl $0x18, %ebx
movb %bl, -0x36(%rbp)
movl %r14d, %eax
movb %al, -0x31(%rbp)
movb %ah, -0x32(%rbp)
leaq 0x37a6cc(%rip), %rax # 0x3af4a0
cmpq $0x0, 0x40(%rax)
jne 0x34eee
leaq 0x37a6ba(%rip), %rdi # 0x3af4a0
callq 0x28530
leaq 0x2f973e(%rip), %r13 # 0x32e530
movl (%r13), %edi
movl $0x20, %r8d
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5a168
movl %eax, %r15d
movl (%r13), %ebx
leaq 0x2fb538(%rip), %rax # 0x330350
movq (%rax), %rax
leaq -0x90(%rbp), %rdi
movl %ebx, %esi
movl $0x7, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x34ef8
leaq -0x39(%rbp), %rsi
movl $0x9, %edx
movl %ebx, %edi
xorl %ecx, %ecx
callq 0x2a301
testq %r12, %r12
je 0x34e8d
movl (%r13), %ebx
movl -0x40(%rbp), %r14d
leaq 0x2fb4f2(%rip), %rax # 0x330350
movq (%rax), %rax
leaq -0x90(%rbp), %rdi
movl %ebx, %esi
movl $0x7, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x34f1d
movl %ebx, %edi
movq %r12, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x2a301
testl %r15d, %r15d
jne 0x34eaa
movl (%r13), %edi
movl $0x20, %r8d
movl $0x2, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5a168
leaq 0x37a5ef(%rip), %rax # 0x3af4a0
movq 0x40(%rax), %rdi
testq %rdi, %rdi
jne 0x34f0b
leaq 0x37a5df(%rip), %rdi # 0x3af4a0
callq 0x28260
callq 0x5c086
movl -0x44(%rbp), %ecx
movl %ecx, (%rax)
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x34f32
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x28f3c
jmp 0x34deb
leaq -0x39(%rbp), %rdx
movq %rax, %rdi
movl %ebx, %esi
callq 0x28f59
jmp 0x34e4a
leaq 0x2fb43e(%rip), %rax # 0x330350
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x34eba
movq %rax, %rdi
movq %r14, %rsi
movl %ebx, %edx
movq %r12, %rcx
callq 0x28fd1
jmp 0x34e8d
callq 0x283d0
|
_myisam_log_command:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov [rbp+var_40], ecx
mov r12, rdx
mov r15, rsi
mov r14d, r8d
mov r13d, edi
mov rax, fs:28h
mov [rbp+var_30], rax
cmp cs:log_type, 1
jnz short loc_34D8D
mov rbx, cs:myisam_pid
jmp short loc_34D95
loc_34D8D:
call my_thread_dbug_id
mov rbx, rax
loc_34D95:
call _my_thread_var
mov eax, [rax]
mov [rbp+var_44], eax
mov [rbp+var_39], r13b
mov eax, [r15+1C0h]
mov [rbp+var_37], al
mov [rbp+var_38], ah
mov [rbp+var_33], bl
mov [rbp+var_34], bh
mov eax, ebx
shr eax, 10h
mov [rbp+var_35], al
shr ebx, 18h
mov [rbp+var_36], bl
mov eax, r14d
mov [rbp+var_31], al
mov [rbp+var_32], ah
lea rax, THR_LOCK_myisam
cmp qword ptr [rax+40h], 0
jnz loc_34EEE
lea rdi, THR_LOCK_myisam
call _pthread_mutex_lock
loc_34DEB:
lea r13, myisam_log_file
mov edi, [r13+0]
mov r8d, 20h ; ' '
mov esi, 1
xor edx, edx
xor ecx, ecx
call my_lock
mov r15d, eax
mov ebx, [r13+0]
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_90]
mov esi, ebx
mov edx, 7
call qword ptr [rax+158h]
test rax, rax
jnz loc_34EF8
lea rsi, [rbp+var_39]
mov edx, 9
mov edi, ebx
xor ecx, ecx
call my_write
loc_34E4A:
test r12, r12
jz short loc_34E8D
mov ebx, [r13+0]
mov r14d, [rbp+var_40]
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_90]
mov esi, ebx
mov edx, 7
call qword ptr [rax+158h]
test rax, rax
jnz loc_34F1D
mov edi, ebx
mov rsi, r12
mov rdx, r14
xor ecx, ecx
call my_write
loc_34E8D:
test r15d, r15d
jnz short loc_34EAA
mov edi, [r13+0]
mov r8d, 20h ; ' '
mov esi, 2
xor edx, edx
xor ecx, ecx
call my_lock
loc_34EAA:
lea rax, THR_LOCK_myisam
mov rdi, [rax+40h]
test rdi, rdi
jnz short loc_34F0B
loc_34EBA:
lea rdi, THR_LOCK_myisam
call _pthread_mutex_unlock
call _my_thread_var
mov ecx, [rbp+var_44]
mov [rax], ecx
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_34F32
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_34EEE:
call _myisam_log_command_cold_1
jmp loc_34DEB
loc_34EF8:
lea rdx, [rbp+var_39]
mov rdi, rax
mov esi, ebx
call _myisam_log_command_cold_2
jmp loc_34E4A
loc_34F0B:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_34EBA
loc_34F1D:
mov rdi, rax
mov rsi, r14
mov edx, ebx
mov rcx, r12
call _myisam_log_command_cold_3
jmp loc_34E8D
loc_34F32:
call ___stack_chk_fail
|
unsigned long long myisam_log_command(long long a1, long long a2, long long a3, unsigned int a4, __int16 a5)
{
int v7; // ebx
__int16 v8; // kr00_2
int v9; // r15d
unsigned int v10; // ebx
long long v11; // rax
const char *v12; // rsi
unsigned int v13; // ebx
long long v14; // r14
long long v15; // rax
_DWORD *v16; // rax
_BYTE v18[76]; // [rsp+0h] [rbp-90h] BYREF
int v19; // [rsp+4Ch] [rbp-44h]
unsigned int v20; // [rsp+50h] [rbp-40h]
_BYTE v21[9]; // [rsp+57h] [rbp-39h] BYREF
unsigned long long v22; // [rsp+60h] [rbp-30h]
v20 = a4;
v22 = __readfsqword(0x28u);
if ( log_type == 1 )
v7 = myisam_pid;
else
v7 = my_thread_dbug_id();
v19 = *(_DWORD *)my_thread_var(a1, (const char *)a2);
v21[0] = a1;
v8 = *(_DWORD *)(a2 + 448);
v21[1] = HIBYTE(v8);
v21[2] = v8;
v21[5] = BYTE1(v7);
v21[6] = v7;
v21[4] = BYTE2(v7);
v21[3] = HIBYTE(v7);
v21[7] = HIBYTE(a5);
v21[8] = a5;
if ( THR_LOCK_myisam[8] )
myisam_log_command_cold_1();
else
pthread_mutex_lock(THR_LOCK_myisam);
v9 = my_lock(myisam_log_file, 1LL, 0LL, 0LL, 32LL);
v10 = myisam_log_file;
v11 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v18, myisam_log_file, 7LL);
if ( v11 )
{
v12 = (const char *)v10;
myisam_log_command_cold_2(v11, v10, (long long)v21);
}
else
{
v12 = v21;
my_write(v10, (long long)v21, 9LL, 0LL);
}
if ( a3 )
{
v13 = myisam_log_file;
v14 = v20;
v15 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v18, myisam_log_file, 7LL);
if ( v15 )
{
v12 = (const char *)v14;
myisam_log_command_cold_3(v15, v14, v13, a3);
}
else
{
v12 = (const char *)a3;
my_write(v13, a3, v14, 0LL);
}
}
if ( !v9 )
{
v12 = (_BYTE *)(&dword_0 + 2);
my_lock(myisam_log_file, 2LL, 0LL, 0LL, 32LL);
}
if ( THR_LOCK_myisam[8] )
PSI_server[44]();
pthread_mutex_unlock(THR_LOCK_myisam);
v16 = (_DWORD *)my_thread_var(THR_LOCK_myisam, v12);
*v16 = v19;
return __readfsqword(0x28u);
}
|
_myisam_log_command:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV dword ptr [RBP + -0x40],ECX
MOV R12,RDX
MOV R15,RSI
MOV R14D,R8D
MOV R13D,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
CMP dword ptr [0x004a66d8],0x1
JNZ 0x00134d8d
MOV RBX,qword ptr [0x004a66d0]
JMP 0x00134d95
LAB_00134d8d:
CALL 0x0015c550
MOV RBX,RAX
LAB_00134d95:
CALL 0x0015c086
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x44],EAX
MOV byte ptr [RBP + -0x39],R13B
MOV EAX,dword ptr [R15 + 0x1c0]
MOV byte ptr [RBP + -0x37],AL
MOV byte ptr [RBP + -0x38],AH
MOV byte ptr [RBP + -0x33],BL
MOV byte ptr [RBP + -0x34],BH
MOV EAX,EBX
SHR EAX,0x10
MOV byte ptr [RBP + -0x35],AL
SHR EBX,0x18
MOV byte ptr [RBP + -0x36],BL
MOV EAX,R14D
MOV byte ptr [RBP + -0x31],AL
MOV byte ptr [RBP + -0x32],AH
LEA RAX,[0x4af4a0]
CMP qword ptr [RAX + 0x40],0x0
JNZ 0x00134eee
LEA RDI,[0x4af4a0]
CALL 0x00128530
LAB_00134deb:
LEA R13,[0x42e530]
MOV EDI,dword ptr [R13]
MOV R8D,0x20
MOV ESI,0x1
XOR EDX,EDX
XOR ECX,ECX
CALL 0x0015a168
MOV R15D,EAX
MOV EBX,dword ptr [R13]
LEA RAX,[0x430350]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x90]
MOV ESI,EBX
MOV EDX,0x7
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x00134ef8
LEA RSI,[RBP + -0x39]
MOV EDX,0x9
MOV EDI,EBX
XOR ECX,ECX
CALL 0x0012a301
LAB_00134e4a:
TEST R12,R12
JZ 0x00134e8d
MOV EBX,dword ptr [R13]
MOV R14D,dword ptr [RBP + -0x40]
LEA RAX,[0x430350]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x90]
MOV ESI,EBX
MOV EDX,0x7
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x00134f1d
MOV EDI,EBX
MOV RSI,R12
MOV RDX,R14
XOR ECX,ECX
CALL 0x0012a301
LAB_00134e8d:
TEST R15D,R15D
JNZ 0x00134eaa
MOV EDI,dword ptr [R13]
MOV R8D,0x20
MOV ESI,0x2
XOR EDX,EDX
XOR ECX,ECX
CALL 0x0015a168
LAB_00134eaa:
LEA RAX,[0x4af4a0]
MOV RDI,qword ptr [RAX + 0x40]
TEST RDI,RDI
JNZ 0x00134f0b
LAB_00134eba:
LEA RDI,[0x4af4a0]
CALL 0x00128260
CALL 0x0015c086
MOV ECX,dword ptr [RBP + -0x44]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00134f32
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00134eee:
CALL 0x00128f3c
JMP 0x00134deb
LAB_00134ef8:
LEA RDX,[RBP + -0x39]
MOV RDI,RAX
MOV ESI,EBX
CALL 0x00128f59
JMP 0x00134e4a
LAB_00134f0b:
LEA RAX,[0x430350]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00134eba
LAB_00134f1d:
MOV RDI,RAX
MOV RSI,R14
MOV EDX,EBX
MOV RCX,R12
CALL 0x00128fd1
JMP 0x00134e8d
LAB_00134f32:
CALL 0x001283d0
|
void _myisam_log_command(int1 param_1,long param_2,long param_3,int4 param_4,
ulong param_5)
{
int4 uVar1;
int4 uVar2;
int iVar3;
int4 *puVar4;
long lVar5;
long in_FS_OFFSET;
int1 local_98 [76];
int4 local_4c;
int4 local_48;
int1 local_41;
int1 local_40;
int1 local_3f;
int1 local_3e;
int1 local_3d;
int1 local_3c;
int1 local_3b;
int1 local_3a;
int1 local_39;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
local_48 = param_4;
if (log_type == 1) {
uVar2 = (int4)myisam_pid;
}
else {
uVar2 = my_thread_dbug_id();
}
puVar4 = (int4 *)_my_thread_var();
local_4c = *puVar4;
local_3f = (int1)*(int4 *)(param_2 + 0x1c0);
local_40 = (int1)((uint)*(int4 *)(param_2 + 0x1c0) >> 8);
local_3b = (int1)uVar2;
local_3c = (int1)((uint)uVar2 >> 8);
local_3d = (int1)((uint)uVar2 >> 0x10);
local_3e = (int1)((uint)uVar2 >> 0x18);
local_39 = (int1)(param_5 & 0xffffffff);
local_3a = (int1)((param_5 & 0xffffffff) >> 8);
local_41 = param_1;
if (THR_LOCK_myisam._64_8_ == 0) {
pthread_mutex_lock((pthread_mutex_t *)THR_LOCK_myisam);
}
else {
_myisam_log_command_cold_1();
}
iVar3 = my_lock(myisam_log_file,1,0,0,0x20);
uVar2 = myisam_log_file;
lVar5 = (**(code **)(PSI_server + 0x158))(local_98,myisam_log_file,7);
if (lVar5 == 0) {
my_write(uVar2,&local_41,9,0);
}
else {
_myisam_log_command_cold_2(lVar5,uVar2,&local_41);
}
uVar1 = local_48;
uVar2 = myisam_log_file;
if (param_3 != 0) {
lVar5 = (**(code **)(PSI_server + 0x158))(local_98,myisam_log_file,7);
if (lVar5 == 0) {
my_write(uVar2,param_3,uVar1,0);
}
else {
_myisam_log_command_cold_3(lVar5,uVar1,uVar2,param_3);
}
}
if (iVar3 == 0) {
my_lock(myisam_log_file,2,0,0,0x20);
}
if (THR_LOCK_myisam._64_8_ != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)THR_LOCK_myisam);
puVar4 = (int4 *)_my_thread_var();
*puVar4 = local_4c;
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
63,343 |
nglog::internal::CheckOpMessageBuilder::NewString[abi:cxx11]()
|
ng-log[P]ng-log/src/logging.cc
|
std::unique_ptr<string> CheckOpMessageBuilder::NewString() {
*stream_ << ")";
return std::make_unique<std::string>(stream_->str());
}
|
O1
|
cpp
|
nglog::internal::CheckOpMessageBuilder::NewString[abi:cxx11]():
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
leaq 0x14d5c(%rip), %rsi # 0x24c15
movl $0x1, %edx
callq 0x75c0
movq (%r14), %rsi
addq $0x8, %rsi
leaq 0x8(%rsp), %rdi
callq 0x7850
movl $0x20, %edi
callq 0x8fc0
movq %rax, %rdx
addq $0x10, %rdx
movq %rdx, (%rax)
leaq 0x18(%rsp), %rcx
movq -0x10(%rcx), %rsi
cmpq %rcx, %rsi
je 0xff04
movq %rsi, (%rax)
movq 0x18(%rsp), %rdx
movq %rdx, 0x10(%rax)
jmp 0xff0a
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x10(%rsp), %rdx
movq %rdx, 0x8(%rax)
movq %rcx, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xff52
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x900c
movq %rbx, %rdi
callq 0x7930
|
_ZN5nglog8internal21CheckOpMessageBuilder9NewStringB5cxx11Ev:
push r14
push rbx
sub rsp, 28h
mov r14, rsi
mov rbx, rdi
mov rdi, [rsi]
lea rsi, aVoidNglogAnony+86h; ")"
mov edx, 1
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rsi, [r14]
add rsi, 8
lea rdi, [rsp+38h+var_30]
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
mov edi, 20h ; ' '; unsigned __int64
call _Znwm; operator new(ulong)
mov rdx, rax
add rdx, 10h
mov [rax], rdx
lea rcx, [rsp+38h+var_20]
mov rsi, [rcx-10h]
cmp rsi, rcx
jz short loc_FF04
mov [rax], rsi
mov rdx, [rsp+38h+var_20]
mov [rax+10h], rdx
jmp short loc_FF0A
loc_FF04:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rdx], xmm0
loc_FF0A:
mov rdx, [rsp+38h+var_28]
mov [rax+8], rdx
mov [rsp+38h+var_30], rcx
mov [rsp+38h+var_28], 0
mov byte ptr [rsp+38h+var_20], 0
mov [rbx], rax
mov rax, rbx
add rsp, 28h
pop rbx
pop r14
retn
mov rbx, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_FF52
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call _ZdlPvm; operator delete(void *,ulong)
loc_FF52:
mov rdi, rbx
call __Unwind_Resume
|
long long * nglog::internal::CheckOpMessageBuilder::NewString[abi:cxx11](long long *a1, _QWORD *a2)
{
long long v2; // rax
_QWORD v4[2]; // [rsp+8h] [rbp-30h] BYREF
__int128 v5; // [rsp+18h] [rbp-20h] BYREF
std::__ostream_insert<char,std::char_traits<char>>(*a2, ")", 1LL);
std::stringbuf::str(v4, *a2 + 8LL);
v2 = operator new(32LL);
*(_QWORD *)v2 = v2 + 16;
if ( (__int128 *)v4[0] == &v5 )
{
*(_OWORD *)(v2 + 16) = v5;
}
else
{
*(_QWORD *)v2 = v4[0];
*(_QWORD *)(v2 + 16) = v5;
}
*(_QWORD *)(v2 + 8) = v4[1];
*a1 = v2;
return a1;
}
|
NewString[abi:cxx11]:
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV R14,RSI
MOV RBX,RDI
MOV RDI,qword ptr [RSI]
LEA RSI,[0x124c15]
MOV EDX,0x1
CALL 0x001075c0
MOV RSI,qword ptr [R14]
ADD RSI,0x8
LEA RDI,[RSP + 0x8]
CALL 0x00107850
LAB_0010fed4:
MOV EDI,0x20
CALL 0x00108fc0
LAB_0010fede:
MOV RDX,RAX
ADD RDX,0x10
MOV qword ptr [RAX],RDX
LEA RCX,[RSP + 0x18]
MOV RSI,qword ptr [RCX + -0x10]
CMP RSI,RCX
JZ 0x0010ff04
MOV qword ptr [RAX],RSI
MOV RDX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX + 0x10],RDX
JMP 0x0010ff0a
LAB_0010ff04:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RDX],XMM0
LAB_0010ff0a:
MOV RDX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX + 0x8],RDX
MOV qword ptr [RSP + 0x8],RCX
MOV qword ptr [RSP + 0x10],0x0
MOV byte ptr [RSP + 0x18],0x0
MOV qword ptr [RBX],RAX
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R14
RET
|
/* nglog::internal::CheckOpMessageBuilder::NewString[abi:cxx11]() */
void nglog::internal::CheckOpMessageBuilder::NewString_abi_cxx11_(void)
{
int8 *puVar1;
int8 *in_RSI;
int8 *in_RDI;
int1 *local_30;
int8 local_28;
int1 local_20;
int7 uStack_1f;
int8 uStack_18;
std::__ostream_insert<char,std::char_traits<char>>((ostream *)*in_RSI,")",1);
std::__cxx11::stringbuf::str();
/* try { // try from 0010fed4 to 0010fedd has its CatchHandler @ 0010ff34 */
puVar1 = (int8 *)operator_new(0x20);
*puVar1 = puVar1 + 2;
if (local_30 == &local_20) {
puVar1[2] = CONCAT71(uStack_1f,local_20);
puVar1[3] = uStack_18;
}
else {
*puVar1 = local_30;
puVar1[2] = CONCAT71(uStack_1f,local_20);
}
puVar1[1] = local_28;
*in_RDI = puVar1;
return;
}
|
|
63,344 |
nglog::internal::CheckOpMessageBuilder::NewString[abi:cxx11]()
|
ng-log[P]ng-log/src/logging.cc
|
std::unique_ptr<string> CheckOpMessageBuilder::NewString() {
*stream_ << ")";
return std::make_unique<std::string>(stream_->str());
}
|
O2
|
cpp
|
nglog::internal::CheckOpMessageBuilder::NewString[abi:cxx11]():
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
leaq 0x11e06(%rip), %rsi # 0x1fbed
callq 0x7560
movq (%r14), %rsi
addq $0x8, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x78e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x102f3
leaq 0x8(%rsp), %rdi
callq 0x7af8
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7af8
movq %rbx, %rdi
callq 0x79c0
|
_ZN5nglog8internal21CheckOpMessageBuilder9NewStringB5cxx11Ev:
push r14
push rbx
sub rsp, 28h
mov r14, rsi
mov rbx, rdi
mov rdi, [rsi]
lea rsi, aVoidNglogAnony+86h; ")"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rsi, [r14]
add rsi, 8
lea r14, [rsp+38h+var_30]
mov rdi, r14
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
mov rdi, rbx
mov rsi, r14
call _ZSt11make_uniqueINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJS5_EENSt9_MakeUniqIT_E15__single_objectEDpOT0_; std::make_unique<std::string,std::string>(std::string &&)
lea rdi, [rsp+38h+var_30]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rax, rbx
add rsp, 28h
pop rbx
pop r14
retn
mov rbx, rax
lea rdi, [rsp+arg_0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
call __Unwind_Resume
|
long long nglog::internal::CheckOpMessageBuilder::NewString[abi:cxx11](long long a1, _QWORD *a2)
{
_BYTE v3[48]; // [rsp+8h] [rbp-30h] BYREF
std::operator<<<std::char_traits<char>>(*a2, ")");
std::stringbuf::str(v3, *a2 + 8LL);
std::make_unique<std::string,std::string>(a1, v3);
std::string::~string(v3);
return a1;
}
|
NewString[abi:cxx11]:
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV R14,RSI
MOV RBX,RDI
MOV RDI,qword ptr [RSI]
LEA RSI,[0x11fbed]
CALL 0x00107560
MOV RSI,qword ptr [R14]
ADD RSI,0x8
LEA R14,[RSP + 0x8]
MOV RDI,R14
CALL 0x001078e0
LAB_0010de00:
MOV RDI,RBX
MOV RSI,R14
CALL 0x001102f3
LAB_0010de0b:
LEA RDI,[RSP + 0x8]
CALL 0x00107af8
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R14
RET
|
/* nglog::internal::CheckOpMessageBuilder::NewString[abi:cxx11]() */
void nglog::internal::CheckOpMessageBuilder::NewString_abi_cxx11_(void)
{
int8 *in_RSI;
string *in_RDI;
string local_30 [32];
std::operator<<((ostream *)*in_RSI,")");
std::__cxx11::stringbuf::str();
/* try { // try from 0010de00 to 0010de0a has its CatchHandler @ 0010de20 */
std::make_unique<std::__cxx11::string,std::__cxx11::string>(in_RDI);
std::__cxx11::string::~string(local_30);
return;
}
|
|
63,345 |
void google::protobuf::internal::RepeatedPtrFieldBase::MergeFromInnerLoop<google::protobuf::internal::GenericTypeHandler<google::protobuf::Message>>(void**, void**, int, int)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/repeated_ptr_field.h
|
PROTOBUF_NOINLINE void MergeFromInnerLoop(void** our_elems,
void** other_elems, int length,
int already_allocated) {
if (already_allocated < length) {
Arena* arena = GetOwningArena();
typename TypeHandler::Type* elem_prototype =
reinterpret_cast<typename TypeHandler::Type*>(other_elems[0]);
for (int i = already_allocated; i < length; i++) {
// Allocate a new empty element that we'll merge into below
typename TypeHandler::Type* new_elem =
TypeHandler::NewFromPrototype(elem_prototype, arena);
our_elems[i] = new_elem;
}
}
// Main loop that does the actual merging
for (int i = 0; i < length; i++) {
// Already allocated: use existing element.
typename TypeHandler::Type* other_elem =
reinterpret_cast<typename TypeHandler::Type*>(other_elems[i]);
typename TypeHandler::Type* new_elem =
reinterpret_cast<typename TypeHandler::Type*>(our_elems[i]);
TypeHandler::Merge(*other_elem, new_elem);
}
}
|
O0
|
c
|
void google::protobuf::internal::RepeatedPtrFieldBase::MergeFromInnerLoop<google::protobuf::internal::GenericTypeHandler<google::protobuf::Message>>(void**, void**, int, int):
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movl %ecx, 0x4c(%rsp)
movl %r8d, 0x48(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x48(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jge 0x53d3e4
movq 0x8(%rsp), %rdi
callq 0x3e9720
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movl 0x48(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jge 0x53d3e2
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x4e1dd0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdx
movq 0x58(%rsp), %rax
movslq 0x34(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x53d3a4
jmp 0x53d3e4
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jge 0x53d438
movq 0x50(%rsp), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x53d440
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x53d3ec
addq $0x68, %rsp
retq
nopl (%rax)
|
_ZN6google8protobuf8internal20RepeatedPtrFieldBase18MergeFromInnerLoopINS0_16RepeatedPtrFieldINS0_30DescriptorProto_ExtensionRangeEE11TypeHandlerEEEvPPvS9_ii:
sub rsp, 68h
mov [rsp+68h+var_8], rdi
mov [rsp+68h+var_10], rsi
mov [rsp+68h+var_18], rdx
mov [rsp+68h+var_1C], ecx
mov [rsp+68h+var_20], r8d
mov rax, [rsp+68h+var_8]
mov [rsp+68h+var_60], rax
mov eax, [rsp+68h+var_20]
cmp eax, [rsp+68h+var_1C]
jge short loc_53D3E4
mov rdi, [rsp+68h+var_60]; this
call _ZNK6google8protobuf8internal20RepeatedPtrFieldBase14GetOwningArenaEv; google::protobuf::internal::RepeatedPtrFieldBase::GetOwningArena(void)
mov [rsp+68h+var_28], rax
mov rax, [rsp+68h+var_18]
mov rax, [rax]
mov [rsp+68h+var_30], rax
mov eax, [rsp+68h+var_20]
mov [rsp+68h+var_34], eax
loc_53D3A4:
mov eax, [rsp+68h+var_34]
cmp eax, [rsp+68h+var_1C]
jge short loc_53D3E2
mov rdi, [rsp+68h+var_30]
mov rsi, [rsp+68h+var_28]
call _ZN6google8protobuf8internal18GenericTypeHandlerINS0_30DescriptorProto_ExtensionRangeEE16NewFromPrototypeEPKS3_PNS0_5ArenaE; google::protobuf::internal::GenericTypeHandler<google::protobuf::DescriptorProto_ExtensionRange>::NewFromPrototype(google::protobuf::DescriptorProto_ExtensionRange const*,google::protobuf::Arena *)
mov [rsp+68h+var_40], rax
mov rdx, [rsp+68h+var_40]
mov rax, [rsp+68h+var_10]
movsxd rcx, [rsp+68h+var_34]
mov [rax+rcx*8], rdx
mov eax, [rsp+68h+var_34]
add eax, 1
mov [rsp+68h+var_34], eax
jmp short loc_53D3A4
loc_53D3E2:
jmp short $+2
loc_53D3E4:
mov [rsp+68h+var_44], 0
loc_53D3EC:
mov eax, [rsp+68h+var_44]
cmp eax, [rsp+68h+var_1C]
jge short loc_53D438
mov rax, [rsp+68h+var_18]
movsxd rcx, [rsp+68h+var_44]
mov rax, [rax+rcx*8]
mov [rsp+68h+var_50], rax
mov rax, [rsp+68h+var_10]
movsxd rcx, [rsp+68h+var_44]
mov rax, [rax+rcx*8]
mov [rsp+68h+var_58], rax
mov rdi, [rsp+68h+var_50]
mov rsi, [rsp+68h+var_58]
call _ZN6google8protobuf8internal18GenericTypeHandlerINS0_30DescriptorProto_ExtensionRangeEE5MergeERKS3_PS3_; google::protobuf::internal::GenericTypeHandler<google::protobuf::DescriptorProto_ExtensionRange>::Merge(google::protobuf::DescriptorProto_ExtensionRange const&,google::protobuf::DescriptorProto_ExtensionRange*)
mov eax, [rsp+68h+var_44]
add eax, 1
mov [rsp+68h+var_44], eax
jmp short loc_53D3EC
loc_53D438:
add rsp, 68h
retn
|
long long google::protobuf::internal::RepeatedPtrFieldBase::MergeFromInnerLoop<google::protobuf::RepeatedPtrField<google::protobuf::DescriptorProto_ExtensionRange>::TypeHandler>(
google::protobuf::internal::RepeatedPtrFieldBase *a1,
long long a2,
long long *a3,
int a4,
int a5)
{
long long result; // rax
unsigned int j; // [rsp+24h] [rbp-44h]
int i; // [rsp+34h] [rbp-34h]
long long v8; // [rsp+38h] [rbp-30h]
int OwningArena; // [rsp+40h] [rbp-28h]
if ( a5 < a4 )
{
OwningArena = google::protobuf::internal::RepeatedPtrFieldBase::GetOwningArena(a1);
v8 = *a3;
for ( i = a5; i < a4; ++i )
*(_QWORD *)(a2 + 8LL * i) = google::protobuf::internal::GenericTypeHandler<google::protobuf::DescriptorProto_ExtensionRange>::NewFromPrototype(
v8,
OwningArena);
}
for ( j = 0; ; ++j )
{
result = j;
if ( (int)j >= a4 )
break;
google::protobuf::internal::GenericTypeHandler<google::protobuf::DescriptorProto_ExtensionRange>::Merge(
a3[j],
*(_QWORD *)(a2 + 8LL * (int)j));
}
return result;
}
|
move_iterator:
MOV qword ptr [RSP + -0x8],RSI
MOV qword ptr [RSP + -0x10],RDI
MOV RAX,qword ptr [RSP + -0x10]
MOV RCX,qword ptr [RSP + -0x8]
MOV qword ptr [RAX],RCX
RET
|
/* std::move_iterator<__gnu_cxx::__normal_iterator<google::protobuf::UnknownField*,
std::vector<google::protobuf::UnknownField, std::allocator<google::protobuf::UnknownField> > >
>::move_iterator(__gnu_cxx::__normal_iterator<google::protobuf::UnknownField*,
std::vector<google::protobuf::UnknownField, std::allocator<google::protobuf::UnknownField> > >)
*/
void __thiscall
std::
move_iterator<__gnu_cxx::__normal_iterator<google::protobuf::UnknownField*,std::vector<google::protobuf::UnknownField,std::allocator<google::protobuf::UnknownField>>>>
::move_iterator(move_iterator<__gnu_cxx::__normal_iterator<google::protobuf::UnknownField*,std::vector<google::protobuf::UnknownField,std::allocator<google::protobuf::UnknownField>>>>
*this,int8 param_2)
{
*(int8 *)this = param_2;
return;
}
|
|
63,346 |
void google::protobuf::internal::RepeatedPtrFieldBase::MergeFromInnerLoop<google::protobuf::internal::GenericTypeHandler<google::protobuf::Message>>(void**, void**, int, int)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/repeated_ptr_field.h
|
PROTOBUF_NOINLINE void MergeFromInnerLoop(void** our_elems,
void** other_elems, int length,
int already_allocated) {
if (already_allocated < length) {
Arena* arena = GetOwningArena();
typename TypeHandler::Type* elem_prototype =
reinterpret_cast<typename TypeHandler::Type*>(other_elems[0]);
for (int i = already_allocated; i < length; i++) {
// Allocate a new empty element that we'll merge into below
typename TypeHandler::Type* new_elem =
TypeHandler::NewFromPrototype(elem_prototype, arena);
our_elems[i] = new_elem;
}
}
// Main loop that does the actual merging
for (int i = 0; i < length; i++) {
// Already allocated: use existing element.
typename TypeHandler::Type* other_elem =
reinterpret_cast<typename TypeHandler::Type*>(other_elems[i]);
typename TypeHandler::Type* new_elem =
reinterpret_cast<typename TypeHandler::Type*>(our_elems[i]);
TypeHandler::Merge(*other_elem, new_elem);
}
}
|
O3
|
c
|
void google::protobuf::internal::RepeatedPtrFieldBase::MergeFromInnerLoop<google::protobuf::internal::GenericTypeHandler<google::protobuf::Message>>(void**, void**, int, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %ecx, 0x4(%rsp)
movl %ecx, %r12d
subl %r8d, %r12d
jle 0x1cfa6e
movq (%rdi), %r15
movslq %r8d, %rax
leaq (%r14,%rax,8), %r13
xorl %ebp, %ebp
movq %r15, %rdi
callq 0x1cf7d6
movq %rax, (%r13,%rbp,8)
incq %rbp
cmpl %ebp, %r12d
jne 0x1cfa59
movl 0x4(%rsp), %eax
testl %eax, %eax
jle 0x1cfa91
movl %eax, %r15d
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rdi
movq (%r14,%r12,8), %rsi
callq 0x1cfaa0
incq %r12
cmpq %r12, %r15
jne 0x1cfa7c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ZN6google8protobuf8internal20RepeatedPtrFieldBase18MergeFromInnerLoopINS0_16RepeatedPtrFieldINS0_9EnumValueEE11TypeHandlerEEEvPPvS9_ii:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdx
mov r14, rsi
mov [rsp+38h+var_34], ecx
mov r12d, ecx
sub r12d, r8d
jle short loc_1CFA6E
mov r15, [rdi]
movsxd rax, r8d
lea r13, [r14+rax*8]
xor ebp, ebp
loc_1CFA59:
mov rdi, r15
call _ZN6google8protobuf5Arena18CreateMaybeMessageINS0_9EnumValueEJEEEPT_PS1_DpOT0_; google::protobuf::Arena::CreateMaybeMessage<google::protobuf::EnumValue>(google::protobuf::Arena*)
mov [r13+rbp*8+0], rax
inc rbp
cmp r12d, ebp
jnz short loc_1CFA59
loc_1CFA6E:
mov eax, [rsp+38h+var_34]
test eax, eax
jle short loc_1CFA91
mov r15d, eax
xor r12d, r12d
loc_1CFA7C:
mov rdi, [rbx+r12*8]; google::protobuf::Message *
mov rsi, [r14+r12*8]; this
call _ZN6google8protobuf8internal18GenericTypeHandlerINS0_9EnumValueEE5MergeERKS3_PS3_; google::protobuf::internal::GenericTypeHandler<google::protobuf::EnumValue>::Merge(google::protobuf::EnumValue const&,google::protobuf::EnumValue*)
inc r12
cmp r15, r12
jnz short loc_1CFA7C
loc_1CFA91:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long google::protobuf::internal::RepeatedPtrFieldBase::MergeFromInnerLoop<google::protobuf::RepeatedPtrField<google::protobuf::EnumValue>::TypeHandler>(
google::protobuf::Arena **a1,
long long a2,
long long a3,
int a4,
int a5)
{
int v6; // r12d
google::protobuf::Arena *v7; // r15
long long v8; // r13
long long v9; // rbp
long long result; // rax
long long v11; // r12
v6 = a4 - a5;
if ( a4 > a5 )
{
v7 = *a1;
v8 = a2 + 8LL * a5;
v9 = 0LL;
do
*(_QWORD *)(v8 + 8 * v9++) = google::protobuf::Arena::CreateMaybeMessage<google::protobuf::EnumValue>(v7);
while ( v6 != (_DWORD)v9 );
}
result = (unsigned int)a4;
if ( a4 > 0 )
{
v11 = 0LL;
do
{
result = google::protobuf::internal::GenericTypeHandler<google::protobuf::EnumValue>::Merge(
*(google::protobuf::Message **)(a3 + 8 * v11),
*(google::protobuf::EnumValue **)(a2 + 8 * v11));
++v11;
}
while ( a4 != v11 );
}
return result;
}
| |||
63,347 |
plutovg_matrix_shear
|
dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-matrix.c
|
void plutovg_matrix_shear(plutovg_matrix_t* matrix, float shx, float shy)
{
plutovg_matrix_t m;
plutovg_matrix_init_shear(&m, shx, shy);
plutovg_matrix_multiply(matrix, &m, matrix);
}
|
O1
|
c
|
plutovg_matrix_shear:
pushq %rbx
subq $0x20, %rsp
movss %xmm0, 0x4(%rsp)
movq %rdi, %rbx
movaps %xmm1, %xmm0
callq 0xa480
movss %xmm0, (%rsp)
movss 0x4(%rsp), %xmm0
callq 0xa480
leaq 0x8(%rsp), %rsi
movl $0x3f800000, (%rsi) # imm = 0x3F800000
movss (%rsp), %xmm1
movss %xmm1, 0x4(%rsi)
movss %xmm0, 0x8(%rsi)
movq $0x3f800000, 0xc(%rsi) # imm = 0x3F800000
movl $0x0, 0x14(%rsi)
movq %rbx, %rdi
movq %rbx, %rdx
callq 0x27d51
addq $0x20, %rsp
popq %rbx
retq
|
plutovg_matrix_shear:
push rbx
sub rsp, 20h
movss [rsp+28h+var_24], xmm0
mov rbx, rdi
movaps xmm0, xmm1
call _tanf
movss [rsp+28h+var_28], xmm0
movss xmm0, [rsp+28h+var_24]
call _tanf
lea rsi, [rsp+28h+var_20]
mov dword ptr [rsi], 3F800000h
movss xmm1, [rsp+28h+var_28]
movss dword ptr [rsi+4], xmm1
movss dword ptr [rsi+8], xmm0
mov qword ptr [rsi+0Ch], 3F800000h
mov dword ptr [rsi+14h], 0
mov rdi, rbx
mov rdx, rbx
call plutovg_matrix_multiply
add rsp, 20h
pop rbx
retn
|
void plutovg_matrix_shear(float *a1, float a2, double a3)
{
float v4[3]; // [rsp+8h] [rbp-20h] BYREF
long long v5; // [rsp+14h] [rbp-14h]
int v6; // [rsp+1Ch] [rbp-Ch]
v4[0] = 1.0;
v4[1] = tanf(a3);
v4[2] = tanf(COERCE_DOUBLE((unsigned long long)LODWORD(a2)));
v5 = 1065353216LL;
v6 = 0;
plutovg_matrix_multiply(a1, v4, a1);
}
|
plutovg_matrix_shear:
PUSH RBX
SUB RSP,0x20
MOVSS dword ptr [RSP + 0x4],XMM0
MOV RBX,RDI
MOVAPS XMM0,XMM1
CALL 0x0010a480
MOVSS dword ptr [RSP],XMM0
MOVSS XMM0,dword ptr [RSP + 0x4]
CALL 0x0010a480
LEA RSI,[RSP + 0x8]
MOV dword ptr [RSI],0x3f800000
MOVSS XMM1,dword ptr [RSP]
MOVSS dword ptr [RSI + 0x4],XMM1
MOVSS dword ptr [RSI + 0x8],XMM0
MOV qword ptr [RSI + 0xc],0x3f800000
MOV dword ptr [RSI + 0x14],0x0
MOV RDI,RBX
MOV RDX,RBX
CALL 0x00127d51
ADD RSP,0x20
POP RBX
RET
|
void plutovg_matrix_shear(float param_1,float param_2,int8 param_3)
{
float fVar1;
int4 local_20;
float local_1c;
float local_18;
int8 local_14;
int4 local_c;
fVar1 = tanf(param_2);
local_18 = tanf(param_1);
local_20 = 0x3f800000;
local_14 = 0x3f800000;
local_c = 0;
local_1c = fVar1;
plutovg_matrix_multiply(param_3,&local_20,param_3);
return;
}
|
|
63,348 |
plutovg_matrix_shear
|
dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-matrix.c
|
void plutovg_matrix_shear(plutovg_matrix_t* matrix, float shx, float shy)
{
plutovg_matrix_t m;
plutovg_matrix_init_shear(&m, shx, shy);
plutovg_matrix_multiply(matrix, &m, matrix);
}
|
O2
|
c
|
plutovg_matrix_shear:
pushq %rbx
subq $0x20, %rsp
movss %xmm0, 0x4(%rsp)
movq %rdi, %rbx
movaps %xmm1, %xmm0
callq 0xa460
movss %xmm0, (%rsp)
movss 0x4(%rsp), %xmm0
callq 0xa460
leaq 0x8(%rsp), %rsi
movl $0x3f800000, (%rsi) # imm = 0x3F800000
movss (%rsp), %xmm1
movss %xmm1, 0x4(%rsi)
movss %xmm0, 0x8(%rsi)
movss 0x163d9(%rip), %xmm0 # 0x3a0c8
movlps %xmm0, 0xc(%rsi)
andl $0x0, 0x14(%rsi)
movq %rbx, %rdi
movq %rbx, %rdx
callq 0x23bc4
addq $0x20, %rsp
popq %rbx
retq
|
plutovg_matrix_shear:
push rbx
sub rsp, 20h
movss [rsp+28h+var_24], xmm0
mov rbx, rdi
movaps xmm0, xmm1
call _tanf
movss [rsp+28h+var_28], xmm0
movss xmm0, [rsp+28h+var_24]
call _tanf
lea rsi, [rsp+28h+var_20]
mov dword ptr [rsi], 3F800000h
movss xmm1, [rsp+28h+var_28]
movss dword ptr [rsi+4], xmm1
movss dword ptr [rsi+8], xmm0
movss xmm0, cs:flt_3A0C8
movlps qword ptr [rsi+0Ch], xmm0
and dword ptr [rsi+14h], 0
mov rdi, rbx
mov rdx, rbx
call plutovg_matrix_multiply
add rsp, 20h
pop rbx
retn
|
void plutovg_matrix_shear(unsigned long long *a1, float a2, double a3)
{
unsigned int v4[3]; // [rsp+8h] [rbp-20h] BYREF
double v5; // [rsp+14h] [rbp-14h] BYREF
int v6; // [rsp+1Ch] [rbp-Ch]
v4[0] = 1065353216;
v4[1] = tanf(a3);
v4[2] = tanf(COERCE_DOUBLE((unsigned long long)LODWORD(a2)));
_mm_storel_ps(&v5, (__m128)0x3F800000u);
v6 = 0;
plutovg_matrix_multiply((long long)a1, v4, a1);
}
|
plutovg_matrix_shear:
PUSH RBX
SUB RSP,0x20
MOVSS dword ptr [RSP + 0x4],XMM0
MOV RBX,RDI
MOVAPS XMM0,XMM1
CALL 0x0010a460
MOVSS dword ptr [RSP],XMM0
MOVSS XMM0,dword ptr [RSP + 0x4]
CALL 0x0010a460
LEA RSI,[RSP + 0x8]
MOV dword ptr [RSI],0x3f800000
MOVSS XMM1,dword ptr [RSP]
MOVSS dword ptr [RSI + 0x4],XMM1
MOVSS dword ptr [RSI + 0x8],XMM0
MOVSS XMM0,dword ptr [0x0013a0c8]
MOVLPS qword ptr [RSI + 0xc],XMM0
AND dword ptr [RSI + 0x14],0x0
MOV RDI,RBX
MOV RDX,RBX
CALL 0x00123bc4
ADD RSP,0x20
POP RBX
RET
|
void plutovg_matrix_shear(float param_1,float param_2,int8 param_3)
{
float fVar1;
int4 local_20;
float local_1c;
float local_18;
ulong local_14;
int4 local_c;
fVar1 = tanf(param_2);
local_18 = tanf(param_1);
local_20 = 0x3f800000;
local_14 = (ulong)DAT_0013a0c8;
local_c = 0;
local_1c = fVar1;
plutovg_matrix_multiply(param_3,&local_20,param_3);
return;
}
|
|
63,349 |
ggml_backend_sched_buffer_supported(ggml_backend_sched*, ggml_tensor*, int)
|
ngxson[P]ggml-easy/ggml/src/ggml-backend.cpp
|
static bool ggml_backend_sched_buffer_supported(ggml_backend_sched_t sched, struct ggml_tensor * t, int backend_id) {
ggml_backend_buffer_t buf = t->view_src ? t->view_src->buffer : t->buffer;
ggml_backend_buffer_type_t buft = NULL;
if (buf) {
// the tensor is already allocated
buft = buf->buft;
} else {
// see if the tensor already has a backend assigned, and use the buffer type of that backend
int tensor_backend_id = tensor_backend_id(t);
if (tensor_backend_id == -1 && t->view_src) {
tensor_backend_id = tensor_backend_id(t->view_src);
}
if (tensor_backend_id != -1) {
buft = sched->bufts[tensor_backend_id];
}
}
return buft != NULL && ggml_backend_supports_buft(sched->backends[backend_id], buft);
}
|
O0
|
cpp
|
ggml_backend_sched_buffer_supported(ggml_backend_sched*, ggml_tensor*, int):
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movq 0x48(%rsp), %rax
cmpq $0x0, 0xe8(%rax)
je 0x64218
movq 0x48(%rsp), %rax
movq 0xe8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x64226
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x64254
movq 0x38(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x642fd
movq 0x50(%rsp), %rax
movq 0x128(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
addq $0x110, %rdi # imm = 0x110
movq 0x48(%rsp), %rsi
callq 0x62b40
movq %rax, %rcx
movq 0x18(%rsp), %rax
movl (%rax,%rcx,4), %eax
movl %eax, 0x2c(%rsp)
cmpl $-0x1, 0x2c(%rsp)
jne 0x642dd
movq 0x48(%rsp), %rax
cmpq $0x0, 0xe8(%rax)
je 0x642dd
movq 0x50(%rsp), %rax
movq 0x128(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rdi
addq $0x110, %rdi # imm = 0x110
movq 0x48(%rsp), %rax
movq 0xe8(%rax), %rsi
callq 0x62b40
movq %rax, %rcx
movq 0x10(%rsp), %rax
movl (%rax,%rcx,4), %eax
movl %eax, 0x2c(%rsp)
cmpl $-0x1, 0x2c(%rsp)
je 0x642fb
movq 0x50(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movq 0x88(%rax,%rcx,8), %rax
movq %rax, 0x30(%rsp)
jmp 0x642fd
xorl %eax, %eax
cmpq $0x0, 0x30(%rsp)
movb %al, 0xf(%rsp)
je 0x64328
movq 0x50(%rsp), %rax
movslq 0x44(%rsp), %rcx
movq 0x8(%rax,%rcx,8), %rdi
movq 0x30(%rsp), %rsi
callq 0x45d80
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
|
_ZL35ggml_backend_sched_buffer_supportedP18ggml_backend_schedP11ggml_tensori:
sub rsp, 58h
mov [rsp+58h+var_8], rdi
mov [rsp+58h+var_10], rsi
mov [rsp+58h+var_14], edx
mov rax, [rsp+58h+var_10]
cmp qword ptr [rax+0E8h], 0
jz short loc_64218
mov rax, [rsp+58h+var_10]
mov rax, [rax+0E8h]
mov rax, [rax+8]
mov [rsp+58h+var_38], rax
jmp short loc_64226
loc_64218:
mov rax, [rsp+58h+var_10]
mov rax, [rax+8]
mov [rsp+58h+var_38], rax
loc_64226:
mov rax, [rsp+58h+var_38]
mov [rsp+58h+var_20], rax
mov [rsp+58h+var_28], 0
cmp [rsp+58h+var_20], 0
jz short loc_64254
mov rax, [rsp+58h+var_20]
mov rax, [rax+48h]
mov [rsp+58h+var_28], rax
jmp loc_642FD
loc_64254:
mov rax, [rsp+58h+var_8]
mov rax, [rax+128h]
mov [rsp+58h+var_40], rax
mov rdi, [rsp+58h+var_8]
add rdi, 110h
mov rsi, [rsp+58h+var_10]
call _ZL24ggml_hash_find_or_insertP13ggml_hash_setP11ggml_tensor; ggml_hash_find_or_insert(ggml_hash_set *,ggml_tensor *)
mov rcx, rax
mov rax, [rsp+58h+var_40]
mov eax, [rax+rcx*4]
mov [rsp+58h+var_2C], eax
cmp [rsp+58h+var_2C], 0FFFFFFFFh
jnz short loc_642DD
mov rax, [rsp+58h+var_10]
cmp qword ptr [rax+0E8h], 0
jz short loc_642DD
mov rax, [rsp+58h+var_8]
mov rax, [rax+128h]
mov [rsp+58h+var_48], rax
mov rdi, [rsp+58h+var_8]
add rdi, 110h
mov rax, [rsp+58h+var_10]
mov rsi, [rax+0E8h]
call _ZL24ggml_hash_find_or_insertP13ggml_hash_setP11ggml_tensor; ggml_hash_find_or_insert(ggml_hash_set *,ggml_tensor *)
mov rcx, rax
mov rax, [rsp+58h+var_48]
mov eax, [rax+rcx*4]
mov [rsp+58h+var_2C], eax
loc_642DD:
cmp [rsp+58h+var_2C], 0FFFFFFFFh
jz short loc_642FB
mov rax, [rsp+58h+var_8]
movsxd rcx, [rsp+58h+var_2C]
mov rax, [rax+rcx*8+88h]
mov [rsp+58h+var_28], rax
loc_642FB:
jmp short $+2
loc_642FD:
xor eax, eax
cmp [rsp+58h+var_28], 0
mov [rsp+58h+var_49], al
jz short loc_64328
mov rax, [rsp+58h+var_8]
movsxd rcx, [rsp+58h+var_14]
mov rdi, [rax+rcx*8+8]
mov rsi, [rsp+58h+var_28]
call _ggml_backend_supports_buft
mov [rsp+58h+var_49], al
loc_64328:
mov al, [rsp+58h+var_49]
and al, 1
add rsp, 58h
retn
|
char ggml_backend_sched_buffer_supported(long long a1, long long a2, int a3)
{
char v4; // [rsp+Fh] [rbp-49h]
long long v5; // [rsp+10h] [rbp-48h]
long long v6; // [rsp+18h] [rbp-40h]
long long v7; // [rsp+20h] [rbp-38h]
int v8; // [rsp+2Ch] [rbp-2Ch]
long long v9; // [rsp+30h] [rbp-28h]
if ( *(_QWORD *)(a2 + 232) )
v7 = *(_QWORD *)(*(_QWORD *)(a2 + 232) + 8LL);
else
v7 = *(_QWORD *)(a2 + 8);
v9 = 0LL;
if ( v7 )
{
v9 = *(_QWORD *)(v7 + 72);
}
else
{
v6 = *(_QWORD *)(a1 + 296);
v8 = *(_DWORD *)(v6 + 4 * ggml_hash_find_or_insert(a1 + 272, a2));
if ( v8 == -1 && *(_QWORD *)(a2 + 232) )
{
v5 = *(_QWORD *)(a1 + 296);
v8 = *(_DWORD *)(v5 + 4 * ggml_hash_find_or_insert(a1 + 272, *(_QWORD *)(a2 + 232)));
}
if ( v8 != -1 )
v9 = *(_QWORD *)(a1 + 8LL * v8 + 136);
}
v4 = 0;
if ( v9 )
v4 = ggml_backend_supports_buft(*(_QWORD *)(a1 + 8LL * a3 + 8), v9);
return v4 & 1;
}
|
ggml_backend_sched_buffer_supported:
SUB RSP,0x58
MOV qword ptr [RSP + 0x50],RDI
MOV qword ptr [RSP + 0x48],RSI
MOV dword ptr [RSP + 0x44],EDX
MOV RAX,qword ptr [RSP + 0x48]
CMP qword ptr [RAX + 0xe8],0x0
JZ 0x00164218
MOV RAX,qword ptr [RSP + 0x48]
MOV RAX,qword ptr [RAX + 0xe8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x20],RAX
JMP 0x00164226
LAB_00164218:
MOV RAX,qword ptr [RSP + 0x48]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x20],RAX
LAB_00164226:
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x38],RAX
MOV qword ptr [RSP + 0x30],0x0
CMP qword ptr [RSP + 0x38],0x0
JZ 0x00164254
MOV RAX,qword ptr [RSP + 0x38]
MOV RAX,qword ptr [RAX + 0x48]
MOV qword ptr [RSP + 0x30],RAX
JMP 0x001642fd
LAB_00164254:
MOV RAX,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RAX + 0x128]
MOV qword ptr [RSP + 0x18],RAX
MOV RDI,qword ptr [RSP + 0x50]
ADD RDI,0x110
MOV RSI,qword ptr [RSP + 0x48]
CALL 0x00162b40
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV EAX,dword ptr [RAX + RCX*0x4]
MOV dword ptr [RSP + 0x2c],EAX
CMP dword ptr [RSP + 0x2c],-0x1
JNZ 0x001642dd
MOV RAX,qword ptr [RSP + 0x48]
CMP qword ptr [RAX + 0xe8],0x0
JZ 0x001642dd
MOV RAX,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RAX + 0x128]
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RSP + 0x50]
ADD RDI,0x110
MOV RAX,qword ptr [RSP + 0x48]
MOV RSI,qword ptr [RAX + 0xe8]
CALL 0x00162b40
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV EAX,dword ptr [RAX + RCX*0x4]
MOV dword ptr [RSP + 0x2c],EAX
LAB_001642dd:
CMP dword ptr [RSP + 0x2c],-0x1
JZ 0x001642fb
MOV RAX,qword ptr [RSP + 0x50]
MOVSXD RCX,dword ptr [RSP + 0x2c]
MOV RAX,qword ptr [RAX + RCX*0x8 + 0x88]
MOV qword ptr [RSP + 0x30],RAX
LAB_001642fb:
JMP 0x001642fd
LAB_001642fd:
XOR EAX,EAX
CMP qword ptr [RSP + 0x30],0x0
MOV byte ptr [RSP + 0xf],AL
JZ 0x00164328
MOV RAX,qword ptr [RSP + 0x50]
MOVSXD RCX,dword ptr [RSP + 0x44]
MOV RDI,qword ptr [RAX + RCX*0x8 + 0x8]
MOV RSI,qword ptr [RSP + 0x30]
CALL 0x00145d80
MOV byte ptr [RSP + 0xf],AL
LAB_00164328:
MOV AL,byte ptr [RSP + 0xf]
AND AL,0x1
ADD RSP,0x58
RET
|
/* ggml_backend_sched_buffer_supported(ggml_backend_sched*, ggml_tensor*, int) */
ulong ggml_backend_sched_buffer_supported
(ggml_backend_sched *param_1,ggml_tensor *param_2,int param_3)
{
long lVar1;
long lVar2;
int8 uVar3;
int1 local_49;
long local_38;
int local_2c;
long local_28;
if (*(long *)(param_2 + 0xe8) == 0) {
local_38 = *(long *)(param_2 + 8);
}
else {
local_38 = *(long *)(*(long *)(param_2 + 0xe8) + 8);
}
local_28 = 0;
if (local_38 == 0) {
lVar1 = *(long *)(param_1 + 0x128);
lVar2 = ggml_hash_find_or_insert((ggml_hash_set *)(param_1 + 0x110),param_2);
local_2c = *(int *)(lVar1 + lVar2 * 4);
if ((local_2c == -1) && (*(long *)(param_2 + 0xe8) != 0)) {
lVar1 = *(long *)(param_1 + 0x128);
lVar2 = ggml_hash_find_or_insert
((ggml_hash_set *)(param_1 + 0x110),*(ggml_tensor **)(param_2 + 0xe8));
local_2c = *(int *)(lVar1 + lVar2 * 4);
}
if (local_2c != -1) {
local_28 = *(long *)(param_1 + (long)local_2c * 8 + 0x88);
}
}
else {
local_28 = *(long *)(local_38 + 0x48);
}
uVar3 = 0;
local_49 = 0;
if (local_28 != 0) {
uVar3 = ggml_backend_supports_buft(*(int8 *)(param_1 + (long)param_3 * 8 + 8),local_28);
local_49 = (int1)uVar3;
}
return CONCAT71((int7)((ulong)uVar3 >> 8),local_49) & 0xffffffffffffff01;
}
|
|
63,350 |
R3D_SetBloomMode
|
r3d/src/r3d_environment.c
|
void R3D_SetBloomMode(R3D_Bloom mode)
{
R3D.env.bloomMode = mode;
if (mode != R3D_BLOOM_DISABLED) {
if (R3D.framebuffer.pingPongBloom.id == 0) {
r3d_framebuffer_load_pingpong_bloom(
R3D.state.resolution.width,
R3D.state.resolution.height
);
}
if (R3D.shader.screen.bloom.id == 0) {
r3d_shader_load_screen_bloom();
}
}
}
|
O3
|
c
|
R3D_SetBloomMode:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0xf3c00(%rip), %rbx # 0x1b1bc0
movl %edi, 0x14e8(%rbx)
testl %edi, %edi
je 0xbdfea
cmpl $0x0, 0x40(%rbx)
jne 0xbdfe1
movl 0x1700(%rbx), %edi
movl 0x1704(%rbx), %esi
callq 0xc1c79
cmpl $0x0, 0x139c(%rbx)
je 0xbdff1
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xc53fa
|
R3D_SetBloomMode:
push rbp
mov rbp, rsp
push rbx
push rax
lea rbx, R3D
mov [rbx+14E8h], edi
test edi, edi
jz short loc_BDFEA
cmp dword ptr [rbx+40h], 0
jnz short loc_BDFE1
mov edi, [rbx+1700h]
mov esi, [rbx+1704h]
call r3d_framebuffer_load_pingpong_bloom
loc_BDFE1:
cmp dword ptr [rbx+139Ch], 0
jz short loc_BDFF1
loc_BDFEA:
add rsp, 8
pop rbx
pop rbp
retn
loc_BDFF1:
add rsp, 8
pop rbx
pop rbp
jmp r3d_shader_load_screen_bloom
|
long long R3D_SetBloomMode(int a1)
{
long long result; // rax
*((_DWORD *)&R3D + 1338) = a1;
if ( a1 )
{
if ( !*((_DWORD *)&R3D + 16) )
result = r3d_framebuffer_load_pingpong_bloom(*((unsigned int *)&R3D + 1472), *((unsigned int *)&R3D + 1473));
if ( !*((_DWORD *)&R3D + 1255) )
return r3d_shader_load_screen_bloom();
}
return result;
}
|
R3D_SetBloomMode:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
LEA RBX,[0x2b1bc0]
MOV dword ptr [RBX + 0x14e8],EDI
TEST EDI,EDI
JZ 0x001bdfea
CMP dword ptr [RBX + 0x40],0x0
JNZ 0x001bdfe1
MOV EDI,dword ptr [RBX + 0x1700]
MOV ESI,dword ptr [RBX + 0x1704]
CALL 0x001c1c79
LAB_001bdfe1:
CMP dword ptr [RBX + 0x139c],0x0
JZ 0x001bdff1
LAB_001bdfea:
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_001bdff1:
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x001c53fa
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void R3D_SetBloomMode(int param_1)
{
DAT_002b30a4._4_4_ = param_1;
if (param_1 != 0) {
if (_DAT_002b1c00 == 0) {
r3d_framebuffer_load_pingpong_bloom(DAT_002b32c0,DAT_002b32c4);
}
if (DAT_002b2f5c == 0) {
r3d_shader_load_screen_bloom();
return;
}
}
return;
}
|
|
63,351 |
inline_mysql_cond_signal
|
eloqsql/include/mysql/psi/mysql_thread.h
|
static inline int inline_mysql_cond_signal(
mysql_cond_t *that)
{
int result;
#ifdef HAVE_PSI_COND_INTERFACE
if (psi_likely(that->m_psi != NULL))
PSI_COND_CALL(signal_cond)(that->m_psi);
#endif
result= pthread_cond_signal(&that->m_cond);
return result;
}
|
O0
|
c
|
inline_mysql_cond_signal:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xe503b
leaq 0x1da091(%rip), %rax # 0x2bf0b8
movq (%rax), %rax
movq 0x170(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rdi
callq 0x2a580
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
|
inline_mysql_cond_signal_2:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
cmp qword ptr [rax+30h], 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_E503B
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+170h]
mov rcx, [rbp+var_8]
mov rdi, [rcx+30h]
call rax
loc_E503B:
mov rdi, [rbp+var_8]
call _pthread_cond_signal
mov [rbp+var_C], eax
mov eax, [rbp+var_C]
add rsp, 10h
pop rbp
retn
|
long long inline_mysql_cond_signal_2(long long a1)
{
if ( *(_QWORD *)(a1 + 48) )
((void ( *)(_QWORD))PSI_server[46])(*(_QWORD *)(a1 + 48));
return (unsigned int)pthread_cond_signal(a1);
}
|
inline_mysql_cond_signal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 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 0x001e503b
LEA RAX,[0x3bf0b8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x170]
MOV RCX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RCX + 0x30]
CALL RAX
LAB_001e503b:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0012a580
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0xc]
ADD RSP,0x10
POP RBP
RET
|
int inline_mysql_cond_signal(pthread_cond_t *param_1)
{
int iVar1;
if (param_1[1].__align != 0) {
(**(code **)(PSI_server + 0x170))(param_1[1].__align);
}
iVar1 = pthread_cond_signal(param_1);
return iVar1;
}
|
|
63,352 |
to_printable_8bit
|
eloqsql/strings/ctype.c
|
static uint to_printable_8bit(uchar *dst, my_wc_t wc, uint bs)
{
/*
This function is used only in context of error messages for now.
All non-BMP characters are currently replaced to question marks
when a message is put into diagnostics area.
*/
DBUG_ASSERT(wc < 0x10000);
*dst++= (char) bs;
*dst++= _dig_vec_upper[(wc >> 12) & 0x0F];
*dst++= _dig_vec_upper[(wc >> 8) & 0x0F];
*dst++= _dig_vec_upper[(wc >> 4) & 0x0F];
*dst++= _dig_vec_upper[wc & 0x0F];
return MY_CS_PRINTABLE_CHAR_LENGTH;
}
|
O0
|
c
|
to_printable_8bit:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
jmp 0xbcd81
movl -0x14(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
shrq $0xc, %rcx
andq $0xf, %rcx
leaq 0x14cbd6(%rip), %rax # 0x209980
movb (%rax,%rcx), %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
shrq $0x8, %rcx
andq $0xf, %rcx
leaq 0x14cbaf(%rip), %rax # 0x209980
movb (%rax,%rcx), %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
shrq $0x4, %rcx
andq $0xf, %rcx
leaq 0x14cb88(%rip), %rax # 0x209980
movb (%rax,%rcx), %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
andq $0xf, %rcx
leaq 0x14cb65(%rip), %rax # 0x209980
movb (%rax,%rcx), %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movl $0x5, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
to_printable_8bit:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
jmp short $+2
loc_BCD81:
mov eax, [rbp+var_14]
mov cl, al
mov rax, [rbp+var_8]
mov rdx, rax
add rdx, 1
mov [rbp+var_8], rdx
mov [rax], cl
mov rcx, [rbp+var_10]
shr rcx, 0Ch
and rcx, 0Fh
lea rax, _dig_vec_upper; "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
mov cl, [rax+rcx]
mov rax, [rbp+var_8]
mov rdx, rax
add rdx, 1
mov [rbp+var_8], rdx
mov [rax], cl
mov rcx, [rbp+var_10]
shr rcx, 8
and rcx, 0Fh
lea rax, _dig_vec_upper; "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
mov cl, [rax+rcx]
mov rax, [rbp+var_8]
mov rdx, rax
add rdx, 1
mov [rbp+var_8], rdx
mov [rax], cl
mov rcx, [rbp+var_10]
shr rcx, 4
and rcx, 0Fh
lea rax, _dig_vec_upper; "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
mov cl, [rax+rcx]
mov rax, [rbp+var_8]
mov rdx, rax
add rdx, 1
mov [rbp+var_8], rdx
mov [rax], cl
mov rcx, [rbp+var_10]
and rcx, 0Fh
lea rax, _dig_vec_upper; "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
mov cl, [rax+rcx]
mov rax, [rbp+var_8]
mov rdx, rax
add rdx, 1
mov [rbp+var_8], rdx
mov [rax], cl
mov eax, 5
pop rbp
retn
|
long long to_printable_8bit(_BYTE *a1, unsigned long long a2, char a3)
{
*a1 = a3;
a1[1] = dig_vec_upper[(unsigned __int16)a2 >> 12];
a1[2] = dig_vec_upper[(a2 >> 8) & 0xF];
a1[3] = dig_vec_upper[(unsigned __int8)a2 >> 4];
a1[4] = dig_vec_upper[a2 & 0xF];
return 5LL;
}
|
to_printable_8bit:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
JMP 0x001bcd81
LAB_001bcd81:
MOV EAX,dword ptr [RBP + -0x14]
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
MOV RCX,qword ptr [RBP + -0x10]
SHR RCX,0xc
AND RCX,0xf
LEA RAX,[0x309980]
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x8]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x8],RDX
MOV byte ptr [RAX],CL
MOV RCX,qword ptr [RBP + -0x10]
SHR RCX,0x8
AND RCX,0xf
LEA RAX,[0x309980]
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x8]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x8],RDX
MOV byte ptr [RAX],CL
MOV RCX,qword ptr [RBP + -0x10]
SHR RCX,0x4
AND RCX,0xf
LEA RAX,[0x309980]
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x8]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x8],RDX
MOV byte ptr [RAX],CL
MOV RCX,qword ptr [RBP + -0x10]
AND RCX,0xf
LEA RAX,[0x309980]
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x8]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x8],RDX
MOV byte ptr [RAX],CL
MOV EAX,0x5
POP RBP
RET
|
int8 to_printable_8bit(int1 *param_1,ulong param_2,int1 param_3)
{
*param_1 = param_3;
param_1[1] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[param_2 >> 0xc & 0xf];
param_1[2] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[param_2 >> 8 & 0xf];
param_1[3] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[param_2 >> 4 & 0xf];
param_1[4] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[param_2 & 0xf];
return 5;
}
|
|
63,353 |
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>::skip_bom()
|
zkingston[P]unknot/build_O1/_deps/json-src/include/nlohmann/detail/input/lexer.hpp
|
bool skip_bom()
{
if (get() == 0xEF)
{
// check if we completely parse the BOM
return get() == 0xBB && get() == 0xBF;
}
// the first character is not the beginning of the BOM; unget it to
// process is later
unget();
return true;
}
|
O1
|
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>::skip_bom():
pushq %rbx
movq %rdi, %rbx
callq 0x10818
cmpl $0xef, %eax
jne 0x31b05
movq %rbx, %rdi
callq 0x10818
cmpl $0xbb, %eax
je 0x31b11
xorl %eax, %eax
jmp 0x31b0f
movq %rbx, %rdi
callq 0x10878
movb $0x1, %al
popq %rbx
retq
movq %rbx, %rdi
callq 0x10818
cmpl $0xbf, %eax
sete %al
jmp 0x31b0f
nop
|
_ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE8skip_bomEv:
push rbx
mov rbx, rdi
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::get(void)
cmp eax, 0EFh
jnz short loc_31B05
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, 0BBh
jz short loc_31B11
xor eax, eax
jmp short loc_31B0F
loc_31B05:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE5ungetEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::unget(void)
mov al, 1
loc_31B0F:
pop rbx
retn
loc_31B11:
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, 0BFh
setz al
jmp short loc_31B0F
|
bool 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>::skip_bom(
nlohmann::json_abi_v3_11_3::detail::input_stream_adapter *this,
double a2,
__m128 a3)
{
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,
a2,
a3) == 239 )
return (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,
a2,
a3) == 187
&& (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,
a2,
a3) == 191;
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::unget((long long)this);
return 1;
}
|
skip_bom:
PUSH RBX
MOV RBX,RDI
CALL 0x00110818
CMP EAX,0xef
JNZ 0x00131b05
MOV RDI,RBX
CALL 0x00110818
CMP EAX,0xbb
JZ 0x00131b11
XOR EAX,EAX
JMP 0x00131b0f
LAB_00131b05:
MOV RDI,RBX
CALL 0x00110878
MOV AL,0x1
LAB_00131b0f:
POP RBX
RET
LAB_00131b11:
MOV RDI,RBX
CALL 0x00110818
CMP EAX,0xbf
SETZ AL
JMP 0x00131b0f
|
/* 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>::skip_bom() */
bool __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>
::skip_bom(lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>
*this)
{
int iVar1;
bool bVar2;
iVar1 = get(this);
if (iVar1 == 0xef) {
iVar1 = get(this);
if (iVar1 == 0xbb) {
iVar1 = get(this);
bVar2 = iVar1 == 0xbf;
}
else {
bVar2 = false;
}
}
else {
unget(this);
bVar2 = true;
}
return bVar2;
}
|
|
63,354 |
ma_gets
|
eloqsql/libmariadb/libmariadb/ma_io.c
|
char *ma_gets(char *ptr, size_t size, MA_FILE *file)
{
if (!file)
return NULL;
switch (file->type) {
case MA_FILE_LOCAL:
return fgets(ptr, (int)size, (FILE *)file->ptr);
break;
#ifdef HAVE_REMOTEIO
case MA_FILE_REMOTE:
return rio_plugin->methods->mgets(ptr, size, file);
break;
#endif
default:
return NULL;
}
}
|
O0
|
c
|
ma_gets:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x59305
movq $0x0, -0x8(%rbp)
jmp 0x5936a
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x1, %eax
je 0x5931f
jmp 0x59315
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x5933c
jmp 0x59362
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %esi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x36600
movq %rax, -0x8(%rbp)
jmp 0x5936a
leaq 0x3913cd(%rip), %rax # 0x3ea710
movq (%rax), %rax
movq 0x58(%rax), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq *%rax
movq %rax, -0x8(%rbp)
jmp 0x5936a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
|
ma_gets:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
cmp [rbp+var_20], 0
jnz short loc_59305
mov [rbp+var_8], 0
jmp short loc_5936A
loc_59305:
mov rax, [rbp+var_20]
mov eax, [rax]
mov [rbp+var_24], eax
sub eax, 1
jz short loc_5931F
jmp short $+2
loc_59315:
mov eax, [rbp+var_24]
sub eax, 2
jz short loc_5933C
jmp short loc_59362
loc_5931F:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_18]
mov esi, eax
mov rax, [rbp+var_20]
mov rdx, [rax+8]
call _fgets
mov [rbp+var_8], rax
jmp short loc_5936A
loc_5933C:
lea rax, rio_plugin
mov rax, [rax]
mov rax, [rax+58h]
mov rax, [rax+20h]
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call rax
mov [rbp+var_8], rax
jmp short loc_5936A
loc_59362:
mov [rbp+var_8], 0
loc_5936A:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
|
long long ma_gets(long long a1, long long a2, long long a3)
{
if ( !a3 )
return 0LL;
if ( *(_DWORD *)a3 == 1 )
return fgets(a1, (unsigned int)a2, *(_QWORD *)(a3 + 8));
if ( *(_DWORD *)a3 == 2 )
return (*(long long ( **)(long long, long long, long long))(*(_QWORD *)(rio_plugin + 88LL) + 32LL))(a1, a2, a3);
return 0LL;
}
|
ma_gets:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x00159305
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0015936a
LAB_00159305:
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x24],EAX
SUB EAX,0x1
JZ 0x0015931f
JMP 0x00159315
LAB_00159315:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0x2
JZ 0x0015933c
JMP 0x00159362
LAB_0015931f:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV ESI,EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x00136600
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0015936a
LAB_0015933c:
LEA RAX,[0x4ea710]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x58]
MOV RAX,qword ptr [RAX + 0x20]
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL RAX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0015936a
LAB_00159362:
MOV qword ptr [RBP + -0x8],0x0
LAB_0015936a:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
char * ma_gets(char *param_1,int8 param_2,int *param_3)
{
char *local_10;
if (param_3 == (int *)0x0) {
local_10 = (char *)0x0;
}
else if (*param_3 == 1) {
local_10 = fgets(param_1,(int)param_2,*(FILE **)(param_3 + 2));
}
else if (*param_3 == 2) {
local_10 = (char *)(**(code **)(*(long *)(rio_plugin + 0x58) + 0x20))(param_1,param_2,param_3);
}
else {
local_10 = (char *)0x0;
}
return local_10;
}
|
|
63,355 |
ma_field_extension_deep_dup
|
eloqsql/libmariadb/libmariadb/mariadb_lib.c
|
MA_FIELD_EXTENSION *ma_field_extension_deep_dup(MA_MEM_ROOT *memroot,
const MA_FIELD_EXTENSION *from)
{
MA_FIELD_EXTENSION *ext= new_ma_field_extension(memroot);
uint i;
if (!ext)
return NULL;
for (i= 0; i < MARIADB_FIELD_ATTR_LAST; i++)
{
if (from->metadata[i].str)
ext->metadata[i]= ma_const_string_copy_root(memroot,
from->metadata[i].str,
from->metadata[i].length);
}
return ext;
}
|
O0
|
c
|
ma_field_extension_deep_dup:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1e1f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1e261
movq $0x0, -0x8(%rbp)
jmp 0x1e2fa
movl $0x0, -0x24(%rbp)
cmpl $0x1, -0x24(%rbp)
jae 0x1e2f2
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x1e2e2
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdx
callq 0x1e310
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x1e2e4
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1e268
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
ma_field_extension_deep_dup:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rdi, [rbp+var_10]
call new_ma_field_extension
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
jnz short loc_1E261
mov [rbp+var_8], 0
jmp loc_1E2FA
loc_1E261:
mov [rbp+var_24], 0
loc_1E268:
cmp [rbp+var_24], 1
jnb loc_1E2F2
mov rax, [rbp+var_18]
mov ecx, [rbp+var_24]
shl rcx, 4
add rax, rcx
cmp qword ptr [rax], 0
jz short loc_1E2E2
mov rax, [rbp+var_20]
mov ecx, [rbp+var_24]
shl rcx, 4
add rax, rcx
mov [rbp+var_40], rax
mov rdi, [rbp+var_10]
mov rax, [rbp+var_18]
mov ecx, [rbp+var_24]
shl rcx, 4
add rax, rcx
mov rsi, [rax]
mov rax, [rbp+var_18]
mov ecx, [rbp+var_24]
shl rcx, 4
add rax, rcx
mov rdx, [rax+8]
call ma_const_string_copy_root
mov rcx, rax
mov rax, [rbp+var_40]
mov [rbp+var_38], rcx
mov [rbp+var_30], rdx
mov rcx, [rbp+var_38]
mov [rax], rcx
mov rcx, [rbp+var_30]
mov [rax+8], rcx
loc_1E2E2:
jmp short $+2
loc_1E2E4:
mov eax, [rbp+var_24]
add eax, 1
mov [rbp+var_24], eax
jmp loc_1E268
loc_1E2F2:
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
loc_1E2FA:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
|
_QWORD * ma_field_extension_deep_dup(long long a1, _QWORD *a2)
{
long long v2; // rdx
int i; // [rsp+1Ch] [rbp-24h]
_QWORD *v5; // [rsp+20h] [rbp-20h]
v5 = (_QWORD *)new_ma_field_extension(a1);
if ( !v5 )
return 0LL;
for ( i = 0; !i; i = 1 )
{
if ( *a2 )
{
*v5 = ma_const_string_copy_root(a1, *a2, a2[1]);
v5[1] = v2;
}
}
return v5;
}
|
ma_field_extension_deep_dup:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0011e1f0
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x0011e261
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0011e2fa
LAB_0011e261:
MOV dword ptr [RBP + -0x24],0x0
LAB_0011e268:
CMP dword ptr [RBP + -0x24],0x1
JNC 0x0011e2f2
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x24]
SHL RCX,0x4
ADD RAX,RCX
CMP qword ptr [RAX],0x0
JZ 0x0011e2e2
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x24]
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x24]
SHL RCX,0x4
ADD RAX,RCX
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x24]
SHL RCX,0x4
ADD RAX,RCX
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x0011e310
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x38],RCX
MOV qword ptr [RBP + -0x30],RDX
MOV RCX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x8],RCX
LAB_0011e2e2:
JMP 0x0011e2e4
LAB_0011e2e4:
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
MOV dword ptr [RBP + -0x24],EAX
JMP 0x0011e268
LAB_0011e2f2:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
LAB_0011e2fa:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
int1 (*) [16] ma_field_extension_deep_dup(int8 param_1,long *param_2)
{
bool bVar1;
int1 auVar2 [16];
int1 (*local_10) [16];
local_10 = (int1 (*) [16])new_ma_field_extension(param_1);
if (local_10 == (int1 (*) [16])0x0) {
local_10 = (int1 (*) [16])0x0;
}
else {
bVar1 = false;
while (!bVar1) {
if (*param_2 != 0) {
auVar2 = ma_const_string_copy_root(param_1,*param_2,param_2[1]);
*local_10 = auVar2;
}
bVar1 = true;
}
}
return local_10;
}
|
|
63,356 |
minja::Value::operator-() const
|
monkey531[P]llama/common/minja.hpp
|
Value operator-() const {
if (is_number_integer())
return -get<int64_t>();
else
return -get<double>();
}
|
O1
|
cpp
|
minja::Value::operator-() const:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x40(%rsi), %al
addb $-0x5, %al
leaq 0x40(%rdi), %r14
movq %rsi, %rdi
cmpb $0x1, %al
ja 0x88d40
callq 0x88f02
negq %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x40(%rbx)
movq %r14, %rdi
movq %rax, %rsi
callq 0x62906
jmp 0x88d6a
callq 0x89034
xorps 0x6b124(%rip), %xmm0 # 0xf3e70
xorps %xmm1, %xmm1
movups %xmm1, (%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm1, 0x20(%rbx)
movups %xmm1, 0x30(%rbx)
movups %xmm1, 0x40(%rbx)
movq %r14, %rdi
callq 0x61ec6
movq %r14, %rdi
movl $0x1, %esi
callq 0x5a908
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
_ZNK5minja5ValuengEv:
push r14
push rbx
push rax
mov rbx, rdi
mov al, [rsi+40h]
add al, 0FBh
lea r14, [rdi+40h]
mov rdi, rsi
cmp al, 1
ja short loc_88D40
call _ZNK5minja5Value3getIlEET_v; minja::Value::get<long>(void)
neg rax
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
movups xmmword ptr [rbx+10h], xmm0
movups xmmword ptr [rbx+20h], xmm0
movups xmmword ptr [rbx+30h], xmm0
movups xmmword ptr [rbx+40h], xmm0
mov rdi, r14
mov rsi, rax
call _ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE5EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEEEEvRT_NSJ_16number_integer_tE; nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)5>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::number_integer_t)
jmp short loc_88D6A
loc_88D40:
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
xorps xmm0, cs:xmmword_F3E70
xorps xmm1, xmm1
movups xmmword ptr [rbx], xmm1
movups xmmword ptr [rbx+10h], xmm1
movups xmmword ptr [rbx+20h], xmm1
movups xmmword ptr [rbx+30h], xmm1
movups xmmword ptr [rbx+40h], xmm1
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE7EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEEEEvRT_NSJ_14number_float_tE; nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)7>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::number_float_t)
loc_88D6A:
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rax, rbx
add rsp, 8
pop rbx
pop r14
retn
|
_OWORD * minja::Value::operator-(_OWORD *a1, long long a2)
{
unsigned __int8 *v2; // r14
long long v3; // rax
double v4; // xmm0_8
v2 = (unsigned __int8 *)(a1 + 4);
if ( (unsigned __int8)(*(_BYTE *)(a2 + 64) - 5) > 1u )
{
v4 = minja::Value::get<double>(a2);
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
a1[3] = 0LL;
a1[4] = 0LL;
nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)7>::construct<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>>(
v2,
-v4);
}
else
{
v3 = minja::Value::get<long>(a2);
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
a1[3] = 0LL;
a1[4] = 0LL;
nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)5>::construct<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>>(
v2,
-v3);
}
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v2);
return a1;
}
|
operator-:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV AL,byte ptr [RSI + 0x40]
ADD AL,0xfb
LEA R14,[RDI + 0x40]
MOV RDI,RSI
CMP AL,0x1
JA 0x00188d40
CALL 0x00188f02
NEG RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOVUPS xmmword ptr [RBX + 0x20],XMM0
MOVUPS xmmword ptr [RBX + 0x30],XMM0
MOVUPS xmmword ptr [RBX + 0x40],XMM0
MOV RDI,R14
MOV RSI,RAX
CALL 0x00162906
JMP 0x00188d6a
LAB_00188d40:
CALL 0x00189034
XORPS XMM0,xmmword ptr [0x001f3e70]
XORPS XMM1,XMM1
MOVUPS xmmword ptr [RBX],XMM1
MOVUPS xmmword ptr [RBX + 0x10],XMM1
MOVUPS xmmword ptr [RBX + 0x20],XMM1
MOVUPS xmmword ptr [RBX + 0x30],XMM1
MOVUPS xmmword ptr [RBX + 0x40],XMM1
MOV RDI,R14
CALL 0x00161ec6
LAB_00188d6a:
MOV RDI,R14
MOV ESI,0x1
CALL 0x0015a908
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* minja::Value::TEMPNAMEPLACEHOLDERVALUE() const */
Value * __thiscall minja::Value::operator-(Value *this)
{
Value *pVVar1;
double dVar2;
long lVar3;
Value *in_RSI;
uint uVar4;
pVVar1 = this + 0x40;
if ((byte)((char)in_RSI[0x40] - 5U) < 2) {
lVar3 = get<long>(in_RSI);
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
nlohmann::json_abi_v3_11_3::detail::
external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)5>::
construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(pVVar1,-lVar3);
}
else {
dVar2 = get<double>(in_RSI);
uVar4 = SUB84(dVar2,0) ^ _DAT_001f3e70;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
nlohmann::json_abi_v3_11_3::detail::
external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)7>::
construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(uVar4,pVVar1);
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(pVVar1,0));
return this;
}
|
|
63,357 |
mysql_close_memory
|
eloqsql/libmariadb/libmariadb/mariadb_lib.c
|
static void mysql_close_memory(MYSQL *mysql)
{
ma_clear_session_state(mysql);
free(mysql->host_info);
free(mysql->host);
free(mysql->user);
free(mysql->passwd);
free(mysql->db);
free(mysql->unix_socket);
free(mysql->server_version);
mysql->host_info= mysql->host= mysql->unix_socket=
mysql->server_version=mysql->user=mysql->passwd=mysql->db=0;
}
|
O3
|
c
|
mysql_close_memory:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3f9c3
movq 0x2d8(%rbx), %rdi
callq 0x36190
movq 0x2b0(%rbx), %rdi
callq 0x36190
movq 0x2b8(%rbx), %rdi
callq 0x36190
movq 0x2c0(%rbx), %rdi
callq 0x36190
movq 0x2e8(%rbx), %rdi
callq 0x36190
movq 0x2c8(%rbx), %rdi
callq 0x36190
movq 0x2d0(%rbx), %rdi
callq 0x36190
movq $0x0, 0x2e8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x2b0(%rbx)
movups %xmm0, 0x2c0(%rbx)
movups %xmm0, 0x2d0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
mysql_close_memory:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
call ma_clear_session_state
mov rdi, [rbx+2D8h]
call _free
mov rdi, [rbx+2B0h]
call _free
mov rdi, [rbx+2B8h]
call _free
mov rdi, [rbx+2C0h]
call _free
mov rdi, [rbx+2E8h]
call _free
mov rdi, [rbx+2C8h]
call _free
mov rdi, [rbx+2D0h]
call _free
mov qword ptr [rbx+2E8h], 0
xorps xmm0, xmm0
movups xmmword ptr [rbx+2B0h], xmm0
movups xmmword ptr [rbx+2C0h], xmm0
movups xmmword ptr [rbx+2D0h], xmm0
add rsp, 8
pop rbx
pop rbp
retn
|
long long mysql_close_memory(_QWORD *a1)
{
long long result; // rax
ma_clear_session_state(a1);
free(a1[91]);
free(a1[86]);
free(a1[87]);
free(a1[88]);
free(a1[93]);
free(a1[89]);
result = free(a1[90]);
a1[93] = 0LL;
*((_OWORD *)a1 + 43) = 0LL;
*((_OWORD *)a1 + 44) = 0LL;
*((_OWORD *)a1 + 45) = 0LL;
return result;
}
|
mysql_close_memory:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
CALL 0x0013f9c3
MOV RDI,qword ptr [RBX + 0x2d8]
CALL 0x00136190
MOV RDI,qword ptr [RBX + 0x2b0]
CALL 0x00136190
MOV RDI,qword ptr [RBX + 0x2b8]
CALL 0x00136190
MOV RDI,qword ptr [RBX + 0x2c0]
CALL 0x00136190
MOV RDI,qword ptr [RBX + 0x2e8]
CALL 0x00136190
MOV RDI,qword ptr [RBX + 0x2c8]
CALL 0x00136190
MOV RDI,qword ptr [RBX + 0x2d0]
CALL 0x00136190
MOV qword ptr [RBX + 0x2e8],0x0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x2b0],XMM0
MOVUPS xmmword ptr [RBX + 0x2c0],XMM0
MOVUPS xmmword ptr [RBX + 0x2d0],XMM0
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void mysql_close_memory(long param_1)
{
ma_clear_session_state();
free(*(void **)(param_1 + 0x2d8));
free(*(void **)(param_1 + 0x2b0));
free(*(void **)(param_1 + 0x2b8));
free(*(void **)(param_1 + 0x2c0));
free(*(void **)(param_1 + 0x2e8));
free(*(void **)(param_1 + 0x2c8));
free(*(void **)(param_1 + 0x2d0));
*(int8 *)(param_1 + 0x2e8) = 0;
*(int8 *)(param_1 + 0x2b0) = 0;
*(int8 *)(param_1 + 0x2b8) = 0;
*(int8 *)(param_1 + 0x2c0) = 0;
*(int8 *)(param_1 + 0x2c8) = 0;
*(int8 *)(param_1 + 0x2d0) = 0;
*(int8 *)(param_1 + 0x2d8) = 0;
return;
}
|
|
63,358 |
my_mb_wc_euc_jp
|
eloqsql/strings/ctype-ujis.c
|
static int
my_mb_wc_euc_jp(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e)
{
int hi;
if (s >= e)
return MY_CS_TOOSMALL;
if ((hi= s[0]) < 0x80) /* ASCII code set: [00..7F] -> [U+0000..U+007F] */
{
*pwc= hi;
return 1;
}
if (hi >= 0xA1 && hi <= 0xFE) /* JIS-X-0208 code set: [A1..FE][A1..FE] */
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
return (*pwc= jisx0208_eucjp_to_unicode[(hi << 8) + s[1]]) ? 2 :
(s[1] < 0xA1 || s[1] > 0xFE) ? MY_CS_ILSEQ : -2;
}
/* JIS-X-0201 HALF WIDTH KATAKANA: [8E][A1..DF] -> [U+FF61..U+FF9F] */
if (hi == 0x8E)
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
if (s[1] < 0xA1 || s[1] > 0xDF)
return MY_CS_ILSEQ;
*pwc= 0xFEC0 + s[1]; /* 0xFFC0 = 0xFF61 - 0xA1 */
return 2;
}
if (hi == 0x8F) /* JIS X 0212 code set: [8F][A1..FE][A1..FE] */
{
if (s + 3 > e)
return MY_CS_TOOSMALL3;
return (*pwc= jisx0212_eucjp_to_unicode[(((int) s[1]) << 8) + s[2]]) ?
3 :
(s[1] < 0xA1 || s[1] > 0xFE || s[2] < 0xA1 || s[2] > 0xFE) ?
MY_CS_ILSEQ : -3;
}
return MY_CS_ILSEQ;
}
|
O3
|
c
|
my_mb_wc_euc_jp:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x836ff
movzbl (%rdx), %edi
testb %dil, %dil
js 0x83701
movq %rdi, (%rsi)
movl $0x1, %eax
popq %rbp
retq
leal 0x5f(%rdi), %eax
cmpb $0x5d, %al
ja 0x8374d
leaq 0x2(%rdx), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %r8
ja 0x836ff
movzbl 0x1(%rdx), %eax
shll $0x9, %edi
leal (%rdi,%rax,2), %eax
leaq 0x20b1e9(%rip), %rcx # 0x28e910
movzwl (%rax,%rcx), %ecx
movq %rcx, (%rsi)
movl $0x2, %eax
testq %rcx, %rcx
jne 0x836ff
movb 0x1(%rdx), %al
incb %al
xorl %ecx, %ecx
cmpb $-0x5e, %al
setb %cl
leal -0x2(,%rcx,2), %eax
jmp 0x836ff
cmpq $0x8f, %rdi
je 0x83791
cmpl $0x8e, %edi
jne 0x837d3
leaq 0x2(%rdx), %rdi
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %rdi
ja 0x836ff
movzbl 0x1(%rdx), %ecx
leal 0x20(%rcx), %edx
movl $0x0, %eax
cmpb $-0x3f, %dl
jb 0x836ff
addq $0xfec0, %rcx # imm = 0xFEC0
movq %rcx, (%rsi)
movl $0x2, %eax
jmp 0x836ff
leaq 0x3(%rdx), %rdi
movl $0xffffff99, %eax # imm = 0xFFFFFF99
cmpq %rcx, %rdi
ja 0x836ff
movzwl 0x1(%rdx), %eax
rolw $0x8, %ax
movzwl %ax, %eax
leaq 0x22b15b(%rip), %rcx # 0x2ae910
movzwl (%rcx,%rax,2), %ecx
movq %rcx, (%rsi)
movl $0x3, %eax
testq %rcx, %rcx
jne 0x836ff
movb 0x1(%rdx), %al
incb %al
cmpb $-0x5e, %al
jae 0x837da
xorl %eax, %eax
jmp 0x836ff
movb 0x2(%rdx), %cl
movl $0x0, %eax
cmpb $-0x5f, %cl
jb 0x836ff
xorl %eax, %eax
cmpb $-0x1, %cl
sete %al
leal (%rax,%rax,2), %eax
addl $-0x3, %eax
jmp 0x836ff
|
my_mb_wc_euc_jp:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short loc_836FF
movzx edi, byte ptr [rdx]
test dil, dil
js short loc_83701
mov [rsi], rdi
mov eax, 1
loc_836FF:
pop rbp
retn
loc_83701:
lea eax, [rdi+5Fh]
cmp al, 5Dh ; ']'
ja short loc_8374D
lea r8, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp r8, rcx
ja short loc_836FF
movzx eax, byte ptr [rdx+1]
shl edi, 9
lea eax, [rdi+rax*2]
lea rcx, jisx0208_eucjp_to_unicode
movzx ecx, word ptr [rax+rcx]
mov [rsi], rcx
mov eax, 2
test rcx, rcx
jnz short loc_836FF
mov al, [rdx+1]
inc al
xor ecx, ecx
cmp al, 0A2h
setb cl
lea eax, ds:0FFFFFFFFFFFFFFFEh[rcx*2]
jmp short loc_836FF
loc_8374D:
cmp rdi, 8Fh
jz short loc_83791
cmp edi, 8Eh
jnz short loc_837D3
lea rdi, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp rdi, rcx
ja short loc_836FF
movzx ecx, byte ptr [rdx+1]
lea edx, [rcx+20h]
mov eax, 0
cmp dl, 0C1h
jb short loc_836FF
add rcx, 0FEC0h
mov [rsi], rcx
mov eax, 2
jmp loc_836FF
loc_83791:
lea rdi, [rdx+3]
mov eax, 0FFFFFF99h
cmp rdi, rcx
ja loc_836FF
movzx eax, word ptr [rdx+1]
rol ax, 8
movzx eax, ax
lea rcx, jisx0212_eucjp_to_unicode
movzx ecx, word ptr [rcx+rax*2]
mov [rsi], rcx
mov eax, 3
test rcx, rcx
jnz loc_836FF
mov al, [rdx+1]
inc al
cmp al, 0A2h
jnb short loc_837DA
loc_837D3:
xor eax, eax
jmp loc_836FF
loc_837DA:
mov cl, [rdx+2]
mov eax, 0
cmp cl, 0A1h
jb loc_836FF
xor eax, eax
cmp cl, 0FFh
setz al
lea eax, [rax+rax*2]
add eax, 0FFFFFFFDh
jmp loc_836FF
|
long long my_mb_wc_euc_jp(long long a1, _QWORD *a2, unsigned __int8 *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rdi
long long v6; // rcx
long long v7; // rcx
long long v8; // rcx
unsigned __int8 v9; // cl
result = 4294967195LL;
if ( (unsigned long long)a3 >= a4 )
return result;
v5 = *a3;
if ( (v5 & 0x80u) == 0LL )
{
*a2 = v5;
return 1LL;
}
if ( (unsigned __int8)(v5 + 95) <= 0x5Du )
{
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
v6 = jisx0208_eucjp_to_unicode[256 * (_DWORD)v5 + a3[1]];
*a2 = v6;
result = 2LL;
if ( !v6 )
return 2 * (unsigned int)((unsigned __int8)(a3[1] + 1) < 0xA2u) - 2;
}
return result;
}
if ( v5 != 143 )
{
if ( (_DWORD)v5 == 142 )
{
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
v7 = a3[1];
result = 0LL;
if ( (unsigned __int8)(v7 + 32) >= 0xC1u )
{
*a2 = v7 + 65216;
return 2LL;
}
}
return result;
}
return 0LL;
}
result = 4294967193LL;
if ( (unsigned long long)(a3 + 3) > a4 )
return result;
v8 = jisx0212_eucjp_to_unicode[(unsigned __int16)__ROL2__(*(_WORD *)(a3 + 1), 8)];
*a2 = v8;
result = 3LL;
if ( v8 )
return result;
if ( (unsigned __int8)(a3[1] + 1) < 0xA2u )
return 0LL;
v9 = a3[2];
result = 0LL;
if ( v9 >= 0xA1u )
return 3 * (unsigned int)(v9 == 0xFF) - 3;
return result;
}
|
my_mb_wc_euc_jp:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x001836ff
MOVZX EDI,byte ptr [RDX]
TEST DIL,DIL
JS 0x00183701
MOV qword ptr [RSI],RDI
MOV EAX,0x1
LAB_001836ff:
POP RBP
RET
LAB_00183701:
LEA EAX,[RDI + 0x5f]
CMP AL,0x5d
JA 0x0018374d
LEA R8,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP R8,RCX
JA 0x001836ff
MOVZX EAX,byte ptr [RDX + 0x1]
SHL EDI,0x9
LEA EAX,[RDI + RAX*0x2]
LEA RCX,[0x38e910]
MOVZX ECX,word ptr [RAX + RCX*0x1]
MOV qword ptr [RSI],RCX
MOV EAX,0x2
TEST RCX,RCX
JNZ 0x001836ff
MOV AL,byte ptr [RDX + 0x1]
INC AL
XOR ECX,ECX
CMP AL,0xa2
SETC CL
LEA EAX,[-0x2 + RCX*0x2]
JMP 0x001836ff
LAB_0018374d:
CMP RDI,0x8f
JZ 0x00183791
CMP EDI,0x8e
JNZ 0x001837d3
LEA RDI,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP RDI,RCX
JA 0x001836ff
MOVZX ECX,byte ptr [RDX + 0x1]
LEA EDX,[RCX + 0x20]
MOV EAX,0x0
CMP DL,0xc1
JC 0x001836ff
ADD RCX,0xfec0
MOV qword ptr [RSI],RCX
MOV EAX,0x2
JMP 0x001836ff
LAB_00183791:
LEA RDI,[RDX + 0x3]
MOV EAX,0xffffff99
CMP RDI,RCX
JA 0x001836ff
MOVZX EAX,word ptr [RDX + 0x1]
ROL AX,0x8
MOVZX EAX,AX
LEA RCX,[0x3ae910]
MOVZX ECX,word ptr [RCX + RAX*0x2]
MOV qword ptr [RSI],RCX
MOV EAX,0x3
TEST RCX,RCX
JNZ 0x001836ff
MOV AL,byte ptr [RDX + 0x1]
INC AL
CMP AL,0xa2
JNC 0x001837da
LAB_001837d3:
XOR EAX,EAX
JMP 0x001836ff
LAB_001837da:
MOV CL,byte ptr [RDX + 0x2]
MOV EAX,0x0
CMP CL,0xa1
JC 0x001836ff
XOR EAX,EAX
CMP CL,0xff
SETZ AL
LEA EAX,[RAX + RAX*0x2]
ADD EAX,-0x3
JMP 0x001836ff
|
int my_mb_wc_euc_jp(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
byte bVar1;
ushort uVar2;
int iVar3;
iVar3 = -0x65;
if (param_3 < param_4) {
bVar1 = *param_3;
if ((char)bVar1 < '\0') {
if ((byte)(bVar1 + 0x5f) < 0x5e) {
iVar3 = -0x66;
if (param_3 + 2 <= param_4) {
uVar2 = *(ushort *)
(jisx0208_eucjp_to_unicode + ((uint)bVar1 * 0x200 + (uint)param_3[1] * 2));
*param_2 = (ulong)uVar2;
iVar3 = 2;
if ((ulong)uVar2 == 0) {
iVar3 = (uint)((byte)(param_3[1] + 1) < 0xa2) * 2 + -2;
}
}
}
else {
if ((ulong)bVar1 == 0x8f) {
if (param_4 < param_3 + 3) {
return -0x67;
}
uVar2 = *(ushort *)
(&jisx0212_eucjp_to_unicode +
(ulong)(ushort)(*(ushort *)(param_3 + 1) << 8 | *(ushort *)(param_3 + 1) >> 8) *
2);
*param_2 = (ulong)uVar2;
if ((ulong)uVar2 != 0) {
return 3;
}
if (0xa1 < (byte)(param_3[1] + 1)) {
if (param_3[2] < 0xa1) {
return 0;
}
return (uint)(param_3[2] == 0xff) * 3 + -3;
}
}
else if (bVar1 == 0x8e) {
if (param_4 < param_3 + 2) {
return -0x66;
}
if ((byte)(param_3[1] + 0x20) < 0xc1) {
return 0;
}
*param_2 = (ulong)param_3[1] + 0xfec0;
return 2;
}
iVar3 = 0;
}
}
else {
*param_2 = (ulong)bVar1;
iVar3 = 1;
}
}
return iVar3;
}
|
|
63,359 |
bool httplib::detail::read_content<httplib::Request>(httplib::Stream&, httplib::Request&, unsigned long, int&, std::function<bool (unsigned long, unsigned long)>, std::function<bool (char const*, unsigned long, unsigned long, unsigned long)>, bool)
|
nickolajgrishuk[P]metricz-cpp/build_O3/_deps/httplib-src/httplib.h
|
bool read_content(Stream &strm, T &x, size_t payload_max_length, int &status,
Progress progress, ContentReceiverWithProgress receiver,
bool decompress) {
return prepare_content_receiver(
x, status, std::move(receiver), decompress,
[&](const ContentReceiverWithProgress &out) {
auto ret = true;
auto exceed_payload_max_length = false;
if (is_chunked_transfer_encoding(x.headers)) {
ret = read_content_chunked(strm, out);
} else if (!has_header(x.headers, "Content-Length")) {
ret = read_content_without_length(strm, out);
} else {
auto len = get_header_value<uint64_t>(x.headers, "Content-Length");
if (len > payload_max_length) {
exceed_payload_max_length = true;
skip_content_with_length(strm, len);
ret = false;
} else if (len > 0) {
ret = read_content_with_length(strm, len, std::move(progress), out);
}
}
if (!ret) { status = exceed_payload_max_length ? 413 : 400; }
return ret;
});
}
|
O3
|
c
|
bool httplib::detail::read_content<httplib::Request>(httplib::Stream&, httplib::Request&, unsigned long, int&, std::function<bool (unsigned long, unsigned long)>, std::function<bool (char const*, unsigned long, unsigned long, unsigned long)>, bool):
pushq %rbx
subq $0x80, %rsp
movb 0x90(%rsp), %al
movq %rdx, 0x50(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movq $0x0, 0x40(%rsp)
movq 0x18(%r9), %rdx
movq %rdx, 0x48(%rsp)
movq 0x10(%r9), %rdx
testq %rdx, %rdx
je 0x27306
movups (%r9), %xmm1
addq $0x10, %r9
movaps %xmm1, 0x30(%rsp)
movq %rdx, 0x40(%rsp)
movups %xmm0, (%r9)
movq %rsi, 0x58(%rsp)
movq %rdi, 0x60(%rsp)
leaq 0x50(%rsp), %rdx
movq %rdx, 0x68(%rsp)
movq %r8, 0x70(%rsp)
movq %rcx, 0x78(%rsp)
movq 0x78(%rsp), %rdx
movq %rdx, 0x20(%rsp)
movups 0x58(%rsp), %xmm0
movups 0x68(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movzbl %al, %eax
leaq 0x30(%rsp), %rdx
movq %rsi, %rdi
movq %rcx, %rsi
movl %eax, %ecx
callq 0x2806d
movl %eax, %ebx
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x27371
leaq 0x30(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebx, %eax
addq $0x80, %rsp
popq %rbx
retq
jmp 0x273a2
movq %rax, %rbx
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x2739a
leaq 0x30(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x8980
movq %rax, %rdi
callq 0x9339
|
_ZN7httplib6detail12read_contentINS_7RequestEEEbRNS_6StreamERT_mRiSt8functionIFbmmEES8_IFbPKcmmmEEb:
push rbx
sub rsp, 80h
mov al, [rsp+88h+arg_0]
mov [rsp+88h+var_38], rdx
xorps xmm0, xmm0
movaps [rsp+88h+var_58], xmm0
mov [rsp+88h+var_48], 0
mov rdx, [r9+18h]
mov [rsp+88h+var_40], rdx
mov rdx, [r9+10h]
test rdx, rdx
jz short loc_27306
movups xmm1, xmmword ptr [r9]
add r9, 10h
movaps [rsp+88h+var_58], xmm1
mov [rsp+88h+var_48], rdx
movups xmmword ptr [r9], xmm0
loc_27306:
mov qword ptr [rsp+88h+var_30], rsi
mov qword ptr [rsp+88h+var_30+8], rdi
lea rdx, [rsp+88h+var_38]
mov qword ptr [rsp+88h+var_20], rdx
mov qword ptr [rsp+88h+var_20+8], r8
mov [rsp+88h+var_10], rcx
mov rdx, [rsp+88h+var_10]
mov [rsp+88h+var_68], rdx
movups xmm0, [rsp+88h+var_30]
movups xmm1, [rsp+88h+var_20]
movups [rsp+88h+var_78], xmm1
movups [rsp+88h+var_88], xmm0
movzx eax, al
lea rdx, [rsp+88h+var_58]
mov rdi, rsi
mov rsi, rcx
mov ecx, eax
call _ZN7httplib6detail24prepare_content_receiverINS_7RequestEZNS0_12read_contentIS2_EEbRNS_6StreamERT_mRiSt8functionIFbmmEES9_IFbPKcmmmEEbEUlRKSF_E_EEbS7_S8_SF_bT0_; httplib::detail::prepare_content_receiver<httplib::Request,httplib::detail::read_content<httplib::Request>(httplib::Stream &,httplib::Request &,ulong,int &,std::function<bool ()(ulong,ulong)>,std::function<bool ()(char const*,ulong,ulong,ulong)>,bool)::{lambda(std::function<bool ()(char const*,ulong,ulong,ulong)> const&)#1}>(httplib::Request &,int &,std::function<bool ()(char const*,ulong,ulong,ulong)>,bool,httplib::detail::read_content<httplib::Request>(httplib::Stream &,httplib::Request &,ulong,int &,std::function<bool ()(ulong,ulong)>,std::function<bool ()(char const*,ulong,ulong,ulong)>,bool)::{lambda(std::function<bool ()(char const*,ulong,ulong,ulong)> const&)#1})
mov ebx, eax
mov rax, [rsp+88h+var_48]
test rax, rax
jz short loc_27371
lea rdi, [rsp+88h+var_58]
mov rsi, rdi
mov edx, 3
call rax
loc_27371:
mov eax, ebx
add rsp, 80h
pop rbx
retn
jmp short loc_273A2
mov rbx, rax
mov rax, [rsp+88h+var_48]
test rax, rax
jz short loc_2739A
lea rdi, [rsp+88h+var_58]
mov rsi, rdi
mov edx, 3
call rax
loc_2739A:
mov rdi, rbx
call __Unwind_Resume
loc_273A2:
mov rdi, rax
call __clang_call_terminate
|
long long httplib::detail::read_content<httplib::Request>(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
__int128 *a6,
unsigned __int8 a7)
{
void ( *v7)(__int128 *, __int128 *, long long); // rdx
__int128 v8; // xmm1
unsigned int v9; // ebx
__int128 v11; // [rsp+30h] [rbp-58h] BYREF
void ( *v12)(__int128 *, __int128 *, long long); // [rsp+40h] [rbp-48h]
long long v13; // [rsp+48h] [rbp-40h]
_QWORD v14[7]; // [rsp+50h] [rbp-38h] BYREF
v14[0] = a3;
v11 = 0LL;
v12 = 0LL;
v13 = *((_QWORD *)a6 + 3);
v7 = (void ( *)(__int128 *, __int128 *, long long))*((_QWORD *)a6 + 2);
if ( v7 )
{
v8 = *a6++;
v11 = v8;
v12 = v7;
*a6 = 0LL;
}
v14[1] = a2;
v14[2] = a1;
v14[3] = v14;
v14[4] = a5;
v14[5] = a4;
v9 = httplib::detail::prepare_content_receiver<httplib::Request,bool httplib::detail::read_content<httplib::Request>(httplib::Stream &,httplib::Request &,unsigned long,int &,std::function<bool ()(unsigned long,unsigned long)>,std::function<bool ()(char const*,unsigned long,unsigned long,unsigned long)>,bool)::{lambda(std::function<bool ()(char const*,unsigned long,unsigned long,unsigned long)> const&)#1}>(
a2,
a4,
(unsigned int)&v11,
a7,
a5,
(_DWORD)a6,
a2);
if ( v12 )
v12(&v11, &v11, 3LL);
return v9;
}
|
read_content<httplib::Request>:
PUSH RBX
SUB RSP,0x80
MOV AL,byte ptr [RSP + 0x90]
MOV qword ptr [RSP + 0x50],RDX
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOV qword ptr [RSP + 0x40],0x0
MOV RDX,qword ptr [R9 + 0x18]
MOV qword ptr [RSP + 0x48],RDX
MOV RDX,qword ptr [R9 + 0x10]
TEST RDX,RDX
JZ 0x00127306
MOVUPS XMM1,xmmword ptr [R9]
ADD R9,0x10
MOVAPS xmmword ptr [RSP + 0x30],XMM1
MOV qword ptr [RSP + 0x40],RDX
MOVUPS xmmword ptr [R9],XMM0
LAB_00127306:
MOV qword ptr [RSP + 0x58],RSI
MOV qword ptr [RSP + 0x60],RDI
LEA RDX,[RSP + 0x50]
MOV qword ptr [RSP + 0x68],RDX
MOV qword ptr [RSP + 0x70],R8
MOV qword ptr [RSP + 0x78],RCX
LAB_00127324:
MOV RDX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0x20],RDX
MOVUPS XMM0,xmmword ptr [RSP + 0x58]
MOVUPS XMM1,xmmword ptr [RSP + 0x68]
MOVUPS xmmword ptr [RSP + 0x10],XMM1
MOVUPS xmmword ptr [RSP],XMM0
MOVZX EAX,AL
LEA RDX,[RSP + 0x30]
MOV RDI,RSI
MOV RSI,RCX
MOV ECX,EAX
CALL 0x0012806d
MOV EBX,EAX
MOV RAX,qword ptr [RSP + 0x40]
TEST RAX,RAX
JZ 0x00127371
LAB_00127362:
LEA RDI,[RSP + 0x30]
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_00127371:
MOV EAX,EBX
ADD RSP,0x80
POP RBX
RET
|
/* bool httplib::detail::read_content<httplib::Request>(httplib::Stream&, httplib::Request&,
unsigned long, int&, std::function<bool (unsigned long, unsigned long)>, std::function<bool (char
const*, unsigned long, unsigned long, unsigned long)>, bool) */
bool httplib::detail::read_content<httplib::Request>
(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 *param_6,int1 param_7)
{
code *pcVar1;
int4 uVar2;
int4 uVar3;
int4 uVar4;
bool bVar5;
int8 *puVar6;
int8 local_58;
int8 uStack_50;
code *local_48;
int8 local_40;
int8 local_38;
int8 local_30;
int8 uStack_28;
int8 *local_20;
int8 uStack_18;
int8 local_10;
local_58 = 0;
uStack_50 = 0;
local_48 = (code *)0x0;
local_40 = param_6[3];
pcVar1 = (code *)param_6[2];
puVar6 = param_6;
if (pcVar1 != (code *)0x0) {
local_58 = *param_6;
uStack_50 = param_6[1];
puVar6 = param_6 + 2;
*puVar6 = 0;
param_6[3] = 0;
local_48 = pcVar1;
}
local_20 = &local_38;
/* try { // try from 00127324 to 00127355 has its CatchHandler @ 0012737e */
local_30._0_4_ = (int4)param_2;
uStack_28._0_4_ = (int4)param_1;
uStack_18._0_4_ = (int4)param_5;
local_38 = param_3;
uVar2 = (int4)local_30;
local_30 = param_2;
uVar3 = (int4)uStack_28;
uStack_28 = param_1;
uVar4 = (int4)uStack_18;
uStack_18 = param_5;
local_10 = param_4;
bVar5 = prepare_content_receiver<httplib::Request,httplib::detail::read_content<httplib::Request>(httplib::Stream&,httplib::Request&,unsigned_long,int&,std::function<bool(unsigned_long,unsigned_long)>,std::function<bool(char_const*,unsigned_long,unsigned_long,unsigned_long)>,bool)::_lambda(std::function<bool(char_const*,unsigned_long,unsigned_long,unsigned_long)>const&)_1_>
(param_2,param_4,&local_58,param_7,param_5,puVar6,uVar2,uVar3,local_20._0_4_,
uVar4,param_4);
if (local_48 != (code *)0x0) {
/* try { // try from 00127362 to 00127370 has its CatchHandler @ 0012737c */
(*local_48)(&local_58,&local_58,3);
}
return bVar5;
}
|
|
63,360 |
mysql_real_query_start
|
eloqsql/libmariadb/libmariadb/mariadb_async.c
|
int STDCALL
mysql_real_query_start(int *ret, MYSQL *mysql, const char *stmt_str, unsigned long length)
{
int res;
struct mysql_async_context *b;
struct mysql_real_query_params parms;
b= mysql->options.extension->async_context;
{
WIN_SET_NONBLOCKING(mysql)
parms.mysql= mysql;
parms.stmt_str= stmt_str;
parms.length= length;
}
b->active= 1;
res= my_context_spawn(&b->async_context, mysql_real_query_start_internal, &parms);
b->active= b->suspended= 0;
if (res > 0)
{
/* Suspended. */
b->suspended= 1;
return b->events_to_wait_for;
}
if (res < 0)
{
set_mariadb_error((mysql), CR_OUT_OF_MEMORY, unknown_sqlstate);
*ret= 1;
}
else
*ret= b->ret_result.r_int;
return 0;
}
|
O0
|
c
|
mysql_real_query_start:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movb $0x1, 0x14(%rax)
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
leaq 0xd6(%rip), %rsi # 0x5f050
leaq -0x50(%rbp), %rdx
callq 0x661d0
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rax
movb $0x0, 0x15(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x14(%rax)
cmpl $0x0, -0x2c(%rbp)
jle 0x5efb2
movq -0x38(%rbp), %rax
movb $0x1, 0x15(%rax)
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x5f03d
cmpl $0x0, -0x2c(%rbp)
jge 0x5f029
jmp 0x5efba
movq -0x18(%rbp), %rax
movl $0x7d8, 0x90(%rax) # imm = 0x7D8
movq -0x18(%rbp), %rdi
addq $0x297, %rdi # imm = 0x297
leaq 0x1d8776(%rip), %rax # 0x237750
movq (%rax), %rsi
movl $0x5, %edx
callq 0x37150
movq -0x18(%rbp), %rax
movb $0x0, 0x29c(%rax)
movq -0x18(%rbp), %rdi
addq $0x97, %rdi
leaq 0x1d875c(%rip), %rax # 0x237760
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x37150
movq -0x18(%rbp), %rax
movb $0x0, 0x296(%rax)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
jmp 0x5f036
movq -0x38(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
mysql_real_query_start:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_18]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_38], rax
mov rax, [rbp+var_18]
mov [rbp+var_50], rax
mov rax, [rbp+var_20]
mov [rbp+var_48], rax
mov rax, [rbp+var_28]
mov [rbp+var_40], rax
mov rax, [rbp+var_38]
mov byte ptr [rax+14h], 1
mov rdi, [rbp+var_38]
add rdi, 38h ; '8'
lea rsi, mysql_real_query_start_internal
lea rdx, [rbp+var_50]
call my_context_spawn
mov [rbp+var_2C], eax
mov rax, [rbp+var_38]
mov byte ptr [rax+15h], 0
mov rax, [rbp+var_38]
mov byte ptr [rax+14h], 0
cmp [rbp+var_2C], 0
jle short loc_5EFB2
mov rax, [rbp+var_38]
mov byte ptr [rax+15h], 1
mov rax, [rbp+var_38]
mov eax, [rax]
mov [rbp+var_4], eax
jmp loc_5F03D
loc_5EFB2:
cmp [rbp+var_2C], 0
jge short loc_5F029
jmp short $+2
loc_5EFBA:
mov rax, [rbp+var_18]
mov dword ptr [rax+90h], 7D8h
mov rdi, [rbp+var_18]
add rdi, 297h
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [rbp+var_18]
mov byte ptr [rax+29Ch], 0
mov rdi, [rbp+var_18]
add rdi, 97h
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
mov rax, [rbp+var_18]
mov byte ptr [rax+296h], 0
mov rax, [rbp+var_10]
mov dword ptr [rax], 1
jmp short loc_5F036
loc_5F029:
mov rax, [rbp+var_38]
mov ecx, [rax+8]
mov rax, [rbp+var_10]
mov [rax], ecx
loc_5F036:
mov [rbp+var_4], 0
loc_5F03D:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
|
long long mysql_real_query_start(_DWORD *a1, long long a2, long long a3, long long a4)
{
_QWORD v5[3]; // [rsp+0h] [rbp-50h] BYREF
unsigned int *v6; // [rsp+18h] [rbp-38h]
int v7; // [rsp+24h] [rbp-2Ch]
long long v8; // [rsp+28h] [rbp-28h]
long long v9; // [rsp+30h] [rbp-20h]
long long v10; // [rsp+38h] [rbp-18h]
_DWORD *v11; // [rsp+40h] [rbp-10h]
v11 = a1;
v10 = a2;
v9 = a3;
v8 = a4;
v6 = *(unsigned int **)(*(_QWORD *)(a2 + 1152) + 40LL);
v5[0] = a2;
v5[1] = a3;
v5[2] = a4;
*((_BYTE *)v6 + 20) = 1;
v7 = my_context_spawn(v6 + 14, mysql_real_query_start_internal, v5);
*((_BYTE *)v6 + 21) = 0;
*((_BYTE *)v6 + 20) = 0;
if ( v7 <= 0 )
{
if ( v7 >= 0 )
{
*v11 = v6[2];
}
else
{
*(_DWORD *)(v10 + 144) = 2008;
strncpy(v10 + 663, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(v10 + 668) = 0;
strncpy(v10 + 151, client_errors[8], 511LL);
*(_BYTE *)(v10 + 662) = 0;
*v11 = 1;
}
return 0;
}
else
{
*((_BYTE *)v6 + 21) = 1;
return *v6;
}
}
|
mysql_real_query_start:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x14],0x1
MOV RDI,qword ptr [RBP + -0x38]
ADD RDI,0x38
LEA RSI,[0x15f050]
LEA RDX,[RBP + -0x50]
CALL 0x001661d0
MOV dword ptr [RBP + -0x2c],EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x15],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x14],0x0
CMP dword ptr [RBP + -0x2c],0x0
JLE 0x0015efb2
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x15],0x1
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0015f03d
LAB_0015efb2:
CMP dword ptr [RBP + -0x2c],0x0
JGE 0x0015f029
JMP 0x0015efba
LAB_0015efba:
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x90],0x7d8
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x297
LEA RAX,[0x337750]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00137150
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x29c],0x0
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x97
LEA RAX,[0x337760]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00137150
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x296],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],0x1
JMP 0x0015f036
LAB_0015f029:
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],ECX
LAB_0015f036:
MOV dword ptr [RBP + -0x4],0x0
LAB_0015f03d:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
int4
mysql_real_query_start(int4 *param_1,long param_2,int8 param_3,int8 param_4)
{
long local_58;
int8 local_50;
int8 local_48;
int4 *local_40;
int local_34;
int8 local_30;
int8 local_28;
long local_20;
int4 *local_18;
int4 local_c;
local_40 = *(int4 **)(*(long *)(param_2 + 0x480) + 0x28);
*(int1 *)(local_40 + 5) = 1;
local_58 = param_2;
local_50 = param_3;
local_48 = param_4;
local_30 = param_4;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
local_34 = my_context_spawn(local_40 + 0xe,mysql_real_query_start_internal,&local_58);
*(int1 *)((long)local_40 + 0x15) = 0;
*(int1 *)(local_40 + 5) = 0;
if (local_34 < 1) {
if (local_34 < 0) {
*(int4 *)(local_20 + 0x90) = 0x7d8;
strncpy((char *)(local_20 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(local_20 + 0x29c) = 0;
strncpy((char *)(local_20 + 0x97),PTR_s_Client_run_out_of_memory_003377a0,0x1ff);
*(int1 *)(local_20 + 0x296) = 0;
*local_18 = 1;
}
else {
*local_18 = local_40[2];
}
local_c = 0;
}
else {
*(int1 *)((long)local_40 + 0x15) = 1;
local_c = *local_40;
}
return local_c;
}
|
|
63,361 |
CLI::Option* CLI::Option::ignore_case<CLI::App>(bool)
|
MikePodsytnik[P]TCRtrie/build_O2/_deps/cli11-src/include/CLI/impl/Option_inl.hpp
|
Option *Option::ignore_case(bool value) {
if(!ignore_case_ && value) {
ignore_case_ = value;
auto *parent = static_cast<T *>(parent_);
for(const Option_p &opt : parent->options_) {
if(opt.get() == this) {
continue;
}
const auto &omatch = opt->matching_name(*this);
if(!omatch.empty()) {
ignore_case_ = false;
throw OptionAlreadyAdded("adding ignore case caused a name conflict with " + omatch);
}
}
} else {
ignore_case_ = value;
}
return this;
}
|
O2
|
cpp
|
CLI::Option* CLI::Option::ignore_case<CLI::App>(bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movb 0x21(%rdi), %al
movb %sil, 0x21(%rdi)
testl %esi, %esi
je 0x15ae1
testb %al, %al
jne 0x15ae1
movq 0x1f0(%rbx), %rax
movq 0xd8(%rax), %r15
movq 0xe0(%rax), %r12
cmpq %r12, %r15
je 0x15ae1
movq (%r15), %rdi
cmpq %rbx, %rdi
je 0x15adb
movq %rbx, %rsi
callq 0x14a4e
cmpq $0x0, 0x8(%rax)
jne 0x15af1
addq $0x8, %r15
jmp 0x15abf
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movb $0x0, 0x21(%rbx)
pushq $0x38
popq %rdi
callq 0x7210
movq %rax, %rbx
leaq 0x13c25(%rip), %rsi # 0x2972f
movq %rsp, %rdi
movq %r14, %rdx
callq 0xd843
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x14c20
xorl %ebp, %ebp
leaq 0x2995c(%rip), %rsi # 0x3f488
leaq 0x8131(%rip), %rdx # 0x1dc64
movq %rbx, %rdi
callq 0x7750
movq %rax, %r14
movq %rsp, %rdi
callq 0x7860
testb %bpl, %bpl
jne 0x15b50
jmp 0x15b58
movq %rax, %r14
movq %rbx, %rdi
callq 0x7360
movq %r14, %rdi
callq 0x7770
|
_ZN3CLI6Option11ignore_caseINS_3AppEEEPS0_b:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 20h
mov rbx, rdi
mov al, [rdi+21h]
mov [rdi+21h], sil
test esi, esi
jz short loc_15AE1
test al, al
jnz short loc_15AE1
mov rax, [rbx+1F0h]
mov r15, [rax+0D8h]
mov r12, [rax+0E0h]
loc_15ABF:
cmp r15, r12
jz short loc_15AE1
mov rdi, [r15]
cmp rdi, rbx
jz short loc_15ADB
mov rsi, rbx
call _ZNK3CLI6Option13matching_nameB5cxx11ERKS0_; CLI::Option::matching_name(CLI::Option const&)
cmp qword ptr [rax+8], 0
jnz short loc_15AF1
loc_15ADB:
add r15, 8
jmp short loc_15ABF
loc_15AE1:
mov rax, rbx
add rsp, 20h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_15AF1:
mov r14, rax
mov byte ptr [rbx+21h], 0
push 38h ; '8'
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aAddingIgnoreCa; "adding ignore case caused a name confli"...
mov rdi, rsp
mov rdx, r14
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
mov bpl, 1
mov rsi, rsp
mov rdi, rbx
call _ZN3CLI18OptionAlreadyAddedC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; CLI::OptionAlreadyAdded::OptionAlreadyAdded(std::string)
xor ebp, ebp
lea rsi, _ZTIN3CLI18OptionAlreadyAddedE; lptinfo
lea rdx, _ZN3CLI5ErrorD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
mov rdi, rsp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_15B50
jmp short loc_15B58
mov r14, rax
loc_15B50:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_15B58:
mov rdi, r14
call __Unwind_Resume
|
long long CLI::Option::ignore_case<CLI::App>(long long a1, int a2)
{
char v2; // al
long long v3; // rax
long long *v4; // r15
long long *v5; // r12
long long *v6; // rax
long long v8; // r14
void *exception; // rbx
_BYTE v10[72]; // [rsp+0h] [rbp-48h] BYREF
v2 = *(_BYTE *)(a1 + 33);
*(_BYTE *)(a1 + 33) = a2;
if ( a2 && !v2 )
{
v3 = *(_QWORD *)(a1 + 496);
v4 = *(long long **)(v3 + 216);
v5 = *(long long **)(v3 + 224);
while ( v4 != v5 )
{
if ( *v4 != a1 )
{
v6 = CLI::Option::matching_name[abi:cxx11](*v4, (_QWORD *)a1);
if ( v6[1] )
{
v8 = (long long)v6;
*(_BYTE *)(a1 + 33) = 0;
exception = __cxa_allocate_exception(0x38uLL);
std::operator+<char>((long long)v10, (long long)"adding ignore case caused a name conflict with ", v8);
CLI::OptionAlreadyAdded::OptionAlreadyAdded((int)exception, (long long)v10);
__cxa_throw(exception, (struct type_info *)&`typeinfo for'CLI::OptionAlreadyAdded, CLI::Error::~Error);
}
}
++v4;
}
}
return a1;
}
|
ignore_case<CLI::App>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x20
MOV RBX,RDI
MOV AL,byte ptr [RDI + 0x21]
MOV byte ptr [RDI + 0x21],SIL
TEST ESI,ESI
JZ 0x00115ae1
TEST AL,AL
JNZ 0x00115ae1
MOV RAX,qword ptr [RBX + 0x1f0]
MOV R15,qword ptr [RAX + 0xd8]
MOV R12,qword ptr [RAX + 0xe0]
LAB_00115abf:
CMP R15,R12
JZ 0x00115ae1
MOV RDI,qword ptr [R15]
CMP RDI,RBX
JZ 0x00115adb
MOV RSI,RBX
CALL 0x00114a4e
CMP qword ptr [RAX + 0x8],0x0
JNZ 0x00115af1
LAB_00115adb:
ADD R15,0x8
JMP 0x00115abf
LAB_00115ae1:
MOV RAX,RBX
ADD RSP,0x20
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00115af1:
MOV R14,RAX
MOV byte ptr [RBX + 0x21],0x0
PUSH 0x38
POP RDI
CALL 0x00107210
MOV RBX,RAX
LAB_00115b03:
LEA RSI,[0x12972f]
MOV RDI,RSP
MOV RDX,R14
CALL 0x0010d843
MOV BPL,0x1
LAB_00115b18:
MOV RSI,RSP
MOV RDI,RBX
CALL 0x00114c20
XOR EBP,EBP
LEA RSI,[0x13f488]
LEA RDX,[0x11dc64]
MOV RDI,RBX
CALL 0x00107750
|
/* CLI::Option* CLI::Option::ignore_case<CLI::App>(bool) */
Option * __thiscall CLI::Option::ignore_case<CLI::App>(Option *this,bool param_1)
{
Option OVar1;
int8 *puVar2;
long lVar3;
OptionAlreadyAdded *pOVar4;
int7 in_register_00000031;
int8 *puVar5;
char acStack_48 [32];
OVar1 = this[0x21];
this[0x21] = (Option)param_1;
if (((int)CONCAT71(in_register_00000031,param_1) != 0) && (OVar1 == (Option)0x0)) {
puVar2 = *(int8 **)(*(long *)(this + 0x1f0) + 0xe0);
for (puVar5 = *(int8 **)(*(long *)(this + 0x1f0) + 0xd8); puVar5 != puVar2;
puVar5 = puVar5 + 1) {
if ((Option *)*puVar5 != this) {
lVar3 = matching_name_abi_cxx11_((Option *)*puVar5,this);
if (*(long *)(lVar3 + 8) != 0) {
this[0x21] = (Option)0x0;
pOVar4 = (OptionAlreadyAdded *)__cxa_allocate_exception(0x38);
/* try { // try from 00115b03 to 00115b14 has its CatchHandler @ 00115b4d */
std::operator+(acStack_48,(string *)"adding ignore case caused a name conflict with ");
/* try { // try from 00115b18 to 00115b3a has its CatchHandler @ 00115b3b */
OptionAlreadyAdded::OptionAlreadyAdded(pOVar4,acStack_48);
/* WARNING: Subroutine does not return */
__cxa_throw(pOVar4,&OptionAlreadyAdded::typeinfo,Error::~Error);
}
}
}
}
return this;
}
|
|
63,362 |
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>::get_token_string() const
|
llama.cpp/common/json.hpp
|
std::string get_token_string() const
{
// escape control characters
std::string result;
for (const auto c : token_string)
{
if (static_cast<unsigned char>(c) <= '\x1F')
{
// escape control characters
std::array<char, 9> cs{{}};
static_cast<void>((std::snprintf)(cs.data(), cs.size(), "<U+%.4X>", static_cast<unsigned char>(c))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
result += cs.data();
}
else
{
// add character as is
result.push_back(static_cast<std::string::value_type>(c));
}
}
return result;
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<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>::get_token_string() const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x38(%rsi), %r13
movq 0x40(%rsi), %rbp
cmpq %rbp, %r13
je 0x750e5
leaq 0xa4806(%rip), %r14 # 0x11989c
leaq 0x8(%rsp), %r15
movzbl (%r13), %ecx
cmpl $0x1f, %ecx
ja 0x750d2
movb $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movl $0x9, %esi
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x20890
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20b50
jmp 0x750dd
movsbl %cl, %esi
movq %rbx, %rdi
callq 0x213a0
incq %r13
cmpq %rbp, %r13
jne 0x7509b
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x750f9
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x75110
movq (%r12), %rsi
incq %rsi
callq 0x20190
movq %r14, %rdi
callq 0x20b00
|
_ZNK8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE16get_token_stringEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
lea r12, [rdi+10h]
mov [rdi], r12
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov r13, [rsi+38h]
mov rbp, [rsi+40h]
cmp r13, rbp
jz short loc_750E5
lea r14, aU4x; "<U+%.4X>"
lea r15, [rsp+48h+var_40]
loc_7509B:
movzx ecx, byte ptr [r13+0]
cmp ecx, 1Fh
ja short loc_750D2
mov [rsp+48h+var_38], 0
mov [rsp+48h+var_40], 0
mov esi, 9
mov rdi, r15
mov rdx, r14
xor eax, eax
call _snprintf
mov rdi, rbx
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
jmp short loc_750DD
loc_750D2:
movsx esi, cl
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
loc_750DD:
inc r13
cmp r13, rbp
jnz short loc_7509B
loc_750E5:
mov rax, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short $+2
loc_750F9:
mov r14, rax
mov rdi, [rbx]; void *
cmp rdi, r12
jz short loc_75110
mov rsi, [r12]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_75110:
mov rdi, r14
call __Unwind_Resume
|
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>::get_token_string(
long long a1,
long long a2)
{
unsigned __int8 *v2; // r13
unsigned __int8 *i; // rbp
unsigned int v4; // ecx
long long v6; // [rsp+8h] [rbp-40h] BYREF
char v7; // [rsp+10h] [rbp-38h]
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v2 = *(unsigned __int8 **)(a2 + 56);
for ( i = *(unsigned __int8 **)(a2 + 64); v2 != i; ++v2 )
{
v4 = *v2;
if ( v4 > 0x1F )
{
std::string::push_back(a1, (unsigned int)(char)v4);
}
else
{
v7 = 0;
v6 = 0LL;
snprintf(&v6, 9LL, "<U+%.4X>", v4);
std::string::append(a1, &v6);
}
}
return a1;
}
|
get_token_string:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
LEA R12,[RDI + 0x10]
MOV qword ptr [RDI],R12
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
MOV R13,qword ptr [RSI + 0x38]
MOV RBP,qword ptr [RSI + 0x40]
CMP R13,RBP
JZ 0x001750e5
LEA R14,[0x21989c]
LEA R15,[RSP + 0x8]
LAB_0017509b:
MOVZX ECX,byte ptr [R13]
CMP ECX,0x1f
JA 0x001750d2
MOV byte ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x8],0x0
MOV ESI,0x9
MOV RDI,R15
MOV RDX,R14
XOR EAX,EAX
CALL 0x00120890
LAB_001750c5:
MOV RDI,RBX
MOV RSI,R15
CALL 0x00120b50
JMP 0x001750dd
LAB_001750d2:
MOVSX ESI,CL
MOV RDI,RBX
CALL 0x001213a0
LAB_001750dd:
INC R13
CMP R13,RBP
JNZ 0x0017509b
LAB_001750e5:
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<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>::get_token_string()
const */
void 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>
::get_token_string(void)
{
byte *pbVar1;
long in_RSI;
long *in_RDI;
byte *pbVar2;
char local_40 [16];
*in_RDI = (long)(in_RDI + 2);
in_RDI[1] = 0;
*(int1 *)(in_RDI + 2) = 0;
pbVar2 = *(byte **)(in_RSI + 0x38);
pbVar1 = *(byte **)(in_RSI + 0x40);
if (pbVar2 != pbVar1) {
do {
if (*pbVar2 < 0x20) {
local_40[8] = 0;
local_40[0] = '\0';
local_40[1] = '\0';
local_40[2] = '\0';
local_40[3] = '\0';
local_40[4] = '\0';
local_40[5] = '\0';
local_40[6] = '\0';
local_40[7] = '\0';
snprintf(local_40,9,"<U+%.4X>");
/* try { // try from 001750c5 to 001750cf has its CatchHandler @ 001750f9 */
std::__cxx11::string::append((char *)in_RDI);
}
else {
/* try { // try from 001750d2 to 001750dc has its CatchHandler @ 001750f7 */
std::__cxx11::string::push_back((char)in_RDI);
}
pbVar2 = pbVar2 + 1;
} while (pbVar2 != pbVar1);
}
return;
}
|
|
63,363 |
mz_deflateReset
|
7CodeWizard[P]stablediffusion/thirdparty/miniz.h
|
int mz_deflateReset(mz_streamp pStream) {
if ((!pStream) || (!pStream->state) || (!pStream->zalloc) ||
(!pStream->zfree))
return MZ_STREAM_ERROR;
pStream->total_in = pStream->total_out = 0;
tdefl_init((tdefl_compressor *)pStream->state, NULL, NULL,
((tdefl_compressor *)pStream->state)->m_flags);
return MZ_OK;
}
|
O2
|
c
|
mz_deflateReset:
pushq %rbx
pushq $-0x2
popq %rbx
testq %rdi, %rdi
je 0x59ad2
movq %rdi, %rax
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x59ad2
cmpq $0x0, 0x40(%rax)
je 0x59ad2
cmpq $0x0, 0x48(%rax)
je 0x59ad2
andq $0x0, 0x28(%rax)
andq $0x0, 0x10(%rax)
movl 0x10(%rdi), %ecx
xorl %ebx, %ebx
xorl %esi, %esi
xorl %edx, %edx
callq 0x59946
movl %ebx, %eax
popq %rbx
retq
|
mz_deflateReset:
push rbx
push 0FFFFFFFFFFFFFFFEh
pop rbx
test rdi, rdi
jz short loc_59AD2
mov rax, rdi
mov rdi, [rdi+38h]
test rdi, rdi
jz short loc_59AD2
cmp qword ptr [rax+40h], 0
jz short loc_59AD2
cmp qword ptr [rax+48h], 0
jz short loc_59AD2
and qword ptr [rax+28h], 0
and qword ptr [rax+10h], 0
mov ecx, [rdi+10h]
xor ebx, ebx
xor esi, esi
xor edx, edx
call tdefl_init
loc_59AD2:
mov eax, ebx
pop rbx
retn
|
long long mz_deflateReset(_QWORD *a1)
{
unsigned int v1; // ebx
long long v3; // rdi
v1 = -2;
if ( a1 )
{
v3 = a1[7];
if ( v3 )
{
if ( a1[8] && a1[9] )
{
a1[5] = 0LL;
a1[2] = 0LL;
v1 = 0;
tdefl_init(v3, 0LL, 0LL, *(_DWORD *)(v3 + 16));
}
}
}
return v1;
}
|
mz_deflateReset:
PUSH RBX
PUSH -0x2
POP RBX
TEST RDI,RDI
JZ 0x00159ad2
MOV RAX,RDI
MOV RDI,qword ptr [RDI + 0x38]
TEST RDI,RDI
JZ 0x00159ad2
CMP qword ptr [RAX + 0x40],0x0
JZ 0x00159ad2
CMP qword ptr [RAX + 0x48],0x0
JZ 0x00159ad2
AND qword ptr [RAX + 0x28],0x0
AND qword ptr [RAX + 0x10],0x0
MOV ECX,dword ptr [RDI + 0x10]
XOR EBX,EBX
XOR ESI,ESI
XOR EDX,EDX
CALL 0x00159946
LAB_00159ad2:
MOV EAX,EBX
POP RBX
RET
|
int4 mz_deflateReset(long param_1)
{
long lVar1;
int4 uVar2;
uVar2 = 0xfffffffe;
if ((((param_1 != 0) && (lVar1 = *(long *)(param_1 + 0x38), lVar1 != 0)) &&
(*(long *)(param_1 + 0x40) != 0)) && (*(long *)(param_1 + 0x48) != 0)) {
*(int8 *)(param_1 + 0x28) = 0;
*(int8 *)(param_1 + 0x10) = 0;
uVar2 = 0;
tdefl_init(lVar1,0,0,*(int4 *)(lVar1 + 0x10));
}
return uVar2;
}
|
|
63,364 |
mz_deflateReset
|
7CodeWizard[P]stablediffusion/thirdparty/miniz.h
|
int mz_deflateReset(mz_streamp pStream) {
if ((!pStream) || (!pStream->state) || (!pStream->zalloc) ||
(!pStream->zfree))
return MZ_STREAM_ERROR;
pStream->total_in = pStream->total_out = 0;
tdefl_init((tdefl_compressor *)pStream->state, NULL, NULL,
((tdefl_compressor *)pStream->state)->m_flags);
return MZ_OK;
}
|
O3
|
c
|
mz_deflateReset:
pushq %rbx
movl $0xfffffffe, %ebx # imm = 0xFFFFFFFE
testq %rdi, %rdi
je 0x7de50
movq 0x38(%rdi), %rax
testq %rax, %rax
je 0x7de50
cmpq $0x0, 0x40(%rdi)
je 0x7de50
cmpq $0x0, 0x48(%rdi)
je 0x7de50
xorl %ebx, %ebx
movq %rbx, 0x28(%rdi)
movq %rbx, 0x10(%rdi)
movl 0x10(%rax), %ecx
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x7dcc6
movl %ebx, %eax
popq %rbx
retq
|
mz_deflateReset:
push rbx
mov ebx, 0FFFFFFFEh
test rdi, rdi
jz short loc_7DE50
mov rax, [rdi+38h]
test rax, rax
jz short loc_7DE50
cmp qword ptr [rdi+40h], 0
jz short loc_7DE50
cmp qword ptr [rdi+48h], 0
jz short loc_7DE50
xor ebx, ebx
mov [rdi+28h], rbx
mov [rdi+10h], rbx
mov ecx, [rax+10h]
mov rdi, rax
xor esi, esi
xor edx, edx
call tdefl_init
loc_7DE50:
mov eax, ebx
pop rbx
retn
|
long long mz_deflateReset(_QWORD *a1)
{
unsigned int v1; // ebx
long long v2; // rax
v1 = -2;
if ( a1 )
{
v2 = a1[7];
if ( v2 )
{
if ( a1[8] && a1[9] )
{
v1 = 0;
a1[5] = 0LL;
a1[2] = 0LL;
tdefl_init(v2, 0LL, 0LL, *(_DWORD *)(v2 + 16));
}
}
}
return v1;
}
| |||
63,365 |
fn_ext
|
eloqsql/mysys/mf_fn_ext.c
|
char *fn_ext(const char *name)
{
register const char *pos, *gpos;
DBUG_ENTER("fn_ext");
DBUG_PRINT("mfunkt",("name: '%s'",name));
#if defined(FN_DEVCHAR) || defined(BASKSLASH_MBTAIL)
{
char buff[FN_REFLEN];
size_t res_length;
gpos= name+ dirname_part(buff,(char*) name, &res_length);
}
#else
if (!(gpos= strrchr(name, FN_LIBCHAR)))
gpos= name;
#endif
pos= strchr(gpos, FN_EXTCHAR);
DBUG_RETURN((char*) (pos ? pos : strend(gpos)));
}
|
O0
|
c
|
fn_ext:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x3968e
movq -0x8(%rbp), %rdi
movl $0x2f, %esi
callq 0x25330
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x396ae
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x2e, %esi
callq 0x25110
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x396d1
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x396de
movq -0x18(%rbp), %rdi
callq 0x878c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
|
fn_ext:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
jmp short $+2
loc_3968E:
mov rdi, [rbp+var_8]
mov esi, 2Fh ; '/'
call _strrchr
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_396AE
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
loc_396AE:
mov rdi, [rbp+var_18]
mov esi, 2Eh ; '.'
call _strchr
mov [rbp+var_10], rax
cmp [rbp+var_10], 0
jz short loc_396D1
mov rax, [rbp+var_10]
mov [rbp+var_20], rax
jmp short loc_396DE
loc_396D1:
mov rdi, [rbp+var_18]
call strend
mov [rbp+var_20], rax
loc_396DE:
mov rax, [rbp+var_20]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
add rsp, 30h
pop rbp
retn
|
long long fn_ext(long long a1)
{
long long v3; // [rsp+18h] [rbp-18h]
long long v4; // [rsp+20h] [rbp-10h]
v3 = strrchr(a1, 47LL);
if ( !v3 )
v3 = a1;
v4 = strchr(v3, 46LL);
if ( v4 )
return v4;
else
return strend(v3);
}
|
fn_ext:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
JMP 0x0013968e
LAB_0013968e:
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,0x2f
CALL 0x00125330
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x001396ae
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
LAB_001396ae:
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,0x2e
CALL 0x00125110
MOV qword ptr [RBP + -0x10],RAX
CMP qword ptr [RBP + -0x10],0x0
JZ 0x001396d1
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001396de
LAB_001396d1:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001878c0
MOV qword ptr [RBP + -0x20],RAX
LAB_001396de:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RSP,0x30
POP RBP
RET
|
char * fn_ext(char *param_1)
{
int8 local_28;
int8 local_20;
local_20 = strrchr(param_1,0x2f);
if (local_20 == (char *)0x0) {
local_20 = param_1;
}
local_28 = strchr(local_20,0x2e);
if (local_28 == (char *)0x0) {
local_28 = (char *)strend(local_20);
}
return local_28;
}
|
|
63,366 |
translog_wait_for_writers
|
eloqsql/storage/maria/ma_loghandler.c
|
static void translog_wait_for_writers(struct st_translog_buffer *buffer)
{
DBUG_ENTER("translog_wait_for_writers");
DBUG_PRINT("enter", ("Buffer #%u %p copies in progress: %u "
"is closing %u File: %d size: %lu",
(uint) buffer->buffer_no, buffer,
(uint) buffer->copy_to_buffer_in_progress,
(uint) buffer->is_closing_buffer,
(buffer->file ? buffer->file->handler.file : -1),
(ulong) buffer->size));
translog_buffer_lock_assert_owner(buffer);
while (buffer->copy_to_buffer_in_progress)
{
DBUG_PRINT("info", ("wait for writers... buffer: #%u %p",
(uint) buffer->buffer_no, buffer));
DBUG_ASSERT(buffer->file != NULL);
mysql_cond_wait(&buffer->waiting_filling_buffer, &buffer->mutex);
DBUG_PRINT("info", ("wait for writers done buffer: #%u %p",
(uint) buffer->buffer_no, buffer));
}
DBUG_VOID_RETURN;
}
|
O3
|
c
|
translog_wait_for_writers:
cmpl $0x0, 0x100078(%rdi)
je 0x4ffcd
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x100040(%rdi), %r14
leaq 0x100090(%rdi), %r15
leaq 0x8b1b1(%rip), %r12 # 0xdb141
cmpq $0x0, 0x100070(%rbx)
jne 0x4ffb0
movq %r14, %rdi
movq %r15, %rsi
callq 0x29430
cmpl $0x0, 0x100078(%rbx)
jne 0x4ff90
jmp 0x4ffc5
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl $0x806, %ecx # imm = 0x806
callq 0x2eea0
jmp 0x4ffa5
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
translog_wait_for_writers:
cmp ds:dword_100078[rdi], 0
jz short locret_4FFCD
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rbx, rdi
lea r14, unk_100040[rdi]
lea r15, unk_100090[rdi]
lea r12, aWorkspaceLlm4b_7; "/workspace/llm4binary/github2025/eloqsq"...
loc_4FF90:
cmp ds:qword_100070[rbx], 0
jnz short loc_4FFB0
mov rdi, r14
mov rsi, r15
call _pthread_cond_wait
loc_4FFA5:
cmp ds:dword_100078[rbx], 0
jnz short loc_4FF90
jmp short loc_4FFC5
loc_4FFB0:
mov rdi, r14
mov rsi, r15
mov rdx, r12
mov ecx, 806h
call psi_cond_wait
jmp short loc_4FFA5
loc_4FFC5:
pop rbx
pop r12
pop r14
pop r15
pop rbp
locret_4FFCD:
retn
|
long long translog_wait_for_writers(long long a1)
{
char *v1; // r14
char *v2; // r15
long long result; // rax
if ( *(int *)((char *)&dword_100078 + a1) )
{
v1 = (char *)&unk_100040 + a1;
v2 = (char *)&unk_100090 + a1;
do
{
if ( *(long long *)((char *)&qword_100070 + a1) )
result = psi_cond_wait(
(long long)v1,
(long long)v2,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x806u);
else
result = pthread_cond_wait(v1, v2);
}
while ( *(int *)((char *)&dword_100078 + a1) );
}
return result;
}
|
translog_wait_for_writers:
CMP dword ptr [RDI + 0x100078],0x0
JZ 0x0014ffcd
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RDI
LEA R14,[RDI + 0x100040]
LEA R15,[RDI + 0x100090]
LEA R12,[0x1db141]
LAB_0014ff90:
CMP qword ptr [RBX + 0x100070],0x0
JNZ 0x0014ffb0
MOV RDI,R14
MOV RSI,R15
CALL 0x00129430
LAB_0014ffa5:
CMP dword ptr [RBX + 0x100078],0x0
JNZ 0x0014ff90
JMP 0x0014ffc5
LAB_0014ffb0:
MOV RDI,R14
MOV RSI,R15
MOV RDX,R12
MOV ECX,0x806
CALL 0x0012eea0
JMP 0x0014ffa5
LAB_0014ffc5:
POP RBX
POP R12
POP R14
POP R15
POP RBP
LAB_0014ffcd:
RET
|
void translog_wait_for_writers(long param_1)
{
pthread_cond_t *__cond;
pthread_mutex_t *__mutex;
if (*(int *)((long)&Elf64_Phdr_ARRAY_00100040[1].p_type + param_1) != 0) {
__cond = (pthread_cond_t *)((long)&Elf64_Phdr_ARRAY_00100040[0].p_type + param_1);
__mutex = (pthread_mutex_t *)((long)&Elf64_Phdr_ARRAY_00100040[1].p_paddr + param_1);
do {
if (*(long *)((long)&Elf64_Phdr_ARRAY_00100040[0].p_align + param_1) == 0) {
pthread_cond_wait(__cond,__mutex);
}
else {
psi_cond_wait(__cond,__mutex,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",0x806
);
}
} while (*(int *)((long)&Elf64_Phdr_ARRAY_00100040[1].p_type + param_1) != 0);
}
return;
}
|
|
63,367 |
ma_bitmap_lock
|
eloqsql/storage/maria/ma_bitmap.c
|
void _ma_bitmap_lock(MARIA_SHARE *share)
{
MARIA_FILE_BITMAP *bitmap= &share->bitmap;
DBUG_ENTER("_ma_bitmap_lock");
if (!share->now_transactional)
DBUG_VOID_RETURN;
mysql_mutex_lock(&bitmap->bitmap_lock);
bitmap->flush_all_requested++;
bitmap->waiting_for_non_flushable++;
while (bitmap->non_flushable)
{
DBUG_PRINT("info", ("waiting for bitmap to be flushable"));
mysql_cond_wait(&bitmap->bitmap_cond, &bitmap->bitmap_lock);
}
bitmap->waiting_for_non_flushable--;
/*
Ensure that _ma_bitmap_flush_all() and _ma_bitmap_lock() are blocked.
ma_bitmap_flushable() is blocked thanks to 'flush_all_requested'.
*/
bitmap->non_flushable= 1;
mysql_mutex_unlock(&bitmap->bitmap_lock);
DBUG_VOID_RETURN;
}
|
O3
|
c
|
ma_bitmap_lock:
cmpb $0x0, 0x7e7(%rdi)
je 0x4f170
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
leaq 0xa98(%rdi), %rbx
cmpq $0x0, 0xad8(%rdi)
jne 0x4f171
movq %rbx, %rdi
callq 0x291d0
incl 0xa40(%r14)
movl 0xa4c(%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0xa4c(%r14)
cmpl $0x0, 0xa48(%r14)
je 0x4f142
leaq 0xae0(%r14), %r15
leaq 0x8c793(%rip), %r12 # 0xdb896
cmpq $0x0, 0xb10(%r14)
jne 0x4f124
movq %r15, %rdi
movq %rbx, %rsi
callq 0x293d0
cmpl $0x0, 0xa48(%r14)
jne 0x4f103
jmp 0x4f139
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movl $0x25c, %ecx # imm = 0x25C
callq 0x2f11c
jmp 0x4f118
movl 0xa4c(%r14), %eax
decl %eax
movl %eax, 0xa4c(%r14)
movl $0x1, 0xa48(%r14)
movq 0xad8(%r14), %rdi
testq %rdi, %rdi
jne 0x4f18a
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x291a0
retq
leaq 0x8c71e(%rip), %rsi # 0xdb896
movq %rbx, %rdi
movl $0x256, %edx # imm = 0x256
callq 0x2ee0b
jmp 0x4f0d3
leaq 0x339ebf(%rip), %rax # 0x389050
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x4f160
|
_ma_bitmap_lock:
cmp byte ptr [rdi+7E7h], 0
jz locret_4F170
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r14, rdi
lea rbx, [rdi+0A98h]
cmp qword ptr [rdi+0AD8h], 0
jnz loc_4F171
mov rdi, rbx
call _pthread_mutex_lock
loc_4F0D3:
inc dword ptr [r14+0A40h]
mov eax, [r14+0A4Ch]
lea ecx, [rax+1]
mov [r14+0A4Ch], ecx
cmp dword ptr [r14+0A48h], 0
jz short loc_4F142
lea r15, [r14+0AE0h]
lea r12, aWorkspaceLlm4b_4; "/workspace/llm4binary/github2025/eloqsq"...
loc_4F103:
cmp qword ptr [r14+0B10h], 0
jnz short loc_4F124
mov rdi, r15
mov rsi, rbx
call _pthread_cond_wait
loc_4F118:
cmp dword ptr [r14+0A48h], 0
jnz short loc_4F103
jmp short loc_4F139
loc_4F124:
mov rdi, r15
mov rsi, rbx
mov rdx, r12
mov ecx, 25Ch
call psi_cond_wait
jmp short loc_4F118
loc_4F139:
mov eax, [r14+0A4Ch]
dec eax
loc_4F142:
mov [r14+0A4Ch], eax
mov dword ptr [r14+0A48h], 1
mov rdi, [r14+0AD8h]
test rdi, rdi
jnz short loc_4F18A
loc_4F160:
mov rdi, rbx
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp _pthread_mutex_unlock
locret_4F170:
retn
loc_4F171:
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, rbx
mov edx, 256h
call psi_mutex_lock
jmp loc_4F0D3
loc_4F18A:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_4F160
|
void ma_bitmap_lock(long long a1)
{
long long v1; // rbx
int v2; // eax
if ( *(_BYTE *)(a1 + 2023) )
{
v1 = a1 + 2712;
if ( *(_QWORD *)(a1 + 2776) )
psi_mutex_lock(a1 + 2712, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c", 0x256u);
else
pthread_mutex_lock(a1 + 2712);
++*(_DWORD *)(a1 + 2624);
v2 = *(_DWORD *)(a1 + 2636);
*(_DWORD *)(a1 + 2636) = v2 + 1;
if ( *(_DWORD *)(a1 + 2632) )
{
do
{
if ( *(_QWORD *)(a1 + 2832) )
psi_cond_wait(
a1 + 2784,
v1,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c",
0x25Cu);
else
pthread_cond_wait(a1 + 2784, v1);
}
while ( *(_DWORD *)(a1 + 2632) );
v2 = *(_DWORD *)(a1 + 2636) - 1;
}
*(_DWORD *)(a1 + 2636) = v2;
*(_DWORD *)(a1 + 2632) = 1;
if ( *(_QWORD *)(a1 + 2776) )
PSI_server[44]();
pthread_mutex_unlock(v1);
}
}
|
_ma_bitmap_lock:
CMP byte ptr [RDI + 0x7e7],0x0
JZ 0x0014f170
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R14,RDI
LEA RBX,[RDI + 0xa98]
CMP qword ptr [RDI + 0xad8],0x0
JNZ 0x0014f171
MOV RDI,RBX
CALL 0x001291d0
LAB_0014f0d3:
INC dword ptr [R14 + 0xa40]
MOV EAX,dword ptr [R14 + 0xa4c]
LEA ECX,[RAX + 0x1]
MOV dword ptr [R14 + 0xa4c],ECX
CMP dword ptr [R14 + 0xa48],0x0
JZ 0x0014f142
LEA R15,[R14 + 0xae0]
LEA R12,[0x1db896]
LAB_0014f103:
CMP qword ptr [R14 + 0xb10],0x0
JNZ 0x0014f124
MOV RDI,R15
MOV RSI,RBX
CALL 0x001293d0
LAB_0014f118:
CMP dword ptr [R14 + 0xa48],0x0
JNZ 0x0014f103
JMP 0x0014f139
LAB_0014f124:
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R12
MOV ECX,0x25c
CALL 0x0012f11c
JMP 0x0014f118
LAB_0014f139:
MOV EAX,dword ptr [R14 + 0xa4c]
DEC EAX
LAB_0014f142:
MOV dword ptr [R14 + 0xa4c],EAX
MOV dword ptr [R14 + 0xa48],0x1
MOV RDI,qword ptr [R14 + 0xad8]
TEST RDI,RDI
JNZ 0x0014f18a
LAB_0014f160:
MOV RDI,RBX
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x001291a0
LAB_0014f170:
RET
LAB_0014f171:
LEA RSI,[0x1db896]
MOV RDI,RBX
MOV EDX,0x256
CALL 0x0012ee0b
JMP 0x0014f0d3
LAB_0014f18a:
LEA RAX,[0x489050]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0014f160
|
void _ma_bitmap_lock(long param_1)
{
pthread_mutex_t *__mutex;
int iVar1;
if (*(char *)(param_1 + 0x7e7) != '\0') {
__mutex = (pthread_mutex_t *)(param_1 + 0xa98);
if (*(long *)(param_1 + 0xad8) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c",
0x256);
}
*(int *)(param_1 + 0xa40) = *(int *)(param_1 + 0xa40) + 1;
iVar1 = *(int *)(param_1 + 0xa4c);
*(int *)(param_1 + 0xa4c) = iVar1 + 1;
if (*(int *)(param_1 + 0xa48) != 0) {
do {
if (*(long *)(param_1 + 0xb10) == 0) {
pthread_cond_wait((pthread_cond_t *)(param_1 + 0xae0),__mutex);
}
else {
psi_cond_wait((pthread_cond_t *)(param_1 + 0xae0),__mutex,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c",0x25c);
}
} while (*(int *)(param_1 + 0xa48) != 0);
iVar1 = *(int *)(param_1 + 0xa4c) + -1;
}
*(int *)(param_1 + 0xa4c) = iVar1;
*(int4 *)(param_1 + 0xa48) = 1;
if (*(long *)(param_1 + 0xad8) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
return;
}
return;
}
|
|
63,368 |
psi_mutex_lock
|
eloqsql/mysys/my_thr_init.c
|
ATTRIBUTE_COLD int psi_mutex_lock(mysql_mutex_t *that,
const char *file, uint line)
{
PSI_mutex_locker_state state;
PSI_mutex_locker *locker= PSI_MUTEX_CALL(start_mutex_wait)
(&state, that->m_psi, PSI_MUTEX_LOCK, file, line);
# ifdef SAFE_MUTEX
int result= safe_mutex_lock(&that->m_mutex, FALSE, file, line);
# else
int result= pthread_mutex_lock(&that->m_mutex);
# endif
if (locker)
PSI_MUTEX_CALL(end_mutex_wait)(locker, result);
return result;
}
|
O0
|
c
|
psi_mutex_lock:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x1d156e(%rip), %rax # 0x28e618
movq (%rax), %rax
movq 0x190(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x40(%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 0x3b300
movl %eax, -0x54(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0xbd0fd
leaq 0x1d152e(%rip), %rax # 0x28e618
movq (%rax), %rax
movq 0x198(%rax), %rax
movq -0x50(%rbp), %rdi
movl -0x54(%rbp), %esi
callq *%rax
movl -0x54(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
psi_mutex_lock:
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+190h]
mov rcx, [rbp+var_8]
mov rsi, [rcx+40h]
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 _pthread_mutex_lock
mov [rbp+var_54], eax
cmp [rbp+var_50], 0
jz short loc_BD0FD
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+198h]
mov rdi, [rbp+var_50]
mov esi, [rbp+var_54]
call rax
loc_BD0FD:
mov eax, [rbp+var_54]
add rsp, 60h
pop rbp
retn
|
long long psi_mutex_lock(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 + 50))(
v6,
*(_QWORD *)(a1 + 64),
0LL,
a2,
a3);
v4 = pthread_mutex_lock(v9);
if ( v5 )
(*((void ( **)(long long, _QWORD))PSI_server + 51))(v5, v4);
return v4;
}
|
psi_mutex_lock:
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,[0x38e618]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x190]
MOV RCX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RCX + 0x40]
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 0x0013b300
MOV dword ptr [RBP + -0x54],EAX
CMP qword ptr [RBP + -0x50],0x0
JZ 0x001bd0fd
LEA RAX,[0x38e618]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x198]
MOV RDI,qword ptr [RBP + -0x50]
MOV ESI,dword ptr [RBP + -0x54]
CALL RAX
LAB_001bd0fd:
MOV EAX,dword ptr [RBP + -0x54]
ADD RSP,0x60
POP RBP
RET
|
int psi_mutex_lock(pthread_mutex_t *param_1,int8 param_2,int4 param_3)
{
int iVar1;
long lVar2;
int1 local_50 [52];
int4 local_1c;
int8 local_18;
pthread_mutex_t *local_10;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
lVar2 = (**(code **)(PSI_server + 400))
(local_50,*(int8 *)((long)param_1 + 0x40),0,param_2,param_3);
iVar1 = pthread_mutex_lock(local_10);
if (lVar2 != 0) {
(**(code **)(PSI_server + 0x198))(lVar2,iVar1);
}
return iVar1;
}
|
|
63,369 |
mysql_shutdown_start_internal
|
eloqsql/libmariadb/libmariadb/mariadb_async.c
|
static void
mysql_shutdown_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_shutdown,
(parms->mysql, parms->shutdown_level),
parms->mysql,
int,
r_int)
}
|
O0
|
c
|
mysql_shutdown_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
movl 0x8(%rax), %esi
callq 0x84f60
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
mysql_shutdown_start_internal:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rdi, [rax]
mov rax, [rbp+var_10]
mov esi, [rax+8]
call mysql_shutdown
mov [rbp+var_14], eax
mov ecx, [rbp+var_14]
mov rax, [rbp+var_20]
mov [rax+8], ecx
mov rax, [rbp+var_20]
mov dword ptr [rax], 0
add rsp, 20h
pop rbp
retn
|
_DWORD * mysql_shutdown_start_internal(long long a1)
{
_DWORD *result; // rax
_DWORD *v2; // [rsp+0h] [rbp-20h]
v2 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)a1 + 1152LL) + 40LL);
v2[2] = mysql_shutdown(*(_QWORD *)a1, *(_DWORD *)(a1 + 8));
result = v2;
*v2 = 0;
return result;
}
|
mysql_shutdown_start_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RAX + 0x8]
CALL 0x00184f60
MOV dword ptr [RBP + -0x14],EAX
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x8],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0x0
ADD RSP,0x20
POP RBP
RET
|
void mysql_shutdown_start_internal(long *param_1)
{
int4 *puVar1;
int4 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_shutdown(*param_1,(int)param_1[1]);
puVar1[2] = uVar2;
*puVar1 = 0;
return;
}
|
|
63,370 |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::get_impl<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 0>(nlohmann::json_abi_v3_11_3::detail::priority_tag<0u>) const
|
monkey531[P]llama/common/./json.hpp
|
const noexcept(noexcept(
JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
{
auto ret = ValueType();
JSONSerializer<ValueType>::from_json(*this, ret);
return ret;
}
|
O3
|
cpp
|
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::get_impl<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 0>(nlohmann::json_abi_v3_11_3::detail::priority_tag<0u>) const:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x3f9f7
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x3f9ef
movq (%r15), %rsi
incq %rsi
callq 0x186a0
movq %r14, %rdi
callq 0x18b90
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE:
push r15
push r14
push rbx
mov rbx, rdi
lea r15, [rdi+10h]
mov [rdi], r15
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rdi, rsi
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEEvRKT_RNSG_8string_tE; nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::string_t &)
mov rax, rbx
pop rbx
pop r14
pop r15
retn
mov r14, rax
mov rdi, [rbx]; void *
cmp rdi, r15
jz short loc_3F9EF
mov rsi, [r15]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3F9EF:
mov rdi, r14
call __Unwind_Resume
|
long long ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE(
long long a1,
long long a2)
{
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
a2,
a1);
return a1;
}
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDI
LEA R15,[RDI + 0x10]
MOV qword ptr [RDI],R15
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
LAB_0013f9c5:
MOV RDI,RSI
MOV RSI,RBX
CALL 0x0013f9f7
LAB_0013f9d0:
MOV RAX,RBX
POP RBX
POP R14
POP R15
RET
|
string_t *
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE
(string_t *param_1,basic_json *param_2)
{
*(string_t **)param_1 = param_1 + 0x10;
*(int8 *)(param_1 + 8) = 0;
param_1[0x10] = (string_t)0x0;
/* try { // try from 0013f9c5 to 0013f9cf has its CatchHandler @ 0013f9d9 */
nlohmann::json_abi_v3_11_3::detail::
from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::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_2,param_1);
return param_1;
}
|
|
63,371 |
mi_fetch_keypage
|
eloqsql/storage/myisam/mi_page.c
|
uchar *_mi_fetch_keypage(register MI_INFO *info, MI_KEYDEF *keyinfo,
my_off_t page, int level,
uchar *buff, int return_buffer)
{
uchar *tmp;
uint page_size;
DBUG_ENTER("_mi_fetch_keypage");
DBUG_PRINT("enter",("page: %ld", (long) page));
tmp=(uchar*) key_cache_read(info->s->key_cache,
info->s->kfile, page, level, (uchar*) buff,
(uint) keyinfo->block_length,
(uint) keyinfo->block_length,
return_buffer);
if (tmp == info->buff)
info->buff_used=1;
else if (!tmp)
{
DBUG_PRINT("error",("Got errno: %d from key_cache_read",my_errno));
info->last_keypage=HA_OFFSET_ERROR;
mi_print_error(info->s, HA_ERR_CRASHED);
my_errno=HA_ERR_CRASHED;
DBUG_RETURN(0);
}
info->last_keypage=page;
page_size=mi_getint(tmp);
if (page_size < 4 || page_size > keyinfo->block_length)
{
DBUG_PRINT("error",("page %lu had wrong page length: %u",
(ulong) page, page_size));
DBUG_DUMP("page", tmp, keyinfo->block_length);
info->last_keypage = HA_OFFSET_ERROR;
mi_print_error(info->s, HA_ERR_CRASHED);
my_errno = HA_ERR_CRASHED;
tmp = 0;
}
DBUG_RETURN(tmp);
}
|
O3
|
c
|
mi_fetch_keypage:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r9d, %eax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdx
movq 0x278(%rdx), %rdi
movl 0x350(%rdx), %esi
movzwl 0xe(%r14), %r9d
movq %r15, %rdx
pushq %rax
pushq %r9
callq 0x5657c
addq $0x10, %rsp
cmpq 0x100(%rbx), %rax
je 0x3e9ae
testq %rax, %rax
jne 0x3e9b5
jmp 0x3e9d9
movb $0x1, 0x33d(%rbx)
movq %r15, 0x190(%rbx)
movzbl 0x1(%rax), %edx
movzbl (%rax), %ecx
andl $0x7f, %ecx
shll $0x8, %ecx
orl %edx, %ecx
cmpl $0x4, %ecx
jb 0x3e9d9
movzwl 0xe(%r14), %edx
cmpl %edx, %ecx
jbe 0x3ea05
movq $-0x1, 0x190(%rbx)
movq (%rbx), %rax
movq 0x268(%rax), %rsi
movl $0x7e, %edi
callq 0x35bda
callq 0x5ecfe
movl $0x7e, (%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
_mi_fetch_keypage:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov eax, r9d
mov r15, rdx
mov r14, rsi
mov rbx, rdi
mov rdx, [rdi]
mov rdi, [rdx+278h]
mov esi, [rdx+350h]
movzx r9d, word ptr [r14+0Eh]
mov rdx, r15
push rax
push r9
call key_cache_read
add rsp, 10h
cmp rax, [rbx+100h]
jz short loc_3E9AE
test rax, rax
jnz short loc_3E9B5
jmp short loc_3E9D9
loc_3E9AE:
mov byte ptr [rbx+33Dh], 1
loc_3E9B5:
mov [rbx+190h], r15
movzx edx, byte ptr [rax+1]
movzx ecx, byte ptr [rax]
and ecx, 7Fh
shl ecx, 8
or ecx, edx
cmp ecx, 4
jb short loc_3E9D9
movzx edx, word ptr [r14+0Eh]
cmp ecx, edx
jbe short loc_3EA05
loc_3E9D9:
mov qword ptr [rbx+190h], 0FFFFFFFFFFFFFFFFh
mov rax, [rbx]
mov rsi, [rax+268h]
mov edi, 7Eh ; '~'
call mi_report_error
call _my_thread_var
mov dword ptr [rax], 7Eh ; '~'
xor eax, eax
loc_3EA05:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
_BYTE * mi_fetch_keypage(_QWORD *a1, long long a2, long long a3)
{
_BYTE *result; // rax
unsigned int v5; // ecx
const char *v6; // rsi
result = (_BYTE *)key_cache_read(*(_QWORD *)(*a1 + 632LL), *(unsigned int *)(*a1 + 848LL), a3);
if ( result == (_BYTE *)a1[32] )
{
*((_BYTE *)a1 + 829) = 1;
}
else if ( !result )
{
LABEL_7:
a1[50] = -1LL;
v6 = *(const char **)(*a1 + 616LL);
mi_report_error(126, (long long)v6);
*(_DWORD *)my_thread_var(126LL, v6) = 126;
return 0LL;
}
a1[50] = a3;
v5 = (unsigned __int8)result[1] | ((*result & 0x7F) << 8);
if ( v5 < 4 || v5 > *(unsigned __int16 *)(a2 + 14) )
goto LABEL_7;
return result;
}
|
_mi_fetch_keypage:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EAX,R9D
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
MOV RDX,qword ptr [RDI]
MOV RDI,qword ptr [RDX + 0x278]
MOV ESI,dword ptr [RDX + 0x350]
MOVZX R9D,word ptr [R14 + 0xe]
MOV RDX,R15
PUSH RAX
PUSH R9
CALL 0x0015657c
ADD RSP,0x10
CMP RAX,qword ptr [RBX + 0x100]
JZ 0x0013e9ae
TEST RAX,RAX
JNZ 0x0013e9b5
JMP 0x0013e9d9
LAB_0013e9ae:
MOV byte ptr [RBX + 0x33d],0x1
LAB_0013e9b5:
MOV qword ptr [RBX + 0x190],R15
MOVZX EDX,byte ptr [RAX + 0x1]
MOVZX ECX,byte ptr [RAX]
AND ECX,0x7f
SHL ECX,0x8
OR ECX,EDX
CMP ECX,0x4
JC 0x0013e9d9
MOVZX EDX,word ptr [R14 + 0xe]
CMP ECX,EDX
JBE 0x0013ea05
LAB_0013e9d9:
MOV qword ptr [RBX + 0x190],-0x1
MOV RAX,qword ptr [RBX]
MOV RSI,qword ptr [RAX + 0x268]
MOV EDI,0x7e
CALL 0x00135bda
CALL 0x0015ecfe
MOV dword ptr [RAX],0x7e
XOR EAX,EAX
LAB_0013ea05:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
byte * _mi_fetch_keypage(long *param_1,long param_2,long param_3)
{
byte *pbVar1;
int4 *puVar2;
uint uVar3;
pbVar1 = (byte *)key_cache_read(*(int8 *)(*param_1 + 0x278),
*(int4 *)(*param_1 + 0x350),param_3);
if (pbVar1 == (byte *)param_1[0x20]) {
*(int1 *)((long)param_1 + 0x33d) = 1;
}
else if (pbVar1 == (byte *)0x0) goto LAB_0013e9d9;
param_1[0x32] = param_3;
uVar3 = (*pbVar1 & 0x7f) << 8 | (uint)pbVar1[1];
if ((3 < uVar3) && (uVar3 <= *(ushort *)(param_2 + 0xe))) {
return pbVar1;
}
LAB_0013e9d9:
param_1[0x32] = -1;
mi_report_error(0x7e,*(int8 *)(*param_1 + 0x268));
puVar2 = (int4 *)_my_thread_var();
*puVar2 = 0x7e;
return (byte *)0x0;
}
|
|
63,372 |
my_uni_utf32
|
eloqsql/strings/ctype-ucs2.c
|
static int
my_uni_utf32(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
if (s + 4 > e)
return MY_CS_TOOSMALL4;
if (wc > 0x10FFFF)
return MY_CS_ILUNI;
s[0]= (uchar) (wc >> 24);
s[1]= (uchar) (wc >> 16) & 0xFF;
s[2]= (uchar) (wc >> 8) & 0xFF;
s[3]= (uchar) wc & 0xFF;
return 4;
}
|
O0
|
c
|
my_uni_utf32:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
cmpq -0x28(%rbp), %rax
jbe 0x5990b
movl $0xffffff98, -0x4(%rbp) # imm = 0xFFFFFF98
jmp 0x5997c
cmpq $0x10ffff, -0x18(%rbp) # imm = 0x10FFFF
jbe 0x5991e
movl $0x0, -0x4(%rbp)
jmp 0x5997c
movq -0x18(%rbp), %rax
shrq $0x18, %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
shrq $0x10, %rax
movzbl %al, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x18(%rbp), %rax
shrq $0x8, %rax
movzbl %al, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x18(%rbp), %rax
movzbl %al, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x3(%rax)
movl $0x4, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_uni_utf32:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_20]
add rax, 4
cmp rax, [rbp+var_28]
jbe short loc_5990B
mov [rbp+var_4], 0FFFFFF98h
jmp short loc_5997C
loc_5990B:
cmp [rbp+var_18], offset unk_10FFFF
jbe short loc_5991E
mov [rbp+var_4], 0
jmp short loc_5997C
loc_5991E:
mov rax, [rbp+var_18]
shr rax, 18h
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov rax, [rbp+var_18]
shr rax, 10h
movzx eax, al
and eax, 0FFh
mov cl, al
mov rax, [rbp+var_20]
mov [rax+1], cl
mov rax, [rbp+var_18]
shr rax, 8
movzx eax, al
and eax, 0FFh
mov cl, al
mov rax, [rbp+var_20]
mov [rax+2], cl
mov rax, [rbp+var_18]
movzx eax, al
and eax, 0FFh
mov cl, al
mov rax, [rbp+var_20]
mov [rax+3], cl
mov [rbp+var_4], 4
loc_5997C:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long my_uni_utf32(long long a1, unsigned long long a2, _BYTE *a3, unsigned long long a4)
{
if ( (unsigned long long)(a3 + 4) <= a4 )
{
if ( a2 <= (unsigned long long)&unk_10FFFF )
{
*a3 = BYTE3(a2);
a3[1] = BYTE2(a2);
a3[2] = BYTE1(a2);
a3[3] = a2;
return 4;
}
else
{
return 0;
}
}
else
{
return (unsigned int)-104;
}
}
|
my_uni_utf32:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x4
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x0015990b
MOV dword ptr [RBP + -0x4],0xffffff98
JMP 0x0015997c
LAB_0015990b:
CMP qword ptr [RBP + -0x18],0x10ffff
JBE 0x0015991e
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0015997c
LAB_0015991e:
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x18
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x10
MOVZX EAX,AL
AND EAX,0xff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x8
MOVZX EAX,AL
AND EAX,0xff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x2],CL
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,AL
AND EAX,0xff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x3],CL
MOV dword ptr [RBP + -0x4],0x4
LAB_0015997c:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_uni_utf32(int8 param_1,ulong param_2,int1 *param_3,int1 *param_4)
{
int4 local_c;
if (param_4 < param_3 + 4) {
local_c = 0xffffff98;
}
else if (param_2 < 0x110000) {
*param_3 = (char)(param_2 >> 0x18);
param_3[1] = (char)(param_2 >> 0x10);
param_3[2] = (char)(param_2 >> 8);
param_3[3] = (char)param_2;
local_c = 4;
}
else {
local_c = 0;
}
return local_c;
}
|
|
63,373 |
SchemaConverter::_add_primitive(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, BuiltinRule const&)
|
monkey531[P]llama/common/json-schema-to-grammar.cpp
|
std::string _add_primitive(const std::string & name, const BuiltinRule & rule) {
auto n = _add_rule(name, rule.content);
for (const auto & dep : rule.deps) {
BuiltinRule dep_rule;
auto it = PRIMITIVE_RULES.find(dep);
if (it == PRIMITIVE_RULES.end()) {
it = STRING_FORMAT_RULES.find(dep);
if (it == STRING_FORMAT_RULES.end()) {
_errors.push_back("Rule " + dep + " not known");
continue;
}
}
if (_rules.find(dep) == _rules.end()) {
_add_primitive(dep, it->second);
}
}
return n;
}
|
O2
|
cpp
|
SchemaConverter::_add_primitive(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, BuiltinRule const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, %r14
movq %rsi, %rbx
movq %rdi, (%rsp)
callq 0x8ed94
movq 0x20(%r14), %r15
movq 0x28(%r14), %rax
movq %rax, 0x28(%rsp)
leaq 0x40(%rsp), %rbp
leaq 0x28(%rbx), %rax
movq %rax, 0x20(%rsp)
leaq 0x30(%rbx), %rax
movq %rax, 0x18(%rsp)
movq %rbx, 0x10(%rsp)
leaq 0xc8(%rbx), %rax
movq %rax, 0x8(%rsp)
leaq 0x88(%rsp), %r13
leaq 0xa8(%rsp), %r12
cmpq 0x28(%rsp), %r15
je 0x9221e
movq %rbp, 0x30(%rsp)
andq $0x0, 0x38(%rsp)
movb $0x0, 0x40(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbp)
andq $0x0, 0x20(%rbp)
leaq 0x6d16f(%rip), %rdi # 0xff2d8
movq %r15, %rsi
callq 0x963d2
movq %rax, %rbx
testq %rax, %rax
jne 0x92190
leaq 0x6d190(%rip), %rdi # 0xff310
movq %r15, %rsi
callq 0x963d2
movq %rax, %rbx
testq %rax, %rax
je 0x921c4
movq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x8f07a
cmpq 0x18(%rsp), %rax
jne 0x9220b
addq $0x28, %rbx
leaq 0x68(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x920d6
leaq 0x68(%rsp), %rdi
jmp 0x92206
movq %r13, %rbx
movq %r13, %rdi
leaq 0x270d1(%rip), %rsi # 0xb92a2
movq %r15, %rdx
callq 0x3a0f3
movq %r12, %r14
movq %r12, %rdi
movq %rbx, %rsi
leaq 0x270bf(%rip), %rdx # 0xb92a8
callq 0x38efc
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x3b5a4
movq %r14, %rdi
callq 0x24208
movq %rbx, %rdi
callq 0x24208
leaq 0x30(%rsp), %rdi
callq 0x8d2de
addq $0x20, %r15
jmp 0x9213b
movq (%rsp), %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0x24208
jmp 0x92249
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x24208
jmp 0x92261
jmp 0x9225e
jmp 0x9225e
jmp 0x9225e
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x8d2de
movq (%rsp), %rdi
callq 0x24208
movq %rbx, %rdi
callq 0x23fc0
|
_ZN15SchemaConverter14_add_primitiveERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERK11BuiltinRule:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0C8h
mov r14, rcx
mov rbx, rsi
mov [rsp+0F8h+var_F8], rdi
call _ZN15SchemaConverter9_add_ruleERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES7_; SchemaConverter::_add_rule(std::string const&,std::string const&)
mov r15, [r14+20h]
mov rax, [r14+28h]
mov [rsp+0F8h+var_D0], rax
lea rbp, [rsp+0F8h+var_B8]
lea rax, [rbx+28h]
mov [rsp+0F8h+var_D8], rax
lea rax, [rbx+30h]
mov [rsp+0F8h+var_E0], rax
mov [rsp+0F8h+var_E8], rbx
lea rax, [rbx+0C8h]
mov [rsp+0F8h+var_F0], rax
lea r13, [rsp+0F8h+var_70]
lea r12, [rsp+0F8h+var_50]
loc_9213B:
cmp r15, [rsp+0F8h+var_D0]
jz loc_9221E
mov [rsp+0F8h+var_C8], rbp
and [rsp+0F8h+var_C0], 0
mov [rsp+0F8h+var_B8], 0
xorps xmm0, xmm0
movups xmmword ptr [rbp+10h], xmm0
and qword ptr [rbp+20h], 0
lea rdi, _Z15PRIMITIVE_RULESB5cxx11; PRIMITIVE_RULES
mov rsi, r15
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_11BuiltinRuleESaIS9_ENSt8__detail10_Select1stESt8equal_toIS5_ESt4hashIS5_ENSB_18_Mod_range_hashingENSB_20_Default_ranged_hashENSB_20_Prime_rehash_policyENSB_17_Hashtable_traitsILb1ELb0ELb1EEEE4findERS7_; std::_Hashtable<std::string,std::pair<std::string const,BuiltinRule>,std::allocator<std::pair<std::string const,BuiltinRule>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(std::string const&)
mov rbx, rax
test rax, rax
jnz short loc_92190
lea rdi, _Z19STRING_FORMAT_RULESB5cxx11; STRING_FORMAT_RULES
mov rsi, r15
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_11BuiltinRuleESaIS9_ENSt8__detail10_Select1stESt8equal_toIS5_ESt4hashIS5_ENSB_18_Mod_range_hashingENSB_20_Default_ranged_hashENSB_20_Prime_rehash_policyENSB_17_Hashtable_traitsILb1ELb0ELb1EEEE4findERS7_; std::_Hashtable<std::string,std::pair<std::string const,BuiltinRule>,std::allocator<std::pair<std::string const,BuiltinRule>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(std::string const&)
mov rbx, rax
test rax, rax
jz short loc_921C4
loc_92190:
mov rdi, [rsp+0F8h+var_D8]
mov rsi, r15
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_S5_ESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EE4findERS7_; std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::string>>>::find(std::string const&)
cmp rax, [rsp+0F8h+var_E0]
jnz short loc_9220B
add rbx, 28h ; '('
lea rdi, [rsp+0F8h+var_90]
mov rsi, [rsp+0F8h+var_E8]
mov rdx, r15
mov rcx, rbx
call _ZN15SchemaConverter14_add_primitiveERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERK11BuiltinRule; SchemaConverter::_add_primitive(std::string const&,BuiltinRule const&)
lea rdi, [rsp+0F8h+var_90]
jmp short loc_92206
loc_921C4:
mov rbx, r13
mov rdi, r13
lea rsi, aRule; "Rule "
mov rdx, r15
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
mov r14, r12
mov rdi, r12
mov rsi, rbx
lea rdx, aNotKnown; " not known"
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
mov rdi, [rsp+0F8h+var_F0]
mov rsi, r14
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJS5_EEERS5_DpOT_; std::vector<std::string>::emplace_back<std::string>(std::string &&)
mov rdi, r14; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx; void *
loc_92206:
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_9220B:
lea rdi, [rsp+0F8h+var_C8]; this
call _ZN11BuiltinRuleD2Ev; BuiltinRule::~BuiltinRule()
add r15, 20h ; ' '
jmp loc_9213B
loc_9221E:
mov rax, [rsp+0F8h+var_F8]
add rsp, 0C8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rdi, [rsp+arg_A0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_92249
mov rbx, rax
loc_92249:
lea rdi, [rsp+arg_80]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_92261
jmp short loc_9225E
jmp short loc_9225E
jmp short $+2
loc_9225E:
mov rbx, rax
loc_92261:
lea rdi, [rsp+arg_28]; this
call _ZN11BuiltinRuleD2Ev; BuiltinRule::~BuiltinRule()
mov rdi, [rsp+0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
call __Unwind_Resume
|
long long SchemaConverter::_add_primitive(long long a1, long long a2, _QWORD *a3, _QWORD *a4)
{
long long v5; // r15
long long v6; // rax
int v7; // ebx
long long v8; // rax
int v9; // r8d
int v10; // r9d
_DWORD *v11; // rdi
long long v13; // [rsp+0h] [rbp-F8h]
long long v14; // [rsp+8h] [rbp-F0h]
int v15; // [rsp+10h] [rbp-E8h]
long long v16; // [rsp+18h] [rbp-E0h]
long long v17; // [rsp+20h] [rbp-D8h]
long long v18; // [rsp+28h] [rbp-D0h]
_DWORD *v19; // [rsp+30h] [rbp-C8h] BYREF
long long v20; // [rsp+38h] [rbp-C0h]
_DWORD v21[4]; // [rsp+40h] [rbp-B8h] BYREF
__int128 v22; // [rsp+50h] [rbp-A8h]
long long v23; // [rsp+60h] [rbp-98h]
_DWORD v24[6]; // [rsp+68h] [rbp-90h] BYREF
char v25; // [rsp+80h] [rbp-78h]
_DWORD v26[6]; // [rsp+88h] [rbp-70h] BYREF
char v27; // [rsp+A0h] [rbp-58h]
_BYTE v28[80]; // [rsp+A8h] [rbp-50h] BYREF
v13 = a1;
SchemaConverter::_add_rule(a1, a2, a3, a4);
v5 = a4[4];
v18 = a4[5];
v17 = a2 + 40;
v16 = a2 + 48;
v15 = a2;
v14 = a2 + 200;
while ( v5 != v18 )
{
v19 = v21;
v20 = 0LL;
LOBYTE(v21[0]) = 0;
v22 = 0LL;
v23 = 0LL;
v6 = std::_Hashtable<std::string,std::pair<std::string const,BuiltinRule>,std::allocator<std::pair<std::string const,BuiltinRule>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(
&PRIMITIVE_RULES[abi:cxx11],
v5);
v7 = v6;
if ( v6
|| (v8 = std::_Hashtable<std::string,std::pair<std::string const,BuiltinRule>,std::allocator<std::pair<std::string const,BuiltinRule>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(
&STRING_FORMAT_RULES[abi:cxx11],
v5),
v7 = v8,
v8) )
{
if ( std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::string>>>::find(
v17,
v5) != v16 )
goto LABEL_9;
SchemaConverter::_add_primitive(
(unsigned int)v24,
v15,
v5,
v7 + 40,
v9,
v10,
v13,
v14,
v15,
v16,
v17,
v18,
(_DWORD)v19,
v20,
v21[0],
v21[2],
v22,
DWORD2(v22),
v23,
v24[0],
v24[2],
v24[4],
v25,
v26[0],
v26[2],
v26[4],
v27);
v11 = v24;
}
else
{
std::operator+<char>((long long)v26, (long long)"Rule ", v5);
std::operator+<char>((long long)v28, (long long)v26, (long long)" not known");
std::vector<std::string>::emplace_back<std::string>(v14, (long long)v28);
std::string::~string(v28);
v11 = v26;
}
std::string::~string(v11);
LABEL_9:
BuiltinRule::~BuiltinRule((void **)&v19);
v5 += 32LL;
}
return v13;
}
|
_add_primitive:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xc8
MOV R14,RCX
MOV RBX,RSI
MOV qword ptr [RSP],RDI
CALL 0x0018ed94
MOV R15,qword ptr [R14 + 0x20]
MOV RAX,qword ptr [R14 + 0x28]
MOV qword ptr [RSP + 0x28],RAX
LEA RBP,[RSP + 0x40]
LEA RAX,[RBX + 0x28]
MOV qword ptr [RSP + 0x20],RAX
LEA RAX,[RBX + 0x30]
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x10],RBX
LEA RAX,[RBX + 0xc8]
MOV qword ptr [RSP + 0x8],RAX
LEA R13,[RSP + 0x88]
LEA R12,[RSP + 0xa8]
LAB_0019213b:
CMP R15,qword ptr [RSP + 0x28]
JZ 0x0019221e
MOV qword ptr [RSP + 0x30],RBP
AND qword ptr [RSP + 0x38],0x0
MOV byte ptr [RSP + 0x40],0x0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBP + 0x10],XMM0
AND qword ptr [RBP + 0x20],0x0
LAB_00192162:
LEA RDI,[0x1ff2d8]
MOV RSI,R15
CALL 0x001963d2
MOV RBX,RAX
TEST RAX,RAX
JNZ 0x00192190
LAB_00192179:
LEA RDI,[0x1ff310]
MOV RSI,R15
CALL 0x001963d2
MOV RBX,RAX
TEST RAX,RAX
JZ 0x001921c4
LAB_00192190:
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,R15
CALL 0x0018f07a
CMP RAX,qword ptr [RSP + 0x18]
JNZ 0x0019220b
ADD RBX,0x28
LAB_001921a8:
LEA RDI,[RSP + 0x68]
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,R15
MOV RCX,RBX
CALL 0x001920d6
LEA RDI,[RSP + 0x68]
JMP 0x00192206
LAB_001921c4:
MOV RBX,R13
MOV RDI,R13
LEA RSI,[0x1b92a2]
MOV RDX,R15
CALL 0x0013a0f3
LAB_001921d9:
MOV R14,R12
MOV RDI,R12
MOV RSI,RBX
LEA RDX,[0x1b92a8]
CALL 0x00138efc
LAB_001921ee:
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,R14
CALL 0x0013b5a4
LAB_001921fb:
MOV RDI,R14
CALL 0x00124208
MOV RDI,RBX
LAB_00192206:
CALL 0x00124208
LAB_0019220b:
LEA RDI,[RSP + 0x30]
CALL 0x0018d2de
ADD R15,0x20
JMP 0x0019213b
LAB_0019221e:
MOV RAX,qword ptr [RSP]
ADD RSP,0xc8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* SchemaConverter::_add_primitive(std::__cxx11::string const&, BuiltinRule const&) */
string * SchemaConverter::_add_primitive(string *param_1,BuiltinRule *param_2)
{
string *psVar1;
long lVar2;
BuiltinRule *pBVar3;
long in_RCX;
string *this;
string *psVar4;
int1 *local_c8;
int8 local_c0;
int1 local_b8 [16];
int8 local_a8;
int8 uStack_a0;
int8 local_98;
string local_90 [32];
string local_70 [32];
string local_50 [32];
_add_rule(param_1,(string *)param_2);
psVar4 = *(string **)(in_RCX + 0x20);
psVar1 = *(string **)(in_RCX + 0x28);
do {
if (psVar4 == psVar1) {
return param_1;
}
local_c0 = 0;
local_b8[0] = 0;
local_a8 = 0;
uStack_a0 = 0;
local_98 = 0;
local_c8 = local_b8;
/* try { // try from 00192162 to 00192170 has its CatchHandler @ 0019225e */
lVar2 = std::
_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,BuiltinRule>,std::allocator<std::pair<std::__cxx11::string_const,BuiltinRule>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
::find((_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,BuiltinRule>,std::allocator<std::pair<std::__cxx11::string_const,BuiltinRule>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
*)PRIMITIVE_RULES_abi_cxx11_,psVar4);
if (lVar2 == 0) {
/* try { // try from 00192179 to 00192187 has its CatchHandler @ 0019225a */
lVar2 = std::
_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,BuiltinRule>,std::allocator<std::pair<std::__cxx11::string_const,BuiltinRule>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
::find((_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,BuiltinRule>,std::allocator<std::pair<std::__cxx11::string_const,BuiltinRule>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
*)STRING_FORMAT_RULES_abi_cxx11_,psVar4);
if (lVar2 != 0) goto LAB_00192190;
/* try { // try from 001921c4 to 001921d8 has its CatchHandler @ 00192258 */
std::operator+((char *)local_70,(string *)"Rule ");
/* try { // try from 001921d9 to 001921ed has its CatchHandler @ 00192246 */
std::operator+(local_50,(char *)local_70);
/* try { // try from 001921ee to 001921fa has its CatchHandler @ 00192234 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<std::__cxx11::string>
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)
(param_2 + 200),local_50);
std::__cxx11::string::~string(local_50);
this = local_70;
LAB_00192206:
std::__cxx11::string::~string(this);
}
else {
LAB_00192190:
/* try { // try from 00192190 to 0019219c has its CatchHandler @ 0019225c */
pBVar3 = (BuiltinRule *)
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::__cxx11::string>,std::_Select1st<std::pair<std::__cxx11::string_const,std::__cxx11::string>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
::find((_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::__cxx11::string>,std::_Select1st<std::pair<std::__cxx11::string_const,std::__cxx11::string>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
*)(param_2 + 0x28),psVar4);
if (pBVar3 == param_2 + 0x30) {
/* try { // try from 001921a8 to 001921bc has its CatchHandler @ 0019225e */
_add_primitive(local_90,param_2);
this = local_90;
goto LAB_00192206;
}
}
BuiltinRule::~BuiltinRule((BuiltinRule *)&local_c8);
psVar4 = psVar4 + 0x20;
} while( true );
}
|
|
63,374 |
PFS_host_allocator::free_array(PFS_host_array*)
|
eloqsql/storage/perfschema/pfs_buffer_container.cc
|
void PFS_host_allocator::free_array(PFS_host_array *array)
{
size_t size= array->m_max;
size_t waits_sizing= size * wait_class_max;
size_t stages_sizing= size * stage_class_max;
size_t statements_sizing= size * statement_class_max;
size_t transactions_sizing= size * transaction_class_max;
size_t memory_sizing= size * memory_class_max;
PFS_FREE_ARRAY(& builtin_memory_host,
size, sizeof(PFS_host), array->m_ptr);
array->m_ptr= NULL;
PFS_FREE_ARRAY(& builtin_memory_host_waits,
waits_sizing, sizeof(PFS_single_stat),
array->m_instr_class_waits_array);
array->m_instr_class_waits_array= NULL;
PFS_FREE_ARRAY(& builtin_memory_host_stages,
stages_sizing, sizeof(PFS_stage_stat),
array->m_instr_class_stages_array);
array->m_instr_class_stages_array= NULL;
PFS_FREE_ARRAY(& builtin_memory_host_statements,
statements_sizing, sizeof(PFS_statement_stat),
array->m_instr_class_statements_array);
array->m_instr_class_statements_array= NULL;
PFS_FREE_ARRAY(& builtin_memory_host_transactions,
transactions_sizing, sizeof(PFS_transaction_stat),
array->m_instr_class_transactions_array);
array->m_instr_class_transactions_array= NULL;
PFS_FREE_ARRAY(& builtin_memory_host_memory,
memory_sizing, sizeof(PFS_memory_stat),
array->m_instr_class_memory_array);
array->m_instr_class_memory_array= NULL;
}
|
O3
|
cpp
|
PFS_host_allocator::free_array(PFS_host_array*):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x48(%rsi), %rcx
movq 0x50(%rsi), %rsi
leaq 0x35d3cc(%rip), %rax # 0x391c60
movl (%rax), %r14d
imulq %rsi, %r14
leaq 0x35cb6e(%rip), %rax # 0x391410
movq (%rax), %r13
imulq %rsi, %r13
leaq 0x35cb70(%rip), %rax # 0x391420
movq (%rax), %r12
imulq %rsi, %r12
leaq 0x35cb92(%rip), %rax # 0x391450
movq (%rax), %r15
imulq %rsi, %r15
leaq 0x35cb74(%rip), %rax # 0x391440
movq (%rax), %rax
imulq %rsi, %rax
movq %rax, -0x30(%rbp)
leaq 0x397ce2(%rip), %rdi # 0x3cc5c0
movl $0x940, %edx # imm = 0x940
callq 0x3628b
xorl %eax, %eax
movq %rax, 0x48(%rbx)
movq 0x60(%rbx), %rcx
leaq 0x397e07(%rip), %rdi # 0x3cc700
movl $0x20, %edx
movq %r14, %rsi
callq 0x3628b
xorl %eax, %eax
movq %rax, 0x60(%rbx)
movq 0x68(%rbx), %rcx
leaq 0x397f29(%rip), %rdi # 0x3cc840
movl $0x20, %edx
movq %r13, %rsi
callq 0x3628b
xorl %r14d, %r14d
movq %r14, 0x68(%rbx)
movq 0x70(%rbx), %rcx
leaq 0x39804a(%rip), %rdi # 0x3cc980
movl $0xb8, %edx
movq %r12, %rsi
callq 0x3628b
movq %r14, 0x70(%rbx)
xorl %r14d, %r14d
movq 0x78(%rbx), %rcx
leaq 0x39816b(%rip), %rdi # 0x3ccac0
movl $0x58, %edx
movq %r15, %rsi
callq 0x3628b
movq %r14, 0x78(%rbx)
xorl %r14d, %r14d
movq 0x80(%rbx), %rcx
leaq 0x398289(%rip), %rdi # 0x3ccc00
movl $0x48, %edx
movq -0x30(%rbp), %rsi
callq 0x3628b
movq %r14, 0x80(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
_ZN18PFS_host_allocator10free_arrayEP14PFS_host_array:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rsi
mov rcx, [rsi+48h]
mov rsi, [rsi+50h]
lea rax, wait_class_max
mov r14d, [rax]
imul r14, rsi
lea rax, stage_class_max
mov r13, [rax]
imul r13, rsi
lea rax, statement_class_max
mov r12, [rax]
imul r12, rsi
lea rax, transaction_class_max
mov r15, [rax]
imul r15, rsi
lea rax, memory_class_max
mov rax, [rax]
imul rax, rsi
mov [rbp+var_30], rax
lea rdi, builtin_memory_host
mov edx, 940h
call _Z14pfs_free_arrayP24PFS_builtin_memory_classmmPv; pfs_free_array(PFS_builtin_memory_class *,ulong,ulong,void *)
xor eax, eax
mov [rbx+48h], rax
mov rcx, [rbx+60h]
lea rdi, builtin_memory_host_waits
mov edx, 20h ; ' '
mov rsi, r14
call _Z14pfs_free_arrayP24PFS_builtin_memory_classmmPv; pfs_free_array(PFS_builtin_memory_class *,ulong,ulong,void *)
xor eax, eax
mov [rbx+60h], rax
mov rcx, [rbx+68h]
lea rdi, builtin_memory_host_stages
mov edx, 20h ; ' '
mov rsi, r13
call _Z14pfs_free_arrayP24PFS_builtin_memory_classmmPv; pfs_free_array(PFS_builtin_memory_class *,ulong,ulong,void *)
xor r14d, r14d
mov [rbx+68h], r14
mov rcx, [rbx+70h]
lea rdi, builtin_memory_host_statements
mov edx, 0B8h
mov rsi, r12
call _Z14pfs_free_arrayP24PFS_builtin_memory_classmmPv; pfs_free_array(PFS_builtin_memory_class *,ulong,ulong,void *)
mov [rbx+70h], r14
xor r14d, r14d
mov rcx, [rbx+78h]
lea rdi, builtin_memory_host_transactions
mov edx, 58h ; 'X'
mov rsi, r15
call _Z14pfs_free_arrayP24PFS_builtin_memory_classmmPv; pfs_free_array(PFS_builtin_memory_class *,ulong,ulong,void *)
mov [rbx+78h], r14
xor r14d, r14d
mov rcx, [rbx+80h]
lea rdi, builtin_memory_host_memory
mov edx, 48h ; 'H'
mov rsi, [rbp+var_30]
call _Z14pfs_free_arrayP24PFS_builtin_memory_classmmPv; pfs_free_array(PFS_builtin_memory_class *,ulong,ulong,void *)
mov [rbx+80h], r14
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long PFS_host_allocator::free_array(long long a1, _QWORD *a2)
{
long long v3; // rcx
long long v4; // rsi
long long v5; // r14
long long v6; // r13
long long v7; // r12
long long v8; // r15
long long result; // rax
long long v10; // [rsp+0h] [rbp-30h]
v3 = a2[9];
v4 = a2[10];
v5 = v4 * (unsigned int)wait_class_max;
v6 = v4 * stage_class_max;
v7 = v4 * statement_class_max;
v8 = v4 * transaction_class_max;
v10 = v4 * memory_class_max;
pfs_free_array(&builtin_memory_host, v4, 2368LL, v3);
a2[9] = 0LL;
pfs_free_array(&builtin_memory_host_waits, v5, 32LL, a2[12]);
a2[12] = 0LL;
pfs_free_array(&builtin_memory_host_stages, v6, 32LL, a2[13]);
a2[13] = 0LL;
pfs_free_array(&builtin_memory_host_statements, v7, 184LL, a2[14]);
a2[14] = 0LL;
pfs_free_array(&builtin_memory_host_transactions, v8, 88LL, a2[15]);
a2[15] = 0LL;
result = pfs_free_array(&builtin_memory_host_memory, v10, 72LL, a2[16]);
a2[16] = 0LL;
return result;
}
|
free_array:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV RCX,qword ptr [RSI + 0x48]
MOV RSI,qword ptr [RSI + 0x50]
LEA RAX,[0x491c60]
MOV R14D,dword ptr [RAX]
IMUL R14,RSI
LEA RAX,[0x491410]
MOV R13,qword ptr [RAX]
IMUL R13,RSI
LEA RAX,[0x491420]
MOV R12,qword ptr [RAX]
IMUL R12,RSI
LEA RAX,[0x491450]
MOV R15,qword ptr [RAX]
IMUL R15,RSI
LEA RAX,[0x491440]
MOV RAX,qword ptr [RAX]
IMUL RAX,RSI
MOV qword ptr [RBP + -0x30],RAX
LEA RDI,[0x4cc5c0]
MOV EDX,0x940
CALL 0x0013628b
XOR EAX,EAX
MOV qword ptr [RBX + 0x48],RAX
MOV RCX,qword ptr [RBX + 0x60]
LEA RDI,[0x4cc700]
MOV EDX,0x20
MOV RSI,R14
CALL 0x0013628b
XOR EAX,EAX
MOV qword ptr [RBX + 0x60],RAX
MOV RCX,qword ptr [RBX + 0x68]
LEA RDI,[0x4cc840]
MOV EDX,0x20
MOV RSI,R13
CALL 0x0013628b
XOR R14D,R14D
MOV qword ptr [RBX + 0x68],R14
MOV RCX,qword ptr [RBX + 0x70]
LEA RDI,[0x4cc980]
MOV EDX,0xb8
MOV RSI,R12
CALL 0x0013628b
MOV qword ptr [RBX + 0x70],R14
XOR R14D,R14D
MOV RCX,qword ptr [RBX + 0x78]
LEA RDI,[0x4ccac0]
MOV EDX,0x58
MOV RSI,R15
CALL 0x0013628b
MOV qword ptr [RBX + 0x78],R14
XOR R14D,R14D
MOV RCX,qword ptr [RBX + 0x80]
LEA RDI,[0x4ccc00]
MOV EDX,0x48
MOV RSI,qword ptr [RBP + -0x30]
CALL 0x0013628b
MOV qword ptr [RBX + 0x80],R14
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* PFS_host_allocator::free_array(PFS_host_array*) */
void __thiscall PFS_host_allocator::free_array(PFS_host_allocator *this,PFS_host_array *param_1)
{
ulong uVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
ulong uVar5;
ulong uVar6;
uVar1 = *(ulong *)(param_1 + 0x50);
uVar5 = (ulong)wait_class_max;
uVar4 = stage_class_max * uVar1;
uVar3 = statement_class_max * uVar1;
uVar6 = transaction_class_max * uVar1;
uVar2 = memory_class_max * uVar1;
pfs_free_array((PFS_builtin_memory_class *)builtin_memory_host,uVar1,0x940,
*(void **)(param_1 + 0x48));
*(int8 *)(param_1 + 0x48) = 0;
pfs_free_array((PFS_builtin_memory_class *)builtin_memory_host_waits,uVar5 * uVar1,0x20,
*(void **)(param_1 + 0x60));
*(int8 *)(param_1 + 0x60) = 0;
pfs_free_array((PFS_builtin_memory_class *)builtin_memory_host_stages,uVar4,0x20,
*(void **)(param_1 + 0x68));
*(int8 *)(param_1 + 0x68) = 0;
pfs_free_array((PFS_builtin_memory_class *)builtin_memory_host_statements,uVar3,0xb8,
*(void **)(param_1 + 0x70));
*(int8 *)(param_1 + 0x70) = 0;
pfs_free_array((PFS_builtin_memory_class *)builtin_memory_host_transactions,uVar6,0x58,
*(void **)(param_1 + 0x78));
*(int8 *)(param_1 + 0x78) = 0;
pfs_free_array((PFS_builtin_memory_class *)builtin_memory_host_memory,uVar2,0x48,
*(void **)(param_1 + 0x80));
*(int8 *)(param_1 + 0x80) = 0;
return;
}
|
|
63,375 |
GetFileModTime
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rcore.c
|
long GetFileModTime(const char *fileName)
{
struct stat result = { 0 };
long modTime = 0;
if (stat(fileName, &result) == 0)
{
time_t mod = result.st_mtime;
modTime = (long)mod;
}
return modTime;
}
|
O0
|
c
|
GetFileModTime:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x98(%rbp), %rdi
xorl %esi, %esi
movl $0x90, %edx
callq 0xa2d0
movq $0x0, -0xa0(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0xa470
cmpl $0x0, %eax
jne 0xd220b
movq -0x40(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
GetFileModTime:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov [rbp+var_8], rdi
lea rdi, [rbp+var_98]
xor esi, esi
mov edx, 90h
call _memset
mov [rbp+var_A0], 0
mov rdi, [rbp+var_8]
lea rsi, [rbp+var_98]
call _stat
cmp eax, 0
jnz short loc_D220B
mov rax, [rbp+var_40]
mov [rbp+var_A8], rax
mov rax, [rbp+var_A8]
mov [rbp+var_A0], rax
loc_D220B:
mov rax, [rbp+var_A0]
add rsp, 0B0h
pop rbp
retn
|
long long GetFileModTime(long long a1)
{
long long v2; // [rsp+10h] [rbp-A0h]
_BYTE v3[88]; // [rsp+18h] [rbp-98h] BYREF
long long v4; // [rsp+70h] [rbp-40h]
long long v5; // [rsp+A8h] [rbp-8h]
v5 = a1;
memset(v3, 0LL, 144LL);
v2 = 0LL;
if ( !(unsigned int)stat(v5, v3) )
return v4;
return v2;
}
|
GetFileModTime:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV qword ptr [RBP + -0x8],RDI
LEA RDI,[RBP + -0x98]
XOR ESI,ESI
MOV EDX,0x90
CALL 0x0010a2d0
MOV qword ptr [RBP + -0xa0],0x0
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[RBP + -0x98]
CALL 0x0010a470
CMP EAX,0x0
JNZ 0x001d220b
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0xa8],RAX
MOV RAX,qword ptr [RBP + -0xa8]
MOV qword ptr [RBP + -0xa0],RAX
LAB_001d220b:
MOV RAX,qword ptr [RBP + -0xa0]
ADD RSP,0xb0
POP RBP
RET
|
__time_t GetFileModTime(char *param_1)
{
int iVar1;
__time_t local_a8;
stat local_a0;
char *local_10;
local_10 = param_1;
memset(&local_a0,0,0x90);
local_a8 = 0;
iVar1 = stat(local_10,&local_a0);
if (iVar1 == 0) {
local_a8 = local_a0.st_mtim.tv_sec;
}
return local_a8;
}
|
|
63,376 |
GetFileModTime
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rcore.c
|
long GetFileModTime(const char *fileName)
{
struct stat result = { 0 };
long modTime = 0;
if (stat(fileName, &result) == 0)
{
time_t mod = result.st_mtime;
modTime = (long)mod;
}
return modTime;
}
|
O2
|
c
|
GetFileModTime:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %r14
movq %rsp, %r15
xorl %ebx, %ebx
movl $0x90, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x92c0
movq %r14, %rdi
movq %r15, %rsi
callq 0x9470
testl %eax, %eax
jne 0x6408e
movq 0x58(%rsp), %rbx
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
GetFileModTime:
push r15
push r14
push rbx
sub rsp, 90h
mov r14, rdi
mov r15, rsp
xor ebx, ebx
mov edx, 90h
mov rdi, r15
xor esi, esi
call _memset
mov rdi, r14
mov rsi, r15
call _stat
test eax, eax
jnz short loc_6408E
mov rbx, [rsp+0A8h+var_50]
loc_6408E:
mov rax, rbx
add rsp, 90h
pop rbx
pop r14
pop r15
retn
|
long long GetFileModTime(long long a1)
{
long long v1; // rbx
_QWORD v3[21]; // [rsp+0h] [rbp-A8h] BYREF
v1 = 0LL;
memset(v3, 0LL, 144LL);
if ( !(unsigned int)stat(a1, v3) )
return v3[11];
return v1;
}
|
GetFileModTime:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x90
MOV R14,RDI
MOV R15,RSP
XOR EBX,EBX
MOV EDX,0x90
MOV RDI,R15
XOR ESI,ESI
CALL 0x001092c0
MOV RDI,R14
MOV RSI,R15
CALL 0x00109470
TEST EAX,EAX
JNZ 0x0016408e
MOV RBX,qword ptr [RSP + 0x58]
LAB_0016408e:
MOV RAX,RBX
ADD RSP,0x90
POP RBX
POP R14
POP R15
RET
|
__time_t GetFileModTime(char *param_1)
{
int iVar1;
__time_t _Var2;
stat sStack_a8;
memset(&sStack_a8,0,0x90);
iVar1 = stat(param_1,&sStack_a8);
_Var2 = 0;
if (iVar1 == 0) {
_Var2 = sStack_a8.st_mtim.tv_sec;
}
return _Var2;
}
|
|
63,377 |
my_wc_mb_bin
|
eloqsql/strings/ctype-bin.c
|
int my_wc_mb_bin(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
if (s >= e)
return MY_CS_TOOSMALL;
if (wc < 256)
{
s[0]= (char) wc;
return 1;
}
return MY_CS_ILUNI;
}
|
O3
|
c
|
my_wc_mb_bin:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x33fd7
xorl %eax, %eax
cmpq $0xff, %rsi
ja 0x33fd7
movb %sil, (%rdx)
movl $0x1, %eax
popq %rbp
retq
|
my_wc_mb_bin:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short loc_33FD7
xor eax, eax
cmp rsi, 0FFh
ja short loc_33FD7
mov [rdx], sil
mov eax, 1
loc_33FD7:
pop rbp
retn
|
long long my_wc_mb_bin(long long a1, unsigned long long a2, _BYTE *a3, unsigned long long a4)
{
long long result; // rax
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
result = 0LL;
if ( a2 <= 0xFF )
{
*a3 = a2;
return 1LL;
}
}
return result;
}
|
my_wc_mb_bin:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x00133fd7
XOR EAX,EAX
CMP RSI,0xff
JA 0x00133fd7
MOV byte ptr [RDX],SIL
MOV EAX,0x1
LAB_00133fd7:
POP RBP
RET
|
int8 my_wc_mb_bin(int8 param_1,ulong param_2,int1 *param_3,int1 *param_4)
{
int8 uVar1;
uVar1 = 0xffffff9b;
if ((param_3 < param_4) && (uVar1 = 0, param_2 < 0x100)) {
*param_3 = (char)param_2;
uVar1 = 1;
}
return uVar1;
}
|
|
63,378 |
ggml_group_norm_impl
|
7CodeWizard[P]stablediffusion/ggml/src/ggml.c
|
static struct ggml_tensor * ggml_group_norm_impl(
struct ggml_context * ctx,
struct ggml_tensor * a,
int n_groups,
bool inplace) {
bool is_node = false;
if (!inplace && (a->grad)) {
GGML_ASSERT(false); // TODO: implement backward
is_node = true;
}
struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);
result->op_params[0] = n_groups;
result->op = GGML_OP_GROUP_NORM;
result->grad = is_node ? ggml_dup_tensor(ctx, result) : NULL;
result->src[0] = a;
return result;
}
|
O1
|
c
|
ggml_group_norm_impl:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
testl %ecx, %ecx
jne 0x9229f
cmpq $0x0, 0x98(%rbx)
jne 0x922e2
testb %cl, %cl
je 0x922a9
movq %rbx, %rsi
callq 0x90b1a
jmp 0x922bf
movl (%rbx), %esi
leaq 0x10(%rbx), %rcx
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x8e8b7
movl %ebp, 0x54(%rax)
movl $0x16, 0x50(%rax)
movq $0x0, 0x98(%rax)
movq %rbx, 0xa0(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0xd1c6
|
ggml_group_norm_impl:
push rbp
push rbx
push rax
mov ebp, edx
mov rbx, rsi
test ecx, ecx
jnz short loc_9229F
cmp qword ptr [rbx+98h], 0
jnz short loc_922E2
test cl, cl
jz short loc_922A9
loc_9229F:
mov rsi, rbx
call ggml_view_tensor
jmp short loc_922BF
loc_922A9:
mov esi, [rbx]
lea rcx, [rbx+10h]
mov edx, 4
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
loc_922BF:
mov [rax+54h], ebp
mov dword ptr [rax+50h], 16h
mov qword ptr [rax+98h], 0
mov [rax+0A0h], rbx
add rsp, 8
pop rbx
pop rbp
retn
loc_922E2:
call ggml_group_norm_impl_cold_1
|
long long ggml_group_norm_impl(
long long a1,
long long a2,
int a3,
int a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
double a9,
double a10,
__m128 a11,
__m128 a12)
{
long long result; // rax
if ( a4 )
{
result = ggml_view_tensor(a1, a2, a5, a6, a7, a8, a9, a10, a11, a12);
}
else
{
if ( *(_QWORD *)(a2 + 152) )
ggml_group_norm_impl_cold_1(a1);
result = ggml_new_tensor_impl(a1, *(_DWORD *)a2, 4, (_QWORD *)(a2 + 16), 0LL, 0LL, a5, a6);
}
*(_DWORD *)(result + 84) = a3;
*(_DWORD *)(result + 80) = 22;
*(_QWORD *)(result + 152) = 0LL;
*(_QWORD *)(result + 160) = a2;
return result;
}
| |||
63,379 |
ggml_group_norm_impl
|
7CodeWizard[P]stablediffusion/ggml/src/ggml.c
|
static struct ggml_tensor * ggml_group_norm_impl(
struct ggml_context * ctx,
struct ggml_tensor * a,
int n_groups,
bool inplace) {
bool is_node = false;
if (!inplace && (a->grad)) {
GGML_ASSERT(false); // TODO: implement backward
is_node = true;
}
struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);
result->op_params[0] = n_groups;
result->op = GGML_OP_GROUP_NORM;
result->grad = is_node ? ggml_dup_tensor(ctx, result) : NULL;
result->src[0] = a;
return result;
}
|
O2
|
c
|
ggml_group_norm_impl:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
testl %ecx, %ecx
je 0x6ae1b
movq %rbx, %rsi
callq 0x69922
jmp 0x6ae2d
cmpq $0x0, 0x98(%rbx)
jne 0x6ae4d
movq %rbx, %rsi
callq 0x68a65
movl %ebp, 0x54(%rax)
movl $0x16, 0x50(%rax)
andq $0x0, 0x98(%rax)
movq %rbx, 0xa0(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x6b0f4(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x6b145(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0x2f3b1(%rip), %rsi # 0x9a21e
leaq 0x36a0a(%rip), %rdx # 0xa187e
leaq 0x2d1c4(%rip), %r8 # 0x9803f
movl $0xfc1, %ecx # imm = 0xFC1
xorl %eax, %eax
callq 0xa8b0
callq 0x67550
callq 0xa300
|
ggml_group_norm_impl:
push rbp
push rbx
push rax
mov ebp, edx
mov rbx, rsi
test ecx, ecx
jz short loc_6AE1B
mov rsi, rbx
call ggml_view_tensor
jmp short loc_6AE2D
loc_6AE1B:
cmp qword ptr [rbx+98h], 0
jnz short loc_6AE4D
mov rsi, rbx
call ggml_dup_tensor
loc_6AE2D:
mov [rax+54h], ebp
mov dword ptr [rax+50h], 16h
and qword ptr [rax+98h], 0
mov [rax+0A0h], rbx
add rsp, 8
pop rbx
pop rbp
retn
loc_6AE4D:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea r8, aFalse; "false"
mov ecx, 0FC1h
xor eax, eax
call _fprintf
call ggml_print_backtrace
call _abort
|
long long ggml_group_norm_impl(
long long a1,
long long a2,
int a3,
int a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
double a9,
double a10,
__m128 a11,
__m128 a12)
{
long long result; // rax
long long v14; // rdi
if ( a4 )
{
result = ggml_view_tensor(a1, a2, a5, a6, a7, a8, a9, a10, a11, a12);
}
else
{
if ( *(_QWORD *)(a2 + 152) )
{
fflush(stdout);
v14 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
4033,
"false");
ggml_print_backtrace();
abort(v14);
}
result = ggml_dup_tensor(a1, (unsigned int *)a2);
}
*(_DWORD *)(result + 84) = a3;
*(_DWORD *)(result + 80) = 22;
*(_QWORD *)(result + 152) = 0LL;
*(_QWORD *)(result + 160) = a2;
return result;
}
|
ggml_group_norm_impl:
PUSH RBP
PUSH RBX
PUSH RAX
MOV EBP,EDX
MOV RBX,RSI
TEST ECX,ECX
JZ 0x0016ae1b
MOV RSI,RBX
CALL 0x00169922
JMP 0x0016ae2d
LAB_0016ae1b:
CMP qword ptr [RBX + 0x98],0x0
JNZ 0x0016ae4d
MOV RSI,RBX
CALL 0x00168a65
LAB_0016ae2d:
MOV dword ptr [RAX + 0x54],EBP
MOV dword ptr [RAX + 0x50],0x16
AND qword ptr [RAX + 0x98],0x0
MOV qword ptr [RAX + 0xa0],RBX
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_0016ae4d:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a187e]
LEA R8,[0x19803f]
MOV ECX,0xfc1
XOR EAX,EAX
CALL 0x0010a8b0
CALL 0x00167550
CALL 0x0010a300
|
void ggml_group_norm_impl(int8 param_1,long param_2,int4 param_3,int param_4)
{
long lVar1;
if (param_4 == 0) {
if (*(long *)(param_2 + 0x98) != 0) {
fflush(*(FILE **)PTR_stdout_001d5f48);
fprintf(*(FILE **)PTR_stderr_001d5fa8,"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c"
,0xfc1,"false");
ggml_print_backtrace();
/* WARNING: Subroutine does not return */
abort();
}
lVar1 = ggml_dup_tensor(param_1,param_2);
}
else {
lVar1 = ggml_view_tensor(param_1,param_2);
}
*(int4 *)(lVar1 + 0x54) = param_3;
*(int4 *)(lVar1 + 0x50) = 0x16;
*(int8 *)(lVar1 + 0x98) = 0;
*(long *)(lVar1 + 0xa0) = param_2;
return;
}
|
|
63,380 |
setup_key_functions
|
eloqsql/storage/maria/ma_open.c
|
static void setup_key_functions(register MARIA_KEYDEF *keyinfo)
{
if (keyinfo->key_alg == HA_KEY_ALG_RTREE)
{
#ifdef HAVE_RTREE_KEYS
keyinfo->ck_insert = maria_rtree_insert;
keyinfo->ck_delete = maria_rtree_delete;
#else
DBUG_ASSERT(0); /* maria_open should check it never happens */
#endif
}
else
{
keyinfo->ck_insert = _ma_ck_write;
keyinfo->ck_delete = _ma_ck_delete;
}
if (keyinfo->flag & HA_SPATIAL)
keyinfo->make_key= _ma_sp_make_key;
else
keyinfo->make_key= _ma_make_key;
if (keyinfo->flag & HA_BINARY_PACK_KEY)
{ /* Simple prefix compression */
keyinfo->bin_search= _ma_seq_search;
keyinfo->get_key= _ma_get_binary_pack_key;
keyinfo->skip_key= _ma_skip_binary_pack_key;
keyinfo->pack_key= _ma_calc_bin_pack_key_length;
keyinfo->store_key= _ma_store_bin_pack_key;
}
else if (keyinfo->flag & HA_VAR_LENGTH_KEY)
{
keyinfo->get_key= _ma_get_pack_key;
keyinfo->skip_key= _ma_skip_pack_key;
if (keyinfo->seg[0].flag & HA_PACK_KEY)
{ /* Prefix compression */
/*
_ma_prefix_search() compares end-space against ASCII blank (' ').
It cannot be used for character sets, that do not encode the
blank character like ASCII does. UCS2 is an example. All
character sets with a fixed width > 1 or a mimimum width > 1
cannot represent blank like ASCII does. In these cases we have
to use _ma_seq_search() for the search.
*/
if (!keyinfo->seg->charset || use_strnxfrm(keyinfo->seg->charset) ||
(keyinfo->seg->flag & HA_NULL_PART) ||
keyinfo->seg->charset->mbminlen > 1)
keyinfo->bin_search= _ma_seq_search;
else
keyinfo->bin_search= _ma_prefix_search;
keyinfo->pack_key= _ma_calc_var_pack_key_length;
keyinfo->store_key= _ma_store_var_pack_key;
}
else
{
keyinfo->bin_search= _ma_seq_search;
keyinfo->pack_key= _ma_calc_var_key_length; /* Variable length key */
keyinfo->store_key= _ma_store_static_key;
}
}
else
{
keyinfo->bin_search= _ma_bin_search;
keyinfo->get_key= _ma_get_static_key;
keyinfo->skip_key= _ma_skip_static_key;
keyinfo->pack_key= _ma_calc_static_key_length;
keyinfo->store_key= _ma_store_static_key;
}
/* set keyinfo->write_comp_flag */
if (keyinfo->flag & HA_SORT_ALLOWS_SAME)
keyinfo->write_comp_flag=SEARCH_BIGGER; /* Put after same key */
else if (keyinfo->flag & ( HA_NOSAME | HA_FULLTEXT))
{
keyinfo->write_comp_flag= SEARCH_FIND | SEARCH_UPDATE; /* No duplicates */
if (keyinfo->flag & HA_NULL_ARE_EQUAL)
keyinfo->write_comp_flag|= SEARCH_NULL_ARE_EQUAL;
}
else
keyinfo->write_comp_flag= SEARCH_SAME; /* Keys in rec-pos order */
keyinfo->write_comp_flag|= SEARCH_INSERT;
return;
}
|
O3
|
c
|
setup_key_functions:
pushq %rbp
movq %rsp, %rbp
cmpb $0x2, 0xa4(%rdi)
leaq 0x101e1(%rip), %rax # 0x64714
cmoveq 0x32fab5(%rip), %rax # 0x383ff0
leaq 0x12ecf(%rip), %rcx # 0x67411
cmoveq 0x32fa76(%rip), %rcx # 0x383fc0
movq %rax, 0x100(%rdi)
movq %rcx, 0x108(%rdi)
movzwl 0xa2(%rdi), %eax
btl $0xa, %eax
jb 0x5456e
leaq -0x1dadd(%rip), %rcx # 0x36a8f
jmp 0x54575
leaq 0x1c303(%rip), %rcx # 0x70878
movq %rcx, 0x110(%rdi)
testb $0x20, %al
jne 0x545ad
testb $0x8, %al
jne 0x54616
leaq 0x4440(%rip), %rcx # 0x589cf
leaq 0x3cbb(%rip), %rsi # 0x58251
leaq 0x2d89(%rip), %rdx # 0x57326
leaq 0x2cec(%rip), %r8 # 0x57290
leaq 0x1da4(%rip), %r9 # 0x5634f
jmp 0x545d0
leaq 0x463f(%rip), %rcx # 0x58bf3
leaq 0x426d(%rip), %rsi # 0x58828
leaq 0x346d(%rip), %rdx # 0x57a2f
leaq 0x31f3(%rip), %r8 # 0x577bc
leaq 0x1ee1(%rip), %r9 # 0x564b1
movq %r9, 0xd8(%rdi)
movq %r8, 0xe0(%rdi)
movl $0xe8, %r8d
movq %rdx, (%rdi,%r8)
movq %rsi, 0xf0(%rdi)
movq %rcx, 0xf8(%rdi)
movl $0x20008, %ecx # imm = 0x20008
btl $0x9, %eax
jb 0x54666
testb $-0x7f, %al
je 0x54661
shll $0x4, %eax
andl $0x8000, %eax # imm = 0x8000
orl $0x20041, %eax # imm = 0x20041
movl %eax, %ecx
jmp 0x54666
leaq 0x2d48(%rip), %rcx # 0x57365
movq %rcx, 0xe0(%rdi)
leaq 0x3088(%rip), %rcx # 0x576b3
movq %rcx, 0xe8(%rdi)
movq 0xc0(%rdi), %rcx
movzwl 0x12(%rcx), %r9d
leaq 0x1e6c(%rip), %rdx # 0x564b1
movl $0xd8, %r8d
testb $0x2, %r9b
jne 0x5466e
leaq 0x4377(%rip), %rcx # 0x589cf
leaq 0x3c0a(%rip), %rsi # 0x58269
jmp 0x545e4
movl $0x20004, %ecx # imm = 0x20004
movl %ecx, 0xb4(%rdi)
popq %rbp
retq
movq (%rcx), %r10
leaq 0x437c(%rip), %rcx # 0x589f4
leaq 0x3c02(%rip), %rsi # 0x58281
testq %r10, %r10
je 0x545e4
movl 0xc(%r10), %r11d
andl $0x40, %r11d
andl $0x10, %r9d
orl %r11d, %r9d
jne 0x545e4
cmpl $0x2, 0x98(%r10)
jb 0x546b3
leaq 0x1e03(%rip), %rdx # 0x564b1
jmp 0x545e4
leaq 0x1fb8(%rip), %rdx # 0x56672
jmp 0x545e4
|
setup_key_functions:
push rbp
mov rbp, rsp
cmp byte ptr [rdi+0A4h], 2
lea rax, _ma_ck_write
cmovz rax, cs:maria_rtree_insert_ptr
lea rcx, _ma_ck_delete
cmovz rcx, cs:maria_rtree_delete_ptr
mov [rdi+100h], rax
mov [rdi+108h], rcx
movzx eax, word ptr [rdi+0A2h]
bt eax, 0Ah
jb short loc_5456E
lea rcx, _ma_make_key
jmp short loc_54575
loc_5456E:
lea rcx, _ma_sp_make_key
loc_54575:
mov [rdi+110h], rcx
test al, 20h
jnz short loc_545AD
test al, 8
jnz loc_54616
lea rcx, _ma_store_static_key
lea rsi, _ma_calc_static_key_length
lea rdx, _ma_skip_static_key
lea r8, _ma_get_static_key
lea r9, _ma_bin_search
jmp short loc_545D0
loc_545AD:
lea rcx, _ma_store_bin_pack_key
lea rsi, _ma_calc_bin_pack_key_length
lea rdx, _ma_skip_binary_pack_key
lea r8, _ma_get_binary_pack_key
lea r9, _ma_seq_search
loc_545D0:
mov [rdi+0D8h], r9
mov [rdi+0E0h], r8
mov r8d, 0E8h
loc_545E4:
mov [rdi+r8], rdx
mov [rdi+0F0h], rsi
mov [rdi+0F8h], rcx
mov ecx, offset stru_20008
bt eax, 9
jb short loc_54666
test al, 81h
jz short loc_54661
shl eax, 4
and eax, 8000h
or eax, 20041h
mov ecx, eax
jmp short loc_54666
loc_54616:
lea rcx, _ma_get_pack_key
mov [rdi+0E0h], rcx
lea rcx, _ma_skip_pack_key
mov [rdi+0E8h], rcx
mov rcx, [rdi+0C0h]
movzx r9d, word ptr [rcx+12h]
lea rdx, _ma_seq_search
mov r8d, 0D8h
test r9b, 2
jnz short loc_5466E
lea rcx, _ma_store_static_key
lea rsi, _ma_calc_var_key_length
jmp short loc_545E4
loc_54661:
mov ecx, 20004h
loc_54666:
mov [rdi+0B4h], ecx
pop rbp
retn
loc_5466E:
mov r10, [rcx]
lea rcx, _ma_store_var_pack_key
lea rsi, _ma_calc_var_pack_key_length
test r10, r10
jz loc_545E4
mov r11d, [r10+0Ch]
and r11d, 40h
and r9d, 10h
or r9d, r11d
jnz loc_545E4
cmp dword ptr [r10+98h], 2
jb short loc_546B3
lea rdx, _ma_seq_search
jmp loc_545E4
loc_546B3:
lea rdx, _ma_prefix_search
jmp loc_545E4
|
long long setup_key_functions(long long a1)
{
long long ( *v1)(); // rax
long long ( *v2)(); // rcx
long long result; // rax
long long ( *v4)(int, int, int, int, int, int, long long); // rcx
long long ( *v5)(); // rcx
long long ( *v6)(); // rsi
long long ( *v7)(); // rdx
long long ( *v8)(); // r8
long long ( *v9)(); // r9
long long v10; // r8
Elf64_Rela *v11; // rcx
long long *v12; // rcx
__int16 v13; // r9
long long v14; // r10
v1 = ma_ck_write;
if ( *(_BYTE *)(a1 + 164) == 2 )
v1 = maria_rtree_insert;
v2 = ma_ck_delete;
if ( *(_BYTE *)(a1 + 164) == 2 )
v2 = maria_rtree_delete;
*(_QWORD *)(a1 + 256) = v1;
*(_QWORD *)(a1 + 264) = v2;
result = *(unsigned __int16 *)(a1 + 162);
if ( (result & 0x400) != 0 )
v4 = ma_sp_make_key;
else
v4 = (long long ( *)(int, int, int, int, int, int, long long))ma_make_key;
*(_QWORD *)(a1 + 272) = v4;
if ( (result & 0x20) != 0 )
{
v5 = ma_store_bin_pack_key;
v6 = ma_calc_bin_pack_key_length;
v7 = ma_skip_binary_pack_key;
v8 = ma_get_binary_pack_key;
v9 = ma_seq_search;
goto LABEL_12;
}
if ( (result & 8) == 0 )
{
v5 = ma_store_static_key;
v6 = ma_calc_static_key_length;
v7 = ma_skip_static_key;
v8 = ma_get_static_key;
v9 = ma_bin_search;
LABEL_12:
*(_QWORD *)(a1 + 216) = v9;
*(_QWORD *)(a1 + 224) = v8;
v10 = 232LL;
goto LABEL_13;
}
*(_QWORD *)(a1 + 224) = ma_get_pack_key;
*(_QWORD *)(a1 + 232) = ma_skip_pack_key;
v12 = *(long long **)(a1 + 192);
v13 = *((_WORD *)v12 + 9);
v7 = ma_seq_search;
v10 = 216LL;
if ( (v13 & 2) != 0 )
{
v14 = *v12;
v5 = ma_store_var_pack_key;
v6 = ma_calc_var_pack_key_length;
if ( v14 && !(*(_DWORD *)(v14 + 12) & 0x40 | v13 & 0x10) )
{
if ( *(_DWORD *)(v14 + 152) < 2u )
v7 = ma_prefix_search;
else
v7 = ma_seq_search;
}
}
else
{
v5 = ma_store_static_key;
v6 = ma_calc_var_key_length;
}
LABEL_13:
*(_QWORD *)(a1 + v10) = v7;
*(_QWORD *)(a1 + 240) = v6;
*(_QWORD *)(a1 + 248) = v5;
v11 = &stru_20008;
if ( (result & 0x200) == 0 )
{
if ( (result & 0x81) != 0 )
{
result = (16 * (_WORD)result) & 0x8000 | 0x20041u;
LODWORD(v11) = result;
}
else
{
LODWORD(v11) = 131076;
}
}
*(_DWORD *)(a1 + 180) = (_DWORD)v11;
return result;
}
|
setup_key_functions:
PUSH RBP
MOV RBP,RSP
CMP byte ptr [RDI + 0xa4],0x2
LEA RAX,[0x164714]
CMOVZ RAX,qword ptr [0x00483ff0]
LEA RCX,[0x167411]
CMOVZ RCX,qword ptr [0x00483fc0]
MOV qword ptr [RDI + 0x100],RAX
MOV qword ptr [RDI + 0x108],RCX
MOVZX EAX,word ptr [RDI + 0xa2]
BT EAX,0xa
JC 0x0015456e
LEA RCX,[0x136a8f]
JMP 0x00154575
LAB_0015456e:
LEA RCX,[0x170878]
LAB_00154575:
MOV qword ptr [RDI + 0x110],RCX
TEST AL,0x20
JNZ 0x001545ad
TEST AL,0x8
JNZ 0x00154616
LEA RCX,[0x1589cf]
LEA RSI,[0x158251]
LEA RDX,[0x157326]
LEA R8,[0x157290]
LEA R9,[0x15634f]
JMP 0x001545d0
LAB_001545ad:
LEA RCX,[0x158bf3]
LEA RSI,[0x158828]
LEA RDX,[0x157a2f]
LEA R8,[0x1577bc]
LEA R9,[0x1564b1]
LAB_001545d0:
MOV qword ptr [RDI + 0xd8],R9
MOV qword ptr [RDI + 0xe0],R8
MOV R8D,0xe8
LAB_001545e4:
MOV qword ptr [RDI + R8*0x1],RDX
MOV qword ptr [RDI + 0xf0],RSI
MOV qword ptr [RDI + 0xf8],RCX
MOV ECX,0x20008
BT EAX,0x9
JC 0x00154666
TEST AL,0x81
JZ 0x00154661
SHL EAX,0x4
AND EAX,0x8000
OR EAX,0x20041
MOV ECX,EAX
JMP 0x00154666
LAB_00154616:
LEA RCX,[0x157365]
MOV qword ptr [RDI + 0xe0],RCX
LEA RCX,[0x1576b3]
MOV qword ptr [RDI + 0xe8],RCX
MOV RCX,qword ptr [RDI + 0xc0]
MOVZX R9D,word ptr [RCX + 0x12]
LEA RDX,[0x1564b1]
MOV R8D,0xd8
TEST R9B,0x2
JNZ 0x0015466e
LEA RCX,[0x1589cf]
LEA RSI,[0x158269]
JMP 0x001545e4
LAB_00154661:
MOV ECX,0x20004
LAB_00154666:
MOV dword ptr [RDI + 0xb4],ECX
POP RBP
RET
LAB_0015466e:
MOV R10,qword ptr [RCX]
LEA RCX,[0x1589f4]
LEA RSI,[0x158281]
TEST R10,R10
JZ 0x001545e4
MOV R11D,dword ptr [R10 + 0xc]
AND R11D,0x40
AND R9D,0x10
OR R9D,R11D
JNZ 0x001545e4
CMP dword ptr [R10 + 0x98],0x2
JC 0x001546b3
LEA RDX,[0x1564b1]
JMP 0x001545e4
LAB_001546b3:
LEA RDX,[0x156672]
JMP 0x001545e4
|
void setup_key_functions(long param_1)
{
ushort uVar1;
ushort uVar2;
long lVar3;
uint uVar4;
code *pcVar5;
code *pcVar6;
code *pcVar7;
code *pcVar8;
long lVar9;
code *pcVar10;
bool bVar11;
bVar11 = *(char *)(param_1 + 0xa4) == '\x02';
pcVar5 = _ma_ck_write;
if (bVar11) {
pcVar5 = (code *)PTR_maria_rtree_insert_00483ff0;
}
pcVar6 = _ma_ck_delete;
if (bVar11) {
pcVar6 = (code *)PTR_maria_rtree_delete_00483fc0;
}
*(code **)(param_1 + 0x100) = pcVar5;
*(code **)(param_1 + 0x108) = pcVar6;
uVar1 = *(ushort *)(param_1 + 0xa2);
if ((uVar1 >> 10 & 1) == 0) {
pcVar5 = _ma_make_key;
}
else {
pcVar5 = _ma_sp_make_key;
}
*(code **)(param_1 + 0x110) = pcVar5;
if ((uVar1 & 0x20) == 0) {
if ((uVar1 & 8) != 0) {
*(code **)(param_1 + 0xe0) = _ma_get_pack_key;
*(code **)(param_1 + 0xe8) = _ma_skip_pack_key;
uVar2 = *(ushort *)((long)*(long **)(param_1 + 0xc0) + 0x12);
pcVar6 = _ma_seq_search;
lVar9 = 0xd8;
if ((uVar2 & 2) == 0) {
pcVar5 = _ma_store_static_key;
pcVar7 = _ma_calc_var_key_length;
}
else {
lVar3 = **(long **)(param_1 + 0xc0);
pcVar5 = _ma_store_var_pack_key;
pcVar7 = _ma_calc_var_pack_key_length;
if ((lVar3 != 0) && ((uVar2 & 0x10) == 0 && (*(uint *)(lVar3 + 0xc) & 0x40) == 0)) {
if (*(uint *)(lVar3 + 0x98) < 2) {
pcVar6 = _ma_prefix_search;
}
else {
pcVar6 = _ma_seq_search;
}
}
}
goto LAB_001545e4;
}
pcVar5 = _ma_store_static_key;
pcVar7 = _ma_calc_static_key_length;
pcVar6 = _ma_skip_static_key;
pcVar8 = _ma_get_static_key;
pcVar10 = _ma_bin_search;
}
else {
pcVar5 = _ma_store_bin_pack_key;
pcVar7 = _ma_calc_bin_pack_key_length;
pcVar6 = _ma_skip_binary_pack_key;
pcVar8 = _ma_get_binary_pack_key;
pcVar10 = _ma_seq_search;
}
*(code **)(param_1 + 0xd8) = pcVar10;
*(code **)(param_1 + 0xe0) = pcVar8;
lVar9 = 0xe8;
LAB_001545e4:
*(code **)(param_1 + lVar9) = pcVar6;
*(code **)(param_1 + 0xf0) = pcVar7;
*(code **)(param_1 + 0xf8) = pcVar5;
uVar4 = 0x20008;
if ((uVar1 >> 9 & 1) == 0) {
if ((uVar1 & 0x81) == 0) {
uVar4 = 0x20004;
}
else {
uVar4 = (uVar1 & 0x800) << 4 | 0x20041;
}
}
*(uint *)(param_1 + 0xb4) = uVar4;
return;
}
|
|
63,381 |
expand_fast_array
|
bluesky950520[P]quickjs/quickjs.c
|
static int expand_fast_array(JSContext *ctx, JSObject *p, uint32_t new_len)
{
uint32_t new_size;
size_t slack;
JSValue *new_array_prop;
/* XXX: potential arithmetic overflow */
new_size = max_int(new_len, p->u.array.u1.size * 3 / 2);
new_array_prop = js_realloc2(ctx, p->u.array.u.values, sizeof(JSValue) * new_size, &slack);
if (!new_array_prop)
return -1;
new_size += slack / sizeof(*new_array_prop);
p->u.array.u.values = new_array_prop;
p->u.array.u1.size = new_size;
return 0;
}
|
O0
|
c
|
expand_fast_array:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movl 0x1c(%rsp), %edi
movq 0x20(%rsp), %rax
imull $0x3, 0x30(%rax), %esi
shrl %esi
callq 0x63600
movl %eax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rsi
movl 0x18(%rsp), %eax
movl %eax, %edx
shlq $0x4, %rdx
leaq 0x10(%rsp), %rcx
callq 0x28170
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x673a3
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x673d9
movq 0x10(%rsp), %rcx
shrq $0x4, %rcx
movl 0x18(%rsp), %eax
addq %rcx, %rax
movl %eax, 0x18(%rsp)
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x38(%rax)
movl 0x18(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x30(%rax)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
|
expand_fast_array:
sub rsp, 38h
mov [rsp+38h+var_10], rdi
mov [rsp+38h+var_18], rsi
mov [rsp+38h+var_1C], edx
mov edi, [rsp+38h+var_1C]
mov rax, [rsp+38h+var_18]
imul esi, [rax+30h], 3
shr esi, 1
call max_int_1
mov [rsp+38h+var_20], eax
mov rdi, [rsp+38h+var_10]
mov rax, [rsp+38h+var_18]
mov rsi, [rax+38h]
mov eax, [rsp+38h+var_20]
mov edx, eax
shl rdx, 4
lea rcx, [rsp+38h+var_28]
call js_realloc2
mov [rsp+38h+var_30], rax
cmp [rsp+38h+var_30], 0
jnz short loc_673A3
mov [rsp+38h+var_4], 0FFFFFFFFh
jmp short loc_673D9
loc_673A3:
mov rcx, [rsp+38h+var_28]
shr rcx, 4
mov eax, [rsp+38h+var_20]
add rax, rcx
mov [rsp+38h+var_20], eax
mov rcx, [rsp+38h+var_30]
mov rax, [rsp+38h+var_18]
mov [rax+38h], rcx
mov ecx, [rsp+38h+var_20]
mov rax, [rsp+38h+var_18]
mov [rax+30h], ecx
mov [rsp+38h+var_4], 0
loc_673D9:
mov eax, [rsp+38h+var_4]
add rsp, 38h
retn
|
long long expand_fast_array(long long a1, long long a2, unsigned int a3)
{
long long v4; // [rsp+8h] [rbp-30h]
unsigned long long v5; // [rsp+10h] [rbp-28h] BYREF
unsigned int v6; // [rsp+18h] [rbp-20h]
unsigned int v7; // [rsp+1Ch] [rbp-1Ch]
long long v8; // [rsp+20h] [rbp-18h]
long long v9; // [rsp+28h] [rbp-10h]
v9 = a1;
v8 = a2;
v7 = a3;
v6 = max_int_1(a3, (unsigned int)(3 * *(_DWORD *)(a2 + 48)) >> 1);
v4 = js_realloc2(a1, *(_QWORD *)(a2 + 56), 16LL * v6, &v5);
if ( v4 )
{
v6 += v5 >> 4;
*(_QWORD *)(v8 + 56) = v4;
*(_DWORD *)(v8 + 48) = v6;
return 0;
}
else
{
return (unsigned int)-1;
}
}
|
expand_fast_array:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RDI
MOV qword ptr [RSP + 0x20],RSI
MOV dword ptr [RSP + 0x1c],EDX
MOV EDI,dword ptr [RSP + 0x1c]
MOV RAX,qword ptr [RSP + 0x20]
IMUL ESI,dword ptr [RAX + 0x30],0x3
SHR ESI,0x1
CALL 0x00163600
MOV dword ptr [RSP + 0x18],EAX
MOV RDI,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RAX + 0x38]
MOV EAX,dword ptr [RSP + 0x18]
MOV EDX,EAX
SHL RDX,0x4
LEA RCX,[RSP + 0x10]
CALL 0x00128170
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x8],0x0
JNZ 0x001673a3
MOV dword ptr [RSP + 0x34],0xffffffff
JMP 0x001673d9
LAB_001673a3:
MOV RCX,qword ptr [RSP + 0x10]
SHR RCX,0x4
MOV EAX,dword ptr [RSP + 0x18]
ADD RAX,RCX
MOV dword ptr [RSP + 0x18],EAX
MOV RCX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX + 0x38],RCX
MOV ECX,dword ptr [RSP + 0x18]
MOV RAX,qword ptr [RSP + 0x20]
MOV dword ptr [RAX + 0x30],ECX
MOV dword ptr [RSP + 0x34],0x0
LAB_001673d9:
MOV EAX,dword ptr [RSP + 0x34]
ADD RSP,0x38
RET
|
int4 expand_fast_array(int8 param_1,long param_2,int4 param_3)
{
long lVar1;
ulong local_28;
uint local_20;
int4 local_1c;
long local_18;
int8 local_10;
int4 local_4;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
local_20 = max_int(param_3,(uint)(*(int *)(param_2 + 0x30) * 3) >> 1);
lVar1 = js_realloc2(local_10,*(int8 *)(local_18 + 0x38),(ulong)local_20 << 4,&local_28);
if (lVar1 == 0) {
local_4 = 0xffffffff;
}
else {
*(long *)(local_18 + 0x38) = lVar1;
*(uint *)(local_18 + 0x30) = local_20 + (int)(local_28 >> 4);
local_4 = 0;
}
return local_4;
}
|
|
63,382 |
ma_end_block_record
|
eloqsql/storage/maria/ma_blockrec.c
|
void _ma_end_block_record(MARIA_HA *info)
{
DBUG_ENTER("_ma_end_block_record");
my_free(info->cur_row.empty_bits);
delete_dynamic(&info->bitmap_blocks);
my_free(info->cur_row.extents);
my_free(info->blob_buff);
/*
The data file is closed, when needed, in ma_once_end_block_record().
The following protects us from doing an extra, not allowed, close
in maria_close()
*/
info->dfile.file= -1;
DBUG_VOID_RETURN;
}
|
O0
|
c
|
ma_end_block_record:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rdi
callq 0xf3bb0
movq -0x8(%rbp), %rdi
addq $0x2c0, %rdi # imm = 0x2C0
callq 0xdadd0
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0xf3bb0
movq -0x8(%rbp), %rax
movq 0x3a8(%rax), %rdi
callq 0xf3bb0
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x480(%rax) # imm = 0xFFFFFFFF
jmp 0x7462c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_ma_end_block_record:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rdi, [rax+0C8h]
call my_free
mov rdi, [rbp+var_8]
add rdi, 2C0h
call delete_dynamic
mov rax, [rbp+var_8]
mov rdi, [rax+90h]
call my_free
mov rax, [rbp+var_8]
mov rdi, [rax+3A8h]
call my_free
mov rax, [rbp+var_8]
mov dword ptr [rax+480h], 0FFFFFFFFh
jmp short $+2
loc_7462C:
add rsp, 10h
pop rbp
retn
|
long long ma_end_block_record(long long a1)
{
long long result; // rax
my_free(*(_QWORD *)(a1 + 200));
delete_dynamic(a1 + 704);
my_free(*(_QWORD *)(a1 + 144));
my_free(*(_QWORD *)(a1 + 936));
result = a1;
*(_DWORD *)(a1 + 1152) = -1;
return result;
}
|
_ma_end_block_record:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0xc8]
CALL 0x001f3bb0
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x2c0
CALL 0x001dadd0
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x90]
CALL 0x001f3bb0
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x3a8]
CALL 0x001f3bb0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x480],0xffffffff
JMP 0x0017462c
LAB_0017462c:
ADD RSP,0x10
POP RBP
RET
|
void _ma_end_block_record(long param_1)
{
my_free(*(int8 *)(param_1 + 200));
delete_dynamic(param_1 + 0x2c0);
my_free(*(int8 *)(param_1 + 0x90));
my_free(*(int8 *)(param_1 + 0x3a8));
*(int4 *)(param_1 + 0x480) = 0xffffffff;
return;
}
|
|
63,383 |
minja::Expression::evaluate(std::shared_ptr<minja::Context> const&) const
|
monkey531[P]llama/common/minja.hpp
|
Value evaluate(const std::shared_ptr<Context> & context) const {
try {
return do_evaluate(context);
} catch (const std::exception & e) {
std::ostringstream out;
out << e.what();
if (location.source) out << error_location_suffix(*location.source, location.pos);
throw std::runtime_error(out.str());
}
}
|
O2
|
cpp
|
minja::Expression::evaluate(std::shared_ptr<minja::Context> const&) const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
callq *(%rax)
movq %rbx, %rax
addq $0x1a0, %rsp # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x6785d
movq %rbx, %rdi
callq 0x24390
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x24be0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x248e0
movq 0x8(%r14), %rsi
testq %rsi, %rsi
jne 0x677eb
pushq $0x10
popq %rdi
callq 0x24470
movq %rax, %r14
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x24e00
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x24e80
xorl %ebp, %ebp
movq 0x9c814(%rip), %rsi # 0x103ff0
movq 0x9c775(%rip), %rdx # 0x103f58
movq %r14, %rdi
callq 0x24f50
movq 0x18(%r14), %rdx
leaq 0x8(%rsp), %rdi
callq 0x5c896
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x24810
leaq 0x8(%rsp), %rdi
callq 0x25258
jmp 0x677a9
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x25258
jmp 0x67849
jmp 0x67846
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x25258
testb %bpl, %bpl
jne 0x6783c
jmp 0x67849
movq %rax, %rbx
movq %r14, %rdi
callq 0x246b0
jmp 0x67849
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x241f0
jmp 0x67858
movq %rax, %rbx
callq 0x24ea0
movq %rbx, %rdi
callq 0x24fe0
movq %rax, %rdi
callq 0x2aa7f
nop
|
_ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE:
push rbp
push r14
push rbx
sub rsp, 1A0h
mov r14, rsi
mov rbx, rdi
mov rax, [rsi]
call qword ptr [rax]
mov rax, rbx
add rsp, 1A0h
pop rbx
pop r14
pop rbp
retn
mov rbx, rax
cmp edx, 1
jnz loc_6785D
mov rdi, rbx; void *
call ___cxa_begin_catch
mov rbx, rax
lea rdi, [rsp+arg_20]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax+10h]
lea rdi, [rsp+arg_20]
mov rsi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rsi, [r14+8]
test rsi, rsi
jnz short loc_677EB
loc_677A9:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, [rsp+arg_28]
lea rdi, [rsp+arg_0]
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
mov bpl, 1
lea rsi, [rsp+arg_0]
mov rdi, r14
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
loc_677EB:
mov rdx, [r14+18h]
lea rdi, [rsp+arg_0]
call _ZN5minjaL21error_location_suffixERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEm; minja::error_location_suffix(std::string const&,ulong)
lea rdi, [rsp+arg_20]
lea rsi, [rsp+arg_0]
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
lea rdi, [rsp+arg_0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_677A9
mov rbx, rax
lea rdi, [rsp+arg_0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_67849
jmp short loc_67846
mov rbx, rax
lea rdi, [rsp+arg_0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_6783C
jmp short loc_67849
mov rbx, rax
loc_6783C:
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_67849
loc_67846:
mov rbx, rax
loc_67849:
lea rdi, [rsp+arg_20]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev; std::ostringstream::~ostringstream()
jmp short loc_67858
mov rbx, rax
loc_67858:
call ___cxa_end_catch
loc_6785D:
mov rdi, rbx
call __Unwind_Resume
mov rdi, rax
call __clang_call_terminate
|
long long minja::Expression::evaluate(long long a1, void (***a2)(void))
{
(**a2)();
return a1;
}
|
evaluate:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x1a0
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RSI]
LAB_00167758:
CALL qword ptr [RAX]
LAB_0016775a:
MOV RAX,RBX
ADD RSP,0x1a0
POP RBX
POP R14
POP RBP
RET
|
/* minja::Expression::evaluate(std::shared_ptr<minja::Context> const&) const */
Expression * __thiscall minja::Expression::evaluate(Expression *this,shared_ptr *param_1)
{
/* try { // try from 00167758 to 00167759 has its CatchHandler @ 00167769 */
(*(code *)**(int8 **)param_1)();
return this;
}
|
|
63,384 |
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[](unsigned long) const
|
monkey531[P]llama/common/json.hpp
|
const_reference operator[](size_type idx) const
{
// const operator[] only works for arrays
if (JSON_HEDLEY_LIKELY(is_array()))
{
return m_data.m_value.array->operator[](idx);
}
JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this));
}
|
O0
|
cpp
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[](unsigned long) const:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xb7ac0
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x163717
jmp 0x16372f
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x48(%rsp), %rsi
callq 0x1631f0
addq $0x58, %rsp
retq
movb $0x1, 0x13(%rsp)
movl $0x20, %edi
callq 0x5a710
movq 0x8(%rsp), %rdi
movq %rax, (%rsp)
callq 0xbe8b0
movq %rax, 0x20(%rsp)
leaq 0xb5e47(%rip), %rsi # 0x21959f
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x1637f0
jmp 0x163769
movq 0x8(%rsp), %rcx
movq (%rsp), %rdi
movl $0x131, %esi # imm = 0x131
leaq 0x28(%rsp), %rdx
callq 0x11a310
jmp 0x163783
movq (%rsp), %rdi
movb $0x0, 0x13(%rsp)
leaq 0x1445e5(%rip), %rsi # 0x2a7d78
leaq -0xa4e3a(%rip), %rdx # 0xbe960
callq 0x5abb0
jmp 0x1637e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x1637c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x5b6f8
testb $0x1, 0x13(%rsp)
jne 0x1637d2
jmp 0x1637db
movq (%rsp), %rdi
callq 0x5b0e0
jmp 0x1637dd
movq 0x18(%rsp), %rdi
callq 0x5ac70
nopw (%rax,%rax)
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixEm:
sub rsp, 58h
mov [rsp+58h+var_8], rdi; char
mov qword ptr [rsp+58h+var_10], rsi; int
mov rdi, [rsp+58h+var_8]
mov [rsp+58h+var_50], rdi; int
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8is_arrayEv; 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>::is_array(void)
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_163717
jmp short loc_16372F
loc_163717:
mov rax, [rsp+58h+var_50]
mov rdi, [rax+8]
mov rsi, qword ptr [rsp+58h+var_10]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EEixEm; 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>>::operator[](ulong)
add rsp, 58h
retn
loc_16372F:
mov [rsp+58h+var_45], 1
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rdi, [rsp+58h+var_50]
mov [rsp+58h+var_58], rax; int
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
mov qword ptr [rsp+58h+var_38], rax; int
lea rsi, aCannotUseOpera; "cannot use operator[] with a numeric ar"...
lea rdi, [rsp+58h+var_30]; int
lea rdx, [rsp+58h+var_38]; int
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA52_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[52],char const*>(char const(&)[52],char const* &&)
jmp short $+2
loc_163769:
mov rcx, [rsp+58h+var_50]
mov rdi, [rsp+58h+var_58]; int
mov esi, 131h
lea rdx, [rsp+58h+var_30]
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
jmp short $+2
loc_163783:
mov rdi, [rsp+58h+var_58]; void *
mov [rsp+58h+var_45], 0
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail10type_errorD2Ev; void (*)(void *)
call ___cxa_throw
|
long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator[](
_QWORD **a1,
long long a2)
{
int v3; // ecx
int v4; // r8d
int v5; // r9d
int exception; // [rsp+0h] [rbp-58h]
nlohmann::json_abi_v3_11_3::detail::type_error *v7; // [rsp+0h] [rbp-58h]
void *v8; // [rsp+8h] [rbp-50h]
int v9; // [rsp+10h] [rbp-48h]
long long v10; // [rsp+18h] [rbp-40h]
int v11[2]; // [rsp+20h] [rbp-38h] BYREF
int v12[8]; // [rsp+28h] [rbp-30h] BYREF
int v13[2]; // [rsp+48h] [rbp-10h]
void *v14; // [rsp+50h] [rbp-8h]
v14 = a1;
*(_QWORD *)v13 = a2;
if ( !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>::is_array(a1) )
{
HIBYTE(v9) = 1;
exception = (unsigned int)__cxa_allocate_exception(0x20uLL);
*(_QWORD *)v11 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name(a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[52],char const*>(
(int)v12,
(int)"cannot use operator[] with a numeric argument with ",
(int)v11,
v3,
v4,
v5,
exception,
a1,
v9,
v10);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
v7,
305,
(long long)v12,
(long long)v8);
__cxa_throw(
v7,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::type_error::~type_error);
}
return 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>>::operator[](
a1[1],
*(long long *)v13);
}
| |||
63,385 |
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[](unsigned long) const
|
monkey531[P]llama/common/json.hpp
|
const_reference operator[](size_type idx) const
{
// const operator[] only works for arrays
if (JSON_HEDLEY_LIKELY(is_array()))
{
return m_data.m_value.array->operator[](idx);
}
JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this));
}
|
O2
|
cpp
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[](unsigned long) const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
cmpb $0x2, (%rdi)
jne 0x7b6a9
movq 0x8(%r14), %rax
shlq $0x4, %rsi
addq (%rax), %rsi
movq %rsi, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x234b0
movq %rax, %rbx
movq %r14, %rdi
callq 0x469c8
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x3d4c9(%rip), %rsi # 0xb8b94
leaq 0x10(%rsp), %rdi
callq 0x7b72c
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x131, %esi # imm = 0x131
movq %r14, %rcx
callq 0x664d0
xorl %ebp, %ebp
leaq 0x84842(%rip), %rsi # 0xfff38
leaq -0x381a5(%rip), %rdx # 0x43558
movq %rbx, %rdi
callq 0x24050
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x24348
testb %bpl, %bpl
jne 0x7b71c
jmp 0x7b724
movq %rax, %r14
movq %rbx, %rdi
callq 0x236f0
movq %r14, %rdi
callq 0x240e0
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixEm:
push rbp; char
push r14; int
push rbx; int
sub rsp, 30h
mov r14, rdi
cmp byte ptr [rdi], 2
jnz short loc_7B6A9
mov rax, [r14+8]
shl rsi, 4
add rsi, [rax]
mov rax, rsi
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_7B6A9:
push 20h ; ' '
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aCannotUseOpera; "cannot use operator[] with a numeric ar"...
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA52_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[52],char const*>(char const(&)[52],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 131h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rdi, [rsp+48h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_7B71C
jmp short loc_7B724
mov r14, rax
loc_7B71C:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_7B724:
mov rdi, r14
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator[](
long long a1,
long long a2)
{
nlohmann::json_abi_v3_11_3::detail::type_error *exception; // rbx
_BYTE v4[56]; // [rsp+10h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 != 2 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::type_error *)__cxa_allocate_exception(0x20uLL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[52],char const*>(
v4,
"cannot use operator[] with a numeric argument with ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
exception,
305,
(long long)v4);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return **(_QWORD **)(a1 + 8) + 16 * a2;
}
|
operator[]:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RDI
CMP byte ptr [RDI],0x2
JNZ 0x0017b6a9
MOV RAX,qword ptr [R14 + 0x8]
SHL RSI,0x4
ADD RSI,qword ptr [RAX]
MOV RAX,RSI
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_0017b6a9:
PUSH 0x20
POP RDI
CALL 0x001234b0
MOV RBX,RAX
MOV RDI,R14
CALL 0x001469c8
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_0017b6c4:
LEA RSI,[0x1b8b94]
LEA RDI,[RSP + 0x10]
CALL 0x0017b72c
MOV BPL,0x1
LAB_0017b6d8:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x131
MOV RCX,R14
CALL 0x001664d0
XOR EBP,EBP
LEA RSI,[0x1fff38]
LEA RDX,[0x143558]
MOV RDI,RBX
CALL 0x00124050
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::operator[](unsigned long) const */
long __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator[](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,ulong param_1)
{
int8 uVar1;
char *local_40;
detail local_38 [32];
if (*this == (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>
)0x2) {
return param_1 * 0x10 + **(long **)(this + 8);
}
uVar1 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name(this);
/* try { // try from 0017b6c4 to 0017b6d4 has its CatchHandler @ 0017b719 */
detail::concat<std::__cxx11::string,char_const(&)[52],char_const*>
(local_38,"cannot use operator[] with a numeric argument with ",&local_40);
/* try { // try from 0017b6d8 to 0017b704 has its CatchHandler @ 0017b705 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar1,0x131,local_38,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::type_error::typeinfo,detail::exception::~exception);
}
|
|
63,386 |
testing::internal::BoolFromGTestEnv(char const*, bool)
|
seiftnesse[P]memoryallocator/build_O3/_deps/googletest-src/googletest/src/gtest-port.cc
|
bool BoolFromGTestEnv(const char* flag, bool default_value) {
#if defined(GTEST_GET_BOOL_FROM_ENV_)
return GTEST_GET_BOOL_FROM_ENV_(flag, default_value);
#else
const std::string env_var = FlagToEnvVar(flag);
const char* const string_value = posix::GetEnv(env_var.c_str());
return string_value == nullptr ? default_value
: strcmp(string_value, "0") != 0;
#endif // defined(GTEST_GET_BOOL_FROM_ENV_)
}
|
O3
|
cpp
|
testing::internal::BoolFromGTestEnv(char const*, bool):
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1b564
movq (%r14), %r14
movq %r14, %rdi
callq 0x9660
testq %rax, %rax
je 0x12007
movb $0x1, %bl
cmpb $0x30, (%rax)
jne 0x12007
cmpb $0x0, 0x1(%rax)
setne %bl
leaq 0x18(%rsp), %rax
cmpq %rax, %r14
je 0x12021
movq 0x18(%rsp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x94c0
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
|
_ZN7testing8internal16BoolFromGTestEnvEPKcb:
push r14
push rbx
sub rsp, 28h
mov ebx, esi
mov rsi, rdi
lea r14, [rsp+38h+var_30]
mov rdi, r14
call _ZN7testing8internalL12FlagToEnvVarB5cxx11EPKc; testing::internal::FlagToEnvVar(char const*)
mov r14, [r14]
mov rdi, r14
call _getenv
test rax, rax
jz short loc_12007
mov bl, 1
cmp byte ptr [rax], 30h ; '0'
jnz short loc_12007
cmp byte ptr [rax+1], 0
setnz bl
loc_12007:
lea rax, [rsp+38h+var_20]
cmp r14, rax
jz short loc_12021
mov rsi, [rsp+38h+var_20]
inc rsi; unsigned __int64
mov rdi, r14; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_12021:
mov eax, ebx
add rsp, 28h
pop rbx
pop r14
retn
|
long long testing::internal::BoolFromGTestEnv(
testing::internal *this,
const char *a2,
int a3,
int a4,
int a5,
int a6)
{
unsigned int v6; // ebx
long long *v7; // r14
_BYTE *v8; // rax
long long *v10; // [rsp+8h] [rbp-30h] BYREF
long long v11; // [rsp+18h] [rbp-20h] BYREF
v6 = (unsigned int)a2;
testing::internal::FlagToEnvVar[abi:cxx11]((unsigned int)&v10, (_DWORD)this, a3, a4, a5, a6);
v7 = v10;
v8 = (_BYTE *)getenv(v10);
if ( v8 )
{
LOBYTE(v6) = 1;
if ( *v8 == 48 )
LOBYTE(v6) = v8[1] != 0;
}
if ( v7 != &v11 )
operator delete(v7, v11 + 1);
return v6;
}
|
BoolFromGTestEnv:
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV EBX,ESI
MOV RSI,RDI
LEA R14,[RSP + 0x8]
MOV RDI,R14
CALL 0x0011b564
MOV R14,qword ptr [R14]
MOV RDI,R14
CALL 0x00109660
TEST RAX,RAX
JZ 0x00112007
MOV BL,0x1
CMP byte ptr [RAX],0x30
JNZ 0x00112007
CMP byte ptr [RAX + 0x1],0x0
SETNZ BL
LAB_00112007:
LEA RAX,[RSP + 0x18]
CMP R14,RAX
JZ 0x00112021
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
MOV RDI,R14
CALL 0x001094c0
LAB_00112021:
MOV EAX,EBX
ADD RSP,0x28
POP RBX
POP R14
RET
|
/* testing::internal::BoolFromGTestEnv(char const*, bool) */
ulong testing::internal::BoolFromGTestEnv(char *param_1,bool param_2)
{
char *pcVar1;
ulong uVar2;
int7 in_register_00000031;
long *local_30 [2];
long local_20 [2];
int7 uVar3;
uVar2 = CONCAT71(in_register_00000031,param_2) & 0xffffffff;
FlagToEnvVar_abi_cxx11_((internal *)local_30,param_1);
pcVar1 = getenv((char *)local_30[0]);
if (pcVar1 != (char *)0x0) {
uVar3 = (int7)(uVar2 >> 8);
uVar2 = CONCAT71(uVar3,1);
if (*pcVar1 == '0') {
uVar2 = CONCAT71(uVar3,pcVar1[1] != '\0');
}
}
if (local_30[0] != local_20) {
operator_delete(local_30[0],local_20[0] + 1);
}
return uVar2;
}
|
|
63,387 |
Cache::getId(unsigned int)
|
DanielDanyang[P]CSC3050-2025-Spring-Project-4/src/Cache.cpp
|
uint32_t Cache::getId(uint32_t addr) {
uint32_t offsetBits = log2i(policy.blockSize);
uint32_t idBits = log2i(policy.blockNum / policy.associativity);
uint32_t mask = (1 << idBits) - 1;
return (addr >> offsetBits) & mask;
}
|
O1
|
cpp
|
Cache::getId(unsigned int):
movl 0x3c(%rdi), %eax
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
movl $0xffffffff, %r8d # imm = 0xFFFFFFFF
testl %eax, %eax
je 0x397a
xorl %r8d, %r8d
cmpl $0x1, %eax
je 0x397a
cmpl $0x2, %eax
jb 0x397a
xorl %r8d, %r8d
movl %eax, %edx
shrl %edx
incl %r8d
cmpl $0x3, %eax
movl %edx, %eax
ja 0x396e
movl 0x40(%rdi), %eax
xorl %edx, %edx
divl 0x44(%rdi)
testl %eax, %eax
je 0x39a1
xorl %ecx, %ecx
cmpl $0x1, %eax
je 0x39a1
cmpl $0x2, %eax
jb 0x39a1
xorl %ecx, %ecx
movl %eax, %edx
shrl %edx
incl %ecx
cmpl $0x3, %eax
movl %edx, %eax
ja 0x3996
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
shll %cl, %eax
movl %r8d, %ecx
shrl %cl, %esi
notl %eax
andl %eax, %esi
movl %esi, %eax
retq
|
_ZN5Cache5getIdEj:
mov eax, [rdi+3Ch]
mov ecx, 0FFFFFFFFh
mov r8d, 0FFFFFFFFh
test eax, eax
jz short loc_397A
xor r8d, r8d
cmp eax, 1
jz short loc_397A
cmp eax, 2
jb short loc_397A
xor r8d, r8d
mov edx, eax
loc_396E:
shr edx, 1
inc r8d
cmp eax, 3
mov eax, edx
ja short loc_396E
loc_397A:
mov eax, [rdi+40h]
xor edx, edx
div dword ptr [rdi+44h]
test eax, eax
jz short loc_39A1
xor ecx, ecx
cmp eax, 1
jz short loc_39A1
cmp eax, 2
jb short loc_39A1
xor ecx, ecx
mov edx, eax
loc_3996:
shr edx, 1
inc ecx
cmp eax, 3
mov eax, edx
ja short loc_3996
loc_39A1:
mov eax, 0FFFFFFFFh
shl eax, cl
mov ecx, r8d
shr esi, cl
not eax
and esi, eax
mov eax, esi
retn
|
long long Cache::getId(Cache *this, unsigned int a2)
{
unsigned int v2; // eax
char v3; // cl
char v4; // r8
unsigned int v5; // edx
bool v6; // cc
unsigned int v7; // eax
unsigned int v8; // edx
v2 = *((_DWORD *)this + 15);
v3 = -1;
v4 = -1;
if ( v2 )
{
v4 = 0;
if ( v2 != 1 )
{
v4 = 0;
v5 = *((_DWORD *)this + 15);
do
{
v5 >>= 1;
++v4;
v6 = v2 <= 3;
v2 = v5;
}
while ( !v6 );
}
}
v7 = *((_DWORD *)this + 16) / *((_DWORD *)this + 17);
if ( v7 )
{
v3 = 0;
if ( v7 != 1 )
{
v3 = 0;
v8 = *((_DWORD *)this + 16) / *((_DWORD *)this + 17);
do
{
v8 >>= 1;
++v3;
v6 = v7 <= 3;
v7 = v8;
}
while ( !v6 );
}
}
return ~(-1 << v3) & (a2 >> v4);
}
|
getId:
MOV EAX,dword ptr [RDI + 0x3c]
MOV ECX,0xffffffff
MOV R8D,0xffffffff
TEST EAX,EAX
JZ 0x0010397a
XOR R8D,R8D
CMP EAX,0x1
JZ 0x0010397a
CMP EAX,0x2
JC 0x0010397a
XOR R8D,R8D
MOV EDX,EAX
LAB_0010396e:
SHR EDX,0x1
INC R8D
CMP EAX,0x3
MOV EAX,EDX
JA 0x0010396e
LAB_0010397a:
MOV EAX,dword ptr [RDI + 0x40]
XOR EDX,EDX
DIV dword ptr [RDI + 0x44]
TEST EAX,EAX
JZ 0x001039a1
XOR ECX,ECX
CMP EAX,0x1
JZ 0x001039a1
CMP EAX,0x2
JC 0x001039a1
XOR ECX,ECX
MOV EDX,EAX
LAB_00103996:
SHR EDX,0x1
INC ECX
CMP EAX,0x3
MOV EAX,EDX
JA 0x00103996
LAB_001039a1:
MOV EAX,0xffffffff
SHL EAX,CL
MOV ECX,R8D
SHR ESI,CL
NOT EAX
AND ESI,EAX
MOV EAX,ESI
RET
|
/* Cache::getId(unsigned int) */
uint __thiscall Cache::getId(Cache *this,uint param_1)
{
bool bVar1;
uint uVar2;
byte bVar3;
ulong uVar4;
byte bVar5;
uVar2 = *(uint *)(this + 0x3c);
bVar5 = 0xff;
if (uVar2 != 0) {
bVar5 = 0;
if ((uVar2 != 1) && (bVar5 = 0, 1 < uVar2)) {
bVar5 = 0;
do {
bVar5 = bVar5 + 1;
bVar1 = 3 < uVar2;
uVar2 = uVar2 >> 1;
} while (bVar1);
}
}
uVar2 = (uint)((ulong)*(uint *)(this + 0x40) / (ulong)*(uint *)(this + 0x44));
bVar3 = 0xff;
if (uVar2 != 0) {
bVar3 = 0;
if ((uVar2 != 1) && (bVar3 = 0, 1 < uVar2)) {
bVar3 = 0;
uVar4 = (ulong)*(uint *)(this + 0x40) / (ulong)*(uint *)(this + 0x44);
do {
bVar3 = bVar3 + 1;
uVar2 = (uint)uVar4;
uVar4 = uVar4 >> 1;
} while (3 < uVar2);
}
}
return param_1 >> (bVar5 & 0x1f) & ~(-1 << (bVar3 & 0x1f));
}
|
|
63,388 |
gguf_get_val_str
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp
|
const char * gguf_get_val_str(const struct gguf_context * ctx, int64_t key_id) {
GGML_ASSERT(key_id >= 0 && key_id < gguf_get_n_kv(ctx));
GGML_ASSERT(ctx->kv[key_id].get_ne() == 1);
return ctx->kv[key_id].get_val<std::string>().c_str();
}
|
O2
|
cpp
|
gguf_get_val_str:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
js 0x4162f
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rax
subq 0x8(%rdi), %rax
pushq $0x58
popq %rcx
cqto
idivq %rcx
cmpq %rsi, %rax
jle 0x4162f
addq $0x8, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e480
movq %rax, %rdi
callq 0x1d8f0
cmpq $0x1, %rax
jne 0x4164b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e480
movq %rax, %rdi
xorl %esi, %esi
callq 0x1ec10
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1dc17(%rip), %rdi # 0x5f24d
leaq 0xcf98(%rip), %rdx # 0x4e5d5
leaq 0x1e07f(%rip), %rcx # 0x5f6c3
movl $0x361, %esi # imm = 0x361
jmp 0x41665
leaq 0x1dbfb(%rip), %rdi # 0x5f24d
leaq 0xcf7c(%rip), %rdx # 0x4e5d5
leaq 0x1e132(%rip), %rcx # 0x5f792
movl $0x362, %esi # imm = 0x362
xorl %eax, %eax
callq 0x1f9b0
|
gguf_get_val_str:
push r14
push rbx
push rax
test rsi, rsi
js short loc_4162F
mov rbx, rsi
mov r14, rdi
mov rax, [rdi+10h]
sub rax, [rdi+8]
push 58h ; 'X'
pop rcx
cqo
idiv rcx
cmp rax, rsi
jle short loc_4162F
add r14, 8
mov rdi, r14
mov rsi, rbx
call __ZNKSt6vectorI7gguf_kvSaIS0_EEixEm; std::vector<gguf_kv>::operator[](ulong)
mov rdi, rax; this
call __ZNK7gguf_kv6get_neEv; gguf_kv::get_ne(void)
cmp rax, 1
jnz short loc_4164B
mov rdi, r14
mov rsi, rbx
call __ZNKSt6vectorI7gguf_kvSaIS0_EEixEm; std::vector<gguf_kv>::operator[](ulong)
mov rdi, rax
xor esi, esi
call __ZNK7gguf_kv7get_valINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEERKT_m; gguf_kv::get_val<std::string>(ulong)
mov rax, [rax]
add rsp, 8
pop rbx
pop r14
retn
loc_4162F:
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, 361h
jmp short loc_41665
loc_4164B:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCtxKvKeyIdGetN; "ctx->kv[key_id].get_ne() == 1"
mov esi, 362h
loc_41665:
xor eax, eax
call _ggml_abort
|
long long gguf_get_val_str(
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
gguf_kv *v15; // rax
long long v16; // rdx
long long v17; // rax
const char *v19; // rcx
int v20; // esi
char v21; // [rsp-8h] [rbp-18h]
v21 = v14;
if ( a2 < 0 || (*(_QWORD *)(a1 + 16) - *(_QWORD *)(a1 + 8)) / 88LL <= a2 )
{
v19 = "key_id >= 0 && key_id < gguf_get_n_kv(ctx)";
v20 = 865;
goto LABEL_7;
}
v15 = (gguf_kv *)std::vector<gguf_kv>::operator[](a1 + 8, a2, (*(_QWORD *)(a1 + 16) - *(_QWORD *)(a1 + 8)) % 88LL);
if ( gguf_kv::get_ne(v15) != 1 )
{
v19 = "ctx->kv[key_id].get_ne() == 1";
v20 = 866;
LABEL_7:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp",
v20,
(long long)"GGML_ASSERT(%s) failed",
(long long)v19,
a13,
a14,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
v21);
}
v17 = std::vector<gguf_kv>::operator[](a1 + 8, a2, v16);
return *(_QWORD *)gguf_kv::get_val<std::string>(v17, 0LL);
}
|
gguf_get_val_str:
PUSH R14
PUSH RBX
PUSH RAX
TEST RSI,RSI
JS 0x0014162f
MOV RBX,RSI
MOV R14,RDI
MOV RAX,qword ptr [RDI + 0x10]
SUB RAX,qword ptr [RDI + 0x8]
PUSH 0x58
POP RCX
CQO
IDIV RCX
CMP RAX,RSI
JLE 0x0014162f
ADD R14,0x8
MOV RDI,R14
MOV RSI,RBX
CALL 0x0011e480
MOV RDI,RAX
CALL 0x0011d8f0
CMP RAX,0x1
JNZ 0x0014164b
MOV RDI,R14
MOV RSI,RBX
CALL 0x0011e480
MOV RDI,RAX
XOR ESI,ESI
CALL 0x0011ec10
MOV RAX,qword ptr [RAX]
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_0014162f:
LEA RDI,[0x15f24d]
LEA RDX,[0x14e5d5]
LEA RCX,[0x15f6c3]
MOV ESI,0x361
JMP 0x00141665
LAB_0014164b:
LEA RDI,[0x15f24d]
LEA RDX,[0x14e5d5]
LEA RCX,[0x15f792]
MOV ESI,0x362
LAB_00141665:
XOR EAX,EAX
CALL 0x0011f9b0
|
int8 gguf_get_val_str(long param_1,ulong param_2)
{
gguf_kv *pgVar1;
long lVar2;
string *psVar3;
char *pcVar4;
int8 uVar5;
if (((long)param_2 < 0) ||
((*(long *)(param_1 + 0x10) - *(long *)(param_1 + 8)) / 0x58 <= (long)param_2)) {
pcVar4 = "key_id >= 0 && key_id < gguf_get_n_kv(ctx)";
uVar5 = 0x361;
}
else {
pgVar1 = (gguf_kv *)
std::vector<gguf_kv,std::allocator<gguf_kv>>::operator[]
((vector<gguf_kv,std::allocator<gguf_kv>> *)(param_1 + 8),param_2);
lVar2 = gguf_kv::get_ne(pgVar1);
if (lVar2 == 1) {
pgVar1 = (gguf_kv *)
std::vector<gguf_kv,std::allocator<gguf_kv>>::operator[]
((vector<gguf_kv,std::allocator<gguf_kv>> *)(param_1 + 8),param_2);
psVar3 = gguf_kv::get_val<std::__cxx11::string>(pgVar1,0);
return *(int8 *)psVar3;
}
pcVar4 = "ctx->kv[key_id].get_ne() == 1";
uVar5 = 0x362;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp",
uVar5,"GGML_ASSERT(%s) failed",pcVar4);
}
|
|
63,389 |
gguf_get_val_str
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp
|
const char * gguf_get_val_str(const struct gguf_context * ctx, int64_t key_id) {
GGML_ASSERT(key_id >= 0 && key_id < gguf_get_n_kv(ctx));
GGML_ASSERT(ctx->kv[key_id].get_ne() == 1);
return ctx->kv[key_id].get_val<std::string>().c_str();
}
|
O3
|
cpp
|
gguf_get_val_str:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
js 0x3eb77
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq 0x10(%r14), %rax
subq %rdi, %rax
sarq $0x3, %rax
movabsq $0x2e8ba2e8ba2e8ba3, %r15 # imm = 0x2E8BA2E8BA2E8BA3
imulq %r15, %rax
cmpq %rsi, %rax
jle 0x3eb77
imulq $0x58, %rbx, %r12
addq %r12, %rdi
callq 0x16610
cmpq $0x1, %rax
jne 0x3eb93
movq 0x8(%r14), %rdi
movq 0x10(%r14), %rax
subq %rdi, %rax
sarq $0x3, %rax
imulq %r15, %rax
cmpq %rbx, %rax
jbe 0x3eb72
addq %r12, %rdi
xorl %esi, %esi
callq 0x17380
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x18b08
leaq 0x1e95f(%rip), %rdi # 0x5d4dd
leaq 0xdae0(%rip), %rdx # 0x4c665
leaq 0x1edc7(%rip), %rcx # 0x5d953
movl $0x361, %esi # imm = 0x361
jmp 0x3ebad
leaq 0x1e943(%rip), %rdi # 0x5d4dd
leaq 0xdac4(%rip), %rdx # 0x4c665
leaq 0x1ee7a(%rip), %rcx # 0x5da22
movl $0x362, %esi # imm = 0x362
xorl %eax, %eax
callq 0x17cd0
|
gguf_get_val_str:
push r15
push r14
push r12
push rbx
push rax
test rsi, rsi
js short loc_3EB77
mov rbx, rsi
mov r14, rdi
mov rdi, [rdi+8]
mov rax, [r14+10h]
sub rax, rdi
sar rax, 3
mov r15, 2E8BA2E8BA2E8BA3h
imul rax, r15
cmp rax, rsi
jle short loc_3EB77
imul r12, rbx, 58h ; 'X'
add rdi, r12; this
call __ZNK7gguf_kv6get_neEv; gguf_kv::get_ne(void)
cmp rax, 1
jnz short loc_3EB93
mov rdi, [r14+8]
mov rax, [r14+10h]
sub rax, rdi
sar rax, 3
imul rax, r15
cmp rax, rbx
jbe short loc_3EB72
add rdi, r12
xor esi, esi
call __ZNK7gguf_kv7get_valINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEERKT_m; gguf_kv::get_val<std::string>(ulong)
mov rax, [rax]
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
loc_3EB72:
call gguf_get_val_str_cold_1
loc_3EB77:
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, 361h
jmp short loc_3EBAD
loc_3EB93:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCtxKvKeyIdGetN; "ctx->kv[key_id].get_ne() == 1"
mov esi, 362h
loc_3EBAD:
xor eax, eax
call _ggml_abort
|
long long gguf_get_val_str(long long a1, long long a2, long long a3, long long a4, int a5, int a6)
{
long long v7; // rdi
long long v8; // rdi
const char *v10; // rcx
int v11; // esi
if ( a2 < 0 || (v7 = *(_QWORD *)(a1 + 8), 0x2E8BA2E8BA2E8BA3LL * ((*(_QWORD *)(a1 + 16) - v7) >> 3) <= a2) )
{
v10 = "key_id >= 0 && key_id < gguf_get_n_kv(ctx)";
v11 = 865;
goto LABEL_9;
}
if ( gguf_kv::get_ne((gguf_kv *)(88 * a2 + v7)) != 1 )
{
v10 = "ctx->kv[key_id].get_ne() == 1";
v11 = 866;
LABEL_9:
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp",
v11,
(unsigned int)"GGML_ASSERT(%s) failed",
(_DWORD)v10,
a5,
a6);
}
v8 = *(_QWORD *)(a1 + 8);
if ( 0x2E8BA2E8BA2E8BA3LL * ((*(_QWORD *)(a1 + 16) - v8) >> 3) <= (unsigned long long)a2 )
gguf_get_val_str_cold_1(v8);
return *(_QWORD *)gguf_kv::get_val<std::string>(88 * a2 + v8, 0LL);
}
|
gguf_get_val_str:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
TEST RSI,RSI
JS 0x0013eb77
MOV RBX,RSI
MOV R14,RDI
MOV RDI,qword ptr [RDI + 0x8]
MOV RAX,qword ptr [R14 + 0x10]
SUB RAX,RDI
SAR RAX,0x3
MOV R15,0x2e8ba2e8ba2e8ba3
IMUL RAX,R15
CMP RAX,RSI
JLE 0x0013eb77
IMUL R12,RBX,0x58
ADD RDI,R12
CALL 0x00116610
CMP RAX,0x1
JNZ 0x0013eb93
MOV RDI,qword ptr [R14 + 0x8]
MOV RAX,qword ptr [R14 + 0x10]
SUB RAX,RDI
SAR RAX,0x3
IMUL RAX,R15
CMP RAX,RBX
JBE 0x0013eb72
ADD RDI,R12
XOR ESI,ESI
CALL 0x00117380
MOV RAX,qword ptr [RAX]
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
LAB_0013eb72:
CALL 0x00118b08
LAB_0013eb77:
LEA RDI,[0x15d4dd]
LEA RDX,[0x14c665]
LEA RCX,[0x15d953]
MOV ESI,0x361
JMP 0x0013ebad
LAB_0013eb93:
LEA RDI,[0x15d4dd]
LEA RDX,[0x14c665]
LEA RCX,[0x15da22]
MOV ESI,0x362
LAB_0013ebad:
XOR EAX,EAX
CALL 0x00117cd0
|
int8 gguf_get_val_str(long param_1,ulong param_2)
{
long lVar1;
ulong uVar2;
string *psVar3;
char *pcVar4;
int8 uVar5;
if ((-1 < (long)param_2) &&
(lVar1 = (*(long *)(param_1 + 0x10) - *(long *)(param_1 + 8) >> 3) * 0x2e8ba2e8ba2e8ba3,
lVar1 - param_2 != 0 && (long)param_2 <= lVar1)) {
lVar1 = gguf_kv::get_ne((gguf_kv *)(*(long *)(param_1 + 8) + param_2 * 0x58));
if (lVar1 != 1) {
pcVar4 = "ctx->kv[key_id].get_ne() == 1";
uVar5 = 0x362;
goto LAB_0013ebad;
}
uVar2 = (*(long *)(param_1 + 0x10) - *(long *)(param_1 + 8) >> 3) * 0x2e8ba2e8ba2e8ba3;
if (param_2 <= uVar2 && uVar2 - param_2 != 0) {
psVar3 = gguf_kv::get_val<std::__cxx11::string>
((gguf_kv *)(*(long *)(param_1 + 8) + param_2 * 0x58),0);
return *(int8 *)psVar3;
}
gguf_get_val_str_cold_1();
}
pcVar4 = "key_id >= 0 && key_id < gguf_get_n_kv(ctx)";
uVar5 = 0x361;
LAB_0013ebad:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp",
uVar5,"GGML_ASSERT(%s) failed",pcVar4);
}
|
|
63,390 |
ModbusTcpServer::process()
|
serhmarch[P]ModbusBridge/modbus/src/ModbusTcpServer.cpp
|
StatusCode ModbusTcpServer::process()
{
ModbusTcpServerPrivate *d = d_ModbusTcpServer(d_ptr);
StatusCode r;
bool fRepeatAgain;
do
{
fRepeatAgain = false;
switch (d->state)
{
case STATE_CLOSED:
if (d->cmdClose)
break;
d->state = STATE_BEGIN_OPEN;
// no need break
case STATE_BEGIN_OPEN:
d->timestampRefresh();
d->state = STATE_WAIT_FOR_OPEN;
// no need break
case STATE_WAIT_FOR_OPEN:
if (d->cmdClose)
{
d->state = STATE_WAIT_FOR_CLOSE;
fRepeatAgain = true;
break;
}
r = open();
if (StatusIsProcessing(r))
return r;
if (StatusIsBad(r)) // an error occured
{
signalError(d->getName(), r, d->lastErrorText());
d->state = STATE_TIMEOUT;
return r;
}
d->state = STATE_OPENED;
signalOpened(d->getName());
fRepeatAgain = true;
break;
case STATE_WAIT_FOR_CLOSE:
r = close();
if (StatusIsProcessing(r))
return r;
if (StatusIsBad(r)) // an error occured
{
signalError(d->getName(), r, d->lastErrorText());
}
d->state = STATE_CLOSED;
signalClosed(d->getName());
clearConnections();
//setMessage("Finalized");
break;
case STATE_OPENED:
////setMessage("Initialized. Waiting for connections...");
d->state = STATE_PROCESS_DEVICE;
// no need break
case STATE_PROCESS_DEVICE:
{
if (d->cmdClose)
{
d->state = STATE_WAIT_FOR_CLOSE;
fRepeatAgain = true;
break;
}
// check up new connection
if (ModbusTcpSocket *s = this->nextPendingConnection())
{
ModbusServerPort *c = createTcpPort(s);
c->connect(&ModbusServerPort::signalTx , static_cast<ModbusServerPort*>(this), &ModbusTcpServer::signalTx );
c->connect(&ModbusServerPort::signalRx , static_cast<ModbusServerPort*>(this), &ModbusTcpServer::signalRx );
c->connect(&ModbusServerPort::signalError, static_cast<ModbusServerPort*>(this), &ModbusTcpServer::signalError);
c->setBroadcastEnabled(isBroadcastEnabled());
c->setUnitMap(unitMap());
d->connections.push_back(c);
signalNewConnection(c->objectName());
}
// process current connections
for (Connections_t::iterator it = d->connections.begin(); it != d->connections.end(); )
{
ModbusServerPort *c = *it;
c->process();
if (!c->isOpen())
{
signalCloseConnection(c->objectName());
it = d->connections.erase(it);
deleteTcpPort(c);
continue;
}
++it;
}
}
break;
case STATE_TIMEOUT:
if (timer() - d->timestamp < timeout())
return Status_Processing;
d->state = STATE_CLOSED;
fRepeatAgain = true;
break;
default:
if (d->cmdClose && isOpen())
d->state = STATE_WAIT_FOR_CLOSE;
else if (isOpen())
d->state = STATE_OPENED;
else
d->state = STATE_CLOSED;
fRepeatAgain = true;
break;
}
}
while(fRepeatAgain);
return Status_Processing;
}
|
O3
|
cpp
|
ModbusTcpServer::process():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
leaq 0xa22f(%rip), %r15 # 0x19614
movl 0x68(%r14), %eax
decl %eax
cmpl $0xa, %eax
ja 0xf42e
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
movl $0x6, 0x68(%r14)
cmpb $0x1, 0x6c(%r14)
je 0xf48d
jmp 0xf4d6
callq 0xfb1c
subl 0x98(%r14), %eax
movq 0x8(%rbx), %rcx
cmpl 0xbc(%rcx), %eax
jae 0xf459
jmp 0xf4cc
cmpb $0x1, 0x6c(%r14)
jne 0xf442
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
testb %al, %al
jne 0xf48d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
testb %al, %al
je 0xf459
movl $0x3, 0x68(%r14)
jmp 0xf3e5
movl $0xb, 0x68(%r14)
jmp 0xf3e5
cmpb $0x0, 0x6c(%r14)
jne 0xf4cc
movl $0x1, 0x68(%r14)
callq 0xfb1c
movl %eax, 0x98(%r14)
movl $0x2, 0x68(%r14)
cmpb $0x1, 0x6c(%r14)
jne 0xf49a
movl $0x9, 0x68(%r14)
jmp 0xf3e5
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
movl %eax, %ebp
negl %eax
jo 0xf4cc
btl $0x18, %ebp
jb 0xf69c
movl $0x3, 0x68(%r14)
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xf028
jmp 0xf3e5
movl $0x80000000, %ebp # imm = 0x80000000
jmp 0xf700
movq %rbx, %rdi
callq 0x17a6a
testq %rax, %rax
je 0xf5fc
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x50(%rcx)
movq %rax, %r12
movl $0x20, %edi
callq 0x5300
leaq 0x12531(%rip), %r13 # 0x21a38
movq %r13, (%rax)
movq %rbx, 0x8(%rax)
leaq -0x4bd(%rip), %rsi # 0xf058
movq %rsi, 0x10(%rax)
xorl %r15d, %r15d
movq %r15, 0x18(%rax)
movq %r12, %rdi
movq %rax, %rdx
callq 0x8ade
movl $0x20, %edi
callq 0x5300
movq %r13, (%rax)
movq %rbx, 0x8(%rax)
leaq -0x4c9(%rip), %rsi # 0xf07a
movq %rsi, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %r12, %rdi
movq %rax, %rdx
callq 0x8ade
movl $0x20, %edi
callq 0x5300
leaq 0x12521(%rip), %rcx # 0x21a88
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
leaq -0x4d9(%rip), %rsi # 0xf09c
movq %rsi, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %r12, %rdi
movq %rax, %rdx
callq 0x8ade
movq %rbx, %rdi
callq 0xef80
movq (%r12), %rcx
movzbl %al, %esi
movq %r12, %rdi
callq *0x38(%rcx)
movq %rbx, %rdi
callq 0xef98
movq (%r12), %rcx
movq %r12, %rdi
movq %rax, %rsi
callq *0x40(%rcx)
leaq 0xc0(%r14), %r15
movl $0x18, %edi
callq 0x5300
movq %r12, 0x10(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x5080
incq 0xd0(%r14)
movq %r12, %rdi
callq 0x8a42
leaq 0xa06a(%rip), %rsi # 0x19652
leaq 0x123(%rip), %rdx # 0xf712
movq %rbx, %rdi
xorl %ecx, %ecx
movq %rax, %r8
callq 0xf9b0
leaq 0xc0(%r14), %r15
movq 0xc0(%r14), %r12
movl $0x80000000, %ebp # imm = 0x80000000
cmpq %r15, %r12
je 0xf700
movq %r15, (%rsp)
movq 0x10(%r12), %r13
movq (%r13), %rax
movq %r13, %rdi
callq *0x48(%rax)
movq (%r13), %rax
movq %r13, %rdi
callq *0x30(%rax)
testb %al, %al
je 0xf63f
movq (%r12), %r12
jmp 0xf695
movq %r13, %rdi
callq 0x8a42
movq %rbx, %rdi
leaq 0xa015(%rip), %rsi # 0x19666
leaq -0x2a4(%rip), %rdx # 0xf3b4
xorl %ecx, %ecx
movq %rax, %r8
callq 0xf9b0
movq (%r12), %r15
decq 0xd0(%r14)
movq %r12, %rdi
callq 0x5500
movl $0x18, %esi
movq %r12, %rdi
callq 0x5310
movq (%rbx), %rax
movq %rbx, %rdi
movq %r13, %rsi
callq *0x58(%rax)
movq %r15, %r12
movq (%rsp), %r15
cmpq %r15, %r12
jne 0xf61c
jmp 0xf700
movq 0x8(%r14), %rsi
movq 0x78(%r14), %rcx
movq %rbx, %rdi
movl %ebp, %edx
callq 0xf09c
movl $0xa, 0x68(%r14)
jmp 0xf700
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movl $0x80000000, %ebp # imm = 0x80000000
movl %eax, %ecx
negl %ecx
jo 0xf700
btl $0x18, %eax
jae 0xf6e4
movq 0x8(%r14), %rsi
movq 0x78(%r14), %rcx
movq %rbx, %rdi
movl %eax, %edx
callq 0xf09c
movl $0xb, 0x68(%r14)
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xf040
movq %rbx, %rdi
callq 0xf274
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
_ZN15ModbusTcpServer7processEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
mov r14, [rdi+8]
lea r15, jpt_F3F7
loc_F3E5:
mov eax, [r14+68h]
dec eax; switch 11 cases
cmp eax, 0Ah
ja short def_F3F7; jumptable 000000000000F3F7 default case, cases 4,5,7,8
movsxd rax, ds:(jpt_F3F7 - 19614h)[r15+rax*4]
add rax, r15
jmp rax; switch jump
loc_F3F9:
mov dword ptr [r14+68h], 6; jumptable 000000000000F3F7 case 3
loc_F401:
cmp byte ptr [r14+6Ch], 1; jumptable 000000000000F3F7 case 6
jz loc_F48D
jmp loc_F4D6
loc_F411:
call timer; jumptable 000000000000F3F7 case 10
sub eax, [r14+98h]
mov rcx, [rbx+8]
cmp eax, [rcx+0BCh]
jnb short loc_F459
jmp loc_F4CC
def_F3F7:
cmp byte ptr [r14+6Ch], 1; jumptable 000000000000F3F7 default case, cases 4,5,7,8
jnz short loc_F442
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax+30h]
test al, al
jnz short loc_F48D
loc_F442:
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax+30h]
test al, al
jz short loc_F459
mov dword ptr [r14+68h], 3
jmp short loc_F3E5
loc_F459:
mov dword ptr [r14+68h], 0Bh
jmp short loc_F3E5
loc_F463:
cmp byte ptr [r14+6Ch], 0; jumptable 000000000000F3F7 case 11
jnz short loc_F4CC
mov dword ptr [r14+68h], 1
loc_F472:
call timer; jumptable 000000000000F3F7 case 1
mov [r14+98h], eax
mov dword ptr [r14+68h], 2
loc_F486:
cmp byte ptr [r14+6Ch], 1; jumptable 000000000000F3F7 case 2
jnz short loc_F49A
loc_F48D:
mov dword ptr [r14+68h], 9
jmp loc_F3E5
loc_F49A:
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax+20h]
mov ebp, eax
neg eax
jo short loc_F4CC
bt ebp, 18h
jb loc_F69C
mov dword ptr [r14+68h], 3
mov rsi, [r14+8]; char *
mov rdi, rbx; this
call _ZN16ModbusServerPort12signalOpenedEPKc; ModbusServerPort::signalOpened(char const*)
jmp loc_F3E5
loc_F4CC:
mov ebp, 80000000h
jmp loc_F700
loc_F4D6:
mov rdi, rbx; this
call _ZN15ModbusTcpServer21nextPendingConnectionEv; ModbusTcpServer::nextPendingConnection(void)
test rax, rax
jz loc_F5FC
mov rcx, [rbx]
mov rdi, rbx
mov rsi, rax
call qword ptr [rcx+50h]
mov r12, rax
mov edi, 20h ; ' '; unsigned __int64
call __Znwm; operator new(ulong)
lea r13, off_21A38
mov [rax], r13
mov [rax+8], rbx
lea rsi, _ZN16ModbusServerPort8signalTxEPKcPKht; void *
mov [rax+10h], rsi
xor r15d, r15d
mov [rax+18h], r15
mov rdi, r12; this
mov rdx, rax; void *
call _ZN12ModbusObject7setSlotEPvS0_; ModbusObject::setSlot(void *,void *)
mov edi, 20h ; ' '; unsigned __int64
call __Znwm; operator new(ulong)
mov [rax], r13
mov [rax+8], rbx
lea rsi, _ZN16ModbusServerPort8signalRxEPKcPKht; void *
mov [rax+10h], rsi
mov [rax+18h], r15
mov rdi, r12; this
mov rdx, rax; void *
call _ZN12ModbusObject7setSlotEPvS0_; ModbusObject::setSlot(void *,void *)
mov edi, 20h ; ' '; unsigned __int64
call __Znwm; operator new(ulong)
lea rcx, off_21A88
mov [rax], rcx
mov [rax+8], rbx
lea rsi, _ZN16ModbusServerPort11signalErrorEPKcN6Modbus10StatusCodeES1_; void *
mov [rax+10h], rsi
mov [rax+18h], r15
mov rdi, r12; this
mov rdx, rax; void *
call _ZN12ModbusObject7setSlotEPvS0_; ModbusObject::setSlot(void *,void *)
mov rdi, rbx; this
call _ZNK16ModbusServerPort18isBroadcastEnabledEv; ModbusServerPort::isBroadcastEnabled(void)
mov rcx, [r12]
movzx esi, al
mov rdi, r12
call qword ptr [rcx+38h]
mov rdi, rbx; this
call _ZNK16ModbusServerPort7unitMapEv; ModbusServerPort::unitMap(void)
mov rcx, [r12]
mov rdi, r12
mov rsi, rax
call qword ptr [rcx+40h]
lea r15, [r14+0C0h]
mov edi, 18h; unsigned __int64
call __Znwm; operator new(ulong)
mov [rax+10h], r12
mov rdi, rax; this
mov rsi, r15; std::__detail::_List_node_base *
call __ZNSt8__detail15_List_node_base7_M_hookEPS0_; std::__detail::_List_node_base::_M_hook(std::__detail::_List_node_base*)
inc qword ptr [r14+0D0h]
mov rdi, r12; this
call _ZNK12ModbusObject10objectNameEv; ModbusObject::objectName(void)
lea rsi, aSignalnewconne; "signalNewConnection"
lea rdx, _ZN15ModbusTcpServer19signalNewConnectionEPKc; ModbusTcpServer::signalNewConnection(char const*)
mov rdi, rbx; this
xor ecx, ecx
mov r8, rax
call _ZN12ModbusObject10emitSignalI15ModbusTcpServerJPKcEEEvS3_MT_FvDpT0_ES6_; ModbusObject::emitSignal<ModbusTcpServer,char const*>(char const*,void (ModbusTcpServer::*)(char const*),char const*)
loc_F5FC:
lea r15, [r14+0C0h]
mov r12, [r14+0C0h]
mov ebp, 80000000h
cmp r12, r15
jz loc_F700
mov [rsp+38h+var_38], r15
loc_F61C:
mov r13, [r12+10h]
mov rax, [r13+0]
mov rdi, r13
call qword ptr [rax+48h]
mov rax, [r13+0]
mov rdi, r13
call qword ptr [rax+30h]
test al, al
jz short loc_F63F
mov r12, [r12]
jmp short loc_F695
loc_F63F:
mov rdi, r13; this
call _ZNK12ModbusObject10objectNameEv; ModbusObject::objectName(void)
mov rdi, rbx; this
lea rsi, aSignalclosecon; "signalCloseConnection"
lea rdx, _ZN15ModbusTcpServer21signalCloseConnectionEPKc; ModbusTcpServer::signalCloseConnection(char const*)
xor ecx, ecx
mov r8, rax
call _ZN12ModbusObject10emitSignalI15ModbusTcpServerJPKcEEEvS3_MT_FvDpT0_ES6_; ModbusObject::emitSignal<ModbusTcpServer,char const*>(char const*,void (ModbusTcpServer::*)(char const*),char const*)
mov r15, [r12]
dec qword ptr [r14+0D0h]
mov rdi, r12; this
call __ZNSt8__detail15_List_node_base9_M_unhookEv; std::__detail::_List_node_base::_M_unhook(void)
mov esi, 18h; unsigned __int64
mov rdi, r12; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rax, [rbx]
mov rdi, rbx
mov rsi, r13
call qword ptr [rax+58h]
mov r12, r15
mov r15, [rsp+38h+var_38]
loc_F695:
cmp r12, r15
jnz short loc_F61C
jmp short loc_F700
loc_F69C:
mov rsi, [r14+8]
mov rcx, [r14+78h]
mov rdi, rbx
mov edx, ebp
call _ZN16ModbusServerPort11signalErrorEPKcN6Modbus10StatusCodeES1_; ModbusServerPort::signalError(char const*,Modbus::StatusCode,char const*)
mov dword ptr [r14+68h], 0Ah
jmp short loc_F700
loc_F6B8:
mov rax, [rbx]; jumptable 000000000000F3F7 case 9
mov rdi, rbx
call qword ptr [rax+28h]
mov ebp, 80000000h
mov ecx, eax
neg ecx
jo short loc_F700
bt eax, 18h
jnb short loc_F6E4
mov rsi, [r14+8]
mov rcx, [r14+78h]
mov rdi, rbx
mov edx, eax
call _ZN16ModbusServerPort11signalErrorEPKcN6Modbus10StatusCodeES1_; ModbusServerPort::signalError(char const*,Modbus::StatusCode,char const*)
loc_F6E4:
mov dword ptr [r14+68h], 0Bh
mov rsi, [r14+8]; char *
mov rdi, rbx; this
call _ZN16ModbusServerPort12signalClosedEPKc; ModbusServerPort::signalClosed(char const*)
mov rdi, rbx; this
call _ZN15ModbusTcpServer16clearConnectionsEv; ModbusTcpServer::clearConnections(void)
loc_F700:
mov eax, ebp
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long ModbusTcpServer::process(ModbusTcpServer *this)
{
ModbusTcpServer *v1; // rbx
long long v2; // r14
unsigned int v3; // ebp
long long PendingConnection; // rax
ModbusObject *v5; // r12
_QWORD *v6; // rax
_QWORD *v7; // rax
_QWORD *v8; // rax
unsigned __int8 isBroadcastEnabled; // al
long long v10; // rax
std::__detail::_List_node_base *v11; // rax
std::__detail::_List_node_base *v12; // r15
std::__detail::_List_node_base *v13; // r12
ModbusObject *v14; // r13
std::__detail::_List_node_base *v15; // r15
unsigned int v16; // eax
v1 = this;
v2 = *((_QWORD *)this + 1);
while ( 2 )
{
switch ( *(_DWORD *)(v2 + 104) )
{
case 1:
goto LABEL_15;
case 2:
goto LABEL_16;
case 3:
*(_DWORD *)(v2 + 104) = 6;
goto LABEL_4;
case 6:
LABEL_4:
if ( *(_BYTE *)(v2 + 108) == 1 )
goto LABEL_17;
PendingConnection = ModbusTcpServer::nextPendingConnection(v1);
if ( PendingConnection )
{
v5 = (ModbusObject *)(*(long long ( **)(ModbusTcpServer *, long long))(*(_QWORD *)v1 + 80LL))(
v1,
PendingConnection);
v6 = (_QWORD *)operator new(0x20uLL);
*v6 = off_21A38;
v6[1] = v1;
v6[2] = ModbusServerPort::signalTx;
v6[3] = 0LL;
ModbusObject::setSlot(v5, ModbusServerPort::signalTx, v6);
v7 = (_QWORD *)operator new(0x20uLL);
*v7 = off_21A38;
v7[1] = v1;
v7[2] = ModbusServerPort::signalRx;
v7[3] = 0LL;
ModbusObject::setSlot(v5, ModbusServerPort::signalRx, v7);
v8 = (_QWORD *)operator new(0x20uLL);
*v8 = off_21A88;
v8[1] = v1;
v8[2] = ModbusServerPort::signalError;
v8[3] = 0LL;
ModbusObject::setSlot(v5, ModbusServerPort::signalError, v8);
isBroadcastEnabled = ModbusServerPort::isBroadcastEnabled(v1);
(*(void ( **)(ModbusObject *, _QWORD))(*(_QWORD *)v5 + 56LL))(v5, isBroadcastEnabled);
v10 = ModbusServerPort::unitMap(v1);
(*(void ( **)(ModbusObject *, long long))(*(_QWORD *)v5 + 64LL))(v5, v10);
v11 = (std::__detail::_List_node_base *)operator new(0x18uLL);
*((_QWORD *)v11 + 2) = v5;
std::__detail::_List_node_base::_M_hook(v11, (std::__detail::_List_node_base *)(v2 + 192));
++*(_QWORD *)(v2 + 208);
ModbusObject::objectName(v5);
ModbusObject::emitSignal<ModbusTcpServer,char const*>(v1);
}
v12 = (std::__detail::_List_node_base *)(v2 + 192);
v13 = *(std::__detail::_List_node_base **)(v2 + 192);
v3 = 0x80000000;
if ( v13 != (std::__detail::_List_node_base *)(v2 + 192) )
{
do
{
v14 = (ModbusObject *)*((_QWORD *)v13 + 2);
(*(void ( **)(ModbusObject *))(*(_QWORD *)v14 + 72LL))(v14);
if ( (*(unsigned __int8 ( **)(ModbusObject *))(*(_QWORD *)v14 + 48LL))(v14) )
{
v13 = *(std::__detail::_List_node_base **)v13;
}
else
{
ModbusObject::objectName(v14);
ModbusObject::emitSignal<ModbusTcpServer,char const*>(v1);
v15 = *(std::__detail::_List_node_base **)v13;
--*(_QWORD *)(v2 + 208);
std::__detail::_List_node_base::_M_unhook(v13);
operator delete(v13, 0x18uLL);
(*(void ( **)(ModbusTcpServer *, ModbusObject *))(*(_QWORD *)v1 + 88LL))(v1, v14);
v13 = v15;
v12 = (std::__detail::_List_node_base *)(v2 + 192);
}
}
while ( v13 != v12 );
}
return v3;
case 9:
v16 = (*(long long ( **)(ModbusTcpServer *))(*(_QWORD *)v1 + 40LL))(v1);
v3 = 0x80000000;
if ( !__OFSUB__(-v16, 1) )
{
if ( (v16 & 0x1000000) != 0 )
ModbusServerPort::signalError(v1, *(_QWORD *)(v2 + 8), v16, *(_QWORD *)(v2 + 120));
*(_DWORD *)(v2 + 104) = 11;
ModbusServerPort::signalClosed(v1, *(const char **)(v2 + 8));
ModbusTcpServer::clearConnections(v1);
}
return v3;
case 0xA:
if ( (unsigned int)timer(this) - *(_DWORD *)(v2 + 152) < *(_DWORD *)(*((_QWORD *)v1 + 1) + 188LL) )
return 0x80000000;
goto LABEL_12;
case 0xB:
if ( *(_BYTE *)(v2 + 108) )
return 0x80000000;
*(_DWORD *)(v2 + 104) = 1;
LABEL_15:
*(_DWORD *)(v2 + 152) = timer(this);
*(_DWORD *)(v2 + 104) = 2;
LABEL_16:
if ( *(_BYTE *)(v2 + 108) == 1 )
{
LABEL_17:
*(_DWORD *)(v2 + 104) = 9;
continue;
}
v3 = (*(long long ( **)(ModbusTcpServer *))(*(_QWORD *)v1 + 32LL))(v1);
if ( !__OFSUB__(-v3, 1) )
{
if ( (v3 & 0x1000000) != 0 )
{
ModbusServerPort::signalError(v1, *(_QWORD *)(v2 + 8), v3, *(_QWORD *)(v2 + 120));
*(_DWORD *)(v2 + 104) = 10;
return v3;
}
*(_DWORD *)(v2 + 104) = 3;
this = v1;
ModbusServerPort::signalOpened(v1, *(const char **)(v2 + 8));
continue;
}
return 0x80000000;
default:
if ( *(_BYTE *)(v2 + 108) == 1 )
{
this = v1;
if ( (*(unsigned __int8 ( **)(ModbusTcpServer *))(*(_QWORD *)v1 + 48LL))(v1) )
goto LABEL_17;
}
this = v1;
if ( (*(unsigned __int8 ( **)(ModbusTcpServer *))(*(_QWORD *)v1 + 48LL))(v1) )
*(_DWORD *)(v2 + 104) = 3;
else
LABEL_12:
*(_DWORD *)(v2 + 104) = 11;
continue;
}
}
}
|
process:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R14,qword ptr [RDI + 0x8]
LEA R15,[0x119614]
LAB_0010f3e5:
MOV EAX,dword ptr [R14 + 0x68]
DEC EAX
CMP EAX,0xa
JA 0x0010f42e
MOVSXD RAX,dword ptr [R15 + RAX*0x4]
ADD RAX,R15
switchD:
JMP RAX
caseD_3:
MOV dword ptr [R14 + 0x68],0x6
caseD_6:
CMP byte ptr [R14 + 0x6c],0x1
JZ 0x0010f48d
JMP 0x0010f4d6
caseD_a:
CALL 0x0010fb1c
SUB EAX,dword ptr [R14 + 0x98]
MOV RCX,qword ptr [RBX + 0x8]
CMP EAX,dword ptr [RCX + 0xbc]
JNC 0x0010f459
JMP 0x0010f4cc
caseD_4:
CMP byte ptr [R14 + 0x6c],0x1
JNZ 0x0010f442
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX + 0x30]
TEST AL,AL
JNZ 0x0010f48d
LAB_0010f442:
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX + 0x30]
TEST AL,AL
JZ 0x0010f459
MOV dword ptr [R14 + 0x68],0x3
JMP 0x0010f3e5
LAB_0010f459:
MOV dword ptr [R14 + 0x68],0xb
JMP 0x0010f3e5
caseD_b:
CMP byte ptr [R14 + 0x6c],0x0
JNZ 0x0010f4cc
MOV dword ptr [R14 + 0x68],0x1
caseD_1:
CALL 0x0010fb1c
MOV dword ptr [R14 + 0x98],EAX
MOV dword ptr [R14 + 0x68],0x2
caseD_2:
CMP byte ptr [R14 + 0x6c],0x1
JNZ 0x0010f49a
LAB_0010f48d:
MOV dword ptr [R14 + 0x68],0x9
JMP 0x0010f3e5
LAB_0010f49a:
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX + 0x20]
MOV EBP,EAX
NEG EAX
JO 0x0010f4cc
BT EBP,0x18
JC 0x0010f69c
MOV dword ptr [R14 + 0x68],0x3
MOV RSI,qword ptr [R14 + 0x8]
MOV RDI,RBX
CALL 0x0010f028
JMP 0x0010f3e5
LAB_0010f4cc:
MOV EBP,0x80000000
JMP 0x0010f700
LAB_0010f4d6:
MOV RDI,RBX
CALL 0x00117a6a
TEST RAX,RAX
JZ 0x0010f5fc
MOV RCX,qword ptr [RBX]
MOV RDI,RBX
MOV RSI,RAX
CALL qword ptr [RCX + 0x50]
MOV R12,RAX
MOV EDI,0x20
CALL 0x00105300
LEA R13,[0x121a38]
MOV qword ptr [RAX],R13
MOV qword ptr [RAX + 0x8],RBX
LEA RSI,[0x10f058]
MOV qword ptr [RAX + 0x10],RSI
XOR R15D,R15D
MOV qword ptr [RAX + 0x18],R15
MOV RDI,R12
MOV RDX,RAX
CALL 0x00108ade
MOV EDI,0x20
CALL 0x00105300
MOV qword ptr [RAX],R13
MOV qword ptr [RAX + 0x8],RBX
LEA RSI,[0x10f07a]
MOV qword ptr [RAX + 0x10],RSI
MOV qword ptr [RAX + 0x18],R15
MOV RDI,R12
MOV RDX,RAX
CALL 0x00108ade
MOV EDI,0x20
CALL 0x00105300
LEA RCX,[0x121a88]
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],RBX
LEA RSI,[0x10f09c]
MOV qword ptr [RAX + 0x10],RSI
MOV qword ptr [RAX + 0x18],R15
MOV RDI,R12
MOV RDX,RAX
CALL 0x00108ade
MOV RDI,RBX
CALL 0x0010ef80
MOV RCX,qword ptr [R12]
MOVZX ESI,AL
MOV RDI,R12
CALL qword ptr [RCX + 0x38]
MOV RDI,RBX
CALL 0x0010ef98
MOV RCX,qword ptr [R12]
MOV RDI,R12
MOV RSI,RAX
CALL qword ptr [RCX + 0x40]
LEA R15,[R14 + 0xc0]
MOV EDI,0x18
CALL 0x00105300
MOV qword ptr [RAX + 0x10],R12
MOV RDI,RAX
MOV RSI,R15
CALL 0x00105080
INC qword ptr [R14 + 0xd0]
MOV RDI,R12
CALL 0x00108a42
LEA RSI,[0x119652]
LEA RDX,[0x10f712]
MOV RDI,RBX
XOR ECX,ECX
MOV R8,RAX
CALL 0x0010f9b0
LAB_0010f5fc:
LEA R15,[R14 + 0xc0]
MOV R12,qword ptr [R14 + 0xc0]
MOV EBP,0x80000000
CMP R12,R15
JZ 0x0010f700
MOV qword ptr [RSP],R15
LAB_0010f61c:
MOV R13,qword ptr [R12 + 0x10]
MOV RAX,qword ptr [R13]
MOV RDI,R13
CALL qword ptr [RAX + 0x48]
MOV RAX,qword ptr [R13]
MOV RDI,R13
CALL qword ptr [RAX + 0x30]
TEST AL,AL
JZ 0x0010f63f
MOV R12,qword ptr [R12]
JMP 0x0010f695
LAB_0010f63f:
MOV RDI,R13
CALL 0x00108a42
MOV RDI,RBX
LEA RSI,[0x119666]
LEA RDX,[0x10f3b4]
XOR ECX,ECX
MOV R8,RAX
CALL 0x0010f9b0
MOV R15,qword ptr [R12]
DEC qword ptr [R14 + 0xd0]
MOV RDI,R12
CALL 0x00105500
MOV ESI,0x18
MOV RDI,R12
CALL 0x00105310
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
MOV RSI,R13
CALL qword ptr [RAX + 0x58]
MOV R12,R15
MOV R15,qword ptr [RSP]
LAB_0010f695:
CMP R12,R15
JNZ 0x0010f61c
JMP 0x0010f700
LAB_0010f69c:
MOV RSI,qword ptr [R14 + 0x8]
MOV RCX,qword ptr [R14 + 0x78]
MOV RDI,RBX
MOV EDX,EBP
CALL 0x0010f09c
MOV dword ptr [R14 + 0x68],0xa
JMP 0x0010f700
caseD_9:
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX + 0x28]
MOV EBP,0x80000000
MOV ECX,EAX
NEG ECX
JO 0x0010f700
BT EAX,0x18
JNC 0x0010f6e4
MOV RSI,qword ptr [R14 + 0x8]
MOV RCX,qword ptr [R14 + 0x78]
MOV RDI,RBX
MOV EDX,EAX
CALL 0x0010f09c
LAB_0010f6e4:
MOV dword ptr [R14 + 0x68],0xb
MOV RSI,qword ptr [R14 + 0x8]
MOV RDI,RBX
CALL 0x0010f040
MOV RDI,RBX
CALL 0x0010f274
LAB_0010f700:
MOV EAX,EBP
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* ModbusTcpServer::process() */
uint __thiscall ModbusTcpServer::process(ModbusTcpServer *this)
{
long lVar1;
int8 *puVar2;
char cVar3;
int1 uVar4;
int iVar5;
int4 uVar6;
uint uVar7;
long lVar8;
ModbusObject *pMVar9;
int8 *puVar10;
int8 uVar11;
_List_node_base *p_Var12;
lVar1 = *(long *)(this + 8);
do {
switch(*(int4 *)(lVar1 + 0x68)) {
case 2:
goto switchD_0010f3f7_caseD_2;
case 3:
*(int4 *)(lVar1 + 0x68) = 6;
case 6:
if (*(char *)(lVar1 + 0x6c) != '\x01') {
lVar8 = nextPendingConnection(this);
if (lVar8 != 0) {
pMVar9 = (ModbusObject *)(**(code **)(*(long *)this + 0x50))(this,lVar8);
puVar10 = (int8 *)operator_new(0x20);
*puVar10 = &PTR__ModbusSlotBase_00121a38;
puVar10[1] = this;
puVar10[2] = ModbusServerPort::signalTx;
puVar10[3] = 0;
ModbusObject::setSlot(pMVar9,ModbusServerPort::signalTx,puVar10);
puVar10 = (int8 *)operator_new(0x20);
*puVar10 = &PTR__ModbusSlotBase_00121a38;
puVar10[1] = this;
puVar10[2] = ModbusServerPort::signalRx;
puVar10[3] = 0;
ModbusObject::setSlot(pMVar9,ModbusServerPort::signalRx,puVar10);
puVar10 = (int8 *)operator_new(0x20);
*puVar10 = &PTR__ModbusSlotBase_00121a88;
puVar10[1] = this;
puVar10[2] = ModbusServerPort::signalError;
puVar10[3] = 0;
ModbusObject::setSlot(pMVar9,ModbusServerPort::signalError,puVar10);
uVar4 = ModbusServerPort::isBroadcastEnabled((ModbusServerPort *)this);
(**(code **)(*(long *)pMVar9 + 0x38))(pMVar9,uVar4);
uVar11 = ModbusServerPort::unitMap((ModbusServerPort *)this);
(**(code **)(*(long *)pMVar9 + 0x40))(pMVar9,uVar11);
p_Var12 = (_List_node_base *)operator_new(0x18);
*(ModbusObject **)(p_Var12 + 0x10) = pMVar9;
std::__detail::_List_node_base::_M_hook(p_Var12);
*(long *)(lVar1 + 0xd0) = *(long *)(lVar1 + 0xd0) + 1;
ModbusObject::objectName(pMVar9);
ModbusObject::emitSignal<ModbusTcpServer,char_const*>
((char *)this,(_func_void_char_ptr *)"signalNewConnection",
(char *)signalNewConnection);
}
puVar10 = *(int8 **)(lVar1 + 0xc0);
while (puVar10 != (int8 *)(lVar1 + 0xc0)) {
pMVar9 = (ModbusObject *)puVar10[2];
(**(code **)(*(long *)pMVar9 + 0x48))(pMVar9);
cVar3 = (**(code **)(*(long *)pMVar9 + 0x30))(pMVar9);
if (cVar3 == '\0') {
ModbusObject::objectName(pMVar9);
ModbusObject::emitSignal<ModbusTcpServer,char_const*>
((char *)this,(_func_void_char_ptr *)"signalCloseConnection",
(char *)signalCloseConnection);
puVar2 = (int8 *)*puVar10;
*(long *)(lVar1 + 0xd0) = *(long *)(lVar1 + 0xd0) + -1;
std::__detail::_List_node_base::_M_unhook();
operator_delete(puVar10,0x18);
(**(code **)(*(long *)this + 0x58))(this,pMVar9);
puVar10 = puVar2;
}
else {
puVar10 = (int8 *)*puVar10;
}
}
return 0x80000000;
}
goto LAB_0010f48d;
default:
if ((*(char *)(lVar1 + 0x6c) == '\x01') &&
(cVar3 = (**(code **)(*(long *)this + 0x30))(this), cVar3 != '\0')) goto LAB_0010f48d;
cVar3 = (**(code **)(*(long *)this + 0x30))(this);
if (cVar3 == '\0') goto LAB_0010f459;
*(int4 *)(lVar1 + 0x68) = 3;
break;
case 9:
uVar7 = (**(code **)(*(long *)this + 0x28))(this);
if ((uVar7 >> 0x18 & 1) != 0) {
ModbusServerPort::signalError
((ModbusServerPort *)this,*(int8 *)(lVar1 + 8),uVar7,
*(int8 *)(lVar1 + 0x78));
}
*(int4 *)(lVar1 + 0x68) = 0xb;
ModbusServerPort::signalClosed((char *)this);
clearConnections(this);
return 0x80000000;
case 10:
iVar5 = timer();
if ((uint)(iVar5 - *(int *)(lVar1 + 0x98)) < *(uint *)(*(long *)(this + 8) + 0xbc)) {
return 0x80000000;
}
LAB_0010f459:
*(int4 *)(lVar1 + 0x68) = 0xb;
break;
case 0xb:
if (*(char *)(lVar1 + 0x6c) != '\0') {
return 0x80000000;
}
*(int4 *)(lVar1 + 0x68) = 1;
case 1:
uVar6 = timer();
*(int4 *)(lVar1 + 0x98) = uVar6;
*(int4 *)(lVar1 + 0x68) = 2;
switchD_0010f3f7_caseD_2:
if (*(char *)(lVar1 + 0x6c) == '\x01') {
LAB_0010f48d:
*(int4 *)(lVar1 + 0x68) = 9;
}
else {
uVar7 = (**(code **)(*(long *)this + 0x20))(this);
if ((uVar7 >> 0x18 & 1) != 0) {
ModbusServerPort::signalError
((ModbusServerPort *)this,*(int8 *)(lVar1 + 8),uVar7,
*(int8 *)(lVar1 + 0x78));
*(int4 *)(lVar1 + 0x68) = 10;
return uVar7;
}
*(int4 *)(lVar1 + 0x68) = 3;
ModbusServerPort::signalOpened((char *)this);
}
}
} while( true );
}
|
|
63,391 |
IsRenderTextureValid
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rtextures.c
|
bool IsRenderTextureValid(RenderTexture2D target)
{
bool result = false;
if ((target.id > 0) && // Validate OpenGL id (loaded on GPU)
IsTextureValid(target.depth) && // Validate FBO depth texture/renderbuffer attachment
IsTextureValid(target.texture)) result = true; // Validate FBO texture attachment
return result;
}
|
O2
|
c
|
IsRenderTextureValid:
pushq %rbx
subq $0x20, %rsp
cmpl $0x0, 0x30(%rsp)
je 0x86f71
leaq 0x30(%rsp), %rbx
movl 0x28(%rbx), %eax
movl %eax, 0x10(%rsp)
movups 0x18(%rbx), %xmm0
movups %xmm0, (%rsp)
callq 0x86edf
testb %al, %al
je 0x86f71
cmpl $0x0, 0x4(%rbx)
setne %cl
movdqu 0x8(%rbx), %xmm0
pxor %xmm1, %xmm1
pcmpgtd %xmm1, %xmm0
movmskps %xmm0, %eax
cmpl $0xf, %eax
sete %al
andb %cl, %al
jmp 0x86f73
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
|
IsRenderTextureValid:
push rbx
sub rsp, 20h
cmp [rsp+28h+arg_0], 0
jz short loc_86F71
lea rbx, [rsp+28h+arg_0]
mov eax, [rbx+28h]
mov [rsp+28h+var_18], eax
movups xmm0, xmmword ptr [rbx+18h]
movups [rsp+28h+var_28], xmm0
call IsTextureValid
test al, al
jz short loc_86F71
cmp dword ptr [rbx+4], 0
setnz cl
movdqu xmm0, xmmword ptr [rbx+8]
pxor xmm1, xmm1
pcmpgtd xmm0, xmm1
movmskps eax, xmm0
cmp eax, 0Fh
setz al
and al, cl
jmp short loc_86F73
loc_86F71:
xor eax, eax
loc_86F73:
add rsp, 20h
pop rbx
retn
|
char IsRenderTextureValid(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
long long a7,
__m128i a8,
long long a9)
{
if ( (_DWORD)a7 && IsTextureValid(a1, a2, a3, a4, a5, a6, a9) )
return (HIDWORD(a7) != 0) & (_mm_movemask_ps((__m128)_mm_cmpgt_epi32(_mm_loadu_si128(&a8), (__m128i)0LL)) == 15);
else
return 0;
}
|
IsRenderTextureValid:
PUSH RBX
SUB RSP,0x20
CMP dword ptr [RSP + 0x30],0x0
JZ 0x00186f71
LEA RBX,[RSP + 0x30]
MOV EAX,dword ptr [RBX + 0x28]
MOV dword ptr [RSP + 0x10],EAX
MOVUPS XMM0,xmmword ptr [RBX + 0x18]
MOVUPS xmmword ptr [RSP],XMM0
CALL 0x00186edf
TEST AL,AL
JZ 0x00186f71
CMP dword ptr [RBX + 0x4],0x0
SETNZ CL
MOVDQU XMM0,xmmword ptr [RBX + 0x8]
PXOR XMM1,XMM1
PCMPGTD XMM0,XMM1
MOVMSKPS EAX,XMM0
CMP EAX,0xf
SETZ AL
AND AL,CL
JMP 0x00186f73
LAB_00186f71:
XOR EAX,EAX
LAB_00186f73:
ADD RSP,0x20
POP RBX
RET
|
int8 IsRenderTextureValid(void)
{
int iVar1;
int8 uVar2;
int1 auVar3 [16];
int iStack0000000000000008;
int iStack000000000000000c;
int iStack0000000000000010;
int iStack0000000000000014;
int iStack0000000000000018;
int iStack000000000000001c;
if ((iStack0000000000000008 != 0) && (uVar2 = IsTextureValid(), (char)uVar2 != '\0')) {
auVar3._0_4_ = -(uint)(0 < iStack0000000000000010);
auVar3._4_4_ = -(uint)(0 < iStack0000000000000014);
auVar3._8_4_ = -(uint)(0 < iStack0000000000000018);
auVar3._12_4_ = -(uint)(0 < iStack000000000000001c);
iVar1 = movmskps((int)uVar2,auVar3);
return CONCAT71((int7)(CONCAT44((int)((ulong)uVar2 >> 0x20),iVar1) >> 8),
iVar1 == 0xf && iStack000000000000000c != 0);
}
return 0;
}
|
|
63,392 |
stbi__out_gif_code(stbi__gif*, unsigned short)
|
llama.cpp/examples/llava/../../common/stb_image.h
|
static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code)
{
stbi_uc *p, *c;
int idx;
// recurse to decode the prefixes, since the linked-list is backwards,
// and working backwards through an interleaved image would be nasty
if (g->codes[code].prefix >= 0)
stbi__out_gif_code(g, g->codes[code].prefix);
if (g->cur_y >= g->max_y) return;
idx = g->cur_x + g->cur_y;
p = &g->out[idx];
g->history[idx / 4] = 1;
c = &g->color_table[g->codes[code].suffix * 4];
if (c[3] > 128) { // don't render transparent pixels;
p[0] = c[2];
p[1] = c[1];
p[2] = c[0];
p[3] = c[3];
}
g->cur_x += 4;
if (g->cur_x >= g->max_x) {
g->cur_x = g->start_x;
g->cur_y += g->step;
while (g->cur_y >= g->max_y && g->parse > 0) {
g->step = (1 << g->parse) * g->line_size;
g->cur_y = g->start_y + (g->step >> 1);
--g->parse;
}
}
}
|
O3
|
c
|
stbi__out_gif_code(stbi__gif*, unsigned short):
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %r14d
movzwl 0x834(%rdi,%r14,4), %eax
testw %ax, %ax
js 0x33447
movzwl %ax, %esi
movq %rbx, %rdi
callq 0x33424
movslq 0x8860(%rbx), %rcx
cmpl 0x8858(%rbx), %ecx
jge 0x3352a
movslq 0x885c(%rbx), %rax
addq %rcx, %rax
movq 0x8(%rbx), %rcx
leal 0x3(%rax), %edx
testl %eax, %eax
cmovnsl %eax, %edx
movq 0x18(%rbx), %rsi
sarl $0x2, %edx
movslq %edx, %rdx
movb $0x1, (%rsi,%rdx)
movq 0x8838(%rbx), %rdx
movzbl 0x837(%rbx,%r14,4), %esi
cmpb $-0x7f, 0x3(%rdx,%rsi,4)
jb 0x334b9
movb 0x2(%rdx,%rsi,4), %dil
movb %dil, (%rcx,%rax)
movb 0x1(%rdx,%rsi,4), %dil
movb %dil, 0x1(%rcx,%rax)
movb (%rdx,%rsi,4), %dil
movb %dil, 0x2(%rcx,%rax)
movb 0x3(%rdx,%rsi,4), %dl
movb %dl, 0x3(%rcx,%rax)
movl 0x885c(%rbx), %eax
addl $0x4, %eax
movl %eax, 0x885c(%rbx)
cmpl 0x8854(%rbx), %eax
jl 0x3352a
movl 0x884c(%rbx), %ecx
movl 0x8858(%rbx), %eax
movl %ecx, 0x885c(%rbx)
movl 0x8860(%rbx), %ecx
addl 0x8844(%rbx), %ecx
movl %ecx, 0x8860(%rbx)
cmpl %eax, %ecx
jl 0x3352a
movl 0x8840(%rbx), %ecx
testl %ecx, %ecx
jle 0x3352a
movl 0x8864(%rbx), %edx
shll %cl, %edx
movl %edx, 0x8844(%rbx)
sarl %edx
addl 0x8850(%rbx), %edx
movl %edx, 0x8860(%rbx)
decl %ecx
movl %ecx, 0x8840(%rbx)
cmpl %eax, %edx
jge 0x334fe
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
_ZL18stbi__out_gif_codeP9stbi__gift:
push r14
push rbx
push rax
mov rbx, rdi
mov r14d, esi
movzx eax, word ptr [rdi+r14*4+834h]
test ax, ax
js short loc_33447
movzx esi, ax
mov rdi, rbx
call _ZL18stbi__out_gif_codeP9stbi__gift; stbi__out_gif_code(stbi__gif *,ushort)
loc_33447:
movsxd rcx, dword ptr [rbx+8860h]
cmp ecx, [rbx+8858h]
jge loc_3352A
movsxd rax, dword ptr [rbx+885Ch]
add rax, rcx
mov rcx, [rbx+8]
lea edx, [rax+3]
test eax, eax
cmovns edx, eax
mov rsi, [rbx+18h]
sar edx, 2
movsxd rdx, edx
mov byte ptr [rsi+rdx], 1
mov rdx, [rbx+8838h]
movzx esi, byte ptr [rbx+r14*4+837h]
cmp byte ptr [rdx+rsi*4+3], 81h
jb short loc_334B9
mov dil, [rdx+rsi*4+2]
mov [rcx+rax], dil
mov dil, [rdx+rsi*4+1]
mov [rcx+rax+1], dil
mov dil, [rdx+rsi*4]
mov [rcx+rax+2], dil
mov dl, [rdx+rsi*4+3]
mov [rcx+rax+3], dl
loc_334B9:
mov eax, [rbx+885Ch]
add eax, 4
mov [rbx+885Ch], eax
cmp eax, [rbx+8854h]
jl short loc_3352A
mov ecx, [rbx+884Ch]
mov eax, [rbx+8858h]
mov [rbx+885Ch], ecx
mov ecx, [rbx+8860h]
add ecx, [rbx+8844h]
mov [rbx+8860h], ecx
cmp ecx, eax
jl short loc_3352A
mov ecx, [rbx+8840h]
loc_334FE:
test ecx, ecx
jle short loc_3352A
mov edx, [rbx+8864h]
shl edx, cl
mov [rbx+8844h], edx
sar edx, 1
add edx, [rbx+8850h]
mov [rbx+8860h], edx
dec ecx
mov [rbx+8840h], ecx
cmp edx, eax
jge short loc_334FE
loc_3352A:
add rsp, 8
pop rbx
pop r14
retn
|
long long stbi__out_gif_code(long long a1, unsigned int a2, long long a3, long long a4, long long a5, long long a6)
{
long long result; // rax
long long v7; // rcx
long long v8; // rax
long long v9; // rcx
long long v10; // rdx
long long v11; // rsi
int v12; // ecx
int v13; // ecx
int v14; // edx
int v15; // edx
result = *(unsigned __int16 *)(a1 + 4LL * a2 + 2100);
if ( (result & 0x8000u) == 0LL )
result = stbi__out_gif_code(a1, (unsigned __int16)result, a3, a4, a5, a6);
v7 = *(int *)(a1 + 34912);
if ( (int)v7 < *(_DWORD *)(a1 + 34904) )
{
v8 = v7 + *(int *)(a1 + 34908);
v9 = *(_QWORD *)(a1 + 8);
*(_BYTE *)(*(_QWORD *)(a1 + 24) + (int)v8 / 4) = 1;
v10 = *(_QWORD *)(a1 + 34872);
v11 = *(unsigned __int8 *)(a1 + 4LL * a2 + 2103);
if ( *(_BYTE *)(v10 + 4 * v11 + 3) >= 0x81u )
{
*(_BYTE *)(v9 + v8) = *(_BYTE *)(v10 + 4 * v11 + 2);
*(_BYTE *)(v9 + v8 + 1) = *(_BYTE *)(v10 + 4 * v11 + 1);
*(_BYTE *)(v9 + v8 + 2) = *(_BYTE *)(v10 + 4 * v11);
*(_BYTE *)(v9 + v8 + 3) = *(_BYTE *)(v10 + 4 * v11 + 3);
}
result = (unsigned int)(*(_DWORD *)(a1 + 34908) + 4);
*(_DWORD *)(a1 + 34908) = result;
if ( (int)result >= *(_DWORD *)(a1 + 34900) )
{
result = *(unsigned int *)(a1 + 34904);
*(_DWORD *)(a1 + 34908) = *(_DWORD *)(a1 + 34892);
v12 = *(_DWORD *)(a1 + 34884) + *(_DWORD *)(a1 + 34912);
*(_DWORD *)(a1 + 34912) = v12;
if ( v12 >= (int)result )
{
v13 = *(_DWORD *)(a1 + 34880);
do
{
if ( v13 <= 0 )
break;
v14 = *(_DWORD *)(a1 + 34916) << v13;
*(_DWORD *)(a1 + 34884) = v14;
v15 = *(_DWORD *)(a1 + 34896) + (v14 >> 1);
*(_DWORD *)(a1 + 34912) = v15;
*(_DWORD *)(a1 + 34880) = --v13;
}
while ( v15 >= (int)result );
}
}
}
return result;
}
|
stbi__out_gif_code:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R14D,ESI
MOVZX EAX,word ptr [RDI + R14*0x4 + 0x834]
TEST AX,AX
JS 0x00133447
MOVZX ESI,AX
MOV RDI,RBX
CALL 0x00133424
LAB_00133447:
MOVSXD RCX,dword ptr [RBX + 0x8860]
CMP ECX,dword ptr [RBX + 0x8858]
JGE 0x0013352a
MOVSXD RAX,dword ptr [RBX + 0x885c]
ADD RAX,RCX
MOV RCX,qword ptr [RBX + 0x8]
LEA EDX,[RAX + 0x3]
TEST EAX,EAX
CMOVNS EDX,EAX
MOV RSI,qword ptr [RBX + 0x18]
SAR EDX,0x2
MOVSXD RDX,EDX
MOV byte ptr [RSI + RDX*0x1],0x1
MOV RDX,qword ptr [RBX + 0x8838]
MOVZX ESI,byte ptr [RBX + R14*0x4 + 0x837]
CMP byte ptr [RDX + RSI*0x4 + 0x3],0x81
JC 0x001334b9
MOV DIL,byte ptr [RDX + RSI*0x4 + 0x2]
MOV byte ptr [RCX + RAX*0x1],DIL
MOV DIL,byte ptr [RDX + RSI*0x4 + 0x1]
MOV byte ptr [RCX + RAX*0x1 + 0x1],DIL
MOV DIL,byte ptr [RDX + RSI*0x4]
MOV byte ptr [RCX + RAX*0x1 + 0x2],DIL
MOV DL,byte ptr [RDX + RSI*0x4 + 0x3]
MOV byte ptr [RCX + RAX*0x1 + 0x3],DL
LAB_001334b9:
MOV EAX,dword ptr [RBX + 0x885c]
ADD EAX,0x4
MOV dword ptr [RBX + 0x885c],EAX
CMP EAX,dword ptr [RBX + 0x8854]
JL 0x0013352a
MOV ECX,dword ptr [RBX + 0x884c]
MOV EAX,dword ptr [RBX + 0x8858]
MOV dword ptr [RBX + 0x885c],ECX
MOV ECX,dword ptr [RBX + 0x8860]
ADD ECX,dword ptr [RBX + 0x8844]
MOV dword ptr [RBX + 0x8860],ECX
CMP ECX,EAX
JL 0x0013352a
MOV ECX,dword ptr [RBX + 0x8840]
LAB_001334fe:
TEST ECX,ECX
JLE 0x0013352a
MOV EDX,dword ptr [RBX + 0x8864]
SHL EDX,CL
MOV dword ptr [RBX + 0x8844],EDX
SAR EDX,0x1
ADD EDX,dword ptr [RBX + 0x8850]
MOV dword ptr [RBX + 0x8860],EDX
DEC ECX
MOV dword ptr [RBX + 0x8840],ECX
CMP EDX,EAX
JGE 0x001334fe
LAB_0013352a:
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* stbi__out_gif_code(stbi__gif*, unsigned short) */
void stbi__out_gif_code(stbi__gif *param_1,ushort param_2)
{
long lVar1;
long lVar2;
long lVar3;
int iVar4;
int iVar5;
int6 in_register_00000032;
ulong uVar6;
uVar6 = CONCAT62(in_register_00000032,param_2) & 0xffffffff;
if (-1 < (short)*(ushort *)(param_1 + uVar6 * 4 + 0x834)) {
stbi__out_gif_code(param_1,*(ushort *)(param_1 + uVar6 * 4 + 0x834));
}
if (*(int *)(param_1 + 0x8860) < *(int *)(param_1 + 0x8858)) {
lVar3 = (long)*(int *)(param_1 + 0x885c) + (long)*(int *)(param_1 + 0x8860);
lVar1 = *(long *)(param_1 + 8);
iVar4 = (int)lVar3;
iVar5 = iVar4 + 3;
if (-1 < iVar4) {
iVar5 = iVar4;
}
*(int1 *)(*(long *)(param_1 + 0x18) + (long)(iVar5 >> 2)) = 1;
lVar2 = *(long *)(param_1 + 0x8838);
uVar6 = (ulong)(byte)param_1[uVar6 * 4 + 0x837];
if (0x80 < *(byte *)(lVar2 + 3 + uVar6 * 4)) {
*(int1 *)(lVar1 + lVar3) = *(int1 *)(lVar2 + 2 + uVar6 * 4);
*(int1 *)(lVar1 + 1 + lVar3) = *(int1 *)(lVar2 + 1 + uVar6 * 4);
*(int1 *)(lVar1 + 2 + lVar3) = *(int1 *)(lVar2 + uVar6 * 4);
*(int1 *)(lVar1 + 3 + lVar3) = *(int1 *)(lVar2 + 3 + uVar6 * 4);
}
iVar4 = *(int *)(param_1 + 0x885c);
*(int *)(param_1 + 0x885c) = iVar4 + 4;
if (*(int *)(param_1 + 0x8854) <= iVar4 + 4) {
*(int4 *)(param_1 + 0x885c) = *(int4 *)(param_1 + 0x884c);
iVar4 = *(int *)(param_1 + 0x8860);
*(int *)(param_1 + 0x8860) = iVar4 + *(int *)(param_1 + 0x8844);
if (*(int *)(param_1 + 0x8858) <= iVar4 + *(int *)(param_1 + 0x8844)) {
iVar4 = *(int *)(param_1 + 0x8840);
do {
if (iVar4 < 1) {
return;
}
iVar5 = *(int *)(param_1 + 0x8864) << ((byte)iVar4 & 0x1f);
*(int *)(param_1 + 0x8844) = iVar5;
iVar5 = (iVar5 >> 1) + *(int *)(param_1 + 0x8850);
*(int *)(param_1 + 0x8860) = iVar5;
iVar4 = iVar4 + -1;
*(int *)(param_1 + 0x8840) = iVar4;
} while (*(int *)(param_1 + 0x8858) <= iVar5);
}
}
}
return;
}
|
|
63,393 |
my_coll_parser_scan_shift_sequence
|
eloqsql/strings/ctype-uca.c
|
static int
my_coll_parser_scan_shift_sequence(MY_COLL_RULE_PARSER *p)
{
MY_COLL_RULE before_extend;
memset(&p->rule.curr, 0, sizeof(p->rule.curr));
/* Scan single shift character or contraction */
if (!my_coll_parser_scan_character_list(p, p->rule.curr,
MY_UCA_MAX_CONTRACTION,
"Contraction"))
return 0;
before_extend= p->rule; /* Remember the part before "/" */
/* Append the part after "/" as expansion */
if (my_coll_parser_curr(p)->term == MY_COLL_LEXEM_EXTEND)
{
my_coll_parser_scan(p);
if (!my_coll_parser_scan_character_list(p, p->rule.base,
MY_UCA_MAX_EXPANSION,
"Expansion"))
return 0;
}
else if (my_coll_parser_curr(p)->term == MY_COLL_LEXEM_CONTEXT)
{
/*
We support 2-character long context sequences only:
one character is the previous context, plus the current character.
It's OK as Unicode's CLDR does not have longer examples.
*/
my_coll_parser_scan(p);
p->rule.with_context= TRUE;
if (!my_coll_parser_scan_character_list(p, p->rule.curr + 1, 1, "context"))
return 0;
}
/* Add rule to the rule list */
if (my_coll_rules_add(p->rules, &p->rule))
return 0;
p->rule= before_extend; /* Restore to the state before "/" */
return 1;
}
|
O3
|
c
|
my_coll_parser_scan_shift_sequence:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %r15
leaq 0xa0(%rdi), %rsi
xorps %xmm0, %xmm0
movups %xmm0, 0xc0(%rdi)
movups %xmm0, 0xb0(%rdi)
movups %xmm0, 0xa0(%rdi)
leaq 0x1f5ef(%rip), %rcx # 0x7ff90
movl $0x6, %edx
callq 0x60af9
xorl %r14d, %r14d
testl %eax, %eax
je 0x60ae8
leaq 0x50(%r15), %rbx
leaq -0xb8(%rbp), %rdi
movl $0xa0, %edx
movq %rbx, %rsi
callq 0x26290
movl (%r15), %eax
cmpl $0x9, %eax
je 0x60a17
cmpl $0x8, %eax
jne 0x60a66
leaq 0x28(%r15), %rdi
movq 0x48(%r15), %rax
movq %rax, 0x20(%r15)
movups 0x28(%r15), %xmm0
movups 0x38(%r15), %xmm1
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
callq 0x605ff
leaq 0x1f3ba(%rip), %rcx # 0x7fdc4
movl $0xa, %edx
movq %r15, %rdi
movq %rbx, %rsi
jmp 0x60a59
leaq 0x28(%r15), %rdi
movq 0x48(%r15), %rax
movq %rax, 0x20(%r15)
movups 0x28(%r15), %xmm0
movups 0x38(%r15), %xmm1
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
callq 0x605ff
movb $0x1, 0xe8(%r15)
leaq 0xa8(%r15), %rsi
leaq 0x2007d(%rip), %rcx # 0x80ace
movl $0x1, %edx
movq %r15, %rdi
callq 0x60af9
testl %eax, %eax
je 0x60ae8
movq 0xf0(%r15), %r15
movq 0x10(%r15), %rcx
cmpq 0x18(%r15), %rcx
jae 0x60a7d
movq 0x20(%r15), %rax
jmp 0x60aae
movq 0x20(%r15), %rdi
movq 0x28(%r15), %rax
movq 0x90(%rax), %rax
addq $0x81, %rcx
movq %rcx, 0x18(%r15)
shlq $0x5, %rcx
leaq (%rcx,%rcx,4), %rsi
callq *%rax
movq %rax, 0x20(%r15)
testq %rax, %rax
je 0x60ae8
movq 0x10(%r15), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%r15)
leaq (%rcx,%rcx,4), %rdi
shlq $0x5, %rdi
addq %rax, %rdi
movl $0xa0, %edx
movq %rbx, %rsi
callq 0x26290
leaq -0xb8(%rbp), %rsi
movl $0xa0, %edx
movq %rbx, %rdi
callq 0x26290
movl $0x1, %r14d
movl %r14d, %eax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
my_coll_parser_scan_shift_sequence:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 0A8h
mov r15, rdi
lea rsi, [rdi+0A0h]
xorps xmm0, xmm0
movups xmmword ptr [rdi+0C0h], xmm0
movups xmmword ptr [rdi+0B0h], xmm0
movups xmmword ptr [rdi+0A0h], xmm0
lea rcx, aContraction; "Contraction"
mov edx, 6
call my_coll_parser_scan_character_list
xor r14d, r14d
test eax, eax
jz loc_60AE8
lea rbx, [r15+50h]
lea rdi, [rbp+var_B8]
mov edx, 0A0h
mov rsi, rbx
call _memcpy
mov eax, [r15]
cmp eax, 9
jz short loc_60A17
cmp eax, 8
jnz loc_60A66
lea rdi, [r15+28h]
mov rax, [r15+48h]
mov [r15+20h], rax
movups xmm0, xmmword ptr [r15+28h]
movups xmm1, xmmword ptr [r15+38h]
movups xmmword ptr [r15+10h], xmm1
movups xmmword ptr [r15], xmm0
call my_coll_lexem_next
lea rcx, aExpansion; "Expansion"
mov edx, 0Ah
mov rdi, r15
mov rsi, rbx
jmp short loc_60A59
loc_60A17:
lea rdi, [r15+28h]
mov rax, [r15+48h]
mov [r15+20h], rax
movups xmm0, xmmword ptr [r15+28h]
movups xmm1, xmmword ptr [r15+38h]
movups xmmword ptr [r15+10h], xmm1
movups xmmword ptr [r15], xmm0
call my_coll_lexem_next
mov byte ptr [r15+0E8h], 1
lea rsi, [r15+0A8h]
lea rcx, aCharsetsCharse_52+23h; "context"
mov edx, 1
mov rdi, r15
loc_60A59:
call my_coll_parser_scan_character_list
test eax, eax
jz loc_60AE8
loc_60A66:
mov r15, [r15+0F0h]
mov rcx, [r15+10h]
cmp rcx, [r15+18h]
jnb short loc_60A7D
mov rax, [r15+20h]
jmp short loc_60AAE
loc_60A7D:
mov rdi, [r15+20h]
mov rax, [r15+28h]
mov rax, [rax+90h]
add rcx, 81h
mov [r15+18h], rcx
shl rcx, 5
lea rsi, [rcx+rcx*4]
call rax
mov [r15+20h], rax
test rax, rax
jz short loc_60AE8
mov rcx, [r15+10h]
loc_60AAE:
lea rdx, [rcx+1]
mov [r15+10h], rdx
lea rdi, [rcx+rcx*4]
shl rdi, 5
add rdi, rax
mov edx, 0A0h
mov rsi, rbx
call _memcpy
lea rsi, [rbp+var_B8]
mov edx, 0A0h
mov rdi, rbx
call _memcpy
mov r14d, 1
loc_60AE8:
mov eax, r14d
add rsp, 0A8h
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long my_coll_parser_scan_shift_sequence(long long a1)
{
unsigned int v1; // r14d
long long v2; // rbx
__int128 v3; // xmm0
char *v4; // rcx
long long v5; // rdx
long long v6; // rsi
__int128 v7; // xmm0
_QWORD *v8; // r15
unsigned long long v9; // rcx
long long v10; // rax
long long v11; // rdi
long long ( *v12)(long long, long long); // rax
unsigned long long v13; // rcx
_BYTE v15[184]; // [rsp+8h] [rbp-B8h] BYREF
*(_OWORD *)(a1 + 192) = 0LL;
*(_OWORD *)(a1 + 176) = 0LL;
*(_OWORD *)(a1 + 160) = 0LL;
v1 = 0;
if ( !(unsigned int)my_coll_parser_scan_character_list(a1, a1 + 160, 6LL, "Contraction") )
return v1;
v2 = a1 + 80;
memcpy(v15, a1 + 80, 160LL);
if ( *(_DWORD *)a1 == 9 )
{
*(_QWORD *)(a1 + 32) = *(_QWORD *)(a1 + 72);
v7 = *(_OWORD *)(a1 + 40);
*(_OWORD *)(a1 + 16) = *(_OWORD *)(a1 + 56);
*(_OWORD *)a1 = v7;
my_coll_lexem_next(a1 + 40);
*(_BYTE *)(a1 + 232) = 1;
v6 = a1 + 168;
v4 = "context";
v5 = 1LL;
LABEL_6:
if ( !(unsigned int)my_coll_parser_scan_character_list(a1, v6, v5, v4) )
return v1;
goto LABEL_7;
}
if ( *(_DWORD *)a1 == 8 )
{
*(_QWORD *)(a1 + 32) = *(_QWORD *)(a1 + 72);
v3 = *(_OWORD *)(a1 + 40);
*(_OWORD *)(a1 + 16) = *(_OWORD *)(a1 + 56);
*(_OWORD *)a1 = v3;
my_coll_lexem_next(a1 + 40);
v4 = "Expansion";
v5 = 10LL;
v6 = a1 + 80;
goto LABEL_6;
}
LABEL_7:
v8 = *(_QWORD **)(a1 + 240);
v9 = v8[2];
if ( v9 < v8[3] )
{
v10 = v8[4];
LABEL_11:
v8[2] = v9 + 1;
memcpy(v10 + 160 * v9, v2, 160LL);
memcpy(v2, v15, 160LL);
return 1;
}
v11 = v8[4];
v12 = *(long long ( **)(long long, long long))(v8[5] + 144LL);
v13 = v9 + 129;
v8[3] = v13;
v10 = v12(v11, 160 * v13);
v8[4] = v10;
if ( v10 )
{
v9 = v8[2];
goto LABEL_11;
}
return v1;
}
|
my_coll_parser_scan_shift_sequence:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0xa8
MOV R15,RDI
LEA RSI,[RDI + 0xa0]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0xc0],XMM0
MOVUPS xmmword ptr [RDI + 0xb0],XMM0
MOVUPS xmmword ptr [RDI + 0xa0],XMM0
LEA RCX,[0x17ff90]
MOV EDX,0x6
CALL 0x00160af9
XOR R14D,R14D
TEST EAX,EAX
JZ 0x00160ae8
LEA RBX,[R15 + 0x50]
LEA RDI,[RBP + -0xb8]
MOV EDX,0xa0
MOV RSI,RBX
CALL 0x00126290
MOV EAX,dword ptr [R15]
CMP EAX,0x9
JZ 0x00160a17
CMP EAX,0x8
JNZ 0x00160a66
LEA RDI,[R15 + 0x28]
MOV RAX,qword ptr [R15 + 0x48]
MOV qword ptr [R15 + 0x20],RAX
MOVUPS XMM0,xmmword ptr [R15 + 0x28]
MOVUPS XMM1,xmmword ptr [R15 + 0x38]
MOVUPS xmmword ptr [R15 + 0x10],XMM1
MOVUPS xmmword ptr [R15],XMM0
CALL 0x001605ff
LEA RCX,[0x17fdc4]
MOV EDX,0xa
MOV RDI,R15
MOV RSI,RBX
JMP 0x00160a59
LAB_00160a17:
LEA RDI,[R15 + 0x28]
MOV RAX,qword ptr [R15 + 0x48]
MOV qword ptr [R15 + 0x20],RAX
MOVUPS XMM0,xmmword ptr [R15 + 0x28]
MOVUPS XMM1,xmmword ptr [R15 + 0x38]
MOVUPS xmmword ptr [R15 + 0x10],XMM1
MOVUPS xmmword ptr [R15],XMM0
CALL 0x001605ff
MOV byte ptr [R15 + 0xe8],0x1
LEA RSI,[R15 + 0xa8]
LEA RCX,[0x180ace]
MOV EDX,0x1
MOV RDI,R15
LAB_00160a59:
CALL 0x00160af9
TEST EAX,EAX
JZ 0x00160ae8
LAB_00160a66:
MOV R15,qword ptr [R15 + 0xf0]
MOV RCX,qword ptr [R15 + 0x10]
CMP RCX,qword ptr [R15 + 0x18]
JNC 0x00160a7d
MOV RAX,qword ptr [R15 + 0x20]
JMP 0x00160aae
LAB_00160a7d:
MOV RDI,qword ptr [R15 + 0x20]
MOV RAX,qword ptr [R15 + 0x28]
MOV RAX,qword ptr [RAX + 0x90]
ADD RCX,0x81
MOV qword ptr [R15 + 0x18],RCX
SHL RCX,0x5
LEA RSI,[RCX + RCX*0x4]
CALL RAX
MOV qword ptr [R15 + 0x20],RAX
TEST RAX,RAX
JZ 0x00160ae8
MOV RCX,qword ptr [R15 + 0x10]
LAB_00160aae:
LEA RDX,[RCX + 0x1]
MOV qword ptr [R15 + 0x10],RDX
LEA RDI,[RCX + RCX*0x4]
SHL RDI,0x5
ADD RDI,RAX
MOV EDX,0xa0
MOV RSI,RBX
CALL 0x00126290
LEA RSI,[RBP + -0xb8]
MOV EDX,0xa0
MOV RDI,RBX
CALL 0x00126290
MOV R14D,0x1
LAB_00160ae8:
MOV EAX,R14D
ADD RSP,0xa8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int8 my_coll_parser_scan_shift_sequence(int *param_1)
{
int *__src;
long lVar1;
code *pcVar2;
int iVar3;
long lVar4;
char *pcVar5;
ulong uVar6;
int8 uVar7;
int *piVar8;
int1 local_c0 [160];
param_1[0x30] = 0;
param_1[0x31] = 0;
param_1[0x32] = 0;
param_1[0x33] = 0;
param_1[0x2c] = 0;
param_1[0x2d] = 0;
param_1[0x2e] = 0;
param_1[0x2f] = 0;
param_1[0x28] = 0;
param_1[0x29] = 0;
param_1[0x2a] = 0;
param_1[0x2b] = 0;
iVar3 = my_coll_parser_scan_character_list(param_1,param_1 + 0x28,6,"Contraction");
if (iVar3 == 0) {
return 0;
}
__src = param_1 + 0x14;
memcpy(local_c0,__src,0xa0);
if (*param_1 == 9) {
*(int8 *)(param_1 + 8) = *(int8 *)(param_1 + 0x12);
param_1[4] = param_1[0xe];
param_1[5] = param_1[0xf];
param_1[6] = param_1[0x10];
param_1[7] = param_1[0x11];
*param_1 = param_1[10];
param_1[1] = param_1[0xb];
param_1[2] = param_1[0xc];
param_1[3] = param_1[0xd];
my_coll_lexem_next(param_1 + 10);
*(int1 *)(param_1 + 0x3a) = 1;
piVar8 = param_1 + 0x2a;
pcVar5 = "context";
uVar7 = 1;
}
else {
if (*param_1 != 8) goto LAB_00160a66;
*(int8 *)(param_1 + 8) = *(int8 *)(param_1 + 0x12);
param_1[4] = param_1[0xe];
param_1[5] = param_1[0xf];
param_1[6] = param_1[0x10];
param_1[7] = param_1[0x11];
*param_1 = param_1[10];
param_1[1] = param_1[0xb];
param_1[2] = param_1[0xc];
param_1[3] = param_1[0xd];
my_coll_lexem_next(param_1 + 10);
pcVar5 = "Expansion";
uVar7 = 10;
piVar8 = __src;
}
iVar3 = my_coll_parser_scan_character_list(param_1,piVar8,uVar7,pcVar5);
if (iVar3 == 0) {
return 0;
}
LAB_00160a66:
lVar1 = *(long *)(param_1 + 0x3c);
uVar6 = *(ulong *)(lVar1 + 0x10);
if (uVar6 < *(ulong *)(lVar1 + 0x18)) {
lVar4 = *(long *)(lVar1 + 0x20);
}
else {
pcVar2 = *(code **)(*(long *)(lVar1 + 0x28) + 0x90);
*(ulong *)(lVar1 + 0x18) = uVar6 + 0x81;
lVar4 = (*pcVar2)(*(int8 *)(lVar1 + 0x20),(uVar6 + 0x81) * 0xa0);
*(long *)(lVar1 + 0x20) = lVar4;
if (lVar4 == 0) {
return 0;
}
uVar6 = *(ulong *)(lVar1 + 0x10);
}
*(ulong *)(lVar1 + 0x10) = uVar6 + 1;
memcpy((void *)(uVar6 * 0xa0 + lVar4),__src,0xa0);
memcpy(__src,local_c0,0xa0);
return 1;
}
|
|
63,394 |
google::protobuf::io::LimitingInputStream::Next(void const**, int*)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_stream_impl_lite.cc
|
bool LimitingInputStream::Next(const void** data, int* size) {
if (limit_ <= 0) return false;
if (!input_->Next(data, size)) return false;
limit_ -= *size;
if (limit_ < 0) {
// We overshot the limit. Reduce *size to hide the rest of the buffer.
*size += limit_;
}
return true;
}
|
O3
|
cpp
|
google::protobuf::io::LimitingInputStream::Next(void const**, int*):
cmpq $0x0, 0x10(%rdi)
jle 0xfd0b7
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0xfd0ba
movslq (%rbx), %rdx
movq 0x10(%r14), %rcx
subq %rdx, %rcx
movq %rcx, 0x10(%r14)
movb $0x1, %al
jns 0xfd0bc
addl %edx, %ecx
movl %ecx, (%rbx)
jmp 0xfd0bc
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
_ZN6google8protobuf2io19LimitingInputStream4NextEPPKvPi:
cmp qword ptr [rdi+10h], 0
jle short loc_FD0B7
push r14
push rbx
push rax
mov rbx, rdx
mov r14, rdi
mov rdi, [rdi+8]
mov rax, [rdi]
call qword ptr [rax+10h]
test al, al
jz short loc_FD0BA
movsxd rdx, dword ptr [rbx]
mov rcx, [r14+10h]
sub rcx, rdx
mov [r14+10h], rcx
mov al, 1
jns short loc_FD0BC
add ecx, edx
mov [rbx], ecx
jmp short loc_FD0BC
loc_FD0B7:
xor eax, eax
retn
loc_FD0BA:
xor eax, eax
loc_FD0BC:
add rsp, 8
pop rbx
pop r14
retn
|
char google::protobuf::io::LimitingInputStream::Next(
google::protobuf::io::LimitingInputStream *this,
const void **a2,
int *a3)
{
long long v4; // rdx
long long v5; // rcx
char result; // al
if ( *((long long *)this + 2) <= 0 )
return 0;
if ( !(*(unsigned __int8 ( **)(_QWORD, const void **))(**((_QWORD **)this + 1) + 16LL))(
*((_QWORD *)this + 1),
a2) )
return 0;
v4 = *a3;
v5 = *((_QWORD *)this + 2) - v4;
*((_QWORD *)this + 2) = v5;
result = 1;
if ( v5 < 0 )
*a3 = v4 + v5;
return result;
}
|
Next:
CMP qword ptr [RDI + 0x10],0x0
JLE 0x001fd0b7
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RDI
MOV RDI,qword ptr [RDI + 0x8]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x10]
TEST AL,AL
JZ 0x001fd0ba
MOVSXD RDX,dword ptr [RBX]
MOV RCX,qword ptr [R14 + 0x10]
SUB RCX,RDX
MOV qword ptr [R14 + 0x10],RCX
MOV AL,0x1
JNS 0x001fd0bc
ADD ECX,EDX
MOV dword ptr [RBX],ECX
JMP 0x001fd0bc
LAB_001fd0b7:
XOR EAX,EAX
RET
LAB_001fd0ba:
XOR EAX,EAX
LAB_001fd0bc:
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* google::protobuf::io::LimitingInputStream::Next(void const**, int*) */
int8 __thiscall
google::protobuf::io::LimitingInputStream::Next
(LimitingInputStream *this,void **param_1,int *param_2)
{
int iVar1;
char cVar2;
int8 uVar3;
long lVar4;
if (0 < *(long *)(this + 0x10)) {
cVar2 = (**(code **)(**(long **)(this + 8) + 0x10))();
if (cVar2 == '\0') {
uVar3 = 0;
}
else {
iVar1 = *param_2;
lVar4 = *(long *)(this + 0x10) - (long)iVar1;
*(long *)(this + 0x10) = lVar4;
uVar3 = 1;
if (lVar4 < 0) {
*param_2 = (int)lVar4 + iVar1;
}
}
return uVar3;
}
return 0;
}
|
|
63,395 |
ggml_backend_tensor_get_and_sync(ggml_backend*, ggml_tensor const*, void*, unsigned long, unsigned long)
|
7CodeWizard[P]stablediffusion/ggml_extend.hpp
|
__STATIC_INLINE__ void ggml_backend_tensor_get_and_sync(ggml_backend_t backend, const struct ggml_tensor* tensor, void* data, size_t offset, size_t size) {
#ifdef SD_USE_CUBLAS
ggml_backend_tensor_get_async(backend, tensor, data, offset, size);
ggml_backend_synchronize(backend);
#else
ggml_backend_tensor_get(tensor, data, offset, size);
#endif
}
|
O0
|
cpp
|
ggml_backend_tensor_get_and_sync(ggml_backend*, ggml_tensor const*, void*, unsigned long, unsigned long):
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
callq 0x166fb0
addq $0x28, %rsp
retq
nopl (%rax)
|
_ZL32ggml_backend_tensor_get_and_syncP12ggml_backendPK11ggml_tensorPvmm:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_10], rsi
mov [rsp+28h+var_18], rdx
mov [rsp+28h+var_20], rcx
mov [rsp+28h+var_28], r8
mov rdi, [rsp+28h+var_10]
mov rsi, [rsp+28h+var_18]
mov rdx, [rsp+28h+var_20]
mov rcx, [rsp+28h+var_28]
call ggml_backend_tensor_get
add rsp, 28h
retn
|
long long ggml_backend_tensor_get_and_sync(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6)
{
return ggml_backend_tensor_get(a2, a3, a4, a5, a5, a6, a5, a4, a3, a2, a1);
}
|
ggml_backend_tensor_get_and_sync:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x18],RSI
MOV qword ptr [RSP + 0x10],RDX
MOV qword ptr [RSP + 0x8],RCX
MOV qword ptr [RSP],R8
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP]
CALL 0x00266fb0
ADD RSP,0x28
RET
|
/* ggml_backend_tensor_get_and_sync(ggml_backend*, ggml_tensor const*, void*, unsigned long,
unsigned long) */
void ggml_backend_tensor_get_and_sync
(ggml_backend *param_1,ggml_tensor *param_2,void *param_3,ulong param_4,ulong param_5
)
{
ggml_backend_tensor_get(param_2,param_3,param_4,param_5);
return;
}
|
|
63,396 |
string_view::operator[](unsigned long) const
|
monkey531[P]llama/common/json-schema-to-grammar.cpp
|
char operator[](size_t pos) const {
auto index = _start + pos;
if (index >= _end) {
throw std::out_of_range("string_view index out of range");
}
return _str[_start + pos];
}
|
O1
|
cpp
|
string_view::operator[](unsigned long) const:
pushq %r14
pushq %rbx
pushq %rax
addq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
jae 0xcab9f
movq (%rdi), %rax
movq (%rax), %rax
movb (%rax,%rsi), %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x1a430
movq %rax, %rbx
leaq 0x2ae17(%rip), %rsi # 0xf59ca
movq %rax, %rdi
callq 0x1a110
movq 0x613ee(%rip), %rsi # 0x12bfb0
movq 0x613c7(%rip), %rdx # 0x12bf90
movq %rbx, %rdi
callq 0x1aea0
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a640
movq %r14, %rdi
callq 0x1af20
|
_ZNK11string_viewixEm:
push r14
push rbx
push rax
add rsi, [rdi+8]
cmp rsi, [rdi+10h]
jnb short loc_CAB9F
mov rax, [rdi]
mov rax, [rax]
mov al, [rax+rsi]
add rsp, 8
pop rbx
pop r14
retn
loc_CAB9F:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aStringViewInde; "string_view index out of range"
mov rdi, rax; this
call __ZNSt12out_of_rangeC1EPKc; std::out_of_range::out_of_range(char const*)
mov rsi, cs:_ZTISt12out_of_range_ptr; lptinfo
mov rdx, cs:_ZNSt12out_of_rangeD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
mov rdi, rbx; void *
call ___cxa_free_exception
mov rdi, r14
call __Unwind_Resume
|
char string_view::operator[](long long a1, long long a2)
{
unsigned long long v2; // rsi
std::out_of_range *exception; // rbx
v2 = *(_QWORD *)(a1 + 8) + a2;
if ( v2 >= *(_QWORD *)(a1 + 16) )
{
exception = (std::out_of_range *)__cxa_allocate_exception(0x10uLL);
std::out_of_range::out_of_range(exception, "string_view index out of range");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::out_of_range,
(void (*)(void *))&std::out_of_range::~out_of_range);
}
return *(_BYTE *)(**(_QWORD **)a1 + v2);
}
|
operator[]:
PUSH R14
PUSH RBX
PUSH RAX
ADD RSI,qword ptr [RDI + 0x8]
CMP RSI,qword ptr [RDI + 0x10]
JNC 0x001cab9f
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX]
MOV AL,byte ptr [RAX + RSI*0x1]
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_001cab9f:
MOV EDI,0x10
CALL 0x0011a430
MOV RBX,RAX
LAB_001cabac:
LEA RSI,[0x1f59ca]
MOV RDI,RAX
CALL 0x0011a110
LAB_001cabbb:
MOV RSI,qword ptr [0x0022bfb0]
MOV RDX,qword ptr [0x0022bf90]
MOV RDI,RBX
CALL 0x0011aea0
|
/* string_view::operator[](unsigned long) const */
int8 __thiscall string_view::operator[](string_view *this,ulong param_1)
{
out_of_range *this_00;
if (param_1 + *(long *)(this + 8) < *(ulong *)(this + 0x10)) {
return CONCAT71((int7)((ulong)**(long **)this >> 8),
*(int1 *)(**(long **)this + param_1 + *(long *)(this + 8)));
}
this_00 = (out_of_range *)__cxa_allocate_exception(0x10);
/* try { // try from 001cabac to 001cabba has its CatchHandler @ 001cabd1 */
std::out_of_range::out_of_range(this_00,"string_view index out of range");
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_0022bfb0,PTR__out_of_range_0022bf90);
}
|
|
63,397 |
string_view::operator[](unsigned long) const
|
monkey531[P]llama/common/json-schema-to-grammar.cpp
|
char operator[](size_t pos) const {
auto index = _start + pos;
if (index >= _end) {
throw std::out_of_range("string_view index out of range");
}
return _str[_start + pos];
}
|
O2
|
cpp
|
string_view::operator[](unsigned long) const:
pushq %r14
pushq %rbx
pushq %rax
addq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
jae 0x94f55
movq (%rdi), %rax
movq (%rax), %rax
movb (%rax,%rsi), %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x23450
movq %rax, %rbx
leaq 0x22a46(%rip), %rsi # 0xb79ad
movq %rax, %rdi
callq 0x23100
movq 0x67042(%rip), %rsi # 0xfbfb8
movq 0x6701b(%rip), %rdx # 0xfbf98
movq %rbx, %rdi
callq 0x23e90
movq %rax, %r14
movq %rbx, %rdi
callq 0x23660
movq %r14, %rdi
callq 0x23f10
|
_ZNK11string_viewixEm:
push r14
push rbx
push rax
add rsi, [rdi+8]
cmp rsi, [rdi+10h]
jnb short loc_94F55
mov rax, [rdi]
mov rax, [rax]
mov al, [rax+rsi]
add rsp, 8
pop rbx
pop r14
retn
loc_94F55:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aStringViewInde; "string_view index out of range"
mov rdi, rax; this
call __ZNSt12out_of_rangeC1EPKc; std::out_of_range::out_of_range(char const*)
mov rsi, cs:_ZTISt12out_of_range_ptr; lptinfo
mov rdx, cs:_ZNSt12out_of_rangeD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
mov rdi, rbx; void *
call ___cxa_free_exception
mov rdi, r14
call __Unwind_Resume
|
char string_view::operator[](long long a1, long long a2)
{
unsigned long long v2; // rsi
std::out_of_range *exception; // rbx
v2 = *(_QWORD *)(a1 + 8) + a2;
if ( v2 >= *(_QWORD *)(a1 + 16) )
{
exception = (std::out_of_range *)__cxa_allocate_exception(0x10uLL);
std::out_of_range::out_of_range(exception, "string_view index out of range");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::out_of_range,
(void (*)(void *))&std::out_of_range::~out_of_range);
}
return *(_BYTE *)(**(_QWORD **)a1 + v2);
}
|
operator[]:
PUSH R14
PUSH RBX
PUSH RAX
ADD RSI,qword ptr [RDI + 0x8]
CMP RSI,qword ptr [RDI + 0x10]
JNC 0x00194f55
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX]
MOV AL,byte ptr [RAX + RSI*0x1]
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_00194f55:
PUSH 0x10
POP RDI
CALL 0x00123450
MOV RBX,RAX
LAB_00194f60:
LEA RSI,[0x1b79ad]
MOV RDI,RAX
CALL 0x00123100
LAB_00194f6f:
MOV RSI,qword ptr [0x001fbfb8]
MOV RDX,qword ptr [0x001fbf98]
MOV RDI,RBX
CALL 0x00123e90
|
/* string_view::operator[](unsigned long) const */
int8 __thiscall string_view::operator[](string_view *this,ulong param_1)
{
out_of_range *this_00;
if (param_1 + *(long *)(this + 8) < *(ulong *)(this + 0x10)) {
return CONCAT71((int7)((ulong)**(long **)this >> 8),
*(int1 *)(**(long **)this + param_1 + *(long *)(this + 8)));
}
this_00 = (out_of_range *)__cxa_allocate_exception(0x10);
/* try { // try from 00194f60 to 00194f6e has its CatchHandler @ 00194f85 */
std::out_of_range::out_of_range(this_00,"string_view index out of range");
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_001fbfb8,PTR__out_of_range_001fbf98);
}
|
|
63,398 |
int2str
|
eloqsql/strings/int2str.c
|
char *
int2str(register long int val, register char *dst, register int radix,
int upcase)
{
char buffer[65];
register char *p;
long int new_val;
const char *dig_vec= upcase ? _dig_vec_upper : _dig_vec_lower;
ulong uval= (ulong) val;
if (radix < 0)
{
if (radix < -36 || radix > -2)
return NullS;
if (val < 0)
{
*dst++ = '-';
/* Avoid integer overflow in (-val) for LONGLONG_MIN (BUG#31799). */
uval = (ulong)0 - uval;
}
radix = -radix;
}
else if (radix > 36 || radix < 2)
return NullS;
/*
The slightly contorted code which follows is due to the fact that
few machines directly support unsigned long / and %. Certainly
the VAX C compiler generates a subroutine call. In the interests
of efficiency (hollow laugh) I let this happen for the first digit
only; after that "val" will be in range so that signed integer
division will do. Sorry 'bout that. CHECK THE CODE PRODUCED BY
YOUR C COMPILER. The first % and / should be unsigned, the second
% and / signed, but C compilers tend to be extraordinarily
sensitive to minor details of style. This works on a VAX, that's
all I claim for it.
*/
p = &buffer[sizeof(buffer)-1];
*p = '\0';
new_val= uval / (ulong) radix;
*--p = dig_vec[(uchar) (uval- (ulong) new_val*(ulong) radix)];
val = new_val;
#ifdef HAVE_LDIV
while (val != 0)
{
ldiv_t res;
res=ldiv(val,radix);
*--p = dig_vec[res.rem];
val= res.quot;
}
#else
while (val != 0)
{
new_val=val/radix;
*--p = dig_vec[(uchar) (val-new_val*radix)];
val= new_val;
}
#endif
while ((*dst++ = *p++) != 0) ;
return dst-1;
}
|
O3
|
c
|
int2str:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x28(%rbp)
testl %ecx, %ecx
jne 0xd4fb0
leaq 0x285ae2(%rip), %r15 # 0x35aa90
jmp 0xd4fb7
leaq 0x285aa9(%rip), %r15 # 0x35aa60
testl %edx, %edx
js 0xd4fc5
leal -0x25(%rdx), %eax
cmpl $-0x23, %eax
jb 0xd4fcd
jmp 0xd4fe1
leal 0x1(%rdx), %eax
cmpl $-0x23, %eax
jae 0xd4fd1
xorl %ebx, %ebx
jmp 0xd5036
testq %rdi, %rdi
jns 0xd4fdf
movb $0x2d, (%rbx)
incq %rbx
negq %rdi
negl %edx
leaq -0x31(%rbp), %r12
movb $0x0, 0x1(%r12)
movl %edx, %r14d
movq %rdi, %rax
xorl %edx, %edx
divq %r14
movzbl %dl, %ecx
movb (%r15,%rcx), %cl
movb %cl, (%r12)
cmpq %r14, %rdi
jb 0xd5022
movq %rax, %rdi
movq %r14, %rsi
callq 0x294e0
movb (%r15,%rdx), %cl
movb %cl, -0x1(%r12)
decq %r12
testq %rax, %rax
jne 0xd5006
decq %rbx
movb (%r12), %al
incq %r12
movb %al, 0x1(%rbx)
incq %rbx
testb %al, %al
jne 0xd5025
movq %fs:0x28, %rax
cmpq -0x28(%rbp), %rax
jne 0xd5055
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x29260
|
int2str:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 50h
mov rbx, rsi
mov rax, fs:28h
mov [rbp+var_28], rax
test ecx, ecx
jnz short loc_D4FB0
lea r15, _dig_vec_lower; "0123456789abcdefghijklmnopqrstuvwxyz"
jmp short loc_D4FB7
loc_D4FB0:
lea r15, _dig_vec_upper; "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
loc_D4FB7:
test edx, edx
js short loc_D4FC5
lea eax, [rdx-25h]
cmp eax, 0FFFFFFDDh
jb short loc_D4FCD
jmp short loc_D4FE1
loc_D4FC5:
lea eax, [rdx+1]
cmp eax, 0FFFFFFDDh
jnb short loc_D4FD1
loc_D4FCD:
xor ebx, ebx
jmp short loc_D5036
loc_D4FD1:
test rdi, rdi
jns short loc_D4FDF
mov byte ptr [rbx], 2Dh ; '-'
inc rbx
neg rdi
loc_D4FDF:
neg edx
loc_D4FE1:
lea r12, [rbp+var_31]
mov byte ptr [r12+1], 0
mov r14d, edx
mov rax, rdi
xor edx, edx
div r14
movzx ecx, dl
mov cl, [r15+rcx]
mov [r12], cl
cmp rdi, r14
jb short loc_D5022
loc_D5006:
mov rdi, rax
mov rsi, r14
call _ldiv
mov cl, [r15+rdx]
mov [r12-1], cl
dec r12
test rax, rax
jnz short loc_D5006
loc_D5022:
dec rbx
loc_D5025:
mov al, [r12]
inc r12
mov [rbx+1], al
inc rbx
test al, al
jnz short loc_D5025
loc_D5036:
mov rax, fs:28h
cmp rax, [rbp+var_28]
jnz short loc_D5055
mov rax, rbx
add rsp, 50h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_D5055:
call ___stack_chk_fail
|
_BYTE * int2str(unsigned long long a1, _BYTE *a2, unsigned int a3, int a4)
{
_BYTE *v4; // rbx
const char *v5; // r15
_BYTE *v6; // rbx
char *v7; // r12
long long v8; // r14
unsigned long long v9; // rax
long long v10; // rdx
char v11; // al
_BYTE v13[9]; // [rsp+3Fh] [rbp-31h] BYREF
unsigned long long v14; // [rsp+48h] [rbp-28h]
v4 = a2;
v14 = __readfsqword(0x28u);
if ( a4 )
v5 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
else
v5 = "0123456789abcdefghijklmnopqrstuvwxyz";
if ( (a3 & 0x80000000) != 0 )
{
if ( a3 + 1 >= 0xFFFFFFDD )
{
if ( (a1 & 0x8000000000000000LL) != 0LL )
{
*a2 = 45;
v4 = a2 + 1;
a1 = -(long long)a1;
}
a3 = -a3;
goto LABEL_12;
}
return 0LL;
}
if ( a3 - 37 < 0xFFFFFFDD )
return 0LL;
LABEL_12:
v7 = v13;
v13[1] = 0;
v8 = a3;
v9 = a1 / a3;
v13[0] = v5[(unsigned __int8)(a1 % a3)];
if ( a1 >= a3 )
{
do
{
v9 = ldiv(v9, v8);
*--v7 = v5[v10];
}
while ( v9 );
}
v6 = v4 - 1;
do
{
v11 = *v7++;
*++v6 = v11;
}
while ( v11 );
return v6;
}
|
int2str:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x50
MOV RBX,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
TEST ECX,ECX
JNZ 0x001d4fb0
LEA R15,[0x45aa90]
JMP 0x001d4fb7
LAB_001d4fb0:
LEA R15,[0x45aa60]
LAB_001d4fb7:
TEST EDX,EDX
JS 0x001d4fc5
LEA EAX,[RDX + -0x25]
CMP EAX,-0x23
JC 0x001d4fcd
JMP 0x001d4fe1
LAB_001d4fc5:
LEA EAX,[RDX + 0x1]
CMP EAX,-0x23
JNC 0x001d4fd1
LAB_001d4fcd:
XOR EBX,EBX
JMP 0x001d5036
LAB_001d4fd1:
TEST RDI,RDI
JNS 0x001d4fdf
MOV byte ptr [RBX],0x2d
INC RBX
NEG RDI
LAB_001d4fdf:
NEG EDX
LAB_001d4fe1:
LEA R12,[RBP + -0x31]
MOV byte ptr [R12 + 0x1],0x0
MOV R14D,EDX
MOV RAX,RDI
XOR EDX,EDX
DIV R14
MOVZX ECX,DL
MOV CL,byte ptr [R15 + RCX*0x1]
MOV byte ptr [R12],CL
CMP RDI,R14
JC 0x001d5022
LAB_001d5006:
MOV RDI,RAX
MOV RSI,R14
CALL 0x001294e0
MOV CL,byte ptr [R15 + RDX*0x1]
MOV byte ptr [R12 + -0x1],CL
DEC R12
TEST RAX,RAX
JNZ 0x001d5006
LAB_001d5022:
DEC RBX
LAB_001d5025:
MOV AL,byte ptr [R12]
INC R12
MOV byte ptr [RBX + 0x1],AL
INC RBX
TEST AL,AL
JNZ 0x001d5025
LAB_001d5036:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x28]
JNZ 0x001d5055
MOV RAX,RBX
ADD RSP,0x50
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001d5055:
CALL 0x00129260
|
int1 * int2str(ulong param_1,int1 *param_2,uint param_3,int param_4)
{
char cVar1;
ulong __numer;
char *pcVar2;
ulong __denom;
char *pcVar3;
long in_FS_OFFSET;
ldiv_t lVar4;
char local_3a [10];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
if (param_4 == 0) {
pcVar3 = "0123456789abcdefghijklmnopqrstuvwxyz";
}
else {
pcVar3 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
}
if ((int)param_3 < 0) {
if (param_3 + 1 < 0xffffffdd) goto LAB_001d4fcd;
if ((long)param_1 < 0) {
*param_2 = 0x2d;
param_2 = param_2 + 1;
param_1 = -param_1;
}
param_3 = -param_3;
}
else if (param_3 - 0x25 < 0xffffffdd) {
LAB_001d4fcd:
param_2 = (int1 *)0x0;
goto LAB_001d5036;
}
pcVar2 = local_3a + 1;
local_3a[2] = 0;
__denom = (ulong)param_3;
__numer = param_1 / __denom;
local_3a[1] = pcVar3[param_1 % __denom & 0xff];
if (__denom <= param_1) {
do {
lVar4 = ldiv(__numer,__denom);
__numer = lVar4.quot;
pcVar2[-1] = pcVar3[lVar4.rem];
pcVar2 = pcVar2 + -1;
} while (__numer != 0);
}
param_2 = param_2 + -1;
do {
cVar1 = *pcVar2;
pcVar2 = pcVar2 + 1;
param_2[1] = cVar1;
param_2 = param_2 + 1;
} while (cVar1 != '\0');
LAB_001d5036:
if (*(long *)(in_FS_OFFSET + 0x28) != local_30) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_2;
}
|
|
63,399 |
testing::internal::(anonymous namespace)::SplitEscapedString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/src/gtest.cc
|
std::vector<std::string> SplitEscapedString(const std::string& str) {
std::vector<std::string> lines;
size_t start = 0, end = str.size();
if (end > 2 && str[0] == '"' && str[end - 1] == '"') {
++start;
--end;
}
bool escaped = false;
for (size_t i = start; i + 1 < end; ++i) {
if (escaped) {
escaped = false;
if (str[i] == 'n') {
lines.push_back(str.substr(start, i - start - 1));
start = i + 1;
}
} else {
escaped = str[i] == '\\';
}
}
lines.push_back(str.substr(start, end - start));
return lines;
}
|
O1
|
cpp
|
testing::internal::(anonymous namespace)::SplitEscapedString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r15
cmpq $0x3, %r15
jb 0x1e0fd
movq (%r14), %rax
cmpb $0x22, (%rax)
jne 0x1e0fd
xorl %edx, %edx
cmpb $0x22, -0x1(%rax,%r15)
leaq -0x1(%r15), %rax
sete %dl
cmoveq %rax, %r15
jmp 0x1e0ff
xorl %edx, %edx
leaq 0x1(%rdx), %rbp
cmpq %r15, %rbp
jae 0x1e174
leaq 0x18(%rsp), %r13
xorl %eax, %eax
leaq 0x8(%rsp), %r12
movq (%r14), %rcx
movb -0x1(%rcx,%rbp), %cl
testb $0x1, %al
je 0x1e162
cmpb $0x6e, %cl
jne 0x1e16a
movq %rbp, %rcx
subq %rdx, %rcx
addq $-0x2, %rcx
movq %r12, %rdi
movq %r14, %rsi
callq 0x8510
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3a1ee
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1e15b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84e0
xorl %eax, %eax
movq %rbp, %rdx
jmp 0x1e16c
cmpb $0x5c, %cl
sete %al
jmp 0x1e16c
xorl %eax, %eax
incq %rbp
cmpq %rbp, %r15
jne 0x1e114
subq %rdx, %r15
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x8510
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3a1ee
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1e1af
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84e0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x1e1e3
jmp 0x1e1f5
jmp 0x1e1f2
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1e1f5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84e0
jmp 0x1e1f5
movq %rax, %r14
movq %rbx, %rdi
callq 0x3244c
movq %r14, %rdi
callq 0x8990
|
_ZN7testing8internal12_GLOBAL__N_118SplitEscapedStringERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r14, rsi
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov r15, [rsi+8]
cmp r15, 3
jb short loc_1E0FD
mov rax, [r14]
cmp byte ptr [rax], 22h ; '"'
jnz short loc_1E0FD
xor edx, edx
cmp byte ptr [rax+r15-1], 22h ; '"'
lea rax, [r15-1]
setz dl
cmovz r15, rax
jmp short loc_1E0FF
loc_1E0FD:
xor edx, edx
loc_1E0FF:
lea rbp, [rdx+1]
cmp rbp, r15
jnb short loc_1E174
lea r13, [rsp+58h+var_40]
xor eax, eax
lea r12, [rsp+58h+var_50]
loc_1E114:
mov rcx, [r14]
mov cl, [rcx+rbp-1]
test al, 1
jz short loc_1E162
cmp cl, 6Eh ; 'n'
jnz short loc_1E16A
mov rcx, rbp
sub rcx, rdx
add rcx, 0FFFFFFFFFFFFFFFEh
mov rdi, r12
mov rsi, r14
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
mov rdi, rbx
mov rsi, r12
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJS5_EEEvDpOT_; std::vector<std::string>::emplace_back<std::string>(std::string &&)
mov rdi, [rsp+58h+var_50]; void *
cmp rdi, r13
jz short loc_1E15B
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1E15B:
xor eax, eax
mov rdx, rbp
jmp short loc_1E16C
loc_1E162:
cmp cl, 5Ch ; '\'
setz al
jmp short loc_1E16C
loc_1E16A:
xor eax, eax
loc_1E16C:
inc rbp
cmp r15, rbp
jnz short loc_1E114
loc_1E174:
sub r15, rdx
lea rdi, [rsp+58h+var_50]
mov rsi, r14
mov rcx, r15
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
lea rsi, [rsp+58h+var_50]
mov rdi, rbx
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJS5_EEEvDpOT_; std::vector<std::string>::emplace_back<std::string>(std::string &&)
lea rax, [rsp+58h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_1E1AF
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1E1AF:
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r14, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]
cmp rdi, rax
jnz short loc_1E1E3
jmp short loc_1E1F5
jmp short loc_1E1F2
mov r14, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, r13
jz short loc_1E1F5
loc_1E1E3:
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_1E1F5
loc_1E1F2:
mov r14, rax
loc_1E1F5:
mov rdi, rbx; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, r14
call __Unwind_Resume
|
long long testing::internal::`anonymous namespace'::SplitEscapedString(long long a1, _QWORD *a2)
{
unsigned long long v2; // r15
_BYTE *v3; // rax
_BOOL8 v4; // rdx
long long v5; // rbp
bool v6; // al
char v7; // cl
void *v9[2]; // [rsp+8h] [rbp-50h] BYREF
_QWORD v10[8]; // [rsp+18h] [rbp-40h] BYREF
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
v2 = a2[1];
if ( v2 >= 3 && (v3 = (_BYTE *)*a2, *(_BYTE *)*a2 == 34) )
{
v4 = v3[v2 - 1] == 34;
if ( v3[v2 - 1] == 34 )
--v2;
}
else
{
v4 = 0LL;
}
v5 = v4 + 1;
if ( v4 + 1 < v2 )
{
v6 = 0;
do
{
v7 = *(_BYTE *)(*a2 + v5 - 1);
if ( v6 )
{
if ( v7 == 110 )
{
std::string::substr(v9, a2, v4, v5 - v4 - 2);
std::vector<std::string>::emplace_back<std::string>(a1, v9);
if ( v9[0] != v10 )
operator delete(v9[0], v10[0] + 1LL);
v6 = 0;
v4 = v5;
}
else
{
v6 = 0;
}
}
else
{
v6 = v7 == 92;
}
++v5;
}
while ( v2 != v5 );
}
std::string::substr(v9, a2, v4, v2 - v4);
std::vector<std::string>::emplace_back<std::string>(a1, v9);
if ( v9[0] != v10 )
operator delete(v9[0], v10[0] + 1LL);
return a1;
}
|
SplitEscapedString:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV R15,qword ptr [RSI + 0x8]
CMP R15,0x3
JC 0x0011e0fd
MOV RAX,qword ptr [R14]
CMP byte ptr [RAX],0x22
JNZ 0x0011e0fd
XOR EDX,EDX
CMP byte ptr [RAX + R15*0x1 + -0x1],0x22
LEA RAX,[R15 + -0x1]
SETZ DL
CMOVZ R15,RAX
JMP 0x0011e0ff
LAB_0011e0fd:
XOR EDX,EDX
LAB_0011e0ff:
LEA RBP,[RDX + 0x1]
CMP RBP,R15
JNC 0x0011e174
LEA R13,[RSP + 0x18]
XOR EAX,EAX
LEA R12,[RSP + 0x8]
LAB_0011e114:
MOV RCX,qword ptr [R14]
MOV CL,byte ptr [RCX + RBP*0x1 + -0x1]
TEST AL,0x1
JZ 0x0011e162
CMP CL,0x6e
JNZ 0x0011e16a
MOV RCX,RBP
SUB RCX,RDX
ADD RCX,-0x2
LAB_0011e12e:
MOV RDI,R12
MOV RSI,R14
CALL 0x00108510
LAB_0011e139:
MOV RDI,RBX
MOV RSI,R12
CALL 0x0013a1ee
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R13
JZ 0x0011e15b
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001084e0
LAB_0011e15b:
XOR EAX,EAX
MOV RDX,RBP
JMP 0x0011e16c
LAB_0011e162:
CMP CL,0x5c
SETZ AL
JMP 0x0011e16c
LAB_0011e16a:
XOR EAX,EAX
LAB_0011e16c:
INC RBP
CMP R15,RBP
JNZ 0x0011e114
LAB_0011e174:
SUB R15,RDX
LAB_0011e177:
LEA RDI,[RSP + 0x8]
MOV RSI,R14
MOV RCX,R15
CALL 0x00108510
LAB_0011e187:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x0013a1ee
LAB_0011e194:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0011e1af
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001084e0
LAB_0011e1af:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* testing::internal::(anonymous namespace)::SplitEscapedString(std::__cxx11::string const&) */
_anonymous_namespace_ * __thiscall
testing::internal::(anonymous_namespace)::SplitEscapedString
(_anonymous_namespace_ *this,string *param_1)
{
char cVar1;
ulong uVar2;
ulong uVar3;
bool bVar4;
long *local_50 [2];
long local_40 [2];
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
uVar3 = *(ulong *)(param_1 + 8);
if ((uVar3 < 3) || (**(char **)param_1 != '\"')) {
uVar2 = 0;
}
else {
bVar4 = (*(char **)param_1)[uVar3 - 1] == '\"';
uVar2 = (ulong)bVar4;
if (bVar4) {
uVar3 = uVar3 - 1;
}
}
uVar2 = uVar2 + 1;
if (uVar2 < uVar3) {
bVar4 = false;
do {
cVar1 = *(char *)(*(long *)param_1 + -1 + uVar2);
if (bVar4) {
if (cVar1 == 'n') {
/* try { // try from 0011e12e to 0011e138 has its CatchHandler @ 0011e1f2 */
std::__cxx11::string::substr((ulong)local_50,(ulong)param_1);
/* try { // try from 0011e139 to 0011e143 has its CatchHandler @ 0011e1d6 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<std::__cxx11::string>
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)this,
(string *)local_50);
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
bVar4 = false;
}
else {
bVar4 = false;
}
}
else {
bVar4 = cVar1 == '\\';
}
uVar2 = uVar2 + 1;
} while (uVar3 != uVar2);
}
/* try { // try from 0011e177 to 0011e186 has its CatchHandler @ 0011e1d4 */
std::__cxx11::string::substr((ulong)local_50,(ulong)param_1);
/* try { // try from 0011e187 to 0011e193 has its CatchHandler @ 0011e1c1 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<std::__cxx11::string>
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)this,
(string *)local_50);
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
return this;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.