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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
44,800 | ft_stroker_add_reverse_left | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-ft-stroker.c | static PVG_FT_Error ft_stroker_add_reverse_left(PVG_FT_Stroker stroker,
PVG_FT_Bool open)
{
PVG_FT_StrokeBorder right = stroker->borders + 0;
PVG_FT_StrokeBorder left = stroker->borders + 1;
PVG_FT_Int new_points;
PVG_FT_Error error = 0;
assert(left->start >= 0);
new_points = left->num_points - left->start;
if (new_points > 0) {
error = ft_stroke_border_grow(right, (PVG_FT_UInt)new_points);
if (error) goto Exit;
{
PVG_FT_Vector* dst_point = right->points + right->num_points;
PVG_FT_Byte* dst_tag = right->tags + right->num_points;
PVG_FT_Vector* src_point = left->points + left->num_points - 1;
PVG_FT_Byte* src_tag = left->tags + left->num_points - 1;
while (src_point >= left->points + left->start) {
*dst_point = *src_point;
*dst_tag = *src_tag;
if (open)
dst_tag[0] &= ~PVG_FT_STROKE_TAG_BEGIN_END;
else {
PVG_FT_Byte ttag =
(PVG_FT_Byte)(dst_tag[0] & PVG_FT_STROKE_TAG_BEGIN_END);
/* switch begin/end tags if necessary */
if (ttag == PVG_FT_STROKE_TAG_BEGIN ||
ttag == PVG_FT_STROKE_TAG_END)
dst_tag[0] ^= PVG_FT_STROKE_TAG_BEGIN_END;
}
src_point--;
src_tag--;
dst_point++;
dst_tag++;
}
}
left->num_points = left->start;
right->num_points += new_points;
right->movable = FALSE;
left->movable = FALSE;
}
Exit:
return error;
} | O0 | c | ft_stroker_add_reverse_left:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rax
addq $0x28, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
jl 0x85721
jmp 0x85740
leaq 0xbab3(%rip), %rdi # 0x911db
leaq 0xb91f(%rip), %rsi # 0x9104e
movl $0x5dc, %edx # imm = 0x5DC
leaq 0xbab1(%rip), %rcx # 0x911ec
callq 0xb210
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
subl 0x1c(%rcx), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jle 0x858bc
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x86ae0
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x85774
jmp 0x858be
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
addq $-0x10, %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x20(%rbp), %rdx
movslq 0x1c(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jb 0x85894
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rax
movb (%rax), %cl
movq -0x38(%rbp), %rax
movb %cl, (%rax)
cmpb $0x0, -0x9(%rbp)
je 0x85832
movq -0x38(%rbp), %rax
movzbl (%rax), %ecx
andl $-0xd, %ecx
movb %cl, (%rax)
jmp 0x8585f
movq -0x38(%rbp), %rax
movzbl (%rax), %eax
andl $0xc, %eax
movb %al, -0x49(%rbp)
movzbl -0x49(%rbp), %eax
cmpl $0x4, %eax
je 0x85851
movzbl -0x49(%rbp), %eax
cmpl $0x8, %eax
jne 0x8585d
movq -0x38(%rbp), %rax
movzbl (%rax), %ecx
xorl $0xc, %ecx
movb %cl, (%rax)
jmp 0x8585f
movq -0x40(%rbp), %rax
addq $-0x10, %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x857d8
movq -0x20(%rbp), %rax
movl 0x1c(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x18(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x18(%rax)
jmp 0x858be
movl -0x28(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| ft_stroker_add_reverse_left:
push rbp
mov rbp, rsp
sub rsp, 50h
mov al, sil
mov [rbp+var_8], rdi
mov [rbp+var_9], al
mov rax, [rbp+var_8]
add rax, 70h ; 'p'
mov [rbp+var_18], rax
mov rax, [rbp+var_8]
add rax, 70h ; 'p'
add rax, 28h ; '('
mov [rbp+var_20], rax
mov [rbp+var_28], 0
mov rax, [rbp+var_20]
cmp dword ptr [rax+1Ch], 0
jl short loc_85721
jmp short loc_85740
loc_85721:
lea rdi, aLeftStart0; "left->start >= 0"
lea rsi, aWorkspaceLlm4b_8; "/workspace/llm4binary/github/2025_star3"...
mov edx, 5DCh
lea rcx, aPvgFtErrorFtSt_2; "PVG_FT_Error ft_stroker_add_reverse_lef"...
call ___assert_fail
loc_85740:
mov rax, [rbp+var_20]
mov eax, [rax]
mov rcx, [rbp+var_20]
sub eax, [rcx+1Ch]
mov [rbp+var_24], eax
cmp [rbp+var_24], 0
jle loc_858BC
mov rdi, [rbp+var_18]
mov esi, [rbp+var_24]
call ft_stroke_border_grow
mov [rbp+var_28], eax
cmp [rbp+var_28], 0
jz short loc_85774
jmp loc_858BE
loc_85774:
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov rcx, [rbp+var_18]
mov ecx, [rcx]
shl rcx, 4
add rax, rcx
mov [rbp+var_30], rax
mov rax, [rbp+var_18]
mov rax, [rax+10h]
mov rcx, [rbp+var_18]
mov ecx, [rcx]
add rax, rcx
mov [rbp+var_38], rax
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov rcx, [rbp+var_20]
mov ecx, [rcx]
shl rcx, 4
add rax, rcx
add rax, 0FFFFFFFFFFFFFFF0h
mov [rbp+var_40], rax
mov rax, [rbp+var_20]
mov rax, [rax+10h]
mov rcx, [rbp+var_20]
mov ecx, [rcx]
add rax, rcx
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_48], rax
loc_857D8:
mov rax, [rbp+var_40]
mov rcx, [rbp+var_20]
mov rcx, [rcx+8]
mov rdx, [rbp+var_20]
movsxd rdx, dword ptr [rdx+1Ch]
shl rdx, 4
add rcx, rdx
cmp rax, rcx
jb loc_85894
mov rax, [rbp+var_30]
mov rcx, [rbp+var_40]
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
mov rax, [rbp+var_48]
mov cl, [rax]
mov rax, [rbp+var_38]
mov [rax], cl
cmp [rbp+var_9], 0
jz short loc_85832
mov rax, [rbp+var_38]
movzx ecx, byte ptr [rax]
and ecx, 0FFFFFFF3h
mov [rax], cl
jmp short loc_8585F
loc_85832:
mov rax, [rbp+var_38]
movzx eax, byte ptr [rax]
and eax, 0Ch
mov [rbp+var_49], al
movzx eax, [rbp+var_49]
cmp eax, 4
jz short loc_85851
movzx eax, [rbp+var_49]
cmp eax, 8
jnz short loc_8585D
loc_85851:
mov rax, [rbp+var_38]
movzx ecx, byte ptr [rax]
xor ecx, 0Ch
mov [rax], cl
loc_8585D:
jmp short $+2
loc_8585F:
mov rax, [rbp+var_40]
add rax, 0FFFFFFFFFFFFFFF0h
mov [rbp+var_40], rax
mov rax, [rbp+var_48]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_48], rax
mov rax, [rbp+var_30]
add rax, 10h
mov [rbp+var_30], rax
mov rax, [rbp+var_38]
add rax, 1
mov [rbp+var_38], rax
jmp loc_857D8
loc_85894:
mov rax, [rbp+var_20]
mov ecx, [rax+1Ch]
mov rax, [rbp+var_20]
mov [rax], ecx
mov ecx, [rbp+var_24]
mov rax, [rbp+var_18]
add ecx, [rax]
mov [rax], ecx
mov rax, [rbp+var_18]
mov byte ptr [rax+18h], 0
mov rax, [rbp+var_20]
mov byte ptr [rax+18h], 0
loc_858BC:
jmp short $+2
loc_858BE:
mov eax, [rbp+var_28]
add rsp, 50h
pop rbp
retn
| long long ft_stroker_add_reverse_left(long long a1, char a2)
{
char v3; // [rsp+7h] [rbp-49h]
_BYTE *v4; // [rsp+8h] [rbp-48h]
_QWORD *v5; // [rsp+10h] [rbp-40h]
_BYTE *v6; // [rsp+18h] [rbp-38h]
_QWORD *v7; // [rsp+20h] [rbp-30h]
unsigned int v8; // [rsp+28h] [rbp-28h]
int v9; // [rsp+2Ch] [rbp-24h]
_DWORD *v10; // [rsp+38h] [rbp-18h]
v10 = (_DWORD *)(a1 + 112);
v8 = 0;
if ( *(int *)(a1 + 180) < 0 )
__assert_fail(
"left->start >= 0",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-ft-stroker.c",
1500LL,
"PVG_FT_Error ft_stroker_add_reverse_left(PVG_FT_Stroker, PVG_FT_Bool)");
v9 = *(_DWORD *)(a1 + 152) - *(_DWORD *)(a1 + 180);
if ( v9 > 0 )
{
v8 = ft_stroke_border_grow(v10, (unsigned int)v9);
if ( !v8 )
{
v7 = (_QWORD *)(16LL * *(unsigned int *)(a1 + 112) + *(_QWORD *)(a1 + 120));
v6 = (_BYTE *)(*(unsigned int *)(a1 + 112) + *(_QWORD *)(a1 + 128));
v5 = (_QWORD *)(16LL * *(unsigned int *)(a1 + 152) + *(_QWORD *)(a1 + 160) - 16);
v4 = (_BYTE *)(*(unsigned int *)(a1 + 152) + *(_QWORD *)(a1 + 168) - 1LL);
while ( (unsigned long long)v5 >= 16LL * *(int *)(a1 + 180) + *(_QWORD *)(a1 + 160) )
{
*v7 = *v5;
v7[1] = v5[1];
*v6 = *v4;
if ( a2 )
{
*v6 &= 0xF3u;
}
else
{
v3 = *v6 & 0xC;
if ( v3 == 4 || v3 == 8 )
*v6 ^= 0xCu;
}
v5 -= 2;
--v4;
v7 += 2;
++v6;
}
*(_DWORD *)(a1 + 152) = *(_DWORD *)(a1 + 180);
*v10 += v9;
*(_BYTE *)(a1 + 136) = 0;
*(_BYTE *)(a1 + 176) = 0;
}
}
return v8;
}
| ft_stroker_add_reverse_left:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV AL,SIL
MOV qword ptr [RBP + -0x8],RDI
MOV byte ptr [RBP + -0x9],AL
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x70
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x70
ADD RAX,0x28
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x28],0x0
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX + 0x1c],0x0
JL 0x00185721
JMP 0x00185740
LAB_00185721:
LEA RDI,[0x1911db]
LEA RSI,[0x19104e]
MOV EDX,0x5dc
LEA RCX,[0x1911ec]
CALL 0x0010b210
LAB_00185740:
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x20]
SUB EAX,dword ptr [RCX + 0x1c]
MOV dword ptr [RBP + -0x24],EAX
CMP dword ptr [RBP + -0x24],0x0
JLE 0x001858bc
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,dword ptr [RBP + -0x24]
CALL 0x00186ae0
MOV dword ptr [RBP + -0x28],EAX
CMP dword ptr [RBP + -0x28],0x0
JZ 0x00185774
JMP 0x001858be
LAB_00185774:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RCX]
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RCX]
ADD RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RCX]
SHL RCX,0x4
ADD RAX,RCX
ADD RAX,-0x10
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RCX]
ADD RAX,RCX
ADD RAX,-0x1
MOV qword ptr [RBP + -0x48],RAX
LAB_001857d8:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RCX + 0x8]
MOV RDX,qword ptr [RBP + -0x20]
MOVSXD RDX,dword ptr [RDX + 0x1c]
SHL RDX,0x4
ADD RCX,RDX
CMP RAX,RCX
JC 0x00185894
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x48]
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],CL
CMP byte ptr [RBP + -0x9],0x0
JZ 0x00185832
MOV RAX,qword ptr [RBP + -0x38]
MOVZX ECX,byte ptr [RAX]
AND ECX,0xfffffff3
MOV byte ptr [RAX],CL
JMP 0x0018585f
LAB_00185832:
MOV RAX,qword ptr [RBP + -0x38]
MOVZX EAX,byte ptr [RAX]
AND EAX,0xc
MOV byte ptr [RBP + -0x49],AL
MOVZX EAX,byte ptr [RBP + -0x49]
CMP EAX,0x4
JZ 0x00185851
MOVZX EAX,byte ptr [RBP + -0x49]
CMP EAX,0x8
JNZ 0x0018585d
LAB_00185851:
MOV RAX,qword ptr [RBP + -0x38]
MOVZX ECX,byte ptr [RAX]
XOR ECX,0xc
MOV byte ptr [RAX],CL
LAB_0018585d:
JMP 0x0018585f
LAB_0018585f:
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,-0x10
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x10
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x1
MOV qword ptr [RBP + -0x38],RAX
JMP 0x001857d8
LAB_00185894:
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x1c]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],ECX
MOV ECX,dword ptr [RBP + -0x24]
MOV RAX,qword ptr [RBP + -0x18]
ADD ECX,dword ptr [RAX]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x18],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x18],0x0
LAB_001858bc:
JMP 0x001858be
LAB_001858be:
MOV EAX,dword ptr [RBP + -0x28]
ADD RSP,0x50
POP RBP
RET
|
int ft_stroker_add_reverse_left(long param_1,char param_2)
{
int8 *puVar1;
int iVar2;
uint *puVar3;
uint *puVar4;
byte *local_50;
int8 *local_48;
byte *local_40;
int8 *local_38;
int local_30;
puVar3 = (uint *)(param_1 + 0x70);
puVar4 = (uint *)(param_1 + 0x98);
local_30 = 0;
if (-1 < *(int *)(param_1 + 0xb4)) {
iVar2 = *puVar4 - *(int *)(param_1 + 0xb4);
if ((0 < iVar2) && (local_30 = ft_stroke_border_grow(puVar3,iVar2), local_30 == 0)) {
local_38 = (int8 *)(*(long *)(param_1 + 0x78) + (ulong)*puVar3 * 0x10);
local_40 = (byte *)(*(long *)(param_1 + 0x80) + (ulong)*puVar3);
local_50 = (byte *)(*(long *)(param_1 + 0xa8) + (ulong)*puVar4);
puVar1 = (int8 *)(*(long *)(param_1 + 0xa0) + (ulong)*puVar4 * 0x10);
while( true ) {
local_48 = puVar1 + -2;
local_50 = local_50 + -1;
if (local_48 <
(int8 *)(*(long *)(param_1 + 0xa0) + (long)*(int *)(param_1 + 0xb4) * 0x10))
break;
*local_38 = *local_48;
local_38[1] = puVar1[-1];
*local_40 = *local_50;
if (param_2 == '\0') {
if (((*local_40 & 0xc) == 4) || ((*local_40 & 0xc) == 8)) {
*local_40 = *local_40 ^ 0xc;
}
}
else {
*local_40 = *local_40 & 0xf3;
}
local_38 = local_38 + 2;
local_40 = local_40 + 1;
puVar1 = local_48;
}
*puVar4 = *(uint *)(param_1 + 0xb4);
*puVar3 = iVar2 + *puVar3;
*(int1 *)(param_1 + 0x88) = 0;
*(int1 *)(param_1 + 0xb0) = 0;
}
return local_30;
}
/* WARNING: Subroutine does not return */
__assert_fail("left->start >= 0",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-ft-stroker.c"
,0x5dc,"PVG_FT_Error ft_stroker_add_reverse_left(PVG_FT_Stroker, PVG_FT_Bool)");
}
| |
44,801 | my_mb_wc_big5 | eloqsql/strings/ctype-big5.c | static int
my_mb_wc_big5(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)
{
pwc[0]=hi;
return 1;
}
if (s+2>e)
return MY_CS_TOOSMALL2;
if (!IS_MB2_CHAR(hi, s[1]))
return MY_CS_ILSEQ;
if (!(pwc[0]=func_big5_uni_onechar((hi<<8)+s[1])))
return -2;
return 2;
} | O3 | c | my_mb_wc_big5:
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x2ceba
movsbq (%rdx), %rdi
testq %rdi, %rdi
js 0x2ce84
movq %rdi, (%rsi)
movl $0x1, %eax
retq
leaq 0x2(%rdx), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %r8
ja 0x2ceba
leal 0x5f(%rdi), %ecx
xorl %eax, %eax
cmpb $0x58, %cl
ja 0x2ceba
movzbl 0x1(%rdx), %ecx
leal -0x7f(%rcx), %edx
cmpb $-0x3f, %dl
setb %dl
leal 0x1(%rcx), %r8d
cmpb $-0x5e, %r8b
setb %r8b
testb %r8b, %dl
je 0x2cebb
retq
pushq %rbp
movq %rsp, %rbp
movzbl %dil, %eax
shll $0x8, %eax
leal (%rax,%rcx), %edx
addl $0xffff5ec0, %edx # imm = 0xFFFF5EC0
cmpl $0x26bc, %edx # imm = 0x26BC
ja 0x2cee2
movl %edx, %eax
leaq 0x32f80(%rip), %rcx # 0x5fe60
jmp 0x2cef9
orl %ecx, %eax
addl $0xffff36c0, %eax # imm = 0xFFFF36C0
cmpl $0x309d, %eax # imm = 0x309D
jae 0x2cf12
movl %eax, %eax
leaq 0x37ce7(%rip), %rcx # 0x64be0
leaq (%rcx,%rax,2), %rax
movzwl (%rax), %eax
movzwl %ax, %ecx
movq %rcx, (%rsi)
movl $0x2, %eax
testw %cx, %cx
jne 0x2cf1e
jmp 0x2cf19
movq $0x0, (%rsi)
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
popq %rbp
retq
| my_mb_wc_big5:
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short locret_2CEBA
movsx rdi, byte ptr [rdx]
test rdi, rdi
js short loc_2CE84
mov [rsi], rdi
mov eax, 1
retn
loc_2CE84:
lea r8, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp r8, rcx
ja short locret_2CEBA
lea ecx, [rdi+5Fh]
xor eax, eax
cmp cl, 58h ; 'X'
ja short locret_2CEBA
movzx ecx, byte ptr [rdx+1]
lea edx, [rcx-7Fh]
cmp dl, 0C1h
setb dl
lea r8d, [rcx+1]
cmp r8b, 0A2h
setb r8b
test dl, r8b
jz short loc_2CEBB
locret_2CEBA:
retn
loc_2CEBB:
push rbp
mov rbp, rsp
movzx eax, dil
shl eax, 8
lea edx, [rax+rcx]
add edx, 0FFFF5EC0h
cmp edx, 26BCh
ja short loc_2CEE2
mov eax, edx
lea rcx, tab_big5_uni0
jmp short loc_2CEF9
loc_2CEE2:
or eax, ecx
add eax, 0FFFF36C0h
cmp eax, 309Dh
jnb short loc_2CF12
mov eax, eax
lea rcx, tab_big5_uni1
loc_2CEF9:
lea rax, [rcx+rax*2]
movzx eax, word ptr [rax]
movzx ecx, ax
mov [rsi], rcx
mov eax, 2
test cx, cx
jnz short loc_2CF1E
jmp short loc_2CF19
loc_2CF12:
mov qword ptr [rsi], 0
loc_2CF19:
mov eax, 0FFFFFFFEh
loc_2CF1E:
pop rbp
retn
| long long my_mb_wc_big5(long long a1, long long *a2, char *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rdi
int v6; // ecx
int v7; // eax
unsigned int v8; // edx
long long v9; // rax
unsigned __int16 *v10; // rcx
long long v11; // rcx
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
v5 = *a3;
if ( v5 >= 0 )
{
*a2 = v5;
return 1LL;
}
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
result = 0LL;
if ( (unsigned __int8)(v5 + 95) <= 0x58u )
{
v6 = (unsigned __int8)a3[1];
if ( (unsigned __int8)(v6 + 1) >= 0xA2u || (unsigned __int8)(v6 - 127) >= 0xC1u )
{
v7 = (unsigned __int8)v5 << 8;
v8 = v7 + v6 - 41280;
if ( v8 > 0x26BC )
{
LODWORD(v9) = (v6 | v7) - 51520;
if ( (unsigned int)v9 >= 0x309D )
{
*a2 = 0LL;
return 4294967294LL;
}
v9 = (unsigned int)v9;
v10 = (unsigned __int16 *)&tab_big5_uni1;
}
else
{
v9 = v8;
v10 = (unsigned __int16 *)&tab_big5_uni0;
}
v11 = v10[v9];
*a2 = v11;
result = 2LL;
if ( (_WORD)v11 )
return result;
return 4294967294LL;
}
}
}
}
return result;
}
| my_mb_wc_big5:
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x0012ceba
MOVSX RDI,byte ptr [RDX]
TEST RDI,RDI
JS 0x0012ce84
MOV qword ptr [RSI],RDI
MOV EAX,0x1
RET
LAB_0012ce84:
LEA R8,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP R8,RCX
JA 0x0012ceba
LEA ECX,[RDI + 0x5f]
XOR EAX,EAX
CMP CL,0x58
JA 0x0012ceba
MOVZX ECX,byte ptr [RDX + 0x1]
LEA EDX,[RCX + -0x7f]
CMP DL,0xc1
SETC DL
LEA R8D,[RCX + 0x1]
CMP R8B,0xa2
SETC R8B
TEST DL,R8B
JZ 0x0012cebb
LAB_0012ceba:
RET
LAB_0012cebb:
PUSH RBP
MOV RBP,RSP
MOVZX EAX,DIL
SHL EAX,0x8
LEA EDX,[RAX + RCX*0x1]
ADD EDX,0xffff5ec0
CMP EDX,0x26bc
JA 0x0012cee2
MOV EAX,EDX
LEA RCX,[0x15fe60]
JMP 0x0012cef9
LAB_0012cee2:
OR EAX,ECX
ADD EAX,0xffff36c0
CMP EAX,0x309d
JNC 0x0012cf12
MOV EAX,EAX
LEA RCX,[0x164be0]
LAB_0012cef9:
LEA RAX,[RCX + RAX*0x2]
MOVZX EAX,word ptr [RAX]
MOVZX ECX,AX
MOV qword ptr [RSI],RCX
MOV EAX,0x2
TEST CX,CX
JNZ 0x0012cf1e
JMP 0x0012cf19
LAB_0012cf12:
MOV qword ptr [RSI],0x0
LAB_0012cf19:
MOV EAX,0xfffffffe
LAB_0012cf1e:
POP RBP
RET
|
int8 my_mb_wc_big5(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
byte bVar1;
byte bVar2;
ushort uVar3;
int *puVar4;
uint uVar5;
if (param_4 <= param_3) {
return 0xffffff9b;
}
bVar1 = *param_3;
if (-1 < (long)(char)bVar1) {
*param_2 = (long)(char)bVar1;
return 1;
}
if (param_4 < param_3 + 2) {
return 0xffffff9a;
}
if ((byte)(bVar1 + 0x5f) < 0x59) {
bVar2 = param_3[1];
if ((byte)(bVar2 + 0x81) < 0xc1 && (byte)(bVar2 + 1) < 0xa2) {
return 0;
}
uVar5 = ((uint)bVar1 * 0x100 + (uint)bVar2) - 0xa140;
if (uVar5 < 0x26bd) {
puVar4 = &tab_big5_uni0;
}
else {
uVar5 = CONCAT11(bVar1,bVar2) - 0xc940;
if (0x309c < uVar5) {
*param_2 = 0;
return 0xfffffffe;
}
puVar4 = &tab_big5_uni1;
}
uVar3 = *(ushort *)(puVar4 + (ulong)uVar5 * 2);
*param_2 = (ulong)uVar3;
if (uVar3 == 0) {
return 0xfffffffe;
}
return 2;
}
return 0;
}
| |
44,802 | alloc_dynamic | eloqsql/mysys/array.c | void *alloc_dynamic(DYNAMIC_ARRAY *array)
{
DBUG_ENTER("alloc_dynamic");
DBUG_ASSERT(array->size_of_element); /* Ensure init() is called */
if (array->elements == array->max_element)
{
char *new_ptr;
if (array->malloc_flags & MY_INIT_BUFFER_USED)
{
/*
In this scenario, the buffer is statically preallocated,
so we have to create an all-new malloc since we overflowed
*/
if (!(new_ptr= (char *) my_malloc(array->m_psi_key,
(array->max_element+
array->alloc_increment) *
array->size_of_element,
MYF(array->malloc_flags | MY_WME))))
DBUG_RETURN(0);
if (array->elements)
memcpy(new_ptr, array->buffer,
array->elements * array->size_of_element);
array->malloc_flags&= ~MY_INIT_BUFFER_USED;
}
else if (!(new_ptr=(char*)
my_realloc(array->m_psi_key, array->buffer,
(array->max_element+ array->alloc_increment) *
array->size_of_element,
MYF(MY_WME | MY_ALLOW_ZERO_PTR |
array->malloc_flags))))
DBUG_RETURN(0);
array->buffer= (uchar*) new_ptr;
array->max_element+=array->alloc_increment;
}
DBUG_RETURN(array->buffer+(array->elements++ * array->size_of_element));
} | O0 | c | alloc_dynamic:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
jmp 0x57c5e
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jne 0x57d87
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
andq $0x100, %rax # imm = 0x100
cmpq $0x0, %rax
je 0x57d1a
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
addl 0x10(%rcx), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
orq $0x10, %rdx
callq 0x58d60
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x57cd5
jmp 0x57cc8
movq $0x0, -0x8(%rbp)
jmp 0x57db0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x57d02
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x26280
movq -0x10(%rbp), %rax
movabsq $0xfffffeff, %rcx # imm = 0xFFFFFEFF
andq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
jmp 0x57d6b
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
addl 0x10(%rcx), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
orq $0x50, %rcx
callq 0x58f30
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x57d69
jmp 0x57d5f
movq $0x0, -0x8(%rbp)
jmp 0x57db0
jmp 0x57d6b
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x10(%rbp), %rax
addl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
jmp 0x57d89
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movl 0x8(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x8(%rdx)
movq -0x10(%rbp), %rdx
imull 0x14(%rdx), %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| alloc_dynamic:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
jmp short $+2
loc_57C5E:
mov rax, [rbp+var_10]
mov eax, [rax+8]
mov rcx, [rbp+var_10]
cmp eax, [rcx+0Ch]
jnz loc_57D87
mov rax, [rbp+var_10]
mov rax, [rax+20h]
and rax, 100h
cmp rax, 0
jz loc_57D1A
mov rax, [rbp+var_10]
mov edi, [rax+18h]
mov rax, [rbp+var_10]
mov eax, [rax+0Ch]
mov rcx, [rbp+var_10]
add eax, [rcx+10h]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
mov esi, eax
mov rax, [rbp+var_10]
mov rdx, [rax+20h]
or rdx, 10h
call my_malloc
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_57CD5
jmp short $+2
loc_57CC8:
mov [rbp+var_8], 0
jmp loc_57DB0
loc_57CD5:
mov rax, [rbp+var_10]
cmp dword ptr [rax+8], 0
jz short loc_57D02
mov rdi, [rbp+var_18]
mov rax, [rbp+var_10]
mov rsi, [rax]
mov rax, [rbp+var_10]
mov eax, [rax+8]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
mov edx, eax
call _memcpy
loc_57D02:
mov rax, [rbp+var_10]
mov rcx, 0FFFFFEFFh
and rcx, [rax+20h]
mov [rax+20h], rcx
jmp short loc_57D6B
loc_57D1A:
mov rax, [rbp+var_10]
mov edi, [rax+18h]
mov rax, [rbp+var_10]
mov rsi, [rax]
mov rax, [rbp+var_10]
mov eax, [rax+0Ch]
mov rcx, [rbp+var_10]
add eax, [rcx+10h]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
mov edx, eax
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
or rcx, 50h
call my_realloc
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_57D69
jmp short $+2
loc_57D5F:
mov [rbp+var_8], 0
jmp short loc_57DB0
loc_57D69:
jmp short $+2
loc_57D6B:
mov rcx, [rbp+var_18]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rax, [rbp+var_10]
mov ecx, [rax+10h]
mov rax, [rbp+var_10]
add ecx, [rax+0Ch]
mov [rax+0Ch], ecx
loc_57D87:
jmp short $+2
loc_57D89:
mov rax, [rbp+var_10]
mov rax, [rax]
mov rdx, [rbp+var_10]
mov ecx, [rdx+8]
mov esi, ecx
add esi, 1
mov [rdx+8], esi
mov rdx, [rbp+var_10]
imul ecx, [rdx+14h]
mov ecx, ecx
add rax, rcx
mov [rbp+var_8], rax
loc_57DB0:
mov rax, [rbp+var_8]
add rsp, 20h
pop rbp
retn
| long long alloc_dynamic(long long *a1)
{
long long v1; // rax
int v2; // ecx
long long v4; // [rsp+8h] [rbp-18h]
if ( *((_DWORD *)a1 + 2) != *((_DWORD *)a1 + 3) )
goto LABEL_11;
if ( (a1[4] & 0x100) == 0 )
{
v4 = my_realloc(
*((unsigned int *)a1 + 6),
*a1,
(unsigned int)(*((_DWORD *)a1 + 5) * (*((_DWORD *)a1 + 4) + *((_DWORD *)a1 + 3))),
a1[4] | 0x50);
if ( !v4 )
return 0LL;
goto LABEL_10;
}
v4 = my_malloc(
*((unsigned int *)a1 + 6),
(unsigned int)(*((_DWORD *)a1 + 5) * (*((_DWORD *)a1 + 4) + *((_DWORD *)a1 + 3))),
a1[4] | 0x10);
if ( v4 )
{
if ( *((_DWORD *)a1 + 2) )
memcpy(v4, *a1, (unsigned int)(*((_DWORD *)a1 + 5) * *((_DWORD *)a1 + 2)));
a1[4] &= 0xFFFFFEFFuLL;
LABEL_10:
*a1 = v4;
*((_DWORD *)a1 + 3) += *((_DWORD *)a1 + 4);
LABEL_11:
v1 = *a1;
v2 = *((_DWORD *)a1 + 2);
*((_DWORD *)a1 + 2) = v2 + 1;
return (unsigned int)(*((_DWORD *)a1 + 5) * v2) + v1;
}
return 0LL;
}
| alloc_dynamic:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
JMP 0x00157c5e
LAB_00157c5e:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX + 0xc]
JNZ 0x00157d87
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
AND RAX,0x100
CMP RAX,0x0
JZ 0x00157d1a
MOV RAX,qword ptr [RBP + -0x10]
MOV EDI,dword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0xc]
MOV RCX,qword ptr [RBP + -0x10]
ADD EAX,dword ptr [RCX + 0x10]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
MOV ESI,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x20]
OR RDX,0x10
CALL 0x00158d60
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x00157cd5
JMP 0x00157cc8
LAB_00157cc8:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00157db0
LAB_00157cd5:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x8],0x0
JZ 0x00157d02
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
MOV EDX,EAX
CALL 0x00126280
LAB_00157d02:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,0xfffffeff
AND RCX,qword ptr [RAX + 0x20]
MOV qword ptr [RAX + 0x20],RCX
JMP 0x00157d6b
LAB_00157d1a:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDI,dword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0xc]
MOV RCX,qword ptr [RBP + -0x10]
ADD EAX,dword ptr [RCX + 0x10]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x20]
OR RCX,0x50
CALL 0x00158f30
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x00157d69
JMP 0x00157d5f
LAB_00157d5f:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00157db0
LAB_00157d69:
JMP 0x00157d6b
LAB_00157d6b:
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
ADD ECX,dword ptr [RAX + 0xc]
MOV dword ptr [RAX + 0xc],ECX
LAB_00157d87:
JMP 0x00157d89
LAB_00157d89:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RDX + 0x8]
MOV ESI,ECX
ADD ESI,0x1
MOV dword ptr [RDX + 0x8],ESI
MOV RDX,qword ptr [RBP + -0x10]
IMUL ECX,dword ptr [RDX + 0x14]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
LAB_00157db0:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x20
POP RBP
RET
|
long alloc_dynamic(long *param_1)
{
long lVar1;
void *local_20;
if ((int)param_1[1] == *(int *)((long)param_1 + 0xc)) {
if ((param_1[4] & 0x100U) == 0) {
local_20 = (void *)my_realloc((int)param_1[3],*param_1,
(*(int *)((long)param_1 + 0xc) + (int)param_1[2]) *
*(int *)((long)param_1 + 0x14),param_1[4] | 0x50);
if (local_20 == (void *)0x0) {
return 0;
}
}
else {
local_20 = (void *)my_malloc((int)param_1[3],
(*(int *)((long)param_1 + 0xc) + (int)param_1[2]) *
*(int *)((long)param_1 + 0x14),param_1[4] | 0x10);
if (local_20 == (void *)0x0) {
return 0;
}
if ((int)param_1[1] != 0) {
memcpy(local_20,(void *)*param_1,
(ulong)(uint)((int)param_1[1] * *(int *)((long)param_1 + 0x14)));
}
param_1[4] = param_1[4] & 0xfffffeff;
}
*param_1 = (long)local_20;
*(int *)((long)param_1 + 0xc) = (int)param_1[2] + *(int *)((long)param_1 + 0xc);
}
lVar1 = param_1[1];
*(int *)(param_1 + 1) = (int)lVar1 + 1;
return *param_1 + (ulong)(uint)((int)lVar1 * *(int *)((long)param_1 + 0x14));
}
| |
44,803 | Prepared_statement::validate_metadata(Prepared_statement*) | eloqsql/sql/sql_prepare.cc | inline bool is_sql_prepare() const { return flags & (uint) IS_SQL_PREPARE; } | O3 | cpp | Prepared_statement::validate_metadata(Prepared_statement*):
testb $0x2, 0x150(%rdi)
jne 0x773c9e
pushq %rbp
movq %rsp, %rbp
movq 0x58(%rdi), %rax
cmpb $0x0, 0x1838(%rax)
jne 0x773c9d
movq 0xe0(%rax), %rax
movl 0x2b0(%rax), %eax
movq 0x58(%rsi), %rcx
movq 0xe0(%rcx), %rcx
cmpl 0x2b0(%rcx), %eax
je 0x773c9d
movq 0xc0(%rdi), %rax
orl $0x400, 0x3e64(%rax) # imm = 0x400
popq %rbp
xorl %eax, %eax
retq
nop
| _ZN18Prepared_statement17validate_metadataEPS_:
test byte ptr [rdi+150h], 2
jnz short loc_773C9E
push rbp
mov rbp, rsp
mov rax, [rdi+58h]
cmp byte ptr [rax+1838h], 0
jnz short loc_773C9D
mov rax, [rax+0E0h]
mov eax, [rax+2B0h]
mov rcx, [rsi+58h]
mov rcx, [rcx+0E0h]
cmp eax, [rcx+2B0h]
jz short loc_773C9D
mov rax, [rdi+0C0h]
or dword ptr [rax+3E64h], 400h
loc_773C9D:
pop rbp
loc_773C9E:
xor eax, eax
retn
| long long Prepared_statement::validate_metadata(Prepared_statement *this, Prepared_statement *a2)
{
long long v2; // rax
if ( (*((_BYTE *)this + 336) & 2) == 0 )
{
v2 = *((_QWORD *)this + 11);
if ( !*(_BYTE *)(v2 + 6200)
&& *(_DWORD *)(*(_QWORD *)(v2 + 224) + 688LL) != *(_DWORD *)(*(_QWORD *)(*((_QWORD *)a2 + 11) + 224LL) + 688LL) )
{
*(_DWORD *)(*((_QWORD *)this + 24) + 15972LL) |= 0x400u;
}
}
return 0LL;
}
| operator<<:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RSI,qword ptr [RSI]
CALL 0x0071bbb0
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP RBP
RET
|
/* ib::logger& ib::logger::TEMPNAMEPLACEHOLDERVALUE(void const* const&) */
logger * __thiscall ib::logger::operator<<(logger *this,void **param_1)
{
std::ostream::_M_insert<void_const*>(this);
return this;
}
| |
44,804 | ftxui::flex_shrink(std::shared_ptr<ftxui::Node>) | Andrewchistyakov[P]flashcards_lyc/build_O2/_deps/ftxui-src/src/ftxui/dom/flex.cpp | Element flex_shrink(Element child) {
return std::make_shared<Flex>(function_flex_shrink, std::move(child));
} | O2 | cpp | ftxui::flex_shrink(std::shared_ptr<ftxui::Node>):
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x2b(%rip), %rsi # 0x1e8d8
movq %rsp, %rdi
callq 0x1e621
leaq 0x8(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0x13452
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
| _ZN5ftxui11flex_shrinkESt10shared_ptrINS_4NodeEE:
push rbx
sub rsp, 10h
mov rdx, rsi
mov rbx, rdi
lea rsi, _ZN5ftxui12_GLOBAL__N_120function_flex_shrinkERNS_11RequirementE; ftxui::`anonymous namespace'::function_flex_shrink(ftxui::Requirement &)
mov rdi, rsp
call _ZSt11make_sharedIN5ftxui12_GLOBAL__N_14FlexEJRFvRNS0_11RequirementEESt10shared_ptrINS0_4NodeEEEES7_IT_EDpOT0_; std::make_shared<ftxui::`anonymous namespace'::Flex,void (&)(ftxui::Requirement &),std::shared_ptr<ftxui::Node>>(void (&)(ftxui::Requirement &),std::shared_ptr<ftxui::Node> &&)
lea rdi, [rsp+18h+var_10]
movaps xmm0, xmmword ptr [rdi-8]
and qword ptr [rdi], 0
movups xmmword ptr [rbx], xmm0
and qword ptr [rdi-8], 0
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rax, rbx
add rsp, 10h
pop rbx
retn
| _OWORD * ftxui::flex_shrink(_OWORD *a1, __int128 *a2)
{
__int128 v2; // xmm0
__int128 v4; // [rsp+0h] [rbp-18h] BYREF
std::make_shared<ftxui::`anonymous namespace'::Flex,void (&)(ftxui::Requirement &),std::shared_ptr<ftxui::Node>>(
&v4,
(long long)ftxui::`anonymous namespace'::function_flex_shrink,
a2);
v2 = v4;
*((_QWORD *)&v4 + 1) = 0LL;
*a1 = v2;
*(_QWORD *)&v4 = 0LL;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count((_QWORD *)&v4 + 1);
return a1;
}
| flex_shrink:
PUSH RBX
SUB RSP,0x10
MOV RDX,RSI
MOV RBX,RDI
LEA RSI,[0x11e8d8]
MOV RDI,RSP
CALL 0x0011e621
LEA RDI,[RSP + 0x8]
MOVAPS XMM0,xmmword ptr [RDI + -0x8]
AND qword ptr [RDI],0x0
MOVUPS xmmword ptr [RBX],XMM0
AND qword ptr [RDI + -0x8],0x0
CALL 0x00113452
MOV RAX,RBX
ADD RSP,0x10
POP RBX
RET
|
/* ftxui::flex_shrink(std::shared_ptr<ftxui::Node>) */
int8 * ftxui::flex_shrink(int8 *param_1)
{
int8 uVar1;
int8 local_18;
int8 uStack_10;
std::
make_shared<ftxui::(anonymous_namespace)::Flex,void(&)(ftxui::Requirement&),std::shared_ptr<ftxui::Node>>
((_func_void_Requirement_ptr *)&local_18,
(shared_ptr *)(anonymous_namespace)::function_flex_shrink);
uVar1 = uStack_10;
uStack_10 = 0;
*param_1 = local_18;
param_1[1] = uVar1;
local_18 = 0;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&uStack_10);
return param_1;
}
| |
44,805 | js_std_tmpfile | bluesky950520[P]quickjs/quickjs-libc.c | static JSValue js_std_tmpfile(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
FILE *f;
f = tmpfile();
if (argc >= 1)
js_set_error_object(ctx, argv[0], f ? 0 : errno);
if (!f)
return JS_NULL;
return js_new_std_file(ctx, f, FALSE);
} | O1 | c | js_std_tmpfile:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %r15
movl %ecx, %ebp
movq %rdi, %rbx
callq 0xe500
movq %rax, %r14
testl %ebp, %ebp
jle 0x17c28
testq %r14, %r14
je 0x17c02
xorl %r8d, %r8d
jmp 0x17c0a
callq 0xe0b0
movl (%rax), %r8d
movq 0x8(%r15), %rdx
cmpl $0x3, %edx
je 0x17c28
movq (%r15), %rsi
leaq 0x84106(%rip), %rcx # 0x9bd23
movq %rbx, %rdi
xorl %r9d, %r9d
callq 0x25428
testq %r14, %r14
je 0x17c3c
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x15d77
jmp 0x17c43
movl $0x2, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| js_std_tmpfile:
push rbp
push r15
push r14
push rbx
push rax
mov r15, r8
mov ebp, ecx
mov rbx, rdi
call _tmpfile
mov r14, rax
test ebp, ebp
jle short loc_17C28
test r14, r14
jz short loc_17C02
xor r8d, r8d
jmp short loc_17C0A
loc_17C02:
call ___errno_location
mov r8d, [rax]
loc_17C0A:
mov rdx, [r15+8]
cmp edx, 3
jz short loc_17C28
mov rsi, [r15]
lea rcx, aErrno; "errno"
mov rdi, rbx
xor r9d, r9d
call JS_SetPropertyStr
loc_17C28:
test r14, r14
jz short loc_17C3C
mov rdi, rbx
mov rsi, r14
xor edx, edx
call js_new_std_file
jmp short loc_17C43
loc_17C3C:
mov edx, 2
xor eax, eax
loc_17C43:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| unsigned long long js_std_tmpfile(long long a1, long long a2, long long a3, int a4, _QWORD *a5)
{
long long v7; // rax
long long v8; // r14
long long v9; // r8
long long v10; // rdx
v7 = tmpfile(a1);
v8 = v7;
if ( a4 > 0 )
{
v9 = v7 ? 0LL : *(unsigned int *)__errno_location(a1);
v10 = a5[1];
if ( (_DWORD)v10 != 3 )
JS_SetPropertyStr(a1, *a5, v10, "errno", v9, 0LL);
}
if ( v8 )
return js_new_std_file(a1, v8, 0);
else
return 0LL;
}
| js_std_tmpfile:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R15,R8
MOV EBP,ECX
MOV RBX,RDI
CALL 0x0010e500
MOV R14,RAX
TEST EBP,EBP
JLE 0x00117c28
TEST R14,R14
JZ 0x00117c02
XOR R8D,R8D
JMP 0x00117c0a
LAB_00117c02:
CALL 0x0010e0b0
MOV R8D,dword ptr [RAX]
LAB_00117c0a:
MOV RDX,qword ptr [R15 + 0x8]
CMP EDX,0x3
JZ 0x00117c28
MOV RSI,qword ptr [R15]
LEA RCX,[0x19bd23]
MOV RDI,RBX
XOR R9D,R9D
CALL 0x00125428
LAB_00117c28:
TEST R14,R14
JZ 0x00117c3c
MOV RDI,RBX
MOV RSI,R14
XOR EDX,EDX
CALL 0x00115d77
JMP 0x00117c43
LAB_00117c3c:
MOV EDX,0x2
XOR EAX,EAX
LAB_00117c43:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int8
js_std_tmpfile(int8 param_1,int8 param_2,int8 param_3,int param_4,
int8 *param_5)
{
FILE *pFVar1;
int *piVar2;
int8 uVar3;
int iVar4;
pFVar1 = tmpfile();
if (0 < param_4) {
if (pFVar1 == (FILE *)0x0) {
piVar2 = __errno_location();
iVar4 = *piVar2;
}
else {
iVar4 = 0;
}
if ((int)param_5[1] != 3) {
JS_SetPropertyStr(param_1,*param_5,param_5[1],"errno",iVar4,0);
}
}
if (pFVar1 == (FILE *)0x0) {
uVar3 = 0;
}
else {
uVar3 = js_new_std_file(param_1,pFVar1,0);
}
return uVar3;
}
| |
44,806 | js_std_tmpfile | bluesky950520[P]quickjs/quickjs-libc.c | static JSValue js_std_tmpfile(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
FILE *f;
f = tmpfile();
if (argc >= 1)
js_set_error_object(ctx, argv[0], f ? 0 : errno);
if (!f)
return JS_NULL;
return js_new_std_file(ctx, f, FALSE);
} | O2 | c | js_std_tmpfile:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %r15
movl %ecx, %ebp
movq %rdi, %rbx
callq 0xe510
movq %rax, %r14
testl %ebp, %ebp
jle 0x128fd
xorl %ecx, %ecx
testq %r14, %r14
jne 0x128ee
callq 0xe0b0
movl (%rax), %ecx
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x12b1d
testq %r14, %r14
je 0x12911
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x10c2a
jmp 0x12916
pushq $0x2
popq %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| js_std_tmpfile:
push rbp
push r15
push r14
push rbx
push rax
mov r15, r8
mov ebp, ecx
mov rbx, rdi
call _tmpfile
mov r14, rax
test ebp, ebp
jle short loc_128FD
xor ecx, ecx
test r14, r14
jnz short loc_128EE
call ___errno_location
mov ecx, [rax]
loc_128EE:
mov rsi, [r15]
mov rdx, [r15+8]
mov rdi, rbx
call js_set_error_object
loc_128FD:
test r14, r14
jz short loc_12911
mov rdi, rbx
mov rsi, r14
xor edx, edx
call js_new_std_file
jmp short loc_12916
loc_12911:
push 2
pop rdx
xor eax, eax
loc_12916:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| unsigned long long js_std_tmpfile(long long a1, long long a2, long long a3, int a4, _QWORD *a5)
{
long long v7; // rax
long long v8; // r14
long long v9; // rcx
v7 = tmpfile(a1);
v8 = v7;
if ( a4 > 0 )
{
v9 = 0LL;
if ( !v7 )
v9 = *(unsigned int *)__errno_location(a1);
js_set_error_object(a1, *a5, a5[1], v9);
}
if ( v8 )
return js_new_std_file(a1, v8, 0);
else
return 0LL;
}
| js_std_tmpfile:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R15,R8
MOV EBP,ECX
MOV RBX,RDI
CALL 0x0010e510
MOV R14,RAX
TEST EBP,EBP
JLE 0x001128fd
XOR ECX,ECX
TEST R14,R14
JNZ 0x001128ee
CALL 0x0010e0b0
MOV ECX,dword ptr [RAX]
LAB_001128ee:
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
MOV RDI,RBX
CALL 0x00112b1d
LAB_001128fd:
TEST R14,R14
JZ 0x00112911
MOV RDI,RBX
MOV RSI,R14
XOR EDX,EDX
CALL 0x00110c2a
JMP 0x00112916
LAB_00112911:
PUSH 0x2
POP RDX
XOR EAX,EAX
LAB_00112916:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int8
js_std_tmpfile(int8 param_1,int8 param_2,int8 param_3,int param_4,
int8 *param_5)
{
FILE *pFVar1;
int *piVar2;
int8 uVar3;
int iVar4;
pFVar1 = tmpfile();
if (0 < param_4) {
iVar4 = 0;
if (pFVar1 == (FILE *)0x0) {
piVar2 = __errno_location();
iVar4 = *piVar2;
}
js_set_error_object(param_1,*param_5,param_5[1],iVar4);
}
if (pFVar1 == (FILE *)0x0) {
uVar3 = 0;
}
else {
uVar3 = js_new_std_file(param_1,pFVar1,0);
}
return uVar3;
}
| |
44,807 | mj_addConstraint | aimrt_mujoco_sim/_deps/mujoco-src/src/engine/engine_core_constraint.c | static void mj_addConstraint(const mjModel* m, mjData* d,
const mjtNum* jac, const mjtNum* pos,
const mjtNum* margin, mjtNum frictionloss,
int size, int type, int id, int NV, const int* chain) {
int empty, nv = m->nv, nefc = d->nefc;
int *nnz = d->efc_J_rownnz, *adr = d->efc_J_rowadr, *ind = d->efc_J_colind;
mjtNum *J = d->efc_J;
// init empty guard for constraints other than contact
if (type == mjCNSTR_CONTACT_FRICTIONLESS ||
type == mjCNSTR_CONTACT_PYRAMIDAL ||
type == mjCNSTR_CONTACT_ELLIPTIC) {
empty = 0;
} else {
empty = 1;
}
// dense: copy entire Jacobian
if (!mj_isSparse(m)) {
// make sure jac is not empty
if (empty) {
for (int i=0; i < size*nv; i++) {
if (jac[i]) {
empty = 0;
break;
}
}
}
// copy if not empty
if (!empty) {
mju_copy(J + nefc*nv, jac, size*nv);
}
}
// sparse: copy chain
else {
// clamp NV (in case -1 was used in constraint construction)
NV = mjMAX(0, NV);
if (NV) {
empty = 0;
} else if (empty) {
// all rows are empty, return early
return;
}
// chain required in sparse mode
if (NV && !chain) {
mjERROR("called with dense arguments");
}
// process size elements
for (int i=0; i < size; i++) {
// set row address
adr[nefc+i] = (nefc+i ? adr[nefc+i-1]+nnz[nefc+i-1] : 0);
// set row descriptor
nnz[nefc+i] = NV;
// copy if not empty
if (NV) {
mju_copyInt(ind + adr[nefc+i], chain, NV);
mju_copy(J + adr[nefc+i], jac + i*NV, NV);
}
}
}
// all rows empty: skip constraint
if (empty) {
return;
}
// set constraint pos, margin, frictionloss, type, id
for (int i=0; i < size; i++) {
d->efc_pos[nefc+i] = (pos ? pos[i] : 0);
d->efc_margin[nefc+i] = (margin ? margin[i] : 0);
d->efc_frictionloss[nefc+i] = frictionloss;
d->efc_type[nefc+i] = type;
d->efc_id[nefc+i] = id;
}
// increase counters
d->nefc += size;
if (type == mjCNSTR_EQUALITY) {
d->ne += size;
} else if (type == mjCNSTR_FRICTION_DOF || type == mjCNSTR_FRICTION_TENDON) {
d->nf += size;
} else if (type == mjCNSTR_LIMIT_JOINT || type == mjCNSTR_LIMIT_TENDON) {
d->nl += size;
}
} | O0 | c | mj_addConstraint:
subq $0x498, %rsp # imm = 0x498
movq 0x4b8(%rsp), %rax
movl 0x4b0(%rsp), %eax
movl 0x4a8(%rsp), %eax
movl 0x4a0(%rsp), %eax
movq %rdi, 0x490(%rsp)
movq %rsi, 0x488(%rsp)
movq %rdx, 0x480(%rsp)
movq %rcx, 0x478(%rsp)
movq %r8, 0x470(%rsp)
vmovsd %xmm0, 0x468(%rsp)
movl %r9d, 0x464(%rsp)
movq 0x490(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x45c(%rsp)
movq 0x488(%rsp), %rax
movl 0x2773c(%rax), %eax
movl %eax, 0x458(%rsp)
movq 0x488(%rsp), %rax
movq 0x27a70(%rax), %rax
movq %rax, 0x450(%rsp)
movq 0x488(%rsp), %rax
movq 0x27a78(%rax), %rax
movq %rax, 0x448(%rsp)
movq 0x488(%rsp), %rax
movq 0x27a88(%rax), %rax
movq %rax, 0x440(%rsp)
movq 0x488(%rsp), %rax
movq 0x27ab0(%rax), %rax
movq %rax, 0x438(%rsp)
cmpl $0x5, 0x4a0(%rsp)
je 0x7136e
cmpl $0x6, 0x4a0(%rsp)
je 0x7136e
cmpl $0x7, 0x4a0(%rsp)
jne 0x7137b
movl $0x0, 0x460(%rsp)
jmp 0x71386
movl $0x1, 0x460(%rsp)
movq 0x490(%rsp), %rdi
callq 0x49770
cmpl $0x0, %eax
jne 0x7145d
cmpl $0x0, 0x460(%rsp)
je 0x71412
movl $0x0, 0x434(%rsp)
movl 0x434(%rsp), %eax
movl 0x464(%rsp), %ecx
imull 0x45c(%rsp), %ecx
cmpl %ecx, %eax
jge 0x71410
movq 0x480(%rsp), %rax
movslq 0x434(%rsp), %rcx
vmovsd (%rax,%rcx,8), %xmm0
vxorps %xmm1, %xmm1, %xmm1
vucomisd %xmm1, %xmm0
jne 0x713ee
jp 0x713ee
jmp 0x713fb
movl $0x0, 0x460(%rsp)
jmp 0x71410
jmp 0x713fd
movl 0x434(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x434(%rsp)
jmp 0x713b1
jmp 0x71412
cmpl $0x0, 0x460(%rsp)
jne 0x71458
movq 0x438(%rsp), %rdi
movl 0x458(%rsp), %eax
imull 0x45c(%rsp), %eax
cltq
shlq $0x3, %rax
addq %rax, %rdi
movq 0x480(%rsp), %rsi
movl 0x464(%rsp), %edx
imull 0x45c(%rsp), %edx
callq 0x492d0
jmp 0x7166b
xorl %eax, %eax
cmpl 0x4b0(%rsp), %eax
jle 0x71470
xorl %eax, %eax
movl %eax, 0x1c(%rsp)
jmp 0x7147b
movl 0x4b0(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x4b0(%rsp)
cmpl $0x0, 0x4b0(%rsp)
je 0x7149d
movl $0x0, 0x460(%rsp)
jmp 0x714ae
cmpl $0x0, 0x460(%rsp)
je 0x714ac
jmp 0x71874
jmp 0x714ae
cmpl $0x0, 0x4b0(%rsp)
je 0x7150e
cmpq $0x0, 0x4b8(%rsp)
jne 0x7150e
movq $0x10, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x4a70cf(%rip), %rsi # 0x5185a7
movl $0x400, %edx # imm = 0x400
callq 0x49400
leaq 0x30(%rsp), %rdi
addq 0x28(%rsp), %rdi
movl $0x400, %esi # imm = 0x400
subq 0x28(%rsp), %rsi
leaq 0x4a70bb(%rip), %rdx # 0x5185b8
movb $0x0, %al
callq 0x49410
leaq 0x30(%rsp), %rdi
callq 0x49420
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x464(%rsp), %eax
jge 0x71669
movl 0x458(%rsp), %eax
addl 0x24(%rsp), %eax
cmpl $0x0, %eax
je 0x71575
movq 0x448(%rsp), %rax
movl 0x458(%rsp), %ecx
addl 0x24(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movq 0x450(%rsp), %rcx
movl 0x458(%rsp), %edx
addl 0x24(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
addl (%rcx,%rdx,4), %eax
movl %eax, 0x18(%rsp)
jmp 0x7157d
xorl %eax, %eax
movl %eax, 0x18(%rsp)
jmp 0x7157d
movl 0x18(%rsp), %edx
movq 0x448(%rsp), %rax
movl 0x458(%rsp), %ecx
addl 0x24(%rsp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl 0x4b0(%rsp), %edx
movq 0x450(%rsp), %rax
movl 0x458(%rsp), %ecx
addl 0x24(%rsp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
cmpl $0x0, 0x4b0(%rsp)
je 0x71657
movq 0x440(%rsp), %rdi
movq 0x448(%rsp), %rax
movl 0x458(%rsp), %ecx
addl 0x24(%rsp), %ecx
movslq %ecx, %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq 0x4b8(%rsp), %rsi
movl 0x4b0(%rsp), %edx
callq 0x49810
movq 0x438(%rsp), %rdi
movq 0x448(%rsp), %rax
movl 0x458(%rsp), %ecx
addl 0x24(%rsp), %ecx
movslq %ecx, %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x480(%rsp), %rsi
movl 0x24(%rsp), %eax
imull 0x4b0(%rsp), %eax
cltq
shlq $0x3, %rax
addq %rax, %rsi
movl 0x4b0(%rsp), %edx
callq 0x492d0
jmp 0x71659
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x71516
jmp 0x7166b
cmpl $0x0, 0x460(%rsp)
je 0x7167a
jmp 0x71874
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x464(%rsp), %eax
jge 0x717ce
cmpq $0x0, 0x478(%rsp)
je 0x716b8
movq 0x478(%rsp), %rax
movslq 0x20(%rsp), %rcx
vmovsd (%rax,%rcx,8), %xmm0
vmovsd %xmm0, 0x10(%rsp)
jmp 0x716c4
vxorps %xmm0, %xmm0, %xmm0
vmovsd %xmm0, 0x10(%rsp)
jmp 0x716c4
vmovsd 0x10(%rsp), %xmm0
movq 0x488(%rsp), %rax
movq 0x27ac0(%rax), %rax
movl 0x458(%rsp), %ecx
addl 0x20(%rsp), %ecx
movslq %ecx, %rcx
vmovsd %xmm0, (%rax,%rcx,8)
cmpq $0x0, 0x470(%rsp)
je 0x71711
movq 0x470(%rsp), %rax
movslq 0x20(%rsp), %rcx
vmovsd (%rax,%rcx,8), %xmm0
vmovsd %xmm0, 0x8(%rsp)
jmp 0x7171d
vxorps %xmm0, %xmm0, %xmm0
vmovsd %xmm0, 0x8(%rsp)
jmp 0x7171d
vmovsd 0x8(%rsp), %xmm0
movq 0x488(%rsp), %rax
movq 0x27ac8(%rax), %rax
movl 0x458(%rsp), %ecx
addl 0x20(%rsp), %ecx
movslq %ecx, %rcx
vmovsd %xmm0, (%rax,%rcx,8)
vmovsd 0x468(%rsp), %xmm0
movq 0x488(%rsp), %rax
movq 0x27ad0(%rax), %rax
movl 0x458(%rsp), %ecx
addl 0x20(%rsp), %ecx
movslq %ecx, %rcx
vmovsd %xmm0, (%rax,%rcx,8)
movl 0x4a0(%rsp), %edx
movq 0x488(%rsp), %rax
movq 0x27a60(%rax), %rax
movl 0x458(%rsp), %ecx
addl 0x20(%rsp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl 0x4a8(%rsp), %edx
movq 0x488(%rsp), %rax
movq 0x27a68(%rax), %rax
movl 0x458(%rsp), %ecx
addl 0x20(%rsp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x71682
movl 0x464(%rsp), %ecx
movq 0x488(%rsp), %rax
addl 0x2773c(%rax), %ecx
movl %ecx, 0x2773c(%rax)
cmpl $0x0, 0x4a0(%rsp)
jne 0x71810
movl 0x464(%rsp), %ecx
movq 0x488(%rsp), %rax
addl 0x27730(%rax), %ecx
movl %ecx, 0x27730(%rax)
jmp 0x71874
cmpl $0x1, 0x4a0(%rsp)
je 0x71824
cmpl $0x2, 0x4a0(%rsp)
jne 0x71841
movl 0x464(%rsp), %ecx
movq 0x488(%rsp), %rax
addl 0x27734(%rax), %ecx
movl %ecx, 0x27734(%rax)
jmp 0x71872
cmpl $0x3, 0x4a0(%rsp)
je 0x71855
cmpl $0x4, 0x4a0(%rsp)
jne 0x71870
movl 0x464(%rsp), %ecx
movq 0x488(%rsp), %rax
addl 0x27738(%rax), %ecx
movl %ecx, 0x27738(%rax)
jmp 0x71872
jmp 0x71874
addq $0x498, %rsp # imm = 0x498
retq
nopl (%rax)
| mj_addConstraint:
sub rsp, 498h
mov rax, [rsp+498h+arg_18]
mov eax, [rsp+498h+arg_10]
mov eax, [rsp+498h+arg_8]
mov eax, [rsp+498h+arg_0]
mov [rsp+498h+var_8], rdi
mov [rsp+498h+var_10], rsi
mov [rsp+498h+var_18], rdx
mov [rsp+498h+var_20], rcx
mov [rsp+498h+var_28], r8
vmovsd [rsp+498h+var_30], xmm0
mov [rsp+498h+var_34], r9d
mov rax, [rsp+498h+var_8]
mov eax, [rax+4]
mov [rsp+498h+var_3C], eax
mov rax, [rsp+498h+var_10]
mov eax, [rax+2773Ch]
mov [rsp+498h+var_40], eax
mov rax, [rsp+498h+var_10]
mov rax, [rax+27A70h]
mov [rsp+498h+var_48], rax
mov rax, [rsp+498h+var_10]
mov rax, [rax+27A78h]
mov [rsp+498h+var_50], rax
mov rax, [rsp+498h+var_10]
mov rax, [rax+27A88h]
mov [rsp+498h+var_58], rax
mov rax, [rsp+498h+var_10]
mov rax, [rax+27AB0h]
mov [rsp+498h+var_60], rax
cmp [rsp+498h+arg_0], 5
jz short loc_7136E
cmp [rsp+498h+arg_0], 6
jz short loc_7136E
cmp [rsp+498h+arg_0], 7
jnz short loc_7137B
loc_7136E:
mov [rsp+498h+var_38], 0
jmp short loc_71386
loc_7137B:
mov [rsp+498h+var_38], 1
loc_71386:
mov rdi, [rsp+498h+var_8]
call _mj_isSparse
cmp eax, 0
jnz loc_7145D
cmp [rsp+498h+var_38], 0
jz short loc_71412
mov [rsp+498h+var_64], 0
loc_713B1:
mov eax, [rsp+498h+var_64]
mov ecx, [rsp+498h+var_34]
imul ecx, [rsp+498h+var_3C]
cmp eax, ecx
jge short loc_71410
mov rax, [rsp+498h+var_18]
movsxd rcx, [rsp+498h+var_64]
vmovsd xmm0, qword ptr [rax+rcx*8]
vxorps xmm1, xmm1, xmm1
vucomisd xmm0, xmm1
jnz short loc_713EE
jp short loc_713EE
jmp short loc_713FB
loc_713EE:
mov [rsp+498h+var_38], 0
jmp short loc_71410
loc_713FB:
jmp short $+2
loc_713FD:
mov eax, [rsp+498h+var_64]
add eax, 1
mov [rsp+498h+var_64], eax
jmp short loc_713B1
loc_71410:
jmp short $+2
loc_71412:
cmp [rsp+498h+var_38], 0
jnz short loc_71458
mov rdi, [rsp+498h+var_60]
mov eax, [rsp+498h+var_40]
imul eax, [rsp+498h+var_3C]
cdqe
shl rax, 3
add rdi, rax
mov rsi, [rsp+498h+var_18]
mov edx, [rsp+498h+var_34]
imul edx, [rsp+498h+var_3C]
call _mju_copy
loc_71458:
jmp loc_7166B
loc_7145D:
xor eax, eax
cmp eax, [rsp+498h+arg_10]
jle short loc_71470
xor eax, eax
mov [rsp+498h+var_47C], eax
jmp short loc_7147B
loc_71470:
mov eax, [rsp+498h+arg_10]
mov [rsp+498h+var_47C], eax
loc_7147B:
mov eax, [rsp+498h+var_47C]
mov [rsp+498h+arg_10], eax
cmp [rsp+498h+arg_10], 0
jz short loc_7149D
mov [rsp+498h+var_38], 0
jmp short loc_714AE
loc_7149D:
cmp [rsp+498h+var_38], 0
jz short loc_714AC
jmp loc_71874
loc_714AC:
jmp short $+2
loc_714AE:
cmp [rsp+498h+arg_10], 0
jz short loc_7150E
cmp [rsp+498h+arg_18], 0
jnz short loc_7150E
mov [rsp+498h+var_470], 10h
lea rdi, [rsp+498h+var_468]
lea rsi, aMjAddconstrain; "mj_addConstraint"
mov edx, 400h
call _strncpy
lea rdi, [rsp+498h+var_468]
add rdi, [rsp+498h+var_470]
mov esi, 400h
sub rsi, [rsp+498h+var_470]
lea rdx, aCalledWithDens; ": called with dense arguments"
mov al, 0
call _snprintf
lea rdi, [rsp+498h+var_468]
call _mju_error_raw
loc_7150E:
mov [rsp+498h+var_474], 0
loc_71516:
mov eax, [rsp+498h+var_474]
cmp eax, [rsp+498h+var_34]
jge loc_71669
mov eax, [rsp+498h+var_40]
add eax, [rsp+498h+var_474]
cmp eax, 0
jz short loc_71575
mov rax, [rsp+498h+var_50]
mov ecx, [rsp+498h+var_40]
add ecx, [rsp+498h+var_474]
sub ecx, 1
movsxd rcx, ecx
mov eax, [rax+rcx*4]
mov rcx, [rsp+498h+var_48]
mov edx, [rsp+498h+var_40]
add edx, [rsp+498h+var_474]
sub edx, 1
movsxd rdx, edx
add eax, [rcx+rdx*4]
mov [rsp+498h+var_480], eax
jmp short loc_7157D
loc_71575:
xor eax, eax
mov [rsp+498h+var_480], eax
jmp short $+2
loc_7157D:
mov edx, [rsp+498h+var_480]
mov rax, [rsp+498h+var_50]
mov ecx, [rsp+498h+var_40]
add ecx, [rsp+498h+var_474]
movsxd rcx, ecx
mov [rax+rcx*4], edx
mov edx, [rsp+498h+arg_10]
mov rax, [rsp+498h+var_48]
mov ecx, [rsp+498h+var_40]
add ecx, [rsp+498h+var_474]
movsxd rcx, ecx
mov [rax+rcx*4], edx
cmp [rsp+498h+arg_10], 0
jz loc_71657
mov rdi, [rsp+498h+var_58]
mov rax, [rsp+498h+var_50]
mov ecx, [rsp+498h+var_40]
add ecx, [rsp+498h+var_474]
movsxd rcx, ecx
movsxd rax, dword ptr [rax+rcx*4]
shl rax, 2
add rdi, rax
mov rsi, [rsp+498h+arg_18]
mov edx, [rsp+498h+arg_10]
call _mju_copyInt
mov rdi, [rsp+498h+var_60]
mov rax, [rsp+498h+var_50]
mov ecx, [rsp+498h+var_40]
add ecx, [rsp+498h+var_474]
movsxd rcx, ecx
movsxd rax, dword ptr [rax+rcx*4]
shl rax, 3
add rdi, rax
mov rsi, [rsp+498h+var_18]
mov eax, [rsp+498h+var_474]
imul eax, [rsp+498h+arg_10]
cdqe
shl rax, 3
add rsi, rax
mov edx, [rsp+498h+arg_10]
call _mju_copy
loc_71657:
jmp short $+2
loc_71659:
mov eax, [rsp+498h+var_474]
add eax, 1
mov [rsp+498h+var_474], eax
jmp loc_71516
loc_71669:
jmp short $+2
loc_7166B:
cmp [rsp+498h+var_38], 0
jz short loc_7167A
jmp loc_71874
loc_7167A:
mov [rsp+498h+var_478], 0
loc_71682:
mov eax, [rsp+498h+var_478]
cmp eax, [rsp+498h+var_34]
jge loc_717CE
cmp [rsp+498h+var_20], 0
jz short loc_716B8
mov rax, [rsp+498h+var_20]
movsxd rcx, [rsp+498h+var_478]
vmovsd xmm0, qword ptr [rax+rcx*8]
vmovsd [rsp+498h+var_488], xmm0
jmp short loc_716C4
loc_716B8:
vxorps xmm0, xmm0, xmm0
vmovsd [rsp+498h+var_488], xmm0
jmp short $+2
loc_716C4:
vmovsd xmm0, [rsp+498h+var_488]
mov rax, [rsp+498h+var_10]
mov rax, [rax+27AC0h]
mov ecx, [rsp+498h+var_40]
add ecx, [rsp+498h+var_478]
movsxd rcx, ecx
vmovsd qword ptr [rax+rcx*8], xmm0
cmp [rsp+498h+var_28], 0
jz short loc_71711
mov rax, [rsp+498h+var_28]
movsxd rcx, [rsp+498h+var_478]
vmovsd xmm0, qword ptr [rax+rcx*8]
vmovsd [rsp+498h+var_490], xmm0
jmp short loc_7171D
loc_71711:
vxorps xmm0, xmm0, xmm0
vmovsd [rsp+498h+var_490], xmm0
jmp short $+2
loc_7171D:
vmovsd xmm0, [rsp+498h+var_490]
mov rax, [rsp+498h+var_10]
mov rax, [rax+27AC8h]
mov ecx, [rsp+498h+var_40]
add ecx, [rsp+498h+var_478]
movsxd rcx, ecx
vmovsd qword ptr [rax+rcx*8], xmm0
vmovsd xmm0, [rsp+498h+var_30]
mov rax, [rsp+498h+var_10]
mov rax, [rax+27AD0h]
mov ecx, [rsp+498h+var_40]
add ecx, [rsp+498h+var_478]
movsxd rcx, ecx
vmovsd qword ptr [rax+rcx*8], xmm0
mov edx, [rsp+498h+arg_0]
mov rax, [rsp+498h+var_10]
mov rax, [rax+27A60h]
mov ecx, [rsp+498h+var_40]
add ecx, [rsp+498h+var_478]
movsxd rcx, ecx
mov [rax+rcx*4], edx
mov edx, [rsp+498h+arg_8]
mov rax, [rsp+498h+var_10]
mov rax, [rax+27A68h]
mov ecx, [rsp+498h+var_40]
add ecx, [rsp+498h+var_478]
movsxd rcx, ecx
mov [rax+rcx*4], edx
mov eax, [rsp+498h+var_478]
add eax, 1
mov [rsp+498h+var_478], eax
jmp loc_71682
loc_717CE:
mov ecx, [rsp+498h+var_34]
mov rax, [rsp+498h+var_10]
add ecx, [rax+2773Ch]
mov [rax+2773Ch], ecx
cmp [rsp+498h+arg_0], 0
jnz short loc_71810
mov ecx, [rsp+498h+var_34]
mov rax, [rsp+498h+var_10]
add ecx, [rax+27730h]
mov [rax+27730h], ecx
jmp short loc_71874
loc_71810:
cmp [rsp+498h+arg_0], 1
jz short loc_71824
cmp [rsp+498h+arg_0], 2
jnz short loc_71841
loc_71824:
mov ecx, [rsp+498h+var_34]
mov rax, [rsp+498h+var_10]
add ecx, [rax+27734h]
mov [rax+27734h], ecx
jmp short loc_71872
loc_71841:
cmp [rsp+498h+arg_0], 3
jz short loc_71855
cmp [rsp+498h+arg_0], 4
jnz short loc_71870
loc_71855:
mov ecx, [rsp+498h+var_34]
mov rax, [rsp+498h+var_10]
add ecx, [rax+27738h]
mov [rax+27738h], ecx
loc_71870:
jmp short $+2
loc_71872:
jmp short $+2
loc_71874:
add rsp, 498h
retn
| long long mj_addConstraint(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
int a6,
__m128 _XMM0,
__m128 _XMM1,
int a9,
int a10,
int a11,
long long a12)
{
long long result; // rax
int v32; // [rsp+18h] [rbp-480h]
unsigned int v33; // [rsp+1Ch] [rbp-47Ch]
int k; // [rsp+20h] [rbp-478h]
unsigned int i; // [rsp+24h] [rbp-474h]
_BYTE v36[16]; // [rsp+30h] [rbp-468h] BYREF
long long v37; // [rsp+40h] [rbp-458h] BYREF
int j; // [rsp+434h] [rbp-64h]
long long v39; // [rsp+438h] [rbp-60h]
long long v40; // [rsp+440h] [rbp-58h]
long long v41; // [rsp+448h] [rbp-50h]
long long v42; // [rsp+450h] [rbp-48h]
int v43; // [rsp+458h] [rbp-40h]
int v44; // [rsp+45Ch] [rbp-3Ch]
BOOL v45; // [rsp+460h] [rbp-38h]
int v46; // [rsp+464h] [rbp-34h]
long long v48; // [rsp+470h] [rbp-28h]
long long v49; // [rsp+478h] [rbp-20h]
long long v50; // [rsp+480h] [rbp-18h]
long long v51; // [rsp+488h] [rbp-10h]
long long v52; // [rsp+490h] [rbp-8h]
v52 = a1;
v51 = a2;
v50 = a3;
v49 = a4;
v48 = a5;
__asm { vmovsd [rsp+498h+var_30], xmm0 }
v46 = a6;
v44 = *(_DWORD *)(a1 + 4);
v43 = *(_DWORD *)(a2 + 161596);
v42 = *(_QWORD *)(a2 + 162416);
v41 = *(_QWORD *)(a2 + 162424);
v40 = *(_QWORD *)(a2 + 162440);
v39 = *(_QWORD *)(a2 + 162480);
v45 = a9 != 5 && a9 != 6 && a9 != 7;
result = mj_isSparse(v52);
if ( (_DWORD)result )
{
if ( a11 >= 0 )
v33 = a11;
else
v33 = 0;
result = v33;
if ( v33 )
{
v45 = 0;
}
else if ( v45 )
{
return result;
}
if ( v33 && !a12 )
{
strncpy(v36, "mj_addConstraint", 1024LL);
snprintf(&v37, 1008LL, ": called with dense arguments");
*(double *)_XMM0.m128_u64 = mju_error_raw(v36);
}
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= v46 )
break;
if ( i + v43 )
v32 = *(_DWORD *)(v42 + 4LL * (int)(i + v43 - 1)) + *(_DWORD *)(v41 + 4LL * (int)(i + v43 - 1));
else
v32 = 0;
*(_DWORD *)(v41 + 4LL * (int)(i + v43)) = v32;
*(_DWORD *)(v42 + 4LL * (int)(i + v43)) = v33;
if ( v33 )
{
mju_copyInt(4LL * *(int *)(v41 + 4LL * (int)(i + v43)) + v40, a12, v33);
mju_copy(8LL * *(int *)(v41 + 4LL * (int)(i + v43)) + v39, 8LL * (int)(v33 * i) + v50, v33);
}
}
}
else
{
if ( v45 )
{
for ( j = 0; ; ++j )
{
result = (unsigned int)j;
if ( j >= v44 * v46 )
break;
result = v50;
_RCX = j;
__asm
{
vmovsd xmm0, qword ptr [rax+rcx*8]
vxorps xmm1, xmm1, xmm1
vucomisd xmm0, xmm1
}
if ( j != v44 * v46 || __SETP__(j, v44 * v46) )
{
v45 = 0;
break;
}
}
}
if ( !v45 )
result = mju_copy(8LL * v44 * v43 + v39, v50, (unsigned int)(v44 * v46));
}
if ( !v45 )
{
for ( k = 0; k < v46; ++k )
{
if ( v49 )
{
_RAX = v49;
_RCX = k;
__asm
{
vmovsd xmm0, qword ptr [rax+rcx*8]
vmovsd [rsp+498h+var_488], xmm0
}
}
else
{
__asm
{
vxorps xmm0, xmm0, xmm0
vmovsd [rsp+498h+var_488], xmm0
}
}
__asm { vmovsd xmm0, [rsp+498h+var_488] }
_RAX = *(_QWORD *)(v51 + 162496);
_RCX = k + v43;
__asm { vmovsd qword ptr [rax+rcx*8], xmm0 }
if ( v48 )
{
_RAX = v48;
_RCX = k;
__asm
{
vmovsd xmm0, qword ptr [rax+rcx*8]
vmovsd [rsp+498h+var_490], xmm0
}
}
else
{
__asm
{
vxorps xmm0, xmm0, xmm0
vmovsd [rsp+498h+var_490], xmm0
}
}
__asm { vmovsd xmm0, [rsp+498h+var_490] }
_RAX = *(_QWORD *)(v51 + 162504);
_RCX = k + v43;
__asm
{
vmovsd qword ptr [rax+rcx*8], xmm0
vmovsd xmm0, [rsp+498h+var_30]
}
_RAX = *(_QWORD *)(v51 + 162512);
_RCX = k + v43;
__asm { vmovsd qword ptr [rax+rcx*8], xmm0 }
*(_DWORD *)(*(_QWORD *)(v51 + 162400) + 4LL * (k + v43)) = a9;
*(_DWORD *)(*(_QWORD *)(v51 + 162408) + 4LL * (k + v43)) = a10;
}
result = v51;
*(_DWORD *)(v51 + 161596) += v46;
if ( a9 )
{
if ( a9 == 1 || a9 == 2 )
{
result = v51;
*(_DWORD *)(v51 + 161588) += v46;
}
else if ( a9 == 3 || a9 == 4 )
{
result = v51;
*(_DWORD *)(v51 + 161592) += v46;
}
}
else
{
result = v51;
*(_DWORD *)(v51 + 161584) += v46;
}
}
return result;
}
| mj_addConstraint:
SUB RSP,0x498
MOV RAX,qword ptr [RSP + 0x4b8]
MOV EAX,dword ptr [RSP + 0x4b0]
MOV EAX,dword ptr [RSP + 0x4a8]
MOV EAX,dword ptr [RSP + 0x4a0]
MOV qword ptr [RSP + 0x490],RDI
MOV qword ptr [RSP + 0x488],RSI
MOV qword ptr [RSP + 0x480],RDX
MOV qword ptr [RSP + 0x478],RCX
MOV qword ptr [RSP + 0x470],R8
VMOVSD qword ptr [RSP + 0x468],XMM0
MOV dword ptr [RSP + 0x464],R9D
MOV RAX,qword ptr [RSP + 0x490]
MOV EAX,dword ptr [RAX + 0x4]
MOV dword ptr [RSP + 0x45c],EAX
MOV RAX,qword ptr [RSP + 0x488]
MOV EAX,dword ptr [RAX + 0x2773c]
MOV dword ptr [RSP + 0x458],EAX
MOV RAX,qword ptr [RSP + 0x488]
MOV RAX,qword ptr [RAX + 0x27a70]
MOV qword ptr [RSP + 0x450],RAX
MOV RAX,qword ptr [RSP + 0x488]
MOV RAX,qword ptr [RAX + 0x27a78]
MOV qword ptr [RSP + 0x448],RAX
MOV RAX,qword ptr [RSP + 0x488]
MOV RAX,qword ptr [RAX + 0x27a88]
MOV qword ptr [RSP + 0x440],RAX
MOV RAX,qword ptr [RSP + 0x488]
MOV RAX,qword ptr [RAX + 0x27ab0]
MOV qword ptr [RSP + 0x438],RAX
CMP dword ptr [RSP + 0x4a0],0x5
JZ 0x0017136e
CMP dword ptr [RSP + 0x4a0],0x6
JZ 0x0017136e
CMP dword ptr [RSP + 0x4a0],0x7
JNZ 0x0017137b
LAB_0017136e:
MOV dword ptr [RSP + 0x460],0x0
JMP 0x00171386
LAB_0017137b:
MOV dword ptr [RSP + 0x460],0x1
LAB_00171386:
MOV RDI,qword ptr [RSP + 0x490]
CALL 0x00149770
CMP EAX,0x0
JNZ 0x0017145d
CMP dword ptr [RSP + 0x460],0x0
JZ 0x00171412
MOV dword ptr [RSP + 0x434],0x0
LAB_001713b1:
MOV EAX,dword ptr [RSP + 0x434]
MOV ECX,dword ptr [RSP + 0x464]
IMUL ECX,dword ptr [RSP + 0x45c]
CMP EAX,ECX
JGE 0x00171410
MOV RAX,qword ptr [RSP + 0x480]
MOVSXD RCX,dword ptr [RSP + 0x434]
VMOVSD XMM0,qword ptr [RAX + RCX*0x8]
VXORPS XMM1,XMM1,XMM1
VUCOMISD XMM0,XMM1
JNZ 0x001713ee
JP 0x001713ee
JMP 0x001713fb
LAB_001713ee:
MOV dword ptr [RSP + 0x460],0x0
JMP 0x00171410
LAB_001713fb:
JMP 0x001713fd
LAB_001713fd:
MOV EAX,dword ptr [RSP + 0x434]
ADD EAX,0x1
MOV dword ptr [RSP + 0x434],EAX
JMP 0x001713b1
LAB_00171410:
JMP 0x00171412
LAB_00171412:
CMP dword ptr [RSP + 0x460],0x0
JNZ 0x00171458
MOV RDI,qword ptr [RSP + 0x438]
MOV EAX,dword ptr [RSP + 0x458]
IMUL EAX,dword ptr [RSP + 0x45c]
CDQE
SHL RAX,0x3
ADD RDI,RAX
MOV RSI,qword ptr [RSP + 0x480]
MOV EDX,dword ptr [RSP + 0x464]
IMUL EDX,dword ptr [RSP + 0x45c]
CALL 0x001492d0
LAB_00171458:
JMP 0x0017166b
LAB_0017145d:
XOR EAX,EAX
CMP EAX,dword ptr [RSP + 0x4b0]
JLE 0x00171470
XOR EAX,EAX
MOV dword ptr [RSP + 0x1c],EAX
JMP 0x0017147b
LAB_00171470:
MOV EAX,dword ptr [RSP + 0x4b0]
MOV dword ptr [RSP + 0x1c],EAX
LAB_0017147b:
MOV EAX,dword ptr [RSP + 0x1c]
MOV dword ptr [RSP + 0x4b0],EAX
CMP dword ptr [RSP + 0x4b0],0x0
JZ 0x0017149d
MOV dword ptr [RSP + 0x460],0x0
JMP 0x001714ae
LAB_0017149d:
CMP dword ptr [RSP + 0x460],0x0
JZ 0x001714ac
JMP 0x00171874
LAB_001714ac:
JMP 0x001714ae
LAB_001714ae:
CMP dword ptr [RSP + 0x4b0],0x0
JZ 0x0017150e
CMP qword ptr [RSP + 0x4b8],0x0
JNZ 0x0017150e
MOV qword ptr [RSP + 0x28],0x10
LEA RDI,[RSP + 0x30]
LEA RSI,[0x6185a7]
MOV EDX,0x400
CALL 0x00149400
LEA RDI,[RSP + 0x30]
ADD RDI,qword ptr [RSP + 0x28]
MOV ESI,0x400
SUB RSI,qword ptr [RSP + 0x28]
LEA RDX,[0x6185b8]
MOV AL,0x0
CALL 0x00149410
LEA RDI,[RSP + 0x30]
CALL 0x00149420
LAB_0017150e:
MOV dword ptr [RSP + 0x24],0x0
LAB_00171516:
MOV EAX,dword ptr [RSP + 0x24]
CMP EAX,dword ptr [RSP + 0x464]
JGE 0x00171669
MOV EAX,dword ptr [RSP + 0x458]
ADD EAX,dword ptr [RSP + 0x24]
CMP EAX,0x0
JZ 0x00171575
MOV RAX,qword ptr [RSP + 0x448]
MOV ECX,dword ptr [RSP + 0x458]
ADD ECX,dword ptr [RSP + 0x24]
SUB ECX,0x1
MOVSXD RCX,ECX
MOV EAX,dword ptr [RAX + RCX*0x4]
MOV RCX,qword ptr [RSP + 0x450]
MOV EDX,dword ptr [RSP + 0x458]
ADD EDX,dword ptr [RSP + 0x24]
SUB EDX,0x1
MOVSXD RDX,EDX
ADD EAX,dword ptr [RCX + RDX*0x4]
MOV dword ptr [RSP + 0x18],EAX
JMP 0x0017157d
LAB_00171575:
XOR EAX,EAX
MOV dword ptr [RSP + 0x18],EAX
JMP 0x0017157d
LAB_0017157d:
MOV EDX,dword ptr [RSP + 0x18]
MOV RAX,qword ptr [RSP + 0x448]
MOV ECX,dword ptr [RSP + 0x458]
ADD ECX,dword ptr [RSP + 0x24]
MOVSXD RCX,ECX
MOV dword ptr [RAX + RCX*0x4],EDX
MOV EDX,dword ptr [RSP + 0x4b0]
MOV RAX,qword ptr [RSP + 0x450]
MOV ECX,dword ptr [RSP + 0x458]
ADD ECX,dword ptr [RSP + 0x24]
MOVSXD RCX,ECX
MOV dword ptr [RAX + RCX*0x4],EDX
CMP dword ptr [RSP + 0x4b0],0x0
JZ 0x00171657
MOV RDI,qword ptr [RSP + 0x440]
MOV RAX,qword ptr [RSP + 0x448]
MOV ECX,dword ptr [RSP + 0x458]
ADD ECX,dword ptr [RSP + 0x24]
MOVSXD RCX,ECX
MOVSXD RAX,dword ptr [RAX + RCX*0x4]
SHL RAX,0x2
ADD RDI,RAX
MOV RSI,qword ptr [RSP + 0x4b8]
MOV EDX,dword ptr [RSP + 0x4b0]
CALL 0x00149810
MOV RDI,qword ptr [RSP + 0x438]
MOV RAX,qword ptr [RSP + 0x448]
MOV ECX,dword ptr [RSP + 0x458]
ADD ECX,dword ptr [RSP + 0x24]
MOVSXD RCX,ECX
MOVSXD RAX,dword ptr [RAX + RCX*0x4]
SHL RAX,0x3
ADD RDI,RAX
MOV RSI,qword ptr [RSP + 0x480]
MOV EAX,dword ptr [RSP + 0x24]
IMUL EAX,dword ptr [RSP + 0x4b0]
CDQE
SHL RAX,0x3
ADD RSI,RAX
MOV EDX,dword ptr [RSP + 0x4b0]
CALL 0x001492d0
LAB_00171657:
JMP 0x00171659
LAB_00171659:
MOV EAX,dword ptr [RSP + 0x24]
ADD EAX,0x1
MOV dword ptr [RSP + 0x24],EAX
JMP 0x00171516
LAB_00171669:
JMP 0x0017166b
LAB_0017166b:
CMP dword ptr [RSP + 0x460],0x0
JZ 0x0017167a
JMP 0x00171874
LAB_0017167a:
MOV dword ptr [RSP + 0x20],0x0
LAB_00171682:
MOV EAX,dword ptr [RSP + 0x20]
CMP EAX,dword ptr [RSP + 0x464]
JGE 0x001717ce
CMP qword ptr [RSP + 0x478],0x0
JZ 0x001716b8
MOV RAX,qword ptr [RSP + 0x478]
MOVSXD RCX,dword ptr [RSP + 0x20]
VMOVSD XMM0,qword ptr [RAX + RCX*0x8]
VMOVSD qword ptr [RSP + 0x10],XMM0
JMP 0x001716c4
LAB_001716b8:
VXORPS XMM0,XMM0,XMM0
VMOVSD qword ptr [RSP + 0x10],XMM0
JMP 0x001716c4
LAB_001716c4:
VMOVSD XMM0,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x488]
MOV RAX,qword ptr [RAX + 0x27ac0]
MOV ECX,dword ptr [RSP + 0x458]
ADD ECX,dword ptr [RSP + 0x20]
MOVSXD RCX,ECX
VMOVSD qword ptr [RAX + RCX*0x8],XMM0
CMP qword ptr [RSP + 0x470],0x0
JZ 0x00171711
MOV RAX,qword ptr [RSP + 0x470]
MOVSXD RCX,dword ptr [RSP + 0x20]
VMOVSD XMM0,qword ptr [RAX + RCX*0x8]
VMOVSD qword ptr [RSP + 0x8],XMM0
JMP 0x0017171d
LAB_00171711:
VXORPS XMM0,XMM0,XMM0
VMOVSD qword ptr [RSP + 0x8],XMM0
JMP 0x0017171d
LAB_0017171d:
VMOVSD XMM0,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP + 0x488]
MOV RAX,qword ptr [RAX + 0x27ac8]
MOV ECX,dword ptr [RSP + 0x458]
ADD ECX,dword ptr [RSP + 0x20]
MOVSXD RCX,ECX
VMOVSD qword ptr [RAX + RCX*0x8],XMM0
VMOVSD XMM0,qword ptr [RSP + 0x468]
MOV RAX,qword ptr [RSP + 0x488]
MOV RAX,qword ptr [RAX + 0x27ad0]
MOV ECX,dword ptr [RSP + 0x458]
ADD ECX,dword ptr [RSP + 0x20]
MOVSXD RCX,ECX
VMOVSD qword ptr [RAX + RCX*0x8],XMM0
MOV EDX,dword ptr [RSP + 0x4a0]
MOV RAX,qword ptr [RSP + 0x488]
MOV RAX,qword ptr [RAX + 0x27a60]
MOV ECX,dword ptr [RSP + 0x458]
ADD ECX,dword ptr [RSP + 0x20]
MOVSXD RCX,ECX
MOV dword ptr [RAX + RCX*0x4],EDX
MOV EDX,dword ptr [RSP + 0x4a8]
MOV RAX,qword ptr [RSP + 0x488]
MOV RAX,qword ptr [RAX + 0x27a68]
MOV ECX,dword ptr [RSP + 0x458]
ADD ECX,dword ptr [RSP + 0x20]
MOVSXD RCX,ECX
MOV dword ptr [RAX + RCX*0x4],EDX
MOV EAX,dword ptr [RSP + 0x20]
ADD EAX,0x1
MOV dword ptr [RSP + 0x20],EAX
JMP 0x00171682
LAB_001717ce:
MOV ECX,dword ptr [RSP + 0x464]
MOV RAX,qword ptr [RSP + 0x488]
ADD ECX,dword ptr [RAX + 0x2773c]
MOV dword ptr [RAX + 0x2773c],ECX
CMP dword ptr [RSP + 0x4a0],0x0
JNZ 0x00171810
MOV ECX,dword ptr [RSP + 0x464]
MOV RAX,qword ptr [RSP + 0x488]
ADD ECX,dword ptr [RAX + 0x27730]
MOV dword ptr [RAX + 0x27730],ECX
JMP 0x00171874
LAB_00171810:
CMP dword ptr [RSP + 0x4a0],0x1
JZ 0x00171824
CMP dword ptr [RSP + 0x4a0],0x2
JNZ 0x00171841
LAB_00171824:
MOV ECX,dword ptr [RSP + 0x464]
MOV RAX,qword ptr [RSP + 0x488]
ADD ECX,dword ptr [RAX + 0x27734]
MOV dword ptr [RAX + 0x27734],ECX
JMP 0x00171872
LAB_00171841:
CMP dword ptr [RSP + 0x4a0],0x3
JZ 0x00171855
CMP dword ptr [RSP + 0x4a0],0x4
JNZ 0x00171870
LAB_00171855:
MOV ECX,dword ptr [RSP + 0x464]
MOV RAX,qword ptr [RSP + 0x488]
ADD ECX,dword ptr [RAX + 0x27738]
MOV dword ptr [RAX + 0x27738],ECX
LAB_00171870:
JMP 0x00171872
LAB_00171872:
JMP 0x00171874
LAB_00171874:
ADD RSP,0x498
RET
|
void mj_addConstraint(int8 param_1,long param_2,long param_3,long param_4,long param_5,
long param_6,int param_7,int param_8,int4 param_9,int param_10,
long param_11)
{
double dVar1;
int iVar2;
int8 local_490;
int8 local_488;
int local_480;
int local_47c;
int local_478;
int local_474;
char local_468 [16];
char acStack_458 [1012];
int local_64;
long local_60;
long local_58;
long local_50;
long local_48;
int local_40;
int local_3c;
int local_38;
int local_34;
int8 local_30;
long local_28;
long local_20;
long local_18;
long local_10;
long local_8;
local_3c = *(int *)(param_2 + 4);
local_40 = *(int *)(param_3 + 0x2773c);
local_48 = *(long *)(param_3 + 0x27a70);
local_50 = *(long *)(param_3 + 0x27a78);
local_58 = *(long *)(param_3 + 0x27a88);
local_60 = *(long *)(param_3 + 0x27ab0);
if (((param_8 == 5) || (param_8 == 6)) || (param_8 == 7)) {
local_38 = 0;
}
else {
local_38 = 1;
}
local_34 = param_7;
local_30 = param_1;
local_28 = param_6;
local_20 = param_5;
local_18 = param_4;
local_10 = param_3;
local_8 = param_2;
iVar2 = mj_isSparse(param_2);
if (iVar2 == 0) {
if (local_38 != 0) {
for (local_64 = 0; local_64 < local_34 * local_3c; local_64 = local_64 + 1) {
dVar1 = *(double *)(local_18 + (long)local_64 * 8);
if ((dVar1 != 0.0) || (NAN(dVar1))) {
local_38 = 0;
break;
}
}
}
if (local_38 == 0) {
mju_copy(local_60 + (long)(local_40 * local_3c) * 8,local_18,local_34 * local_3c);
}
}
else {
if (param_10 < 0) {
local_47c = 0;
}
else {
local_47c = param_10;
}
if (local_47c == 0) {
if (local_38 != 0) {
return;
}
}
else {
local_38 = 0;
}
if ((local_47c != 0) && (param_11 == 0)) {
strncpy(local_468,"mj_addConstraint",0x400);
snprintf(acStack_458,0x3f0,": called with dense arguments");
mju_error_raw(local_468);
}
for (local_474 = 0; local_474 < local_34; local_474 = local_474 + 1) {
if (local_40 + local_474 == 0) {
local_480 = 0;
}
else {
local_480 = *(int *)(local_50 + (long)(local_40 + local_474 + -1) * 4) +
*(int *)(local_48 + (long)(local_40 + local_474 + -1) * 4);
}
*(int *)(local_50 + (long)(local_40 + local_474) * 4) = local_480;
*(int *)(local_48 + (long)(local_40 + local_474) * 4) = local_47c;
if (local_47c != 0) {
mju_copyInt(local_58 + (long)*(int *)(local_50 + (long)(local_40 + local_474) * 4) * 4,
param_11,local_47c);
mju_copy(local_60 + (long)*(int *)(local_50 + (long)(local_40 + local_474) * 4) * 8,
local_18 + (long)(local_474 * local_47c) * 8,local_47c);
}
}
}
if (local_38 == 0) {
for (local_478 = 0; local_478 < local_34; local_478 = local_478 + 1) {
if (local_20 == 0) {
local_488 = 0;
}
else {
local_488 = *(int8 *)(local_20 + (long)local_478 * 8);
}
*(int8 *)(*(long *)(local_10 + 0x27ac0) + (long)(local_40 + local_478) * 8) = local_488;
if (local_28 == 0) {
local_490 = 0;
}
else {
local_490 = *(int8 *)(local_28 + (long)local_478 * 8);
}
*(int8 *)(*(long *)(local_10 + 0x27ac8) + (long)(local_40 + local_478) * 8) = local_490;
*(int8 *)(*(long *)(local_10 + 0x27ad0) + (long)(local_40 + local_478) * 8) = local_30;
*(int *)(*(long *)(local_10 + 0x27a60) + (long)(local_40 + local_478) * 4) = param_8;
*(int4 *)(*(long *)(local_10 + 0x27a68) + (long)(local_40 + local_478) * 4) = param_9;
}
*(int *)(local_10 + 0x2773c) = local_34 + *(int *)(local_10 + 0x2773c);
if (param_8 == 0) {
*(int *)(local_10 + 0x27730) = local_34 + *(int *)(local_10 + 0x27730);
}
else if ((param_8 == 1) || (param_8 == 2)) {
*(int *)(local_10 + 0x27734) = local_34 + *(int *)(local_10 + 0x27734);
}
else if ((param_8 == 3) || (param_8 == 4)) {
*(int *)(local_10 + 0x27738) = local_34 + *(int *)(local_10 + 0x27738);
}
}
return;
}
| |
44,808 | mj_addConstraint | aimrt_mujoco_sim/_deps/mujoco-src/src/engine/engine_core_constraint.c | static void mj_addConstraint(const mjModel* m, mjData* d,
const mjtNum* jac, const mjtNum* pos,
const mjtNum* margin, mjtNum frictionloss,
int size, int type, int id, int NV, const int* chain) {
int empty, nv = m->nv, nefc = d->nefc;
int *nnz = d->efc_J_rownnz, *adr = d->efc_J_rowadr, *ind = d->efc_J_colind;
mjtNum *J = d->efc_J;
// init empty guard for constraints other than contact
if (type == mjCNSTR_CONTACT_FRICTIONLESS ||
type == mjCNSTR_CONTACT_PYRAMIDAL ||
type == mjCNSTR_CONTACT_ELLIPTIC) {
empty = 0;
} else {
empty = 1;
}
// dense: copy entire Jacobian
if (!mj_isSparse(m)) {
// make sure jac is not empty
if (empty) {
for (int i=0; i < size*nv; i++) {
if (jac[i]) {
empty = 0;
break;
}
}
}
// copy if not empty
if (!empty) {
mju_copy(J + nefc*nv, jac, size*nv);
}
}
// sparse: copy chain
else {
// clamp NV (in case -1 was used in constraint construction)
NV = mjMAX(0, NV);
if (NV) {
empty = 0;
} else if (empty) {
// all rows are empty, return early
return;
}
// chain required in sparse mode
if (NV && !chain) {
mjERROR("called with dense arguments");
}
// process size elements
for (int i=0; i < size; i++) {
// set row address
adr[nefc+i] = (nefc+i ? adr[nefc+i-1]+nnz[nefc+i-1] : 0);
// set row descriptor
nnz[nefc+i] = NV;
// copy if not empty
if (NV) {
mju_copyInt(ind + adr[nefc+i], chain, NV);
mju_copy(J + adr[nefc+i], jac + i*NV, NV);
}
}
}
// all rows empty: skip constraint
if (empty) {
return;
}
// set constraint pos, margin, frictionloss, type, id
for (int i=0; i < size; i++) {
d->efc_pos[nefc+i] = (pos ? pos[i] : 0);
d->efc_margin[nefc+i] = (margin ? margin[i] : 0);
d->efc_frictionloss[nefc+i] = frictionloss;
d->efc_type[nefc+i] = type;
d->efc_id[nefc+i] = id;
}
// increase counters
d->nefc += size;
if (type == mjCNSTR_EQUALITY) {
d->ne += size;
} else if (type == mjCNSTR_FRICTION_DOF || type == mjCNSTR_FRICTION_TENDON) {
d->nf += size;
} else if (type == mjCNSTR_LIMIT_JOINT || type == mjCNSTR_LIMIT_TENDON) {
d->nl += size;
}
} | O3 | c | mj_addConstraint:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x458, %rsp # imm = 0x458
movq %r9, %r13
movq %rcx, %r12
movq %rdx, %rbx
movl 0x498(%rsp), %r15d
movl 0x490(%rsp), %r14d
movslq 0x2773c(%rdx), %rax
movq %rax, 0x8(%rsp)
movq 0x27a70(%rdx), %r9
movq 0x27a78(%rdx), %r10
movq 0x27a88(%rdx), %rax
movq %rax, 0x48(%rsp)
movq 0x27ab0(%rdx), %rax
movq %rax, 0x40(%rsp)
leal -0x8(%r15), %eax
cmpl $0x1, %esi
vmovsd %xmm0, 0x18(%rsp)
movq %r8, 0x10(%rsp)
je 0x42731
cmpl $0x2, %esi
jne 0x4287a
cmpl $0x3b, %edi
jle 0x4287a
movl 0x4a8(%rsp), %edx
cmpl $-0x3, %eax
setb %al
xorl %ebp, %ebp
testl %edx, %edx
cmovgl %edx, %ebp
setle %cl
testb %cl, %al
jne 0x429c6
testl %edx, %edx
setle %al
cmpq $0x0, 0x4b0(%rsp)
setne %cl
orb %al, %cl
jne 0x427c5
leaq 0x17ba2b(%rip), %rsi # 0x1be197
leaq 0x50(%rsp), %rdi
movl $0x400, %edx # imm = 0x400
movq %r9, 0x28(%rsp)
movq %r10, 0x20(%rsp)
callq 0x2d240
vmovups 0x17ba1b(%rip), %xmm0 # 0x1be1a8
leaq 0x50(%rsp), %rdi
vmovaps %xmm0, 0x10(%rdi)
vmovups 0x17ba17(%rip), %xmm0 # 0x1be1b6
vmovups %xmm0, 0x1e(%rdi)
callq 0x2d260
movq 0x20(%rsp), %r10
movq 0x28(%rsp), %r9
movl 0x4a8(%rsp), %edx
movq 0x10(%rsp), %r8
vmovsd 0x18(%rsp), %xmm0
testl %r14d, %r14d
jle 0x42991
movq %r13, 0x30(%rsp)
movq %rbx, 0x38(%rsp)
movl %ebp, %eax
movl %r14d, %ecx
movq %rcx, 0x20(%rsp)
shlq $0x3, %rax
movq %rax, 0x28(%rsp)
movq 0x8(%rsp), %rax
movq %rax, %rbx
negq %rbx
leaq (%r10,%rax,4), %r13
leaq (%r9,%rax,4), %r14
xorl %r15d, %r15d
movl $0x0, %eax
cmpq %r15, %rbx
je 0x42815
movl -0x4(%r14,%r15,4), %eax
addl -0x4(%r13,%r15,4), %eax
movl %eax, (%r13,%r15,4)
movl %ebp, (%r14,%r15,4)
testl %edx, %edx
jle 0x42869
movslq (%r13,%r15,4), %rax
movq 0x48(%rsp), %rcx
leaq (%rcx,%rax,4), %rdi
movq 0x4b0(%rsp), %rsi
movl %ebp, %edx
callq 0x2d600
movslq (%r13,%r15,4), %rax
movq 0x40(%rsp), %rcx
leaq (%rcx,%rax,8), %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x2d120
movl 0x4a8(%rsp), %edx
movq 0x10(%rsp), %r8
vmovsd 0x18(%rsp), %xmm0
incq %r15
addq 0x28(%rsp), %r12
cmpq %r15, 0x20(%rsp)
jne 0x42801
jmp 0x428df
movl %r14d, %edx
imull %edi, %edx
cmpl $-0x4, %eax
ja 0x428b0
testl %edx, %edx
jle 0x429c6
movl %edx, %eax
xorl %ecx, %ecx
vxorpd %xmm0, %xmm0, %xmm0
vmovsd (%r12,%rcx,8), %xmm1
vucomisd %xmm0, %xmm1
jne 0x428b0
jp 0x428b0
incq %rcx
cmpq %rcx, %rax
jne 0x42895
jmp 0x429c6
movq %r13, 0x30(%rsp)
movq %rbx, 0x38(%rsp)
movslq %edi, %rax
imulq 0x8(%rsp), %rax
movq 0x40(%rsp), %rcx
leaq (%rcx,%rax,8), %rdi
movq %r12, %rsi
callq 0x2d120
movq 0x10(%rsp), %r8
vmovsd 0x18(%rsp), %xmm0
movl 0x490(%rsp), %r14d
testl %r14d, %r14d
movq 0x38(%rsp), %rbx
movl 0x498(%rsp), %r15d
movq 0x30(%rsp), %r10
jle 0x42991
movl 0x4a0(%rsp), %eax
movq 0x8(%rsp), %r12
leaq (,%r12,8), %rcx
movq 0x27ac0(%rbx), %rdx
addq %rcx, %rdx
movq 0x27ac8(%rbx), %rsi
addq %rcx, %rsi
addq 0x27ad0(%rbx), %rcx
movl %r14d, %edi
shlq $0x2, %r12
movq 0x27a60(%rbx), %r11
addq %r12, %r11
addq 0x27a68(%rbx), %r12
shlq $0x2, %rdi
xorl %r9d, %r9d
vxorps %xmm2, %xmm2, %xmm2
vxorpd %xmm1, %xmm1, %xmm1
testq %r8, %r8
je 0x42963
vmovsd (%r8,%r9,2), %xmm1
vmovsd %xmm1, (%rdx,%r9,2)
testq %r10, %r10
je 0x42974
vmovsd (%r10,%r9,2), %xmm2
vmovsd %xmm2, (%rsi,%r9,2)
vmovsd %xmm0, (%rcx,%r9,2)
movl %r15d, (%r11,%r9)
movl %eax, (%r12,%r9)
addq $0x4, %r9
cmpq %r9, %rdi
jne 0x42950
addl %r14d, 0x2773c(%rbx)
testl %r15d, %r15d
je 0x429ac
cmpl $0x2, %r15d
ja 0x429b5
addl %r14d, 0x27734(%rbx)
jmp 0x429c6
addl %r14d, 0x27730(%rbx)
jmp 0x429c6
addl $-0x3, %r15d
cmpl $0x1, %r15d
ja 0x429c6
addl %r14d, 0x27738(%rbx)
addq $0x458, %rsp # imm = 0x458
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| mj_addConstraint:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 458h
mov r13, r9
mov r12, rcx
mov rbx, rdx
mov r15d, [rsp+488h+arg_8]
mov r14d, [rsp+488h+arg_0]
movsxd rax, dword ptr [rdx+2773Ch]
mov [rsp+488h+var_480], rax
mov r9, [rdx+27A70h]
mov r10, [rdx+27A78h]
mov rax, [rdx+27A88h]
mov [rsp+488h+var_440], rax
mov rax, qword ptr ds:stru_27AB0.r_offset[rdx]
mov [rsp+488h+var_448], rax
lea eax, [r15-8]
cmp esi, 1
vmovsd [rsp+488h+var_470], xmm0
mov [rsp+488h+var_478], r8
jz short loc_42731
cmp esi, 2
jnz loc_4287A
cmp edi, 3Bh ; ';'
jle loc_4287A
loc_42731:
mov edx, [rsp+488h+arg_18]
cmp eax, 0FFFFFFFDh
setb al
xor ebp, ebp
test edx, edx
cmovg ebp, edx
setle cl
test al, cl
jnz loc_429C6
test edx, edx
setle al
cmp [rsp+488h+arg_20], 0
setnz cl
or cl, al
jnz short loc_427C5
lea rsi, aMjAddconstrain; "mj_addConstraint"
lea rdi, [rsp+488h+var_438]
mov edx, 400h
mov [rsp+488h+var_460], r9
mov [rsp+488h+var_468], r10
call _strncpy
vmovups xmm0, cs:xmmword_1BE1A8
lea rdi, [rsp+488h+var_438]
vmovaps xmmword ptr [rdi+10h], xmm0
vmovups xmm0, cs:xmmword_1BE1A8+0Eh
vmovups xmmword ptr [rdi+1Eh], xmm0
call _mju_error_raw
mov r10, [rsp+488h+var_468]
mov r9, [rsp+488h+var_460]
mov edx, [rsp+488h+arg_18]
mov r8, [rsp+488h+var_478]
vmovsd xmm0, [rsp+488h+var_470]
loc_427C5:
test r14d, r14d
jle loc_42991
mov [rsp+488h+var_458], r13
mov [rsp+488h+var_450], rbx
mov eax, ebp
mov ecx, r14d
mov [rsp+488h+var_468], rcx
shl rax, 3
mov [rsp+488h+var_460], rax
mov rax, [rsp+488h+var_480]
mov rbx, rax
neg rbx
lea r13, [r10+rax*4]
lea r14, [r9+rax*4]
xor r15d, r15d
loc_42801:
mov eax, 0
cmp rbx, r15
jz short loc_42815
mov eax, [r14+r15*4-4]
add eax, [r13+r15*4-4]
loc_42815:
mov [r13+r15*4+0], eax
mov [r14+r15*4], ebp
test edx, edx
jle short loc_42869
movsxd rax, dword ptr [r13+r15*4+0]
mov rcx, [rsp+488h+var_440]
lea rdi, [rcx+rax*4]
mov rsi, [rsp+488h+arg_20]
mov edx, ebp
call _mju_copyInt
movsxd rax, dword ptr [r13+r15*4+0]
mov rcx, [rsp+488h+var_448]
lea rdi, [rcx+rax*8]
mov rsi, r12
mov edx, ebp
call _mju_copy
mov edx, [rsp+488h+arg_18]
mov r8, [rsp+488h+var_478]
vmovsd xmm0, [rsp+488h+var_470]
loc_42869:
inc r15
add r12, [rsp+488h+var_460]
cmp [rsp+488h+var_468], r15
jnz short loc_42801
jmp short loc_428DF
loc_4287A:
mov edx, r14d
imul edx, edi
cmp eax, 0FFFFFFFCh
ja short loc_428B0
test edx, edx
jle loc_429C6
mov eax, edx
xor ecx, ecx
vxorpd xmm0, xmm0, xmm0
loc_42895:
vmovsd xmm1, qword ptr [r12+rcx*8]
vucomisd xmm1, xmm0
jnz short loc_428B0
jp short loc_428B0
inc rcx
cmp rax, rcx
jnz short loc_42895
jmp loc_429C6
loc_428B0:
mov [rsp+488h+var_458], r13
mov [rsp+488h+var_450], rbx
movsxd rax, edi
imul rax, [rsp+488h+var_480]
mov rcx, [rsp+488h+var_448]
lea rdi, [rcx+rax*8]
mov rsi, r12
call _mju_copy
mov r8, [rsp+488h+var_478]
vmovsd xmm0, [rsp+488h+var_470]
loc_428DF:
mov r14d, [rsp+488h+arg_0]
test r14d, r14d
mov rbx, [rsp+488h+var_450]
mov r15d, [rsp+488h+arg_8]
mov r10, [rsp+488h+var_458]
jle loc_42991
mov eax, [rsp+488h+arg_10]
mov r12, [rsp+488h+var_480]
lea rcx, ds:0[r12*8]
mov rdx, [rbx+27AC0h]
add rdx, rcx
mov rsi, qword ptr ds:stru_27AC8.r_offset[rbx]
add rsi, rcx
add rcx, [rbx+27AD0h]
mov edi, r14d
shl r12, 2
mov r11, [rbx+27A60h]
add r11, r12
add r12, qword ptr ds:stru_27A68.r_offset[rbx]
shl rdi, 2
xor r9d, r9d
loc_42950:
vxorps xmm2, xmm2, xmm2
vxorpd xmm1, xmm1, xmm1
test r8, r8
jz short loc_42963
vmovsd xmm1, qword ptr [r8+r9*2]
loc_42963:
vmovsd qword ptr [rdx+r9*2], xmm1
test r10, r10
jz short loc_42974
vmovsd xmm2, qword ptr [r10+r9*2]
loc_42974:
vmovsd qword ptr [rsi+r9*2], xmm2
vmovsd qword ptr [rcx+r9*2], xmm0
mov [r11+r9], r15d
mov [r12+r9], eax
add r9, 4
cmp rdi, r9
jnz short loc_42950
loc_42991:
add [rbx+2773Ch], r14d
test r15d, r15d
jz short loc_429AC
cmp r15d, 2
ja short loc_429B5
add [rbx+27734h], r14d
jmp short loc_429C6
loc_429AC:
add [rbx+27730h], r14d
jmp short loc_429C6
loc_429B5:
add r15d, 0FFFFFFFDh
cmp r15d, 1
ja short loc_429C6
add dword ptr ds:stru_27738.r_offset[rbx], r14d
loc_429C6:
add rsp, 458h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| void mj_addConstraint(
int a1,
int a2,
long long a3,
long long a4,
long long _R8,
long long a6,
__m128 _XMM0,
__m128 _XMM1,
__m128 _XMM2,
int a10,
unsigned int a11,
int a12,
int a13,
long long a14)
{
_DWORD *v16; // rbx
unsigned int v17; // r15d
int v18; // r14d
long long v19; // r9
long long v20; // r10
unsigned int v21; // eax
int v22; // edx
bool v23; // al
unsigned int v24; // ebp
long long v28; // r13
long long v29; // r14
long long i; // r15
int v31; // eax
long long v32; // rdx
bool v33; // zf
bool v34; // pf
long long v41; // r11
unsigned long long v42; // r12
long long v44; // [rsp+8h] [rbp-480h]
long long v45; // [rsp+10h] [rbp-478h]
long long v47; // [rsp+20h] [rbp-468h]
long long v48; // [rsp+28h] [rbp-460h]
long long v49; // [rsp+30h] [rbp-458h]
_QWORD *v50; // [rsp+38h] [rbp-450h]
long long v51; // [rsp+40h] [rbp-448h]
long long v52; // [rsp+48h] [rbp-440h]
_BYTE v53[1080]; // [rsp+50h] [rbp-438h] BYREF
_R12 = a4;
v16 = (_DWORD *)a3;
v17 = a11;
v18 = a10;
v44 = *(int *)(a3 + 161596);
v19 = *(_QWORD *)(a3 + 162416);
v20 = *(_QWORD *)(a3 + 162424);
v52 = *(_QWORD *)(a3 + 162440);
v51 = *(unsigned long long *)((char *)&stru_27AB0.r_offset + a3);
v21 = a11 - 8;
__asm { vmovsd [rsp+488h+var_470], xmm0 }
v45 = _R8;
if ( a2 != 1 && (a2 != 2 || a1 <= 59) )
{
v32 = (unsigned int)(a1 * a10);
if ( v21 <= 0xFFFFFFFC )
{
if ( (int)v32 <= 0 )
return;
v33 = 1;
v34 = __SETP__(0, 0);
_RCX = 0LL;
__asm { vxorpd xmm0, xmm0, xmm0 }
while ( 1 )
{
__asm
{
vmovsd xmm1, qword ptr [r12+rcx*8]
vucomisd xmm1, xmm0
}
if ( !v33 || v34 )
break;
v33 = (unsigned int)v32 == ++_RCX;
v34 = __SETP__((unsigned int)v32, _RCX);
if ( (unsigned int)v32 == _RCX )
return;
}
}
v49 = a6;
v50 = v16;
mju_copy(v51 + 8 * v44 * a1, _R12, v32);
_R8 = v45;
__asm { vmovsd xmm0, [rsp+488h+var_470] }
goto LABEL_25;
}
v22 = a13;
v23 = v21 < 0xFFFFFFFD;
v24 = 0;
if ( a13 > 0 )
v24 = a13;
if ( a13 > 0 || !v23 )
{
if ( a13 > 0 && a14 == 0 )
{
v48 = v19;
v47 = v20;
strncpy(v53, "mj_addConstraint", 1024LL);
__asm { vmovups xmm0, cs:xmmword_1BE1A8 }
_RDI = v53;
__asm
{
vmovaps xmmword ptr [rdi+10h], xmm0
vmovups xmm0, cs:xmmword_1BE1A8+0Eh
vmovups xmmword ptr [rdi+1Eh], xmm0
}
mju_error_raw(v53);
v20 = v47;
v19 = v48;
v22 = a13;
_R8 = v45;
__asm { vmovsd xmm0, [rsp+488h+var_470] }
}
if ( a10 <= 0 )
goto LABEL_32;
v49 = a6;
v50 = v16;
v28 = v20 + 4 * v44;
v29 = v19 + 4 * v44;
for ( i = 0LL; i != a10; ++i )
{
v31 = 0;
if ( -v44 != i )
v31 = *(_DWORD *)(v28 + 4 * i - 4) + *(_DWORD *)(v29 + 4 * i - 4);
*(_DWORD *)(v28 + 4 * i) = v31;
*(_DWORD *)(v29 + 4 * i) = v24;
if ( v22 > 0 )
{
mju_copyInt(v52 + 4LL * *(int *)(v28 + 4 * i), a14, v24);
mju_copy(v51 + 8LL * *(int *)(v28 + 4 * i), _R12, v24);
v22 = a13;
_R8 = v45;
__asm { vmovsd xmm0, [rsp+488h+var_470] }
}
_R12 += 8LL * v24;
}
LABEL_25:
v18 = a10;
v16 = v50;
v17 = a11;
_R10 = v49;
if ( a10 > 0 )
{
_RDX = 8 * v44 + v50[20312];
_RSI = 8 * v44 + *(unsigned long long *)((char *)&stru_27AC8.r_offset + (_QWORD)v50);
_RCX = v50[20314] + 8 * v44;
v41 = 4 * v44 + v50[20300];
v42 = *(unsigned long long *)((char *)&stru_27A68.r_offset + (_QWORD)v50) + 4 * v44;
_R9 = 0LL;
do
{
__asm
{
vxorps xmm2, xmm2, xmm2
vxorpd xmm1, xmm1, xmm1
}
if ( _R8 )
__asm { vmovsd xmm1, qword ptr [r8+r9*2] }
__asm { vmovsd qword ptr [rdx+r9*2], xmm1 }
if ( v49 )
__asm { vmovsd xmm2, qword ptr [r10+r9*2] }
__asm
{
vmovsd qword ptr [rsi+r9*2], xmm2
vmovsd qword ptr [rcx+r9*2], xmm0
}
*(_DWORD *)(v41 + _R9) = a11;
*(_DWORD *)(v42 + _R9) = a12;
_R9 += 4LL;
}
while ( 4LL * (unsigned int)a10 != _R9 );
}
LABEL_32:
v16[40399] += v18;
if ( v17 )
{
if ( v17 > 2 )
{
if ( v17 - 3 <= 1 )
*(_DWORD *)((char *)&stru_27738.r_offset + (_QWORD)v16) += v18;
}
else
{
v16[40397] += v18;
}
}
else
{
v16[40396] += v18;
}
}
}
| mj_addConstraint:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x458
MOV R13,R9
MOV R12,RCX
MOV RBX,RDX
MOV R15D,dword ptr [RSP + 0x498]
MOV R14D,dword ptr [RSP + 0x490]
MOVSXD RAX,dword ptr [RDX + 0x2773c]
MOV qword ptr [RSP + 0x8],RAX
MOV R9,qword ptr [RDX + 0x27a70]
MOV R10,qword ptr [RDX + 0x27a78]
MOV RAX,qword ptr [RDX + 0x27a88]
MOV qword ptr [RSP + 0x48],RAX
MOV RAX,qword ptr [RDX + 0x27ab0]
MOV qword ptr [RSP + 0x40],RAX
LEA EAX,[R15 + -0x8]
CMP ESI,0x1
VMOVSD qword ptr [RSP + 0x18],XMM0
MOV qword ptr [RSP + 0x10],R8
JZ 0x00142731
CMP ESI,0x2
JNZ 0x0014287a
CMP EDI,0x3b
JLE 0x0014287a
LAB_00142731:
MOV EDX,dword ptr [RSP + 0x4a8]
CMP EAX,-0x3
SETC AL
XOR EBP,EBP
TEST EDX,EDX
CMOVG EBP,EDX
SETLE CL
TEST AL,CL
JNZ 0x001429c6
TEST EDX,EDX
SETLE AL
CMP qword ptr [RSP + 0x4b0],0x0
SETNZ CL
OR CL,AL
JNZ 0x001427c5
LEA RSI,[0x2be197]
LEA RDI,[RSP + 0x50]
MOV EDX,0x400
MOV qword ptr [RSP + 0x28],R9
MOV qword ptr [RSP + 0x20],R10
CALL 0x0012d240
VMOVUPS XMM0,xmmword ptr [0x002be1a8]
LEA RDI,[RSP + 0x50]
VMOVAPS xmmword ptr [RDI + 0x10],XMM0
VMOVUPS XMM0,xmmword ptr [0x002be1b6]
VMOVUPS xmmword ptr [RDI + 0x1e],XMM0
CALL 0x0012d260
MOV R10,qword ptr [RSP + 0x20]
MOV R9,qword ptr [RSP + 0x28]
MOV EDX,dword ptr [RSP + 0x4a8]
MOV R8,qword ptr [RSP + 0x10]
VMOVSD XMM0,qword ptr [RSP + 0x18]
LAB_001427c5:
TEST R14D,R14D
JLE 0x00142991
MOV qword ptr [RSP + 0x30],R13
MOV qword ptr [RSP + 0x38],RBX
MOV EAX,EBP
MOV ECX,R14D
MOV qword ptr [RSP + 0x20],RCX
SHL RAX,0x3
MOV qword ptr [RSP + 0x28],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV RBX,RAX
NEG RBX
LEA R13,[R10 + RAX*0x4]
LEA R14,[R9 + RAX*0x4]
XOR R15D,R15D
LAB_00142801:
MOV EAX,0x0
CMP RBX,R15
JZ 0x00142815
MOV EAX,dword ptr [R14 + R15*0x4 + -0x4]
ADD EAX,dword ptr [R13 + R15*0x4 + -0x4]
LAB_00142815:
MOV dword ptr [R13 + R15*0x4],EAX
MOV dword ptr [R14 + R15*0x4],EBP
TEST EDX,EDX
JLE 0x00142869
MOVSXD RAX,dword ptr [R13 + R15*0x4]
MOV RCX,qword ptr [RSP + 0x48]
LEA RDI,[RCX + RAX*0x4]
MOV RSI,qword ptr [RSP + 0x4b0]
MOV EDX,EBP
CALL 0x0012d600
MOVSXD RAX,dword ptr [R13 + R15*0x4]
MOV RCX,qword ptr [RSP + 0x40]
LEA RDI,[RCX + RAX*0x8]
MOV RSI,R12
MOV EDX,EBP
CALL 0x0012d120
MOV EDX,dword ptr [RSP + 0x4a8]
MOV R8,qword ptr [RSP + 0x10]
VMOVSD XMM0,qword ptr [RSP + 0x18]
LAB_00142869:
INC R15
ADD R12,qword ptr [RSP + 0x28]
CMP qword ptr [RSP + 0x20],R15
JNZ 0x00142801
JMP 0x001428df
LAB_0014287a:
MOV EDX,R14D
IMUL EDX,EDI
CMP EAX,-0x4
JA 0x001428b0
TEST EDX,EDX
JLE 0x001429c6
MOV EAX,EDX
XOR ECX,ECX
VXORPD XMM0,XMM0,XMM0
LAB_00142895:
VMOVSD XMM1,qword ptr [R12 + RCX*0x8]
VUCOMISD XMM1,XMM0
JNZ 0x001428b0
JP 0x001428b0
INC RCX
CMP RAX,RCX
JNZ 0x00142895
JMP 0x001429c6
LAB_001428b0:
MOV qword ptr [RSP + 0x30],R13
MOV qword ptr [RSP + 0x38],RBX
MOVSXD RAX,EDI
IMUL RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP + 0x40]
LEA RDI,[RCX + RAX*0x8]
MOV RSI,R12
CALL 0x0012d120
MOV R8,qword ptr [RSP + 0x10]
VMOVSD XMM0,qword ptr [RSP + 0x18]
LAB_001428df:
MOV R14D,dword ptr [RSP + 0x490]
TEST R14D,R14D
MOV RBX,qword ptr [RSP + 0x38]
MOV R15D,dword ptr [RSP + 0x498]
MOV R10,qword ptr [RSP + 0x30]
JLE 0x00142991
MOV EAX,dword ptr [RSP + 0x4a0]
MOV R12,qword ptr [RSP + 0x8]
LEA RCX,[R12*0x8]
MOV RDX,qword ptr [RBX + 0x27ac0]
ADD RDX,RCX
MOV RSI,qword ptr [RBX + 0x27ac8]
ADD RSI,RCX
ADD RCX,qword ptr [RBX + 0x27ad0]
MOV EDI,R14D
SHL R12,0x2
MOV R11,qword ptr [RBX + 0x27a60]
ADD R11,R12
ADD R12,qword ptr [RBX + 0x27a68]
SHL RDI,0x2
XOR R9D,R9D
LAB_00142950:
VXORPS XMM2,XMM2,XMM2
VXORPD XMM1,XMM1,XMM1
TEST R8,R8
JZ 0x00142963
VMOVSD XMM1,qword ptr [R8 + R9*0x2]
LAB_00142963:
VMOVSD qword ptr [RDX + R9*0x2],XMM1
TEST R10,R10
JZ 0x00142974
VMOVSD XMM2,qword ptr [R10 + R9*0x2]
LAB_00142974:
VMOVSD qword ptr [RSI + R9*0x2],XMM2
VMOVSD qword ptr [RCX + R9*0x2],XMM0
MOV dword ptr [R11 + R9*0x1],R15D
MOV dword ptr [R12 + R9*0x1],EAX
ADD R9,0x4
CMP RDI,R9
JNZ 0x00142950
LAB_00142991:
ADD dword ptr [RBX + 0x2773c],R14D
TEST R15D,R15D
JZ 0x001429ac
CMP R15D,0x2
JA 0x001429b5
ADD dword ptr [RBX + 0x27734],R14D
JMP 0x001429c6
LAB_001429ac:
ADD dword ptr [RBX + 0x27730],R14D
JMP 0x001429c6
LAB_001429b5:
ADD R15D,-0x3
CMP R15D,0x1
JA 0x001429c6
ADD dword ptr [RBX + 0x27738],R14D
LAB_001429c6:
ADD RSP,0x458
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void mj_addConstraint(int8 param_1,int param_2,int param_3,long param_4,long param_5,
long param_6,long param_7,uint param_8,uint param_9,int4 param_10,
uint param_11,long param_12)
{
double dVar1;
long lVar2;
long lVar3;
long lVar4;
long lVar5;
long lVar6;
long lVar7;
int iVar8;
long lVar9;
uint uVar10;
long lVar11;
ulong uVar12;
int8 uVar13;
int8 uVar14;
char local_438 [16];
char local_428 [8];
char acStack_420 [6];
char acStack_41a [2];
char acStack_418 [6];
char acStack_412 [994];
lVar9 = (long)*(int *)(param_4 + 0x2773c);
lVar2 = *(long *)(param_4 + 0x27a70);
lVar3 = *(long *)(param_4 + 0x27a78);
lVar4 = *(long *)(param_4 + 0x27a88);
lVar5 = *(long *)(param_4 + 0x27ab0);
if ((param_3 == 1) || ((param_3 == 2 && (0x3b < param_2)))) {
uVar10 = 0;
if (0 < (int)param_11) {
uVar10 = param_11;
}
if (param_9 - 8 < 0xfffffffd && (int)param_11 < 1) {
return;
}
if (param_12 == 0 && 0 < (int)param_11) {
strncpy(local_438,"mj_addConstraint",0x400);
local_428[0] = s___called_with_dense_arguments_002be1a8[0];
local_428[1] = s___called_with_dense_arguments_002be1a8[1];
local_428[2] = s___called_with_dense_arguments_002be1a8[2];
local_428[3] = s___called_with_dense_arguments_002be1a8[3];
local_428[4] = s___called_with_dense_arguments_002be1a8[4];
local_428[5] = s___called_with_dense_arguments_002be1a8[5];
local_428[6] = s___called_with_dense_arguments_002be1a8[6];
local_428[7] = s___called_with_dense_arguments_002be1a8[7];
acStack_420[0] = s___called_with_dense_arguments_002be1a8[8];
acStack_420[1] = s___called_with_dense_arguments_002be1a8[9];
acStack_420[2] = s___called_with_dense_arguments_002be1a8[10];
acStack_420[3] = s___called_with_dense_arguments_002be1a8[0xb];
acStack_420[4] = s___called_with_dense_arguments_002be1a8[0xc];
acStack_420[5] = s___called_with_dense_arguments_002be1a8[0xd];
acStack_41a[0] = s___called_with_dense_arguments_002be1a8[0xe];
acStack_41a[1] = s___called_with_dense_arguments_002be1a8[0xf];
acStack_418[0] = s___called_with_dense_arguments_002be1a8[0x10];
acStack_418[1] = s___called_with_dense_arguments_002be1a8[0x11];
acStack_418[2] = s___called_with_dense_arguments_002be1a8[0x12];
acStack_418[3] = s___called_with_dense_arguments_002be1a8[0x13];
acStack_418[4] = s___called_with_dense_arguments_002be1a8[0x14];
acStack_418[5] = s___called_with_dense_arguments_002be1a8[0x15];
acStack_412[0] = s___called_with_dense_arguments_002be1a8[0x16];
acStack_412[1] = s___called_with_dense_arguments_002be1a8[0x17];
acStack_412[2] = s___called_with_dense_arguments_002be1a8[0x18];
acStack_412[3] = s___called_with_dense_arguments_002be1a8[0x19];
acStack_412[4] = s___called_with_dense_arguments_002be1a8[0x1a];
acStack_412[5] = s___called_with_dense_arguments_002be1a8[0x1b];
acStack_412[6] = s___called_with_dense_arguments_002be1a8[0x1c];
acStack_412[7] = s___called_with_dense_arguments_002be1a8[0x1d];
mju_error_raw();
}
if ((int)param_8 < 1) goto LAB_00142991;
lVar3 = lVar3 + lVar9 * 4;
lVar2 = lVar2 + lVar9 * 4;
uVar12 = 0;
do {
iVar8 = 0;
if (-uVar12 != lVar9) {
iVar8 = *(int *)(lVar2 + -4 + uVar12 * 4) + *(int *)(lVar3 + -4 + uVar12 * 4);
}
*(int *)(lVar3 + uVar12 * 4) = iVar8;
*(uint *)(lVar2 + uVar12 * 4) = uVar10;
if (0 < (int)param_11) {
mju_copyInt(lVar4 + (long)*(int *)(lVar3 + uVar12 * 4) * 4,param_12,uVar10);
mju_copy(lVar5 + (long)*(int *)(lVar3 + uVar12 * 4) * 8,param_5,uVar10);
}
uVar12 = uVar12 + 1;
param_5 = param_5 + (ulong)uVar10 * 8;
} while (param_8 != uVar12);
}
else {
if (param_9 - 8 < 0xfffffffd) {
if ((int)(param_8 * param_2) < 1) {
return;
}
uVar12 = 0;
while ((dVar1 = *(double *)(param_5 + uVar12 * 8), dVar1 == 0.0 && (!NAN(dVar1)))) {
uVar12 = uVar12 + 1;
if (param_8 * param_2 == uVar12) {
return;
}
}
}
mju_copy(lVar5 + param_2 * lVar9 * 8,param_5);
}
if (0 < (int)param_8) {
lVar3 = lVar9 * 8;
lVar2 = *(long *)(param_4 + 0x27ac0);
lVar4 = *(long *)(param_4 + 0x27ac8);
lVar5 = *(long *)(param_4 + 0x27ad0);
lVar6 = *(long *)(param_4 + 0x27a60);
lVar7 = *(long *)(param_4 + 0x27a68);
lVar11 = 0;
do {
uVar14 = 0;
uVar13 = 0;
if (param_6 != 0) {
uVar13 = *(int8 *)(param_6 + lVar11 * 2);
}
*(int8 *)(lVar2 + lVar3 + lVar11 * 2) = uVar13;
if (param_7 != 0) {
uVar14 = *(int8 *)(param_7 + lVar11 * 2);
}
*(int8 *)(lVar4 + lVar3 + lVar11 * 2) = uVar14;
*(int8 *)(lVar3 + lVar5 + lVar11 * 2) = param_1;
*(uint *)(lVar6 + lVar9 * 4 + lVar11) = param_9;
*(int4 *)(lVar9 * 4 + lVar7 + lVar11) = param_10;
lVar11 = lVar11 + 4;
} while ((ulong)param_8 << 2 != lVar11);
}
LAB_00142991:
*(int *)(param_4 + 0x2773c) = *(int *)(param_4 + 0x2773c) + param_8;
if (param_9 == 0) {
*(int *)(param_4 + 0x27730) = *(int *)(param_4 + 0x27730) + param_8;
}
else if (param_9 < 3) {
*(int *)(param_4 + 0x27734) = *(int *)(param_4 + 0x27734) + param_8;
}
else if (param_9 - 3 < 2) {
*(int *)(param_4 + 0x27738) = *(int *)(param_4 + 0x27738) + param_8;
}
return;
}
| |
44,809 | format[abi:cxx11](char const*, ...) | monkey531[P]llama/examples/llava/clip.cpp | static std::string format(const char * fmt, ...) {
va_list ap;
va_list ap2;
va_start(ap, fmt);
va_copy(ap2, ap);
int size = vsnprintf(NULL, 0, fmt, ap);
GGML_ASSERT(size >= 0 && size < INT_MAX); // NOLINT
std::vector<char> buf(size + 1);
int size2 = vsnprintf(buf.data(), size + 1, fmt, ap2);
GGML_ASSERT(size2 == size);
va_end(ap2);
va_end(ap);
return std::string(buf.data(), buf.size());
} | O0 | cpp | format[abi:cxx11](char const*, ...):
subq $0x178, %rsp # imm = 0x178
movq %rdi, 0x30(%rsp)
movq %rdi, %r10
movq %r10, 0x38(%rsp)
testb %al, %al
je 0x8f425
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %xmm4, 0xb0(%rsp)
movaps %xmm5, 0xc0(%rsp)
movaps %xmm6, 0xd0(%rsp)
movaps %xmm7, 0xe0(%rsp)
movq %r9, 0x68(%rsp)
movq %r8, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rdi, 0x170(%rsp)
movq %rsi, 0x168(%rsp)
leaq 0x150(%rsp), %rax
leaq 0x40(%rsp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x180(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
leaq 0x130(%rsp), %rax
leaq 0x150(%rsp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq 0x168(%rsp), %rdx
leaq 0x150(%rsp), %rcx
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x7e4a8
movl %eax, 0x12c(%rsp)
cmpl $0x0, 0x12c(%rsp)
jl 0x8f4cb
cmpl $0x7fffffff, 0x12c(%rsp) # imm = 0x7FFFFFFF
jl 0x8f4ec
leaq 0x5cbda(%rip), %rdi # 0xec0ac
movl $0x55, %esi
leaq 0x5cc20(%rip), %rdx # 0xec0fe
leaq 0x5dc0c(%rip), %rcx # 0xed0f1
movb $0x0, %al
callq 0x7c570
movl 0x12c(%rsp), %eax
incl %eax
cltq
movq %rax, 0x20(%rsp)
leaq 0x10f(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x7cdd0
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x110(%rsp), %rdi
callq 0x76320
jmp 0x8f527
leaq 0x10f(%rsp), %rdi
callq 0x78810
leaq 0x110(%rsp), %rdi
callq 0x72650
movq %rax, %rdi
movl 0x12c(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rsi
movq 0x168(%rsp), %rdx
leaq 0x130(%rsp), %rcx
callq 0x7e4a8
movl %eax, 0xf8(%rsp)
movl 0xf8(%rsp), %eax
cmpl 0x12c(%rsp), %eax
je 0x8f5df
leaq 0x5cb28(%rip), %rdi # 0xec0ac
leaq 0x5cb73(%rip), %rdx # 0xec0fe
leaq 0x5db7b(%rip), %rcx # 0xed10d
xorl %eax, %eax
movl $0x58, %esi
callq 0x7c570
jmp 0x8f5a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
leaq 0x10f(%rsp), %rdi
callq 0x78810
jmp 0x8f685
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
jmp 0x8f678
leaq 0x110(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x72650
movq (%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0x72d70
movq %rax, 0x10(%rsp)
leaq 0xf7(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x7cdd0
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x78d60
jmp 0x8f630
leaq 0xf7(%rsp), %rdi
callq 0x78810
leaq 0x110(%rsp), %rdi
callq 0x76910
movq 0x38(%rsp), %rax
addq $0x178, %rsp # imm = 0x178
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
leaq 0xf7(%rsp), %rdi
callq 0x78810
leaq 0x110(%rsp), %rdi
callq 0x76910
movq 0x100(%rsp), %rdi
callq 0x7cd60
nopw %cs:(%rax,%rax)
| _ZL6formatB5cxx11PKcz:
sub rsp, 178h
mov [rsp+178h+var_148], rdi
mov r10, rdi
mov [rsp+178h+var_140], r10
test al, al
jz short loc_8F425
movaps [rsp+178h+var_108], xmm0
movaps [rsp+178h+var_F8], xmm1
movaps [rsp+178h+var_E8], xmm2
movaps [rsp+178h+var_D8], xmm3
movaps [rsp+178h+var_C8], xmm4
movaps [rsp+178h+var_B8], xmm5
movaps [rsp+178h+var_A8], xmm6
movaps [rsp+178h+var_98], xmm7
loc_8F425:
mov [rsp+178h+var_110], r9
mov [rsp+178h+var_118], r8
mov [rsp+178h+var_120], rcx
mov [rsp+178h+var_128], rdx
mov [rsp+178h+var_8], rdi
mov [rsp+178h+var_10], rsi
lea rax, [rsp+178h+var_28]
lea rcx, [rsp+178h+var_138]
mov [rax+10h], rcx
lea rcx, [rsp+178h+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 10h
lea rax, [rsp+178h+var_48]
lea rcx, [rsp+178h+var_28]
mov rdx, [rcx+10h]
mov [rax+10h], rdx
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rax], xmm0
mov rdx, [rsp+178h+var_10]
lea rcx, [rsp+178h+var_28]
xor eax, eax
mov esi, eax
mov rdi, rsi
call vsnprintf
mov [rsp+178h+var_4C], eax
cmp [rsp+178h+var_4C], 0
jl short loc_8F4CB
cmp [rsp+178h+var_4C], 7FFFFFFFh
jl short loc_8F4EC
loc_8F4CB:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov esi, 55h ; 'U'
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aSize0SizeIntMa; "size >= 0 && size < INT_MAX"
mov al, 0
call _ggml_abort
loc_8F4EC:
mov eax, [rsp+178h+var_4C]
inc eax
cdqe
mov [rsp+178h+var_158], rax
lea rdi, [rsp+178h+var_69]
mov [rsp+178h+var_150], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rsi, [rsp+178h+var_158]
mov rdx, [rsp+178h+var_150]
lea rdi, [rsp+178h+var_68]
call __ZNSt6vectorIcSaIcEEC2EmRKS0_; std::vector<char>::vector(ulong,std::allocator<char> const&)
jmp short $+2
loc_8F527:
lea rdi, [rsp+178h+var_69]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
lea rdi, [rsp+178h+var_68]
call __ZNSt6vectorIcSaIcEE4dataEv; std::vector<char>::data(void)
mov rdi, rax
mov eax, [rsp+178h+var_4C]
add eax, 1
movsxd rsi, eax
mov rdx, [rsp+178h+var_10]
lea rcx, [rsp+178h+var_48]
call vsnprintf
mov [rsp+178h+var_80], eax
mov eax, [rsp+178h+var_80]
cmp eax, [rsp+178h+var_4C]
jz short loc_8F5DF
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aSize2Size; "size2 == size"
xor eax, eax
mov esi, 58h ; 'X'
call _ggml_abort
jmp short $+2
loc_8F5A0:
mov rcx, rax
mov eax, edx
mov [rsp+178h+var_78], rcx
mov [rsp+178h+var_7C], eax
lea rdi, [rsp+178h+var_69]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_8F685
mov rcx, rax
mov eax, edx
mov [rsp+178h+var_78], rcx
mov [rsp+178h+var_7C], eax
jmp loc_8F678
loc_8F5DF:
lea rdi, [rsp+178h+var_68]
mov [rsp+178h+var_178], rdi
call __ZNSt6vectorIcSaIcEE4dataEv; std::vector<char>::data(void)
mov rdi, [rsp+178h+var_178]
mov [rsp+178h+var_170], rax
call __ZNKSt6vectorIcSaIcEE4sizeEv; std::vector<char>::size(void)
mov [rsp+178h+var_168], rax
lea rdi, [rsp+178h+var_81]
mov [rsp+178h+var_160], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdi, [rsp+178h+var_148]
mov rsi, [rsp+178h+var_170]
mov rdx, [rsp+178h+var_168]
mov rcx, [rsp+178h+var_160]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1EPKcmRKS3_; std::string::basic_string(char const*,ulong,std::allocator<char> const&)
jmp short $+2
loc_8F630:
lea rdi, [rsp+178h+var_81]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
lea rdi, [rsp+178h+var_68]
call __ZNSt6vectorIcSaIcEED2Ev; std::vector<char>::~vector()
mov rax, [rsp+178h+var_140]
add rsp, 178h
retn
mov rcx, rax
mov eax, edx
mov [rsp+178h+var_78], rcx
mov [rsp+178h+var_7C], eax
lea rdi, [rsp+178h+var_81]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
loc_8F678:
lea rdi, [rsp+178h+var_68]
call __ZNSt6vectorIcSaIcEED2Ev; std::vector<char>::~vector()
loc_8F685:
mov rdi, [rsp+178h+var_78]
call __Unwind_Resume
| long long format[abi:cxx11](
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
int v15; // ecx
int v16; // r8d
int v17; // r9d
long long v18; // rax
int v19; // edx
long long v21; // [rsp+8h] [rbp-170h]
long long v22; // [rsp+10h] [rbp-168h]
unsigned int v23; // [rsp+20h] [rbp-158h]
_BYTE v24[16]; // [rsp+40h] [rbp-138h] BYREF
long long v25; // [rsp+50h] [rbp-128h]
long long v26; // [rsp+58h] [rbp-120h]
long long v27; // [rsp+60h] [rbp-118h]
long long v28; // [rsp+68h] [rbp-110h]
__m128 v29; // [rsp+70h] [rbp-108h]
__m128 v30; // [rsp+80h] [rbp-F8h]
__m128 v31; // [rsp+90h] [rbp-E8h]
__m128 v32; // [rsp+A0h] [rbp-D8h]
__m128 v33; // [rsp+B0h] [rbp-C8h]
__m128 v34; // [rsp+C0h] [rbp-B8h]
__m128 v35; // [rsp+D0h] [rbp-A8h]
__m128 v36; // [rsp+E0h] [rbp-98h]
char v37; // [rsp+F7h] [rbp-81h] BYREF
int v38; // [rsp+F8h] [rbp-80h]
int v39; // [rsp+FCh] [rbp-7Ch]
long long v40; // [rsp+100h] [rbp-78h]
char v41; // [rsp+10Fh] [rbp-69h] BYREF
_BYTE v42[28]; // [rsp+110h] [rbp-68h] BYREF
unsigned int v43; // [rsp+12Ch] [rbp-4Ch]
__int128 v44; // [rsp+130h] [rbp-48h] BYREF
_BYTE *v45; // [rsp+140h] [rbp-38h]
__int128 v46; // [rsp+150h] [rbp-28h] BYREF
_BYTE *v47; // [rsp+160h] [rbp-18h]
long long v48; // [rsp+168h] [rbp-10h]
long long v49; // [rsp+170h] [rbp-8h]
v29 = a7;
v30 = a8;
v31 = a9;
v32 = a10;
v33 = a11;
v34 = a12;
v35 = a13;
v36 = a14;
v28 = a6;
v27 = a5;
v26 = a4;
v25 = a3;
v49 = a1;
v48 = a2;
v47 = v24;
*((_QWORD *)&v46 + 1) = &a15;
*(_QWORD *)&v46 = 0x3000000010LL;
v45 = v24;
v44 = v46;
v43 = vsnprintf(0LL, 0LL, a2, &v46);
if ( v43 > 0x7FFFFFFE )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/examples/llava/clip.cpp",
85LL,
"GGML_ASSERT(%s) failed",
"size >= 0 && size < INT_MAX");
v23 = v43 + 1;
std::allocator<char>::allocator();
std::vector<char>::vector((unsigned int)v42, v23, (unsigned int)&v41, v15, v16, v17);
std::allocator<char>::~allocator(&v41);
v18 = std::vector<char>::data(v42);
v38 = vsnprintf(v18, (int)(v43 + 1), v48, &v44);
if ( v38 != v43 )
{
v40 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/examples/llava/clip.cpp",
88LL,
"GGML_ASSERT(%s) failed",
"size2 == size");
v39 = v19;
std::allocator<char>::~allocator(&v41);
_Unwind_Resume(v40);
}
v21 = std::vector<char>::data(v42);
v22 = std::vector<char>::size(v42);
std::allocator<char>::allocator();
std::string::basic_string(a1, v21, v22, &v37);
std::allocator<char>::~allocator(&v37);
std::vector<char>::~vector(v42);
return a1;
}
| format[abi:cxx11]:
SUB RSP,0x178
MOV qword ptr [RSP + 0x30],RDI
MOV R10,RDI
MOV qword ptr [RSP + 0x38],R10
TEST AL,AL
JZ 0x0018f425
MOVAPS xmmword ptr [RSP + 0x70],XMM0
MOVAPS xmmword ptr [RSP + 0x80],XMM1
MOVAPS xmmword ptr [RSP + 0x90],XMM2
MOVAPS xmmword ptr [RSP + 0xa0],XMM3
MOVAPS xmmword ptr [RSP + 0xb0],XMM4
MOVAPS xmmword ptr [RSP + 0xc0],XMM5
MOVAPS xmmword ptr [RSP + 0xd0],XMM6
MOVAPS xmmword ptr [RSP + 0xe0],XMM7
LAB_0018f425:
MOV qword ptr [RSP + 0x68],R9
MOV qword ptr [RSP + 0x60],R8
MOV qword ptr [RSP + 0x58],RCX
MOV qword ptr [RSP + 0x50],RDX
MOV qword ptr [RSP + 0x170],RDI
MOV qword ptr [RSP + 0x168],RSI
LEA RAX,[RSP + 0x150]
LEA RCX,[RSP + 0x40]
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RSP + 0x180]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x10
LEA RAX,[RSP + 0x130]
LEA RCX,[RSP + 0x150]
MOV RDX,qword ptr [RCX + 0x10]
MOV qword ptr [RAX + 0x10],RDX
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RAX],XMM0
MOV RDX,qword ptr [RSP + 0x168]
LEA RCX,[RSP + 0x150]
XOR EAX,EAX
MOV ESI,EAX
MOV RDI,RSI
CALL 0x0017e4a8
MOV dword ptr [RSP + 0x12c],EAX
CMP dword ptr [RSP + 0x12c],0x0
JL 0x0018f4cb
CMP dword ptr [RSP + 0x12c],0x7fffffff
JL 0x0018f4ec
LAB_0018f4cb:
LEA RDI,[0x1ec0ac]
MOV ESI,0x55
LEA RDX,[0x1ec0fe]
LEA RCX,[0x1ed0f1]
MOV AL,0x0
CALL 0x0017c570
LAB_0018f4ec:
MOV EAX,dword ptr [RSP + 0x12c]
INC EAX
CDQE
MOV qword ptr [RSP + 0x20],RAX
LEA RDI,[RSP + 0x10f]
MOV qword ptr [RSP + 0x28],RDI
CALL 0x0017cdd0
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
LAB_0018f518:
LEA RDI,[RSP + 0x110]
CALL 0x00176320
JMP 0x0018f527
LAB_0018f527:
LEA RDI,[RSP + 0x10f]
CALL 0x00178810
LEA RDI,[RSP + 0x110]
CALL 0x00172650
MOV RDI,RAX
MOV EAX,dword ptr [RSP + 0x12c]
ADD EAX,0x1
MOVSXD RSI,EAX
MOV RDX,qword ptr [RSP + 0x168]
LEA RCX,[RSP + 0x130]
CALL 0x0017e4a8
MOV dword ptr [RSP + 0xf8],EAX
MOV EAX,dword ptr [RSP + 0xf8]
CMP EAX,dword ptr [RSP + 0x12c]
JZ 0x0018f5df
LAB_0018f57d:
LEA RDI,[0x1ec0ac]
LEA RDX,[0x1ec0fe]
LEA RCX,[0x1ed10d]
XOR EAX,EAX
MOV ESI,0x58
CALL 0x0017c570
JMP 0x0018f5a0
LAB_0018f5a0:
MOV RCX,RAX
MOV EAX,EDX
MOV qword ptr [RSP + 0x100],RCX
MOV dword ptr [RSP + 0xfc],EAX
LEA RDI,[RSP + 0x10f]
CALL 0x00178810
JMP 0x0018f685
LAB_0018f5df:
LEA RDI,[RSP + 0x110]
MOV qword ptr [RSP],RDI
CALL 0x00172650
MOV RDI,qword ptr [RSP]
MOV qword ptr [RSP + 0x8],RAX
CALL 0x00172d70
MOV qword ptr [RSP + 0x10],RAX
LEA RDI,[RSP + 0xf7]
MOV qword ptr [RSP + 0x18],RDI
CALL 0x0017cdd0
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x18]
LAB_0018f629:
CALL 0x00178d60
LAB_0018f62e:
JMP 0x0018f630
LAB_0018f630:
LEA RDI,[RSP + 0xf7]
CALL 0x00178810
LEA RDI,[RSP + 0x110]
CALL 0x00176910
MOV RAX,qword ptr [RSP + 0x38]
ADD RSP,0x178
RET
LAB_0018f685:
MOV RDI,qword ptr [RSP + 0x100]
CALL 0x0017cd60
|
/* format[abi:cxx11](char const*, ...) */
char * format_abi_cxx11_(char *param_1,...)
{
char in_AL;
int iVar1;
char *pcVar2;
ulong uVar3;
int8 in_RCX;
int8 in_RDX;
char *in_RSI;
int8 in_R8;
int8 in_R9;
int4 in_XMM0_Da;
int8 in_XMM1_Qa;
int8 in_XMM2_Qa;
int8 in_XMM3_Qa;
int8 in_XMM4_Qa;
int8 in_XMM5_Qa;
int8 in_XMM6_Qa;
int8 in_XMM7_Qa;
int1 auVar4 [12];
int1 local_138 [16];
int8 local_128;
int8 local_120;
int8 local_118;
int8 local_110;
int4 local_108;
int8 local_f8;
int8 local_e8;
int8 local_d8;
int8 local_c8;
int8 local_b8;
int8 local_a8;
int8 local_98;
allocator local_81;
int local_80;
int4 local_7c;
int8 local_78;
allocator local_69;
vector<char,std::allocator<char>> local_68 [28];
int local_4c;
int8 local_48;
int1 *puStack_40;
int1 *local_38;
int4 local_28;
int4 uStack_24;
int1 *puStack_20;
int1 *local_18;
char *local_10;
char *local_8;
if (in_AL != '\0') {
local_108 = in_XMM0_Da;
local_f8 = in_XMM1_Qa;
local_e8 = in_XMM2_Qa;
local_d8 = in_XMM3_Qa;
local_c8 = in_XMM4_Qa;
local_b8 = in_XMM5_Qa;
local_a8 = in_XMM6_Qa;
local_98 = in_XMM7_Qa;
}
local_38 = local_138;
puStack_40 = &stack0x00000008;
uStack_24 = 0x30;
local_28 = 0x10;
local_48 = 0x3000000010;
local_128 = in_RDX;
local_120 = in_RCX;
local_118 = in_R8;
local_110 = in_R9;
puStack_20 = puStack_40;
local_18 = local_38;
local_10 = in_RSI;
local_8 = param_1;
local_4c = vsnprintf((char *)0x0,0,in_RSI,&local_28);
if ((local_4c < 0) || (0x7ffffffe < local_4c)) {
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/examples/llava/clip.cpp",
0x55,"GGML_ASSERT(%s) failed","size >= 0 && size < INT_MAX");
}
iVar1 = local_4c + 1;
std::allocator<char>::allocator();
/* try { // try from 0018f518 to 0018f524 has its CatchHandler @ 0018f5a0 */
std::vector<char,std::allocator<char>>::vector(local_68,(long)iVar1,&local_69);
std::allocator<char>::~allocator((allocator<char> *)&local_69);
pcVar2 = (char *)std::vector<char,std::allocator<char>>::data(local_68);
local_80 = vsnprintf(pcVar2,(long)(local_4c + 1),local_10,&local_48);
if (local_80 != local_4c) {
/* try { // try from 0018f57d to 0018f59d has its CatchHandler @ 0018f5c6 */
auVar4 = ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/examples/llava/clip.cpp"
,0x58,"GGML_ASSERT(%s) failed","size2 == size");
local_7c = auVar4._8_4_;
local_78 = auVar4._0_8_;
/* catch() { ... } // from try @ 0018f518 with catch @ 0018f5a0 */
std::allocator<char>::~allocator((allocator<char> *)&local_69);
/* WARNING: Subroutine does not return */
_Unwind_Resume(local_78);
}
pcVar2 = (char *)std::vector<char,std::allocator<char>>::data(local_68);
uVar3 = std::vector<char,std::allocator<char>>::size(local_68);
std::allocator<char>::allocator();
/* try { // try from 0018f629 to 0018f62d has its CatchHandler @ 0018f657 */
std::__cxx11::string::string((string *)param_1,pcVar2,uVar3,&local_81);
std::allocator<char>::~allocator((allocator<char> *)&local_81);
std::vector<char,std::allocator<char>>::~vector(local_68);
return param_1;
}
| |
44,810 | format[abi:cxx11](char const*, ...) | monkey531[P]llama/examples/llava/clip.cpp | static std::string format(const char * fmt, ...) {
va_list ap;
va_list ap2;
va_start(ap, fmt);
va_copy(ap2, ap);
int size = vsnprintf(NULL, 0, fmt, ap);
GGML_ASSERT(size >= 0 && size < INT_MAX); // NOLINT
std::vector<char> buf(size + 1);
int size2 = vsnprintf(buf.data(), size + 1, fmt, ap2);
GGML_ASSERT(size2 == size);
va_end(ap2);
va_end(ap);
return std::string(buf.data(), buf.size());
} | O1 | cpp | format[abi:cxx11](char const*, ...):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x60(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x25c73
movaps %xmm0, 0x90(%rsp)
movaps %xmm1, 0xa0(%rsp)
movaps %xmm2, 0xb0(%rsp)
movaps %xmm3, 0xc0(%rsp)
movaps %xmm4, 0xd0(%rsp)
movaps %xmm5, 0xe0(%rsp)
movaps %xmm6, 0xf0(%rsp)
movaps %xmm7, 0x100(%rsp)
movabsq $0x3000000010, %rax # imm = 0x3000000010
leaq 0x40(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x140(%rsp), %rax
movq %rax, 0x8(%rcx)
movq %rsi, 0x10(%rcx)
movq %rsi, 0x30(%rsp)
movq (%rcx), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rcx), %rax
movq %rax, 0x28(%rsp)
xorl %edi, %edi
xorl %esi, %esi
movq %r14, %rdx
callq 0x1c748
cmpl $0x7fffffff, %eax # imm = 0x7FFFFFFF
jae 0x25d37
movl %eax, %r15d
leal 0x1(%r15), %r12d
leaq 0x8(%rsp), %r13
leaq 0x7(%rsp), %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0x1aca0
movq (%r13), %rdi
leaq 0x20(%rsp), %rcx
movq %r12, %rsi
movq %r14, %rdx
callq 0x1c748
cmpl %r15d, %eax
jne 0x25d58
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x1a5f0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x25d23
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x1b330
movq %rbx, %rax
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x265e6(%rip), %rdi # 0x4c324
leaq 0x26631(%rip), %rdx # 0x4c376
leaq 0x27628(%rip), %rcx # 0x4d374
movl $0x55, %esi
xorl %eax, %eax
callq 0x1c120
leaq 0x265c5(%rip), %rdi # 0x4c324
leaq 0x26610(%rip), %rdx # 0x4c376
leaq 0x27623(%rip), %rcx # 0x4d390
movl $0x58, %esi
xorl %eax, %eax
callq 0x1c120
jmp 0x25d7b
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x25d95
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x1b330
movq %rbx, %rdi
callq 0x1c330
| _ZL6formatB5cxx11PKcz:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 110h
mov r14, rsi
mov rbx, rdi
lea rsi, [rsp+138h+var_D8]
mov [rsi+10h], rdx
mov [rsi+18h], rcx
mov [rsi+20h], r8
mov [rsi+28h], r9
test al, al
jz short loc_25C73
movaps [rsp+138h+var_A8], xmm0
movaps [rsp+138h+var_98], xmm1
movaps [rsp+138h+var_88], xmm2
movaps [rsp+138h+var_78], xmm3
movaps [rsp+138h+var_68], xmm4
movaps [rsp+138h+var_58], xmm5
movaps [rsp+138h+var_48], xmm6
movaps [rsp+138h+var_38], xmm7
loc_25C73:
mov rax, 3000000010h
lea rcx, [rsp+138h+var_F8]
mov [rcx], rax
lea rax, [rsp+138h+arg_0]
mov [rcx+8], rax
mov [rcx+10h], rsi
mov [rsp+138h+var_108], rsi
mov rax, [rcx]
mov [rsp+138h+var_118], rax
mov rax, [rcx+8]
mov [rsp+138h+var_110], rax
xor edi, edi
xor esi, esi
mov rdx, r14
call vsnprintf
cmp eax, 7FFFFFFFh
jnb short loc_25D37
mov r15d, eax
lea r12d, [r15+1]
lea r13, [rsp+138h+var_130]
lea rdx, [rsp+138h+var_131]
mov rdi, r13
mov rsi, r12
call __ZNSt6vectorIcSaIcEEC2EmRKS0_; std::vector<char>::vector(ulong,std::allocator<char> const&)
mov rdi, [r13+0]
lea rcx, [rsp+138h+var_118]
mov rsi, r12
mov rdx, r14
call vsnprintf
cmp eax, r15d
jnz short loc_25D58
mov rsi, [rsp+138h+var_130]
mov rdx, [rsp+138h+var_128]
lea rax, [rbx+10h]
mov [rbx], rax
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rdi, [rsp+138h+var_130]; void *
test rdi, rdi
jz short loc_25D23
mov rsi, [rsp+138h+var_120]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_25D23:
mov rax, rbx
add rsp, 110h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_25D37:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aSize0SizeIntMa; "size >= 0 && size < INT_MAX"
mov esi, 55h ; 'U'
xor eax, eax
call _ggml_abort
loc_25D58:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aSize2Size; "size2 == size"
mov esi, 58h ; 'X'
xor eax, eax
call _ggml_abort
jmp short $+2
loc_25D7B:
mov rbx, rax
mov rdi, [rsp+138h+var_130]; void *
test rdi, rdi
jz short loc_25D95
mov rsi, [rsp+138h+var_120]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_25D95:
mov rdi, rbx
call __Unwind_Resume
| _QWORD * format[abi:cxx11](
_QWORD *a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
unsigned int v15; // eax
unsigned int v16; // r15d
long long v17; // r12
void *v18; // rsi
void *v19; // rdx
long long v21; // rbx
char v22; // [rsp+7h] [rbp-131h] BYREF
void *v23[2]; // [rsp+8h] [rbp-130h] BYREF
long long v24; // [rsp+18h] [rbp-120h]
_QWORD v25[4]; // [rsp+20h] [rbp-118h] BYREF
_QWORD v26[4]; // [rsp+40h] [rbp-F8h] BYREF
_BYTE v27[16]; // [rsp+60h] [rbp-D8h] BYREF
long long v28; // [rsp+70h] [rbp-C8h]
long long v29; // [rsp+78h] [rbp-C0h]
long long v30; // [rsp+80h] [rbp-B8h]
long long v31; // [rsp+88h] [rbp-B0h]
__m128 v32; // [rsp+90h] [rbp-A8h]
__m128 v33; // [rsp+A0h] [rbp-98h]
__m128 v34; // [rsp+B0h] [rbp-88h]
__m128 v35; // [rsp+C0h] [rbp-78h]
__m128 v36; // [rsp+D0h] [rbp-68h]
__m128 v37; // [rsp+E0h] [rbp-58h]
__m128 v38; // [rsp+F0h] [rbp-48h]
__m128 v39; // [rsp+100h] [rbp-38h]
v32 = a7;
v33 = a8;
v34 = a9;
v35 = a10;
v36 = a11;
v37 = a12;
v38 = a13;
v39 = a14;
v28 = a3;
v29 = a4;
v30 = a5;
v31 = a6;
v26[0] = 0x3000000010LL;
v26[1] = &a15;
v26[2] = v27;
v25[2] = v27;
v25[0] = 0x3000000010LL;
v25[1] = &a15;
v15 = vsnprintf(0LL, 0LL, a2, v26);
if ( v15 >= 0x7FFFFFFF )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/examples/llava/clip.cpp",
85LL,
"GGML_ASSERT(%s) failed",
"size >= 0 && size < INT_MAX");
LABEL_7:
v21 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/examples/llava/clip.cpp",
88LL,
"GGML_ASSERT(%s) failed",
"size2 == size");
if ( v23[0] )
operator delete(v23[0], v24 - (unsigned long long)v23[0]);
_Unwind_Resume(v21);
}
v16 = v15;
v17 = v15 + 1;
std::vector<char>::vector(v23, v17, &v22);
if ( (unsigned int)vsnprintf(v23[0], v17, a2, v25) != v16 )
goto LABEL_7;
v18 = v23[0];
v19 = v23[1];
*a1 = a1 + 2;
std::string::_M_construct<char const*>(a1, v18, v19);
if ( v23[0] )
operator delete(v23[0], v24 - (unsigned long long)v23[0]);
return a1;
}
| format[abi:cxx11]:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x110
MOV R14,RSI
MOV RBX,RDI
LEA RSI,[RSP + 0x60]
MOV qword ptr [RSI + 0x10],RDX
MOV qword ptr [RSI + 0x18],RCX
MOV qword ptr [RSI + 0x20],R8
MOV qword ptr [RSI + 0x28],R9
TEST AL,AL
JZ 0x00125c73
MOVAPS xmmword ptr [RSP + 0x90],XMM0
MOVAPS xmmword ptr [RSP + 0xa0],XMM1
MOVAPS xmmword ptr [RSP + 0xb0],XMM2
MOVAPS xmmword ptr [RSP + 0xc0],XMM3
MOVAPS xmmword ptr [RSP + 0xd0],XMM4
MOVAPS xmmword ptr [RSP + 0xe0],XMM5
MOVAPS xmmword ptr [RSP + 0xf0],XMM6
MOVAPS xmmword ptr [RSP + 0x100],XMM7
LAB_00125c73:
MOV RAX,0x3000000010
LEA RCX,[RSP + 0x40]
MOV qword ptr [RCX],RAX
LEA RAX,[RSP + 0x140]
MOV qword ptr [RCX + 0x8],RAX
MOV qword ptr [RCX + 0x10],RSI
MOV qword ptr [RSP + 0x30],RSI
MOV RAX,qword ptr [RCX]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RCX + 0x8]
MOV qword ptr [RSP + 0x28],RAX
XOR EDI,EDI
XOR ESI,ESI
MOV RDX,R14
CALL 0x0011c748
CMP EAX,0x7fffffff
JNC 0x00125d37
MOV R15D,EAX
LEA R12D,[R15 + 0x1]
LEA R13,[RSP + 0x8]
LEA RDX,[RSP + 0x7]
MOV RDI,R13
MOV RSI,R12
CALL 0x0011aca0
MOV RDI,qword ptr [R13]
LEA RCX,[RSP + 0x20]
MOV RSI,R12
MOV RDX,R14
CALL 0x0011c748
CMP EAX,R15D
JNZ 0x00125d58
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LAB_00125d04:
MOV RDI,RBX
CALL 0x0011a5f0
LAB_00125d0c:
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x00125d23
MOV RSI,qword ptr [RSP + 0x18]
SUB RSI,RDI
CALL 0x0011b330
LAB_00125d23:
MOV RAX,RBX
ADD RSP,0x110
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_00125d37:
LEA RDI,[0x14c324]
LEA RDX,[0x14c376]
LEA RCX,[0x14d374]
MOV ESI,0x55
XOR EAX,EAX
CALL 0x0011c120
LAB_00125d58:
LEA RDI,[0x14c324]
LEA RDX,[0x14c376]
LEA RCX,[0x14d390]
MOV ESI,0x58
XOR EAX,EAX
CALL 0x0011c120
LAB_00125d79:
JMP 0x00125d7b
LAB_00125d7b:
MOV RBX,RAX
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x00125d95
MOV RSI,qword ptr [RSP + 0x18]
SUB RSI,RDI
CALL 0x0011b330
LAB_00125d95:
MOV RDI,RBX
CALL 0x0011c330
|
/* format[abi:cxx11](char const*, ...) */
char * format_abi_cxx11_(char *param_1,...)
{
char in_AL;
uint uVar1;
uint uVar2;
int8 uVar3;
int8 in_RCX;
int8 in_RDX;
char *in_RSI;
int8 in_R8;
int8 in_R9;
int8 in_XMM0_Qa;
int8 in_XMM1_Qa;
int8 in_XMM2_Qa;
int8 in_XMM3_Qa;
int8 in_XMM4_Qa;
int8 in_XMM5_Qa;
int8 in_XMM6_Qa;
int8 in_XMM7_Qa;
char *local_130;
int8 local_128;
long local_120;
int8 local_118;
int1 *local_110;
int1 *local_108;
int8 local_f8;
int1 *local_f0;
int1 *local_e8;
int1 local_d8 [16];
int8 local_c8;
int8 local_c0;
int8 local_b8;
int8 local_b0;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int8 local_48;
int8 local_38;
local_108 = local_d8;
if (in_AL != '\0') {
local_a8 = in_XMM0_Qa;
local_98 = in_XMM1_Qa;
local_88 = in_XMM2_Qa;
local_78 = in_XMM3_Qa;
local_68 = in_XMM4_Qa;
local_58 = in_XMM5_Qa;
local_48 = in_XMM6_Qa;
local_38 = in_XMM7_Qa;
}
local_f8 = 0x3000000010;
local_110 = &stack0x00000008;
local_118 = 0x3000000010;
local_f0 = local_110;
local_e8 = local_108;
local_c8 = in_RDX;
local_c0 = in_RCX;
local_b8 = in_R8;
local_b0 = in_R9;
uVar1 = vsnprintf((char *)0x0,0,in_RSI,&local_f8);
if (uVar1 < 0x7fffffff) {
std::vector<char,std::allocator<char>>::vector
((ulong)&local_130,(allocator *)(ulong)(uVar1 + 1));
uVar2 = vsnprintf(local_130,(size_t)(ulong)(uVar1 + 1),in_RSI,&local_118);
if (uVar2 == uVar1) {
*(char **)param_1 = param_1 + 0x10;
/* try { // try from 00125d04 to 00125d0b has its CatchHandler @ 00125d79 */
std::__cxx11::string::_M_construct<char_const*>(param_1,local_130,local_128);
if (local_130 != (char *)0x0) {
operator_delete(local_130,local_120 - (long)local_130);
}
return param_1;
}
}
else {
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/examples/llava/clip.cpp",
0x55,"GGML_ASSERT(%s) failed","size >= 0 && size < INT_MAX");
}
/* try { // try from 00125d58 to 00125d78 has its CatchHandler @ 00125d7b */
uVar3 = ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/examples/llava/clip.cpp"
,0x58,"GGML_ASSERT(%s) failed","size2 == size");
/* catch() { ... } // from try @ 00125d04 with catch @ 00125d79 */
/* catch() { ... } // from try @ 00125d58 with catch @ 00125d7b */
if (local_130 != (char *)0x0) {
operator_delete(local_130,local_120 - (long)local_130);
}
/* WARNING: Subroutine does not return */
_Unwind_Resume(uVar3);
}
| |
44,811 | my_charset_file_tailoring_realloc | eloqsql/strings/ctype.c | static int
my_charset_file_tailoring_realloc(MY_CHARSET_FILE *i, size_t newlen)
{
if (i->tailoring_alloced_length > newlen ||
(i->tailoring= i->loader->realloc(i->tailoring,
(i->tailoring_alloced_length=
(newlen + 32*1024)))))
{
return MY_XML_OK;
}
return MY_XML_ERROR;
} | O0 | c | my_charset_file_tailoring_realloc:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x698(%rax), %rax
cmpq -0x18(%rbp), %rax
ja 0xcc2d7
movq -0x10(%rbp), %rax
movq 0x7a8(%rax), %rax
movq 0x90(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x688(%rcx), %rdi
movq -0x18(%rbp), %rsi
addq $0x8000, %rsi # imm = 0x8000
movq -0x10(%rbp), %rcx
movq %rsi, 0x698(%rcx)
callq *%rax
movq -0x10(%rbp), %rcx
movq %rax, 0x688(%rcx)
cmpq $0x0, %rax
je 0xcc2e0
movl $0x0, -0x4(%rbp)
jmp 0xcc2e7
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
| my_charset_file_tailoring_realloc:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov rax, [rax+698h]
cmp rax, [rbp+var_18]
ja short loc_CC2D7
mov rax, [rbp+var_10]
mov rax, [rax+7A8h]
mov rax, [rax+90h]
mov rcx, [rbp+var_10]
mov rdi, [rcx+688h]
mov rsi, [rbp+var_18]
add rsi, 8000h
mov rcx, [rbp+var_10]
mov [rcx+698h], rsi
call rax
mov rcx, [rbp+var_10]
mov [rcx+688h], rax
cmp rax, 0
jz short loc_CC2E0
loc_CC2D7:
mov [rbp+var_4], 0
jmp short loc_CC2E7
loc_CC2E0:
mov [rbp+var_4], 1
loc_CC2E7:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
| long long my_charset_file_tailoring_realloc(_QWORD *a1, unsigned long long a2)
{
long long ( *v2)(long long); // rax
long long v3; // rdi
long long v4; // rax
unsigned int v7; // [rsp+1Ch] [rbp-4h]
v7 = 0;
if ( a1[211] <= a2 )
{
v2 = *(long long ( **)(long long))(a1[245] + 144LL);
v3 = a1[209];
a1[211] = a2 + 0x8000;
v4 = v2(v3);
a1[209] = v4;
if ( !v4 )
return 1;
}
return v7;
}
| my_charset_file_tailoring_realloc:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x698]
CMP RAX,qword ptr [RBP + -0x18]
JA 0x001cc2d7
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x7a8]
MOV RAX,qword ptr [RAX + 0x90]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RCX + 0x688]
MOV RSI,qword ptr [RBP + -0x18]
ADD RSI,0x8000
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x698],RSI
CALL RAX
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x688],RAX
CMP RAX,0x0
JZ 0x001cc2e0
LAB_001cc2d7:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001cc2e7
LAB_001cc2e0:
MOV dword ptr [RBP + -0x4],0x1
LAB_001cc2e7:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int4 my_charset_file_tailoring_realloc(long param_1,ulong param_2)
{
code *pcVar1;
long lVar2;
if (*(ulong *)(param_1 + 0x698) <= param_2) {
pcVar1 = *(code **)(*(long *)(param_1 + 0x7a8) + 0x90);
*(ulong *)(param_1 + 0x698) = param_2 + 0x8000;
lVar2 = (*pcVar1)(*(int8 *)(param_1 + 0x688));
*(long *)(param_1 + 0x688) = lVar2;
if (lVar2 == 0) {
return 1;
}
}
return 0;
}
| |
44,812 | ma_bitmap_free_full_pages | eloqsql/storage/maria/ma_bitmap.c | my_bool _ma_bitmap_free_full_pages(MARIA_HA *info, const uchar *extents,
uint count)
{
MARIA_FILE_BITMAP *bitmap= &info->s->bitmap;
my_bool res;
DBUG_ENTER("_ma_bitmap_free_full_pages");
for (; count--; extents+= ROW_EXTENT_SIZE)
{
pgcache_page_no_t page= uint5korr(extents);
uint page_count= (uint2korr(extents + ROW_EXTENT_PAGE_SIZE) &
~START_EXTENT_BIT);
if (!(page_count & TAIL_BIT))
{
if (page == 0 && page_count == 0)
continue; /* Not used extent */
if (pagecache_delete_pages(info->s->pagecache, &info->dfile, page,
page_count, PAGECACHE_LOCK_WRITE, 1))
DBUG_RETURN(1);
mysql_mutex_lock(&bitmap->bitmap_lock);
res= _ma_bitmap_reset_full_page_bits(info, bitmap, page, page_count);
mysql_mutex_unlock(&bitmap->bitmap_lock);
if (res)
DBUG_RETURN(1);
}
}
DBUG_RETURN(0);
} | O3 | c | ma_bitmap_free_full_pages:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testl %edx, %edx
je 0x41853
movl %edx, %ebx
movq %rsi, %r14
movq (%rdi), %rax
leaq 0xa10(%rax), %rcx
movq %rcx, -0x48(%rbp)
leaq 0x470(%rdi), %rcx
movq %rcx, -0x50(%rbp)
movq %rax, -0x40(%rbp)
addq $0xa98, %rax # imm = 0xA98
movq %rax, -0x38(%rbp)
movzwl 0x5(%r14), %r13d
testw %r13w, %r13w
js 0x4181a
movl (%r14), %eax
movzbl 0x4(%r14), %r15d
shlq $0x20, %r15
orq %rax, %r15
andl $0xbfff, %r13d # imm = 0xBFFF
jne 0x41798
testq %r15, %r15
je 0x4181a
movq %rdi, %r12
movq (%rdi), %rax
movq 0x600(%rax), %rdi
movq -0x50(%rbp), %rsi
movq %r15, %rdx
movl %r13d, %ecx
movl $0x4, %r8d
movl $0x1, %r9d
callq 0x33614
testb %al, %al
jne 0x4186c
movb $0x1, %al
movl %eax, -0x2c(%rbp)
movq -0x40(%rbp), %rax
cmpq $0x0, 0xad8(%rax)
jne 0x4182a
movq -0x38(%rbp), %rdi
callq 0x29220
movq %r12, %rdi
movq -0x48(%rbp), %rsi
movq %r15, %rdx
movl %r13d, %ecx
callq 0x4106a
movl %eax, %r15d
movq -0x40(%rbp), %rax
movq 0xad8(%rax), %rdi
testq %rdi, %rdi
jne 0x41841
movq -0x38(%rbp), %rdi
callq 0x291e0
testb %r15b, %r15b
movq %r12, %rdi
jne 0x4185a
decl %ebx
addq $0x7, %r14
testl %ebx, %ebx
jne 0x41768
jmp 0x41853
movq -0x38(%rbp), %rdi
leaq 0x97cd8(%rip), %rsi # 0xd950d
movl $0xb31, %edx # imm = 0xB31
callq 0x2eb8f
jmp 0x417e4
leaq 0x3447c8(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x41809
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %al
movl %eax, -0x2c(%rbp)
jmp 0x4185a
| _ma_bitmap_free_full_pages:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
test edx, edx
jz loc_41853
mov ebx, edx
mov r14, rsi
mov rax, [rdi]
lea rcx, [rax+0A10h]
mov [rbp+var_48], rcx
lea rcx, [rdi+470h]
mov [rbp+var_50], rcx
mov [rbp+var_40], rax
add rax, 0A98h
mov [rbp+var_38], rax
loc_41768:
movzx r13d, word ptr [r14+5]
test r13w, r13w
js loc_4181A
mov eax, [r14]
movzx r15d, byte ptr [r14+4]
shl r15, 20h
or r15, rax
and r13d, 0BFFFh
jnz short loc_41798
test r15, r15
jz loc_4181A
loc_41798:
mov r12, rdi
mov rax, [rdi]
mov rdi, [rax+600h]
mov rsi, [rbp+var_50]
mov rdx, r15
mov ecx, r13d
mov r8d, 4
mov r9d, 1
call pagecache_delete_pages
test al, al
jnz loc_4186C
mov al, 1
mov [rbp+var_2C], eax
mov rax, [rbp+var_40]
cmp qword ptr [rax+0AD8h], 0
jnz short loc_4182A
mov rdi, [rbp+var_38]
call _pthread_mutex_lock
loc_417E4:
mov rdi, r12
mov rsi, [rbp+var_48]
mov rdx, r15
mov ecx, r13d
call _ma_bitmap_reset_full_page_bits
mov r15d, eax
mov rax, [rbp+var_40]
mov rdi, [rax+0AD8h]
test rdi, rdi
jnz short loc_41841
loc_41809:
mov rdi, [rbp+var_38]
call _pthread_mutex_unlock
test r15b, r15b
mov rdi, r12
jnz short loc_4185A
loc_4181A:
dec ebx
add r14, 7
test ebx, ebx
jnz loc_41768
jmp short loc_41853
loc_4182A:
mov rdi, [rbp+var_38]
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 0B31h
call psi_mutex_lock
jmp short loc_417E4
loc_41841:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_41809
loc_41853:
mov [rbp+var_2C], 0
loc_4185A:
mov eax, [rbp+var_2C]
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4186C:
mov al, 1
mov [rbp+var_2C], eax
jmp short loc_4185A
| long long ma_bitmap_free_full_pages(long long *a1, unsigned int *a2, int a3)
{
int v3; // ebx
__int16 v5; // r13
unsigned long long v6; // r15
unsigned int v7; // r13d
unsigned int v8; // eax
char v9; // r15
long long v11; // [rsp+8h] [rbp-48h]
long long v12; // [rsp+10h] [rbp-40h]
long long v13; // [rsp+18h] [rbp-38h]
unsigned int v14; // [rsp+24h] [rbp-2Ch]
if ( a3 )
{
v3 = a3;
v11 = *a1 + 2576;
v12 = *a1;
v13 = *a1 + 2712;
do
{
v5 = *(_WORD *)((char *)a2 + 5);
if ( v5 >= 0 )
{
v6 = *a2 | ((unsigned long long)*((unsigned __int8 *)a2 + 4) << 32);
v7 = v5 & 0xBFFF;
if ( v7 || v6 )
{
if ( pagecache_delete_pages(*(_QWORD *)(*a1 + 1536), (long long)(a1 + 142), v6, v7, 4u, 1) )
{
LOBYTE(v8) = 1;
return v8;
}
LOBYTE(v8) = 1;
v14 = v8;
if ( *(_QWORD *)(v12 + 2776) )
psi_mutex_lock(v13, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c", 0xB31u);
else
pthread_mutex_lock(v13);
v9 = ma_bitmap_reset_full_page_bits(a1, v11, v6, v7);
if ( *(_QWORD *)(v12 + 2776) )
PSI_server[44]();
pthread_mutex_unlock(v13);
if ( v9 )
return v14;
}
}
--v3;
a2 = (unsigned int *)((char *)a2 + 7);
}
while ( v3 );
}
return 0;
}
| _ma_bitmap_free_full_pages:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
TEST EDX,EDX
JZ 0x00141853
MOV EBX,EDX
MOV R14,RSI
MOV RAX,qword ptr [RDI]
LEA RCX,[RAX + 0xa10]
MOV qword ptr [RBP + -0x48],RCX
LEA RCX,[RDI + 0x470]
MOV qword ptr [RBP + -0x50],RCX
MOV qword ptr [RBP + -0x40],RAX
ADD RAX,0xa98
MOV qword ptr [RBP + -0x38],RAX
LAB_00141768:
MOVZX R13D,word ptr [R14 + 0x5]
TEST R13W,R13W
JS 0x0014181a
MOV EAX,dword ptr [R14]
MOVZX R15D,byte ptr [R14 + 0x4]
SHL R15,0x20
OR R15,RAX
AND R13D,0xbfff
JNZ 0x00141798
TEST R15,R15
JZ 0x0014181a
LAB_00141798:
MOV R12,RDI
MOV RAX,qword ptr [RDI]
MOV RDI,qword ptr [RAX + 0x600]
MOV RSI,qword ptr [RBP + -0x50]
MOV RDX,R15
MOV ECX,R13D
MOV R8D,0x4
MOV R9D,0x1
CALL 0x00133614
TEST AL,AL
JNZ 0x0014186c
MOV AL,0x1
MOV dword ptr [RBP + -0x2c],EAX
MOV RAX,qword ptr [RBP + -0x40]
CMP qword ptr [RAX + 0xad8],0x0
JNZ 0x0014182a
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x00129220
LAB_001417e4:
MOV RDI,R12
MOV RSI,qword ptr [RBP + -0x48]
MOV RDX,R15
MOV ECX,R13D
CALL 0x0014106a
MOV R15D,EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RAX + 0xad8]
TEST RDI,RDI
JNZ 0x00141841
LAB_00141809:
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x001291e0
TEST R15B,R15B
MOV RDI,R12
JNZ 0x0014185a
LAB_0014181a:
DEC EBX
ADD R14,0x7
TEST EBX,EBX
JNZ 0x00141768
JMP 0x00141853
LAB_0014182a:
MOV RDI,qword ptr [RBP + -0x38]
LEA RSI,[0x1d950d]
MOV EDX,0xb31
CALL 0x0012eb8f
JMP 0x001417e4
LAB_00141841:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00141809
LAB_00141853:
MOV dword ptr [RBP + -0x2c],0x0
LAB_0014185a:
MOV EAX,dword ptr [RBP + -0x2c]
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0014186c:
MOV AL,0x1
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x0014185a
|
int4 _ma_bitmap_free_full_pages(long *param_1,uint5 *param_2,int param_3)
{
ushort uVar1;
long lVar2;
char cVar3;
pthread_mutex_t *__mutex;
int8 uVar4;
int7 uVar5;
ulong uVar6;
if (param_3 != 0) {
lVar2 = *param_1;
__mutex = (pthread_mutex_t *)(lVar2 + 0xa98);
do {
uVar1 = *(ushort *)((long)param_2 + 5);
if (-1 < (short)uVar1) {
uVar6 = (ulong)*param_2;
if (((uVar1 & 0xbfff) != 0) || (uVar6 != 0)) {
uVar4 = pagecache_delete_pages
(*(int8 *)(*param_1 + 0x600),param_1 + 0x8e,uVar6,uVar1 & 0xbfff,4
,1);
uVar5 = (int7)((ulong)uVar4 >> 8);
if ((char)uVar4 != '\0') {
return (int)CONCAT71(uVar5,1);
}
if (*(long *)(lVar2 + 0xad8) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c",
0xb31);
}
cVar3 = _ma_bitmap_reset_full_page_bits(param_1,lVar2 + 0xa10,uVar6,uVar1 & 0xbfff);
if (*(long *)(lVar2 + 0xad8) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
if (cVar3 != '\0') {
return (int)CONCAT71(uVar5,1);
}
}
}
param_3 = param_3 + -1;
param_2 = (uint5 *)((long)param_2 + 7);
} while (param_3 != 0);
}
return 0;
}
| |
44,813 | my_strntoull_8bit | eloqsql/strings/ctype-simple.c | ulonglong my_strntoull_8bit(CHARSET_INFO *cs,
const char *nptr, size_t l, int base,
char **endptr, int *err)
{
int negative;
register ulonglong cutoff;
register uint cutlim;
register ulonglong i;
register const char *s, *e;
const char *save;
int overflow;
*err= 0; /* Initialize error indicator */
s = nptr;
e = nptr+l;
for(; s<e && my_isspace(cs,*s); s++);
if (s == e)
{
goto noconv;
}
if (*s == '-')
{
negative = 1;
++s;
}
else if (*s == '+')
{
negative = 0;
++s;
}
else
negative = 0;
save = s;
cutoff = (~(ulonglong) 0) / (unsigned long int) base;
cutlim = (uint) ((~(ulonglong) 0) % (unsigned long int) base);
overflow = 0;
i = 0;
for ( ; s != e; s++)
{
register uchar c= *s;
if (c>='0' && c<='9')
c -= '0';
else if (c>='A' && c<='Z')
c = c - 'A' + 10;
else if (c>='a' && c<='z')
c = c - 'a' + 10;
else
break;
if (c >= base)
break;
if (i > cutoff || (i == cutoff && c > cutlim))
overflow = 1;
else
{
i *= (ulonglong) base;
i += c;
}
}
if (s == save)
goto noconv;
if (endptr != NULL)
*endptr = (char *) s;
if (overflow)
{
err[0]= ERANGE;
return (~(ulonglong) 0);
}
return (negative ? -((longlong) i) : (longlong) i);
noconv:
err[0]= EDOM;
if (endptr != NULL)
*endptr = (char *) nptr;
return 0L;
} | O3 | c | my_strntoull_8bit:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl $0x0, (%r9)
leaq (%rsi,%rdx), %r11
movq %rsi, %r10
testq %rdx, %rdx
jle 0x70e51
movq 0x40(%rdi), %rax
movq %rsi, %r10
movzbl (%r10), %edx
testb $0x8, 0x1(%rax,%rdx)
je 0x70e51
incq %r10
cmpq %r11, %r10
jb 0x70e3e
cmpq %r11, %r10
je 0x70f39
movb (%r10), %dil
leal -0x2b(%rdi), %eax
andb $-0x3, %al
cmpb $0x1, %al
adcq $0x0, %r10
movslq %ecx, %rbx
movq $-0x1, %rax
xorl %edx, %edx
movq %rbx, -0x38(%rbp)
divq %rbx
xorl %r12d, %r12d
cmpq %r11, %r10
je 0x70f16
movq %rdi, -0x30(%rbp)
movq %r10, %r14
xorl %r15d, %r15d
movq %r15, %rdi
movl %r12d, %r13d
movb (%r14), %r12b
leal -0x30(%r12), %ebx
cmpb $0xa, %bl
jb 0x70ec5
leal -0x41(%r12), %ebx
cmpb $0x19, %bl
ja 0x70eb4
addb $-0x37, %r12b
jmp 0x70ec2
leal -0x61(%r12), %ebx
cmpb $0x19, %bl
ja 0x70f04
addb $-0x57, %r12b
movl %r12d, %ebx
movzbl %bl, %ebx
cmpl %ecx, %ebx
jge 0x70f04
movl $0x1, %r12d
cmpq %rax, %rdi
jbe 0x70edc
movq %rdi, %r15
jmp 0x70ef3
jne 0x70ee5
movq %rax, %r15
cmpl %edx, %ebx
ja 0x70ef3
imulq -0x38(%rbp), %rdi
movl %ebx, %r15d
addq %rdi, %r15
movl %r13d, %r12d
incq %r14
cmpq %r11, %r14
jne 0x70e91
movq %r15, %rdi
movq %r11, %r14
movl %r12d, %r13d
testl %r13d, %r13d
sete %al
movq %rdi, %r12
movq %r14, %r11
movq -0x30(%rbp), %rdi
jmp 0x70f18
movb $0x1, %al
cmpq %r10, %r11
je 0x70f39
testq %r8, %r8
je 0x70f25
movq %r11, (%r8)
testb %al, %al
je 0x70f4c
movq %r12, %rax
negq %rax
cmpb $0x2d, %dil
cmovneq %r12, %rax
jmp 0x70f5a
movl $0x21, (%r9)
testq %r8, %r8
je 0x70f48
movq %rsi, (%r8)
xorl %eax, %eax
jmp 0x70f5a
movl $0x22, (%r9)
movq $-0x1, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_strntoull_8bit:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
mov dword ptr [r9], 0
lea r11, [rsi+rdx]
mov r10, rsi
test rdx, rdx
jle short loc_70E51
mov rax, [rdi+40h]
mov r10, rsi
loc_70E3E:
movzx edx, byte ptr [r10]
test byte ptr [rax+rdx+1], 8
jz short loc_70E51
inc r10
cmp r10, r11
jb short loc_70E3E
loc_70E51:
cmp r10, r11
jz loc_70F39
mov dil, [r10]
lea eax, [rdi-2Bh]
and al, 0FDh
cmp al, 1
adc r10, 0
movsxd rbx, ecx
mov rax, 0FFFFFFFFFFFFFFFFh
xor edx, edx
mov [rbp+var_38], rbx
div rbx
xor r12d, r12d
cmp r10, r11
jz loc_70F16
mov [rbp+var_30], rdi
mov r14, r10
xor r15d, r15d
loc_70E91:
mov rdi, r15
mov r13d, r12d
mov r12b, [r14]
lea ebx, [r12-30h]
cmp bl, 0Ah
jb short loc_70EC5
lea ebx, [r12-41h]
cmp bl, 19h
ja short loc_70EB4
add r12b, 0C9h
jmp short loc_70EC2
loc_70EB4:
lea ebx, [r12-61h]
cmp bl, 19h
ja short loc_70F04
add r12b, 0A9h
loc_70EC2:
mov ebx, r12d
loc_70EC5:
movzx ebx, bl
cmp ebx, ecx
jge short loc_70F04
mov r12d, 1
cmp rdi, rax
jbe short loc_70EDC
mov r15, rdi
jmp short loc_70EF3
loc_70EDC:
jnz short loc_70EE5
mov r15, rax
cmp ebx, edx
ja short loc_70EF3
loc_70EE5:
imul rdi, [rbp+var_38]
mov r15d, ebx
add r15, rdi
mov r12d, r13d
loc_70EF3:
inc r14
cmp r14, r11
jnz short loc_70E91
mov rdi, r15
mov r14, r11
mov r13d, r12d
loc_70F04:
test r13d, r13d
setz al
mov r12, rdi
mov r11, r14
mov rdi, [rbp+var_30]
jmp short loc_70F18
loc_70F16:
mov al, 1
loc_70F18:
cmp r11, r10
jz short loc_70F39
test r8, r8
jz short loc_70F25
mov [r8], r11
loc_70F25:
test al, al
jz short loc_70F4C
mov rax, r12
neg rax
cmp dil, 2Dh ; '-'
cmovnz rax, r12
jmp short loc_70F5A
loc_70F39:
mov dword ptr [r9], 21h ; '!'
test r8, r8
jz short loc_70F48
mov [r8], rsi
loc_70F48:
xor eax, eax
jmp short loc_70F5A
loc_70F4C:
mov dword ptr [r9], 22h ; '"'
mov rax, 0FFFFFFFFFFFFFFFFh
loc_70F5A:
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_strntoull_8bit(
long long a1,
unsigned __int8 *a2,
long long a3,
int a4,
unsigned __int8 **a5,
_DWORD *a6)
{
unsigned __int8 *v6; // r11
unsigned __int8 *v7; // r10
unsigned __int8 v8; // di
unsigned __int8 *v9; // r10
unsigned long long v10; // rax
unsigned long long v11; // r12
unsigned __int8 *v12; // r14
unsigned long long v13; // r15
unsigned long long v14; // rdi
int v15; // r13d
unsigned __int8 v16; // r12
unsigned __int8 v17; // bl
unsigned __int8 v18; // r12
bool v19; // al
long long result; // rax
unsigned __int8 v21; // [rsp+8h] [rbp-30h]
*a6 = 0;
v6 = &a2[a3];
v7 = a2;
if ( a3 > 0 )
{
v7 = a2;
do
{
if ( (*(_BYTE *)(*(_QWORD *)(a1 + 64) + *v7 + 1LL) & 8) == 0 )
break;
++v7;
}
while ( v7 < v6 );
}
if ( v7 == v6 )
goto LABEL_30;
v8 = *v7;
v9 = &v7[((*v7 - 43) & 0xFD) == 0];
v10 = 0xFFFFFFFFFFFFFFFFLL / a4;
v11 = 0LL;
if ( v9 == v6 )
{
v19 = 1;
}
else
{
v21 = v8;
v12 = v9;
v13 = 0LL;
while ( 1 )
{
v14 = v13;
v15 = v11;
v16 = *v12;
v17 = *v12 - 48;
if ( v17 >= 0xAu )
{
if ( (unsigned __int8)(v16 - 65) > 0x19u )
{
if ( (unsigned __int8)(v16 - 97) > 0x19u )
break;
v18 = v16 - 87;
}
else
{
v18 = v16 - 55;
}
v17 = v18;
}
if ( v17 >= a4 )
break;
LODWORD(v11) = 1;
if ( v13 <= v10 )
{
if ( v13 != v10 || (v13 = 0xFFFFFFFFFFFFFFFFLL / a4, v17 <= (unsigned int)(0xFFFFFFFFFFFFFFFFLL % a4)) )
{
v13 = a4 * v14 + v17;
LODWORD(v11) = v15;
}
}
if ( ++v12 == v6 )
{
v14 = v13;
v12 = &a2[a3];
v15 = v11;
break;
}
}
v19 = v15 == 0;
v11 = v14;
v6 = v12;
v8 = v21;
}
if ( v6 == v9 )
{
LABEL_30:
*a6 = 33;
if ( a5 )
*a5 = a2;
return 0LL;
}
else
{
if ( a5 )
*a5 = v6;
if ( v19 )
{
result = -(long long)v11;
if ( v8 != 45 )
return v11;
}
else
{
*a6 = 34;
return -1LL;
}
}
return result;
}
| my_strntoull_8bit:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV dword ptr [R9],0x0
LEA R11,[RSI + RDX*0x1]
MOV R10,RSI
TEST RDX,RDX
JLE 0x00170e51
MOV RAX,qword ptr [RDI + 0x40]
MOV R10,RSI
LAB_00170e3e:
MOVZX EDX,byte ptr [R10]
TEST byte ptr [RAX + RDX*0x1 + 0x1],0x8
JZ 0x00170e51
INC R10
CMP R10,R11
JC 0x00170e3e
LAB_00170e51:
CMP R10,R11
JZ 0x00170f39
MOV DIL,byte ptr [R10]
LEA EAX,[RDI + -0x2b]
AND AL,0xfd
CMP AL,0x1
ADC R10,0x0
MOVSXD RBX,ECX
MOV RAX,-0x1
XOR EDX,EDX
MOV qword ptr [RBP + -0x38],RBX
DIV RBX
XOR R12D,R12D
CMP R10,R11
JZ 0x00170f16
MOV qword ptr [RBP + -0x30],RDI
MOV R14,R10
XOR R15D,R15D
LAB_00170e91:
MOV RDI,R15
MOV R13D,R12D
MOV R12B,byte ptr [R14]
LEA EBX,[R12 + -0x30]
CMP BL,0xa
JC 0x00170ec5
LEA EBX,[R12 + -0x41]
CMP BL,0x19
JA 0x00170eb4
ADD R12B,0xc9
JMP 0x00170ec2
LAB_00170eb4:
LEA EBX,[R12 + -0x61]
CMP BL,0x19
JA 0x00170f04
ADD R12B,0xa9
LAB_00170ec2:
MOV EBX,R12D
LAB_00170ec5:
MOVZX EBX,BL
CMP EBX,ECX
JGE 0x00170f04
MOV R12D,0x1
CMP RDI,RAX
JBE 0x00170edc
MOV R15,RDI
JMP 0x00170ef3
LAB_00170edc:
JNZ 0x00170ee5
MOV R15,RAX
CMP EBX,EDX
JA 0x00170ef3
LAB_00170ee5:
IMUL RDI,qword ptr [RBP + -0x38]
MOV R15D,EBX
ADD R15,RDI
MOV R12D,R13D
LAB_00170ef3:
INC R14
CMP R14,R11
JNZ 0x00170e91
MOV RDI,R15
MOV R14,R11
MOV R13D,R12D
LAB_00170f04:
TEST R13D,R13D
SETZ AL
MOV R12,RDI
MOV R11,R14
MOV RDI,qword ptr [RBP + -0x30]
JMP 0x00170f18
LAB_00170f16:
MOV AL,0x1
LAB_00170f18:
CMP R11,R10
JZ 0x00170f39
TEST R8,R8
JZ 0x00170f25
MOV qword ptr [R8],R11
LAB_00170f25:
TEST AL,AL
JZ 0x00170f4c
MOV RAX,R12
NEG RAX
CMP DIL,0x2d
CMOVNZ RAX,R12
JMP 0x00170f5a
LAB_00170f39:
MOV dword ptr [R9],0x21
TEST R8,R8
JZ 0x00170f48
MOV qword ptr [R8],RSI
LAB_00170f48:
XOR EAX,EAX
JMP 0x00170f5a
LAB_00170f4c:
MOV dword ptr [R9],0x22
MOV RAX,-0x1
LAB_00170f5a:
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong my_strntoull_8bit(long param_1,byte *param_2,long param_3,int param_4,ulong *param_5,
int4 *param_6)
{
byte bVar1;
byte bVar2;
int1 auVar3 [16];
int1 auVar4 [16];
ulong uVar5;
ulong uVar6;
ulong uVar7;
byte *pbVar8;
byte *pbVar9;
byte bVar10;
ulong uVar11;
ulong uVar12;
int iVar13;
byte *pbVar14;
bool bVar15;
*param_6 = 0;
pbVar9 = param_2 + param_3;
pbVar8 = param_2;
if (0 < param_3) {
do {
if ((*(byte *)(*(long *)(param_1 + 0x40) + 1 + (ulong)*pbVar8) & 8) == 0) break;
pbVar8 = pbVar8 + 1;
} while (pbVar8 < pbVar9);
}
if (pbVar8 != pbVar9) {
bVar1 = *pbVar8;
pbVar8 = pbVar8 + ((bVar1 - 0x2b & 0xfd) == 0);
auVar3._8_8_ = 0;
auVar3._0_8_ = (long)param_4;
auVar4 = ZEXT816(0) << 0x40 | ZEXT816(0xffffffffffffffff);
uVar6 = SUB168(auVar4 / auVar3,0);
uVar7 = 0;
if (pbVar8 == pbVar9) {
bVar15 = true;
}
else {
uVar11 = uVar7;
pbVar14 = pbVar8;
uVar7 = 0;
do {
iVar13 = (int)uVar11;
bVar2 = *pbVar14;
bVar10 = bVar2 - 0x30;
if (9 < bVar10) {
if ((byte)(bVar2 + 0xbf) < 0x1a) {
bVar10 = bVar2 - 0x37;
}
else {
if (0x19 < (byte)(bVar2 + 0x9f)) goto LAB_00170f04;
bVar10 = bVar2 + 0xa9;
}
}
if (param_4 <= (int)(uint)bVar10) goto LAB_00170f04;
uVar12 = 1;
uVar5 = uVar7;
if ((uVar7 <= uVar6) &&
((uVar7 != uVar6 || (uVar5 = uVar6, (uint)bVar10 <= SUB164(auVar4 % auVar3,0))))) {
uVar12 = uVar11;
uVar5 = (ulong)bVar10 + uVar7 * (long)param_4;
}
uVar7 = uVar5;
pbVar14 = pbVar14 + 1;
uVar11 = uVar12;
} while (pbVar14 != pbVar9);
iVar13 = (int)uVar12;
pbVar14 = pbVar9;
LAB_00170f04:
pbVar9 = pbVar14;
bVar15 = iVar13 == 0;
}
if (pbVar9 != pbVar8) {
if (param_5 != (ulong *)0x0) {
*param_5 = (ulong)pbVar9;
}
if (bVar15) {
if (bVar1 == 0x2d) {
return -uVar7;
}
return uVar7;
}
*param_6 = 0x22;
return 0xffffffffffffffff;
}
}
*param_6 = 0x21;
if (param_5 != (ulong *)0x0) {
*param_5 = (ulong)param_2;
}
return 0;
}
| |
44,814 | my_coll_parser_scan_logical_position | eloqsql/strings/ctype-uca.c | static int
my_coll_parser_scan_logical_position(MY_COLL_RULE_PARSER *p,
my_wc_t *pwc, size_t limit)
{
MY_COLL_RULES *rules= p->rules;
MY_COLL_LEXEM *lexem= my_coll_parser_curr(p);
if (!lex_cmp(lexem, C_STRING_WITH_LEN("[first non-ignorable]")))
lexem->code= rules->uca->first_non_ignorable;
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[last non-ignorable]")))
lexem->code= rules->uca->last_non_ignorable;
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[first primary ignorable]")))
lexem->code= rules->uca->first_primary_ignorable;
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[last primary ignorable]")))
lexem->code= rules->uca->last_primary_ignorable;
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[first secondary ignorable]")))
lexem->code= rules->uca->first_secondary_ignorable;
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[last secondary ignorable]")))
lexem->code= rules->uca->last_secondary_ignorable;
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[first tertiary ignorable]")))
lexem->code= rules->uca->first_tertiary_ignorable;
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[last tertiary ignorable]")))
lexem->code= rules->uca->last_tertiary_ignorable;
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[first trailing]")))
lexem->code= rules->uca->first_trailing;
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[last trailing]")))
lexem->code= rules->uca->last_trailing;
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[first variable]")))
lexem->code= rules->uca->first_variable;
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[last variable]")))
lexem->code= rules->uca->last_variable;
else
return 0; /* Don't scan the next token */
if (!my_coll_rule_expand(pwc, limit, lexem->code))
{
/*
Logical position can not be in a contraction,
so the above call should never fail.
Let's assert in debug version and print
a nice error message in production version.
*/
DBUG_ASSERT(0);
return my_coll_parser_too_long_error(p, "Logical position");
}
return my_coll_parser_scan(p);
} | O0 | c | my_coll_parser_scan_logical_position:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe4300
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x34d20(%rip), %rsi # 0x119cfb
movl $0x15, %edx
callq 0xe4a80
cmpl $0x0, %eax
jne 0xe5004
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x70(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0xe5274
movq -0x30(%rbp), %rdi
leaq 0x34d02(%rip), %rsi # 0x119d11
movl $0x14, %edx
callq 0xe4a80
cmpl $0x0, %eax
jne 0xe5038
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x78(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0xe5272
movq -0x30(%rbp), %rdi
leaq 0x34ce3(%rip), %rsi # 0x119d26
movl $0x19, %edx
callq 0xe4a80
cmpl $0x0, %eax
jne 0xe506f
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x80(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0xe5270
movq -0x30(%rbp), %rdi
leaq 0x34cc6(%rip), %rsi # 0x119d40
movl $0x18, %edx
callq 0xe4a80
cmpl $0x0, %eax
jne 0xe50a6
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x88(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0xe526e
movq -0x30(%rbp), %rdi
leaq 0x34ca8(%rip), %rsi # 0x119d59
movl $0x1b, %edx
callq 0xe4a80
cmpl $0x0, %eax
jne 0xe50dd
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x90(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0xe526c
movq -0x30(%rbp), %rdi
leaq 0x34c8d(%rip), %rsi # 0x119d75
movl $0x1a, %edx
callq 0xe4a80
cmpl $0x0, %eax
jne 0xe5114
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x98(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0xe526a
movq -0x30(%rbp), %rdi
leaq 0x34c71(%rip), %rsi # 0x119d90
movl $0x1a, %edx
callq 0xe4a80
cmpl $0x0, %eax
jne 0xe514b
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xa0(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0xe5268
movq -0x30(%rbp), %rdi
leaq 0x34c55(%rip), %rsi # 0x119dab
movl $0x19, %edx
callq 0xe4a80
cmpl $0x0, %eax
jne 0xe5182
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xa8(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0xe5266
movq -0x30(%rbp), %rdi
leaq 0x34c38(%rip), %rsi # 0x119dc5
movl $0x10, %edx
callq 0xe4a80
cmpl $0x0, %eax
jne 0xe51b9
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xb0(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0xe5264
movq -0x30(%rbp), %rdi
leaq 0x34c12(%rip), %rsi # 0x119dd6
movl $0xf, %edx
callq 0xe4a80
cmpl $0x0, %eax
jne 0xe51ed
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xb8(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0xe5262
movq -0x30(%rbp), %rdi
leaq 0x34bee(%rip), %rsi # 0x119de6
movl $0x10, %edx
callq 0xe4a80
cmpl $0x0, %eax
jne 0xe5221
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xc0(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0xe5260
movq -0x30(%rbp), %rdi
leaq 0x34bcb(%rip), %rsi # 0x119df7
movl $0xf, %edx
callq 0xe4a80
cmpl $0x0, %eax
jne 0xe5255
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xc8(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0xe525e
movl $0x0, -0x4(%rbp)
jmp 0xe52b3
jmp 0xe5260
jmp 0xe5262
jmp 0xe5264
jmp 0xe5266
jmp 0xe5268
jmp 0xe526a
jmp 0xe526c
jmp 0xe526e
jmp 0xe5270
jmp 0xe5272
jmp 0xe5274
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rax
movslq 0x24(%rax), %rdx
callq 0xe53d0
cmpl $0x0, %eax
jne 0xe52a7
jmp 0xe5290
jmp 0xe5292
movq -0x10(%rbp), %rdi
leaq 0x34b6a(%rip), %rsi # 0x119e07
callq 0xe5440
movl %eax, -0x4(%rbp)
jmp 0xe52b3
movq -0x10(%rbp), %rdi
callq 0xe4ae0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| my_coll_parser_scan_logical_position:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
mov rax, [rax+0F0h]
mov [rbp+var_28], rax
mov rdi, [rbp+var_10]
call my_coll_parser_curr
mov [rbp+var_30], rax
mov rdi, [rbp+var_30]
lea rsi, aFirstNonIgnora; "[first non-ignorable]"
mov edx, 15h
call lex_cmp
cmp eax, 0
jnz short loc_E5004
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+70h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp loc_E5274
loc_E5004:
mov rdi, [rbp+var_30]
lea rsi, aLastNonIgnorab; "[last non-ignorable]"
mov edx, 14h
call lex_cmp
cmp eax, 0
jnz short loc_E5038
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+78h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp loc_E5272
loc_E5038:
mov rdi, [rbp+var_30]
lea rsi, aFirstPrimaryIg; "[first primary ignorable]"
mov edx, 19h
call lex_cmp
cmp eax, 0
jnz short loc_E506F
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+80h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp loc_E5270
loc_E506F:
mov rdi, [rbp+var_30]
lea rsi, aLastPrimaryIgn; "[last primary ignorable]"
mov edx, 18h
call lex_cmp
cmp eax, 0
jnz short loc_E50A6
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+88h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp loc_E526E
loc_E50A6:
mov rdi, [rbp+var_30]
lea rsi, aFirstSecondary; "[first secondary ignorable]"
mov edx, 1Bh
call lex_cmp
cmp eax, 0
jnz short loc_E50DD
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+90h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp loc_E526C
loc_E50DD:
mov rdi, [rbp+var_30]
lea rsi, aLastSecondaryI; "[last secondary ignorable]"
mov edx, 1Ah
call lex_cmp
cmp eax, 0
jnz short loc_E5114
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+98h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp loc_E526A
loc_E5114:
mov rdi, [rbp+var_30]
lea rsi, aFirstTertiaryI; "[first tertiary ignorable]"
mov edx, 1Ah
call lex_cmp
cmp eax, 0
jnz short loc_E514B
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+0A0h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp loc_E5268
loc_E514B:
mov rdi, [rbp+var_30]
lea rsi, aLastTertiaryIg; "[last tertiary ignorable]"
mov edx, 19h
call lex_cmp
cmp eax, 0
jnz short loc_E5182
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+0A8h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp loc_E5266
loc_E5182:
mov rdi, [rbp+var_30]
lea rsi, aFirstTrailing; "[first trailing]"
mov edx, 10h
call lex_cmp
cmp eax, 0
jnz short loc_E51B9
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+0B0h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp loc_E5264
loc_E51B9:
mov rdi, [rbp+var_30]
lea rsi, aLastTrailing; "[last trailing]"
mov edx, 0Fh
call lex_cmp
cmp eax, 0
jnz short loc_E51ED
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+0B8h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp short loc_E5262
loc_E51ED:
mov rdi, [rbp+var_30]
lea rsi, aFirstVariable; "[first variable]"
mov edx, 10h
call lex_cmp
cmp eax, 0
jnz short loc_E5221
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+0C0h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp short loc_E5260
loc_E5221:
mov rdi, [rbp+var_30]
lea rsi, aLastVariable; "[last variable]"
mov edx, 0Fh
call lex_cmp
cmp eax, 0
jnz short loc_E5255
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+0C8h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp short loc_E525E
loc_E5255:
mov [rbp+var_4], 0
jmp short loc_E52B3
loc_E525E:
jmp short $+2
loc_E5260:
jmp short $+2
loc_E5262:
jmp short $+2
loc_E5264:
jmp short $+2
loc_E5266:
jmp short $+2
loc_E5268:
jmp short $+2
loc_E526A:
jmp short $+2
loc_E526C:
jmp short $+2
loc_E526E:
jmp short $+2
loc_E5270:
jmp short $+2
loc_E5272:
jmp short $+2
loc_E5274:
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rax, [rbp+var_30]
movsxd rdx, dword ptr [rax+24h]
call my_coll_rule_expand
cmp eax, 0
jnz short loc_E52A7
jmp short $+2
loc_E5290:
jmp short $+2
loc_E5292:
mov rdi, [rbp+var_10]
lea rsi, aLogicalPositio; "Logical position"
call my_coll_parser_too_long_error
mov [rbp+var_4], eax
jmp short loc_E52B3
loc_E52A7:
mov rdi, [rbp+var_10]
call my_coll_parser_scan
mov [rbp+var_4], eax
loc_E52B3:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long my_coll_parser_scan_logical_position(long long a1, long long a2, long long a3)
{
long long v4; // [rsp+0h] [rbp-30h]
long long v5; // [rsp+8h] [rbp-28h]
v5 = *(_QWORD *)(a1 + 240);
v4 = my_coll_parser_curr(a1);
if ( (unsigned int)lex_cmp(v4, (long long)"[first non-ignorable]", 0x15uLL) )
{
if ( (unsigned int)lex_cmp(v4, (long long)"[last non-ignorable]", 0x14uLL) )
{
if ( (unsigned int)lex_cmp(v4, (long long)"[first primary ignorable]", 0x19uLL) )
{
if ( (unsigned int)lex_cmp(v4, (long long)"[last primary ignorable]", 0x18uLL) )
{
if ( (unsigned int)lex_cmp(v4, (long long)"[first secondary ignorable]", 0x1BuLL) )
{
if ( (unsigned int)lex_cmp(v4, (long long)"[last secondary ignorable]", 0x1AuLL) )
{
if ( (unsigned int)lex_cmp(v4, (long long)"[first tertiary ignorable]", 0x1AuLL) )
{
if ( (unsigned int)lex_cmp(v4, (long long)"[last tertiary ignorable]", 0x19uLL) )
{
if ( (unsigned int)lex_cmp(v4, (long long)"[first trailing]", 0x10uLL) )
{
if ( (unsigned int)lex_cmp(v4, (long long)"[last trailing]", 0xFuLL) )
{
if ( (unsigned int)lex_cmp(v4, (long long)"[first variable]", 0x10uLL) )
{
if ( (unsigned int)lex_cmp(v4, (long long)"[last variable]", 0xFuLL) )
return 0;
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 200LL);
}
else
{
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 192LL);
}
}
else
{
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 184LL);
}
}
else
{
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 176LL);
}
}
else
{
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 168LL);
}
}
else
{
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 160LL);
}
}
else
{
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 152LL);
}
}
else
{
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 144LL);
}
}
else
{
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 136LL);
}
}
else
{
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 128LL);
}
}
else
{
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 120LL);
}
}
else
{
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 112LL);
}
if ( (unsigned int)my_coll_rule_expand(a2, a3, *(int *)(v4 + 36)) )
return (unsigned int)my_coll_parser_scan(a1);
else
return (unsigned int)my_coll_parser_too_long_error(a1, "Logical position");
}
| my_coll_parser_scan_logical_position:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xf0]
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001e4300
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x219cfb]
MOV EDX,0x15
CALL 0x001e4a80
CMP EAX,0x0
JNZ 0x001e5004
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x70]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x001e5274
LAB_001e5004:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x219d11]
MOV EDX,0x14
CALL 0x001e4a80
CMP EAX,0x0
JNZ 0x001e5038
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x78]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x001e5272
LAB_001e5038:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x219d26]
MOV EDX,0x19
CALL 0x001e4a80
CMP EAX,0x0
JNZ 0x001e506f
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x80]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x001e5270
LAB_001e506f:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x219d40]
MOV EDX,0x18
CALL 0x001e4a80
CMP EAX,0x0
JNZ 0x001e50a6
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x88]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x001e526e
LAB_001e50a6:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x219d59]
MOV EDX,0x1b
CALL 0x001e4a80
CMP EAX,0x0
JNZ 0x001e50dd
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x90]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x001e526c
LAB_001e50dd:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x219d75]
MOV EDX,0x1a
CALL 0x001e4a80
CMP EAX,0x0
JNZ 0x001e5114
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x98]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x001e526a
LAB_001e5114:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x219d90]
MOV EDX,0x1a
CALL 0x001e4a80
CMP EAX,0x0
JNZ 0x001e514b
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0xa0]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x001e5268
LAB_001e514b:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x219dab]
MOV EDX,0x19
CALL 0x001e4a80
CMP EAX,0x0
JNZ 0x001e5182
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0xa8]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x001e5266
LAB_001e5182:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x219dc5]
MOV EDX,0x10
CALL 0x001e4a80
CMP EAX,0x0
JNZ 0x001e51b9
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0xb0]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x001e5264
LAB_001e51b9:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x219dd6]
MOV EDX,0xf
CALL 0x001e4a80
CMP EAX,0x0
JNZ 0x001e51ed
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0xb8]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x001e5262
LAB_001e51ed:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x219de6]
MOV EDX,0x10
CALL 0x001e4a80
CMP EAX,0x0
JNZ 0x001e5221
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0xc0]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x001e5260
LAB_001e5221:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x219df7]
MOV EDX,0xf
CALL 0x001e4a80
CMP EAX,0x0
JNZ 0x001e5255
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0xc8]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x001e525e
LAB_001e5255:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001e52b3
LAB_001e525e:
JMP 0x001e5260
LAB_001e5260:
JMP 0x001e5262
LAB_001e5262:
JMP 0x001e5264
LAB_001e5264:
JMP 0x001e5266
LAB_001e5266:
JMP 0x001e5268
LAB_001e5268:
JMP 0x001e526a
LAB_001e526a:
JMP 0x001e526c
LAB_001e526c:
JMP 0x001e526e
LAB_001e526e:
JMP 0x001e5270
LAB_001e5270:
JMP 0x001e5272
LAB_001e5272:
JMP 0x001e5274
LAB_001e5274:
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x30]
MOVSXD RDX,dword ptr [RAX + 0x24]
CALL 0x001e53d0
CMP EAX,0x0
JNZ 0x001e52a7
JMP 0x001e5290
LAB_001e5290:
JMP 0x001e5292
LAB_001e5292:
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x219e07]
CALL 0x001e5440
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001e52b3
LAB_001e52a7:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001e4ae0
MOV dword ptr [RBP + -0x4],EAX
LAB_001e52b3:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 my_coll_parser_scan_logical_position(long param_1,int8 param_2,int8 param_3)
{
long lVar1;
int iVar2;
long lVar3;
int4 local_c;
lVar1 = *(long *)(param_1 + 0xf0);
lVar3 = my_coll_parser_curr(param_1);
iVar2 = lex_cmp(lVar3,"[first non-ignorable]",0x15);
if (iVar2 == 0) {
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 0x70);
}
else {
iVar2 = lex_cmp(lVar3,"[last non-ignorable]",0x14);
if (iVar2 == 0) {
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 0x78);
}
else {
iVar2 = lex_cmp(lVar3,"[first primary ignorable]",0x19);
if (iVar2 == 0) {
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 0x80);
}
else {
iVar2 = lex_cmp(lVar3,"[last primary ignorable]",0x18);
if (iVar2 == 0) {
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 0x88);
}
else {
iVar2 = lex_cmp(lVar3,"[first secondary ignorable]",0x1b);
if (iVar2 == 0) {
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 0x90);
}
else {
iVar2 = lex_cmp(lVar3,"[last secondary ignorable]",0x1a);
if (iVar2 == 0) {
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 0x98);
}
else {
iVar2 = lex_cmp(lVar3,"[first tertiary ignorable]",0x1a);
if (iVar2 == 0) {
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 0xa0);
}
else {
iVar2 = lex_cmp(lVar3,"[last tertiary ignorable]",0x19);
if (iVar2 == 0) {
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 0xa8);
}
else {
iVar2 = lex_cmp(lVar3,"[first trailing]",0x10);
if (iVar2 == 0) {
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 0xb0);
}
else {
iVar2 = lex_cmp(lVar3,"[last trailing]",0xf);
if (iVar2 == 0) {
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 0xb8);
}
else {
iVar2 = lex_cmp(lVar3,"[first variable]",0x10);
if (iVar2 == 0) {
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 0xc0);
}
else {
iVar2 = lex_cmp(lVar3,"[last variable]",0xf);
if (iVar2 != 0) {
return 0;
}
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 200);
}
}
}
}
}
}
}
}
}
}
}
iVar2 = my_coll_rule_expand(param_2,param_3,(long)*(int *)(lVar3 + 0x24));
if (iVar2 == 0) {
local_c = my_coll_parser_too_long_error(param_1,"Logical position");
}
else {
local_c = my_coll_parser_scan(param_1);
}
return local_c;
}
| |
44,815 | my_parse_charset_xml | eloqsql/strings/ctype.c | my_bool
my_parse_charset_xml(MY_CHARSET_LOADER *loader, const char *buf, size_t len)
{
MY_XML_PARSER p;
struct my_cs_file_info info;
my_bool rc;
my_charset_file_init(&info);
my_xml_parser_create(&p);
my_xml_set_enter_handler(&p,cs_enter);
my_xml_set_value_handler(&p,cs_value);
my_xml_set_leave_handler(&p,cs_leave);
info.loader= loader;
my_xml_set_user_data(&p, (void *) &info);
rc= (my_xml_parse(&p,buf,len) == MY_XML_OK) ? FALSE : TRUE;
my_xml_parser_free(&p);
my_charset_file_free(&info);
if (rc != MY_XML_OK)
{
const char *errstr= my_xml_error_string(&p);
if (sizeof(loader->error) > 32 + strlen(errstr))
{
/* We cannot use my_snprintf() here. See previous comment. */
sprintf(loader->error, "at line %d pos %d: %s",
my_xml_error_lineno(&p)+1,
(int) my_xml_error_pos(&p),
my_xml_error_string(&p));
}
}
return rc;
} | O0 | c | my_parse_charset_xml:
pushq %rbp
movq %rsp, %rbp
subq $0x960, %rsp # imm = 0x960
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x920(%rbp)
movq %rsi, -0x928(%rbp)
movq %rdx, -0x930(%rbp)
leaq -0x918(%rbp), %rdi
callq 0x6daa0
leaq -0x168(%rbp), %rdi
callq 0x7a0d0
leaq -0x168(%rbp), %rdi
leaq 0x1bd(%rip), %rsi # 0x6daf0
callq 0x7a190
leaq -0x168(%rbp), %rdi
leaq 0x29a(%rip), %rsi # 0x6dbe0
callq 0x7a170
leaq -0x168(%rbp), %rdi
leaq 0x9f7(%rip), %rsi # 0x6e350
callq 0x7a1b0
movq -0x920(%rbp), %rax
movq %rax, -0x170(%rbp)
leaq -0x168(%rbp), %rdi
leaq -0x918(%rbp), %rsi
callq 0x7a1d0
movq -0x928(%rbp), %rsi
movq -0x930(%rbp), %rdx
leaq -0x168(%rbp), %rdi
callq 0x78fa0
movl %eax, %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movb %al, -0x931(%rbp)
leaq -0x168(%rbp), %rdi
callq 0x7a130
leaq -0x918(%rbp), %rdi
callq 0x6e660
movsbl -0x931(%rbp), %eax
cmpl $0x0, %eax
je 0x6da6d
leaq -0x168(%rbp), %rdi
callq 0x7a1f0
movq %rax, -0x940(%rbp)
movq -0x940(%rbp), %rdi
callq 0x24120
movq %rax, %rcx
addq $0x20, %rcx
movl $0x80, %eax
cmpq %rcx, %rax
jbe 0x6da6b
movq -0x920(%rbp), %rax
movq %rax, -0x950(%rbp)
leaq -0x168(%rbp), %rdi
callq 0x7a280
addl $0x1, %eax
movl %eax, -0x948(%rbp)
leaq -0x168(%rbp), %rdi
callq 0x7a210
movl %eax, -0x944(%rbp)
leaq -0x168(%rbp), %rdi
callq 0x7a1f0
movq -0x950(%rbp), %rdi
movl -0x948(%rbp), %edx
movl -0x944(%rbp), %ecx
movq %rax, %r8
leaq 0x105c5(%rip), %rsi # 0x7e029
movb $0x0, %al
callq 0x240a0
jmp 0x6da6d
movb -0x931(%rbp), %al
movb %al, -0x951(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x6da9a
movb -0x951(%rbp), %al
addq $0x960, %rsp # imm = 0x960
popq %rbp
retq
callq 0x242b0
nop
| my_parse_charset_xml:
push rbp
mov rbp, rsp
sub rsp, 960h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_920], rdi
mov [rbp+var_928], rsi
mov [rbp+var_930], rdx
lea rdi, [rbp+var_918]
call my_charset_file_init
lea rdi, [rbp+var_168]
call my_xml_parser_create
lea rdi, [rbp+var_168]
lea rsi, cs_enter
call my_xml_set_enter_handler
lea rdi, [rbp+var_168]
lea rsi, cs_value
call my_xml_set_value_handler
lea rdi, [rbp+var_168]
lea rsi, cs_leave
call my_xml_set_leave_handler
mov rax, [rbp+var_920]
mov [rbp+var_170], rax
lea rdi, [rbp+var_168]
lea rsi, [rbp+var_918]
call my_xml_set_user_data
mov rsi, [rbp+var_928]
mov rdx, [rbp+var_930]
lea rdi, [rbp+var_168]
call my_xml_parse
mov edx, eax
mov eax, 1
xor ecx, ecx
cmp edx, 0
cmovz eax, ecx
mov [rbp+var_931], al
lea rdi, [rbp+var_168]
call my_xml_parser_free
lea rdi, [rbp+var_918]
call my_charset_file_free
movsx eax, [rbp+var_931]
cmp eax, 0
jz loc_6DA6D
lea rdi, [rbp+var_168]
call my_xml_error_string
mov [rbp+var_940], rax
mov rdi, [rbp+var_940]
call _strlen
mov rcx, rax
add rcx, 20h ; ' '
mov eax, 80h
cmp rax, rcx
jbe short loc_6DA6B
mov rax, [rbp+var_920]
mov [rbp+var_950], rax
lea rdi, [rbp+var_168]
call my_xml_error_lineno
add eax, 1
mov [rbp+var_948], eax
lea rdi, [rbp+var_168]
call my_xml_error_pos
mov [rbp+var_944], eax
lea rdi, [rbp+var_168]
call my_xml_error_string
mov rdi, [rbp+var_950]
mov edx, [rbp+var_948]
mov ecx, [rbp+var_944]
mov r8, rax
lea rsi, aAtLineDPosDS; "at line %d pos %d: %s"
mov al, 0
call _sprintf
loc_6DA6B:
jmp short $+2
loc_6DA6D:
mov al, [rbp+var_931]
mov [rbp+var_951], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_6DA9A
mov al, [rbp+var_951]
add rsp, 960h
pop rbp
retn
loc_6DA9A:
call ___stack_chk_fail
| bool my_parse_charset_xml(long long a1, long long a2, long long a3)
{
const char *v3; // rax
int v5; // [rsp+18h] [rbp-948h]
int v6; // [rsp+1Ch] [rbp-944h]
long long v7; // [rsp+20h] [rbp-940h]
bool v8; // [rsp+2Fh] [rbp-931h]
_BYTE v10[1960]; // [rsp+48h] [rbp-918h] BYREF
long long v11; // [rsp+7F0h] [rbp-170h]
_BYTE v12[352]; // [rsp+7F8h] [rbp-168h] BYREF
unsigned long long v13; // [rsp+958h] [rbp-8h]
v13 = __readfsqword(0x28u);
my_charset_file_init(v10);
my_xml_parser_create(v12);
my_xml_set_enter_handler(v12, cs_enter);
my_xml_set_value_handler(v12, cs_value);
my_xml_set_leave_handler(v12, cs_leave);
v11 = a1;
my_xml_set_user_data(v12, v10);
v8 = (unsigned int)my_xml_parse(v12, a2, a3) != 0;
my_xml_parser_free(v12);
my_charset_file_free(v10);
if ( v8 )
{
v7 = my_xml_error_string(v12);
if ( (unsigned long long)(strlen(v7) + 32) < 0x80 )
{
v5 = my_xml_error_lineno(v12) + 1;
v6 = my_xml_error_pos(v12);
v3 = (const char *)my_xml_error_string(v12);
sprintf(a1, "at line %d pos %d: %s", v5, v6, v3);
}
}
return v8;
}
| my_parse_charset_xml:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x960
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x920],RDI
MOV qword ptr [RBP + -0x928],RSI
MOV qword ptr [RBP + -0x930],RDX
LEA RDI,[RBP + -0x918]
CALL 0x0016daa0
LEA RDI,[RBP + -0x168]
CALL 0x0017a0d0
LEA RDI,[RBP + -0x168]
LEA RSI,[0x16daf0]
CALL 0x0017a190
LEA RDI,[RBP + -0x168]
LEA RSI,[0x16dbe0]
CALL 0x0017a170
LEA RDI,[RBP + -0x168]
LEA RSI,[0x16e350]
CALL 0x0017a1b0
MOV RAX,qword ptr [RBP + -0x920]
MOV qword ptr [RBP + -0x170],RAX
LEA RDI,[RBP + -0x168]
LEA RSI,[RBP + -0x918]
CALL 0x0017a1d0
MOV RSI,qword ptr [RBP + -0x928]
MOV RDX,qword ptr [RBP + -0x930]
LEA RDI,[RBP + -0x168]
CALL 0x00178fa0
MOV EDX,EAX
MOV EAX,0x1
XOR ECX,ECX
CMP EDX,0x0
CMOVZ EAX,ECX
MOV byte ptr [RBP + -0x931],AL
LEA RDI,[RBP + -0x168]
CALL 0x0017a130
LEA RDI,[RBP + -0x918]
CALL 0x0016e660
MOVSX EAX,byte ptr [RBP + -0x931]
CMP EAX,0x0
JZ 0x0016da6d
LEA RDI,[RBP + -0x168]
CALL 0x0017a1f0
MOV qword ptr [RBP + -0x940],RAX
MOV RDI,qword ptr [RBP + -0x940]
CALL 0x00124120
MOV RCX,RAX
ADD RCX,0x20
MOV EAX,0x80
CMP RAX,RCX
JBE 0x0016da6b
MOV RAX,qword ptr [RBP + -0x920]
MOV qword ptr [RBP + -0x950],RAX
LEA RDI,[RBP + -0x168]
CALL 0x0017a280
ADD EAX,0x1
MOV dword ptr [RBP + -0x948],EAX
LEA RDI,[RBP + -0x168]
CALL 0x0017a210
MOV dword ptr [RBP + -0x944],EAX
LEA RDI,[RBP + -0x168]
CALL 0x0017a1f0
MOV RDI,qword ptr [RBP + -0x950]
MOV EDX,dword ptr [RBP + -0x948]
MOV ECX,dword ptr [RBP + -0x944]
MOV R8,RAX
LEA RSI,[0x17e029]
MOV AL,0x0
CALL 0x001240a0
LAB_0016da6b:
JMP 0x0016da6d
LAB_0016da6d:
MOV AL,byte ptr [RBP + -0x931]
MOV byte ptr [RBP + -0x951],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0016da9a
MOV AL,byte ptr [RBP + -0x951]
ADD RSP,0x960
POP RBP
RET
LAB_0016da9a:
CALL 0x001242b0
|
int8 my_parse_charset_xml(char *param_1,int8 param_2,int8 param_3)
{
int iVar1;
int iVar2;
uint uVar3;
char *__s;
size_t sVar4;
int8 uVar5;
long in_FS_OFFSET;
int1 local_920 [1960];
char *local_178;
int1 local_170 [352];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
my_charset_file_init(local_920);
my_xml_parser_create(local_170);
my_xml_set_enter_handler(local_170,cs_enter);
my_xml_set_value_handler(local_170,cs_value);
my_xml_set_leave_handler(local_170,cs_leave);
local_178 = param_1;
my_xml_set_user_data(local_170,local_920);
iVar1 = my_xml_parse(local_170,param_2,param_3);
my_xml_parser_free(local_170);
my_charset_file_free(local_920);
if (iVar1 != 0) {
__s = (char *)my_xml_error_string(local_170);
sVar4 = strlen(__s);
if (sVar4 + 0x20 < 0x80) {
iVar2 = my_xml_error_lineno(local_170);
uVar3 = my_xml_error_pos(local_170);
uVar5 = my_xml_error_string(local_170);
sprintf(param_1,"at line %d pos %d: %s",(ulong)(iVar2 + 1),(ulong)uVar3,uVar5);
}
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),iVar1 != 0);
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
44,816 | int fmt::v10::basic_format_args<fmt::v10::basic_format_context<fmt::v10::appender, char>>::get_id<char>(fmt::v10::basic_string_view<char>) const | AlayaLite/build_O0/_deps/spdlog-src/include/spdlog/fmt/bundled/core.h | auto get_id(basic_string_view<Char> name) const -> int {
if (!has_named_args()) return -1;
const auto& named_args =
(is_packed() ? values_[-1] : args_[-1].value_).named_args;
for (size_t i = 0; i < named_args.size; ++i) {
if (named_args.data[i].name == name) return named_args.data[i].id;
}
return -1;
} | O0 | c | int fmt::v10::basic_format_args<fmt::v10::basic_format_context<fmt::v10::appender, char>>::get_id<char>(fmt::v10::basic_string_view<char>) const:
subq $0x78, %rsp
movq %rsi, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xab3e0
testb $0x1, %al
jne 0xab2b3
movl $0xffffffff, 0x64(%rsp) # imm = 0xFFFFFFFF
jmp 0xab3c9
movq 0x10(%rsp), %rdi
callq 0x957e0
testb $0x1, %al
jne 0xab2c3
jmp 0xab2d7
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
addq $-0x10, %rax
movq %rax, 0x8(%rsp)
jmp 0xab2e9
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
addq $-0x20, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq $0x0, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xab3c1
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq 0x38(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
leaq 0x28(%rsp), %rcx
movq %rcx, 0x70(%rsp)
movq %rax, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, (%rsp)
movq 0x68(%rsp), %rcx
movq %rcx, (%rax)
movq 0x68(%rsp), %rdi
callq 0x16290
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0x49760
testb $0x1, %al
jne 0xab38f
jmp 0xab3ac
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq 0x38(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, 0x64(%rsp)
jmp 0xab3c9
jmp 0xab3ae
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0xab2fc
movl $0xffffffff, 0x64(%rsp) # imm = 0xFFFFFFFF
movl 0x64(%rsp), %eax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| _ZNK3fmt3v1017basic_format_argsINS0_20basic_format_contextINS0_8appenderEcEEE6get_idIcEEiNS0_17basic_string_viewIT_EE:
sub rsp, 78h
mov [rsp+78h+var_28], rsi
mov [rsp+78h+var_20], rdx
mov [rsp+78h+var_30], rdi
mov rdi, [rsp+78h+var_30]
mov [rsp+78h+var_68], rdi
call _ZNK3fmt3v1017basic_format_argsINS0_20basic_format_contextINS0_8appenderEcEEE14has_named_argsEv; fmt::v10::basic_format_args<fmt::v10::basic_format_context<fmt::v10::appender,char>>::has_named_args(void)
test al, 1
jnz short loc_AB2B3
mov [rsp+78h+var_14], 0FFFFFFFFh
jmp loc_AB3C9
loc_AB2B3:
mov rdi, [rsp+78h+var_68]
call _ZNK3fmt3v1017basic_format_argsINS0_20basic_format_contextINS0_8appenderEcEEE9is_packedEv; fmt::v10::basic_format_args<fmt::v10::basic_format_context<fmt::v10::appender,char>>::is_packed(void)
test al, 1
jnz short loc_AB2C3
jmp short loc_AB2D7
loc_AB2C3:
mov rax, [rsp+78h+var_68]
mov rax, [rax+8]
add rax, 0FFFFFFFFFFFFFFF0h
mov [rsp+78h+var_70], rax
jmp short loc_AB2E9
loc_AB2D7:
mov rax, [rsp+78h+var_68]
mov rax, [rax+8]
add rax, 0FFFFFFFFFFFFFFE0h
mov [rsp+78h+var_70], rax
loc_AB2E9:
mov rax, [rsp+78h+var_70]
mov [rsp+78h+var_38], rax
mov [rsp+78h+var_40], 0
loc_AB2FC:
mov rax, [rsp+78h+var_40]
mov rcx, [rsp+78h+var_38]
cmp rax, [rcx+8]
jnb loc_AB3C1
mov rax, [rsp+78h+var_38]
mov rax, [rax]
mov rcx, [rsp+78h+var_40]
shl rcx, 4
add rax, rcx
mov rax, [rax]
lea rcx, [rsp+78h+var_50]
mov [rsp+78h+var_8], rcx
mov [rsp+78h+var_10], rax
mov rax, [rsp+78h+var_8]
mov [rsp+78h+var_78], rax
mov rcx, [rsp+78h+var_10]
mov [rax], rcx
mov rdi, [rsp+78h+var_10]
call _strlen
mov rcx, rax
mov rax, [rsp+78h+var_78]
mov [rax+8], rcx
mov rax, [rsp+78h+var_28]
mov [rsp+78h+var_60], rax
mov rax, [rsp+78h+var_20]
mov [rsp+78h+var_58], rax
mov rdi, [rsp+78h+var_50]
mov rsi, [rsp+78h+var_48]
mov rdx, [rsp+78h+var_60]
mov rcx, [rsp+78h+var_58]
call _ZN3fmt3v10eqENS0_17basic_string_viewIcEES2_; fmt::v10::operator==(fmt::v10::basic_string_view<char>,fmt::v10::basic_string_view<char>)
test al, 1
jnz short loc_AB38F
jmp short loc_AB3AC
loc_AB38F:
mov rax, [rsp+78h+var_38]
mov rax, [rax]
mov rcx, [rsp+78h+var_40]
shl rcx, 4
add rax, rcx
mov eax, [rax+8]
mov [rsp+78h+var_14], eax
jmp short loc_AB3C9
loc_AB3AC:
jmp short $+2
loc_AB3AE:
mov rax, [rsp+78h+var_40]
add rax, 1
mov [rsp+78h+var_40], rax
jmp loc_AB2FC
loc_AB3C1:
mov [rsp+78h+var_14], 0FFFFFFFFh
loc_AB3C9:
mov eax, [rsp+78h+var_14]
add rsp, 78h
retn
| long long fmt::v10::basic_format_args<fmt::v10::basic_format_context<fmt::v10::appender,char>>::get_id<char>(
_QWORD *a1,
long long a2,
long long a3)
{
long long v3; // rax
long long v5; // [rsp+8h] [rbp-70h]
long long v6; // [rsp+28h] [rbp-50h] BYREF
long long v7; // [rsp+30h] [rbp-48h]
unsigned long long i; // [rsp+38h] [rbp-40h]
_QWORD *v9; // [rsp+40h] [rbp-38h]
_QWORD *v10; // [rsp+48h] [rbp-30h]
long long v11; // [rsp+50h] [rbp-28h]
long long v12; // [rsp+58h] [rbp-20h]
long long v14; // [rsp+68h] [rbp-10h]
long long *v15; // [rsp+70h] [rbp-8h]
v11 = a2;
v12 = a3;
v10 = a1;
if ( (fmt::v10::basic_format_args<fmt::v10::basic_format_context<fmt::v10::appender,char>>::has_named_args() & 1) != 0 )
{
if ( fmt::v10::basic_format_args<fmt::v10::basic_format_context<fmt::v10::appender,char>>::is_packed(a1) )
v5 = a1[1] - 16LL;
else
v5 = a1[1] - 32LL;
v9 = (_QWORD *)v5;
for ( i = 0LL; i < v9[1]; ++i )
{
v3 = *(_QWORD *)(16 * i + *v9);
v15 = &v6;
v14 = v3;
v6 = v3;
v7 = strlen(v3);
if ( fmt::v10::operator==(v6, v7, v11, v12) )
return *(unsigned int *)(16 * i + *v9 + 8);
}
return (unsigned int)-1;
}
else
{
return (unsigned int)-1;
}
}
| get_id<char>:
SUB RSP,0x78
MOV qword ptr [RSP + 0x50],RSI
MOV qword ptr [RSP + 0x58],RDX
MOV qword ptr [RSP + 0x48],RDI
MOV RDI,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x10],RDI
CALL 0x001ab3e0
TEST AL,0x1
JNZ 0x001ab2b3
MOV dword ptr [RSP + 0x64],0xffffffff
JMP 0x001ab3c9
LAB_001ab2b3:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x001957e0
TEST AL,0x1
JNZ 0x001ab2c3
JMP 0x001ab2d7
LAB_001ab2c3:
MOV RAX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RAX + 0x8]
ADD RAX,-0x10
MOV qword ptr [RSP + 0x8],RAX
JMP 0x001ab2e9
LAB_001ab2d7:
MOV RAX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RAX + 0x8]
ADD RAX,-0x20
MOV qword ptr [RSP + 0x8],RAX
LAB_001ab2e9:
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x38],0x0
LAB_001ab2fc:
MOV RAX,qword ptr [RSP + 0x38]
MOV RCX,qword ptr [RSP + 0x40]
CMP RAX,qword ptr [RCX + 0x8]
JNC 0x001ab3c1
MOV RAX,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RSP + 0x38]
SHL RCX,0x4
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
LEA RCX,[RSP + 0x28]
MOV qword ptr [RSP + 0x70],RCX
MOV qword ptr [RSP + 0x68],RAX
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RSP],RAX
MOV RCX,qword ptr [RSP + 0x68]
MOV qword ptr [RAX],RCX
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x00116290
MOV RCX,RAX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x20],RAX
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP + 0x20]
CALL 0x00149760
TEST AL,0x1
JNZ 0x001ab38f
JMP 0x001ab3ac
LAB_001ab38f:
MOV RAX,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RSP + 0x38]
SHL RCX,0x4
ADD RAX,RCX
MOV EAX,dword ptr [RAX + 0x8]
MOV dword ptr [RSP + 0x64],EAX
JMP 0x001ab3c9
LAB_001ab3ac:
JMP 0x001ab3ae
LAB_001ab3ae:
MOV RAX,qword ptr [RSP + 0x38]
ADD RAX,0x1
MOV qword ptr [RSP + 0x38],RAX
JMP 0x001ab2fc
LAB_001ab3c1:
MOV dword ptr [RSP + 0x64],0xffffffff
LAB_001ab3c9:
MOV EAX,dword ptr [RSP + 0x64]
ADD RSP,0x78
RET
|
/* int fmt::v10::basic_format_args<fmt::v10::basic_format_context<fmt::v10::appender, char>
>::get_id<char>(fmt::v10::basic_string_view<char>) const */
int fmt::v10::basic_format_args<fmt::v10::basic_format_context<fmt::v10::appender,char>>::
get_id<char>(basic_format_args<fmt::v10::basic_format_context<fmt::v10::appender,char>> *param_1
,int8 param_2,int8 param_3)
{
ulong uVar1;
size_t sVar2;
long *local_70;
char *local_50 [2];
ulong local_40;
long *local_38;
basic_format_args<fmt::v10::basic_format_context<fmt::v10::appender,char>> *local_30;
int8 local_28;
int8 local_20;
char *local_10;
char **local_8;
local_30 = param_1;
local_28 = param_2;
local_20 = param_3;
uVar1 = has_named_args(param_1);
if ((uVar1 & 1) != 0) {
uVar1 = is_packed(param_1);
if ((uVar1 & 1) == 0) {
local_70 = (long *)(*(long *)(param_1 + 8) + -0x20);
}
else {
local_70 = (long *)(*(long *)(param_1 + 8) + -0x10);
}
local_38 = local_70;
for (local_40 = 0; local_40 < (ulong)local_38[1]; local_40 = local_40 + 1) {
local_50[0] = *(char **)(*local_38 + local_40 * 0x10);
local_8 = local_50;
local_10 = local_50[0];
sVar2 = strlen(local_50[0]);
uVar1 = v10::operator==(local_50[0],sVar2,local_28,local_20);
if ((uVar1 & 1) != 0) {
return *(int *)(*local_38 + local_40 * 0x10 + 8);
}
}
}
return -1;
}
| |
44,817 | handle_posted_message | bluesky950520[P]quickjs/quickjs-libc.c | static int handle_posted_message(JSRuntime *rt, JSContext *ctx,
JSWorkerMessageHandler *port)
{
JSWorkerMessagePipe *ps = port->recv_pipe;
int ret;
struct list_head *el;
JSWorkerMessage *msg;
JSValue obj, data_obj, func, retval;
pthread_mutex_lock(&ps->mutex);
if (!list_empty(&ps->msg_queue)) {
el = ps->msg_queue.next;
msg = list_entry(el, JSWorkerMessage, link);
/* remove the message from the queue */
list_del(&msg->link);
if (list_empty(&ps->msg_queue)) {
uint8_t buf[16];
int ret;
for(;;) {
ret = read(ps->read_fd, buf, sizeof(buf));
if (ret >= 0)
break;
if (errno != EAGAIN && errno != EINTR)
break;
}
}
pthread_mutex_unlock(&ps->mutex);
data_obj = JS_ReadObject(ctx, msg->data, msg->data_len,
JS_READ_OBJ_SAB | JS_READ_OBJ_REFERENCE);
js_free_message(msg);
if (JS_IsException(data_obj))
goto fail;
obj = JS_NewObject(ctx);
if (JS_IsException(obj)) {
JS_FreeValue(ctx, data_obj);
goto fail;
}
JS_DefinePropertyValueStr(ctx, obj, "data", data_obj, JS_PROP_C_W_E);
/* 'func' might be destroyed when calling itself (if it frees the
handler), so must take extra care */
func = JS_DupValue(ctx, port->on_message_func);
retval = JS_Call(ctx, func, JS_UNDEFINED, 1, &obj);
JS_FreeValue(ctx, obj);
JS_FreeValue(ctx, func);
if (JS_IsException(retval)) {
fail:
js_std_dump_error(ctx);
} else {
JS_FreeValue(ctx, retval);
}
ret = 1;
} else {
pthread_mutex_unlock(&ps->mutex);
ret = 0;
}
return ret;
} | O0 | c | handle_posted_message:
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq 0xd0(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0xc8(%rsp)
movq 0xc8(%rsp), %rdi
addq $0x8, %rdi
callq 0xe950
movq 0xc8(%rsp), %rdi
addq $0x30, %rdi
callq 0x16440
cmpl $0x0, %eax
jne 0x1cb67
movq 0xc8(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0xb8(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rdi
callq 0x15d90
movq 0xc8(%rsp), %rdi
addq $0x30, %rdi
callq 0x16440
cmpl $0x0, %eax
je 0x1c908
jmp 0x1c8c7
movq 0xc8(%rsp), %rax
movl 0x40(%rax), %edi
leaq 0x60(%rsp), %rsi
movl $0x10, %edx
callq 0xe460
movl %eax, 0x5c(%rsp)
cmpl $0x0, 0x5c(%rsp)
jl 0x1c8ee
jmp 0x1c906
callq 0xe0b0
cmpl $0xb, (%rax)
je 0x1c904
callq 0xe0b0
cmpl $0x4, (%rax)
je 0x1c904
jmp 0x1c906
jmp 0x1c8c7
jmp 0x1c908
movq 0xc8(%rsp), %rdi
addq $0x8, %rdi
callq 0xe640
movq 0xd8(%rsp), %rdi
movq 0xb0(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0xb0(%rsp), %rax
movq 0x18(%rax), %rdx
movl $0xc, %ecx
callq 0x4b7f0
movq %rax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0xb0(%rsp), %rdi
callq 0x1c440
movq 0x90(%rsp), %rdi
movq 0x98(%rsp), %rsi
callq 0xf0d0
cmpl $0x0, %eax
je 0x1c993
jmp 0x1cb34
movq 0xd8(%rsp), %rdi
callq 0x292b0
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0xa0(%rsp), %rdi
movq 0xa8(%rsp), %rsi
callq 0xf0d0
cmpl $0x0, %eax
je 0x1ca00
movq 0xd8(%rsp), %rdi
movq 0x90(%rsp), %rsi
movq 0x98(%rsp), %rdx
callq 0x229d0
jmp 0x1cb34
movq 0xd8(%rsp), %rdi
movq 0xa0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
movq 0x90(%rsp), %r8
movq 0x98(%rsp), %r9
leaq 0xec0ba(%rip), %rcx # 0x108ae9
movl $0x7, (%rsp)
callq 0x36220
movq 0xd8(%rsp), %rdi
movq 0xd0(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x20(%rax), %rdx
callq 0x203d0
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0xd8(%rsp), %rdi
movl $0x0, 0x8(%rsp)
movq $0x3, 0x10(%rsp)
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %r8
movl $0x1, %r9d
leaq 0xa0(%rsp), %rax
movq %rax, (%rsp)
callq 0x38d90
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0xd8(%rsp), %rdi
movq 0xa0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
callq 0x229d0
movq 0xd8(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rdx
callq 0x229d0
movq 0x70(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0xf0d0
cmpl $0x0, %eax
je 0x1cb43
jmp 0x1cb34
movq 0xd8(%rsp), %rdi
callq 0x10690
jmp 0x1cb5a
movq 0xd8(%rsp), %rdi
movq 0x70(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0x229d0
movl $0x1, 0xc4(%rsp)
jmp 0x1cb83
movq 0xc8(%rsp), %rdi
addq $0x8, %rdi
callq 0xe640
movl $0x0, 0xc4(%rsp)
movl 0xc4(%rsp), %eax
addq $0xe8, %rsp
retq
nopw %cs:(%rax,%rax)
| handle_posted_message:
sub rsp, 0E8h
mov [rsp+0E8h+var_8], rdi
mov [rsp+0E8h+var_10], rsi
mov [rsp+0E8h+var_18], rdx
mov rax, [rsp+0E8h+var_18]
mov rax, [rax+10h]
mov [rsp+0E8h+var_20], rax
mov rdi, [rsp+0E8h+var_20]
add rdi, 8
call _pthread_mutex_lock
mov rdi, [rsp+0E8h+var_20]
add rdi, 30h ; '0'
call list_empty
cmp eax, 0
jnz loc_1CB67
mov rax, [rsp+0E8h+var_20]
mov rax, [rax+38h]
mov [rsp+0E8h+var_30], rax
mov rax, [rsp+0E8h+var_30]
mov [rsp+0E8h+var_38], rax
mov rdi, [rsp+0E8h+var_38]
call list_del
mov rdi, [rsp+0E8h+var_20]
add rdi, 30h ; '0'
call list_empty
cmp eax, 0
jz short loc_1C908
jmp short $+2
loc_1C8C7:
mov rax, [rsp+0E8h+var_20]
mov edi, [rax+40h]
lea rsi, [rsp+0E8h+var_88]
mov edx, 10h
call _read
mov [rsp+0E8h+var_8C], eax
cmp [rsp+0E8h+var_8C], 0
jl short loc_1C8EE
jmp short loc_1C906
loc_1C8EE:
call ___errno_location
cmp dword ptr [rax], 0Bh
jz short loc_1C904
call ___errno_location
cmp dword ptr [rax], 4
jz short loc_1C904
jmp short loc_1C906
loc_1C904:
jmp short loc_1C8C7
loc_1C906:
jmp short $+2
loc_1C908:
mov rdi, [rsp+0E8h+var_20]
add rdi, 8
call _pthread_mutex_unlock
mov rdi, [rsp+0E8h+var_10]
mov rax, [rsp+0E8h+var_38]
mov rsi, [rax+10h]
mov rax, [rsp+0E8h+var_38]
mov rdx, [rax+18h]
mov ecx, 0Ch
call JS_ReadObject
mov [rsp+0E8h+var_A0], rax
mov [rsp+0E8h+var_98], rdx
mov rax, [rsp+0E8h+var_A0]
mov [rsp+0E8h+var_58], rax
mov rax, [rsp+0E8h+var_98]
mov [rsp+0E8h+var_50], rax
mov rdi, [rsp+0E8h+var_38]
call js_free_message
mov rdi, [rsp+0E8h+var_58]
mov rsi, [rsp+0E8h+var_50]
call JS_IsException_0
cmp eax, 0
jz short loc_1C993
jmp loc_1CB34
loc_1C993:
mov rdi, [rsp+0E8h+var_10]
call JS_NewObject
mov [rsp+0E8h+var_B0], rax
mov [rsp+0E8h+var_A8], rdx
mov rax, [rsp+0E8h+var_B0]
mov [rsp+0E8h+var_48], rax
mov rax, [rsp+0E8h+var_A8]
mov [rsp+0E8h+var_40], rax
mov rdi, [rsp+0E8h+var_48]
mov rsi, [rsp+0E8h+var_40]
call JS_IsException_0
cmp eax, 0
jz short loc_1CA00
mov rdi, [rsp+0E8h+var_10]
mov rsi, [rsp+0E8h+var_58]
mov rdx, [rsp+0E8h+var_50]
call JS_FreeValue
jmp loc_1CB34
loc_1CA00:
mov rdi, [rsp+0E8h+var_10]
mov rsi, [rsp+0E8h+var_48]
mov rdx, [rsp+0E8h+var_40]
mov r8, [rsp+0E8h+var_58]
mov r9, [rsp+0E8h+var_50]
lea rcx, aData; "data"
mov dword ptr [rsp+0E8h+var_E8], 7
call JS_DefinePropertyValueStr
mov rdi, [rsp+0E8h+var_10]
mov rax, [rsp+0E8h+var_18]
mov rsi, [rax+18h]
mov rdx, [rax+20h]
call JS_DupValue
mov [rsp+0E8h+var_C0], rax
mov [rsp+0E8h+var_B8], rdx
mov rax, [rsp+0E8h+var_C0]
mov [rsp+0E8h+var_68], rax
mov rax, [rsp+0E8h+var_B8]
mov [rsp+0E8h+var_60], rax
mov rdi, [rsp+0E8h+var_10]
mov dword ptr [rsp+0E8h+var_E0], 0
mov [rsp+0E8h+var_D8], 3
mov rsi, [rsp+0E8h+var_68]
mov rdx, [rsp+0E8h+var_60]
mov rcx, [rsp+0E8h+var_E0]
mov r8, [rsp+0E8h+var_D8]
mov r9d, 1
lea rax, [rsp+0E8h+var_48]
mov [rsp+0E8h+var_E8], rax
call JS_Call
mov [rsp+0E8h+var_D0], rax
mov [rsp+0E8h+var_C8], rdx
mov rax, [rsp+0E8h+var_D0]
mov [rsp+0E8h+var_78], rax
mov rax, [rsp+0E8h+var_C8]
mov [rsp+0E8h+var_70], rax
mov rdi, [rsp+0E8h+var_10]
mov rsi, [rsp+0E8h+var_48]
mov rdx, [rsp+0E8h+var_40]
call JS_FreeValue
mov rdi, [rsp+0E8h+var_10]
mov rsi, [rsp+0E8h+var_68]
mov rdx, [rsp+0E8h+var_60]
call JS_FreeValue
mov rdi, [rsp+0E8h+var_78]
mov rsi, [rsp+0E8h+var_70]
call JS_IsException_0
cmp eax, 0
jz short loc_1CB43
jmp short $+2
loc_1CB34:
mov rdi, [rsp+0E8h+var_10]
call js_std_dump_error
jmp short loc_1CB5A
loc_1CB43:
mov rdi, [rsp+0E8h+var_10]
mov rsi, [rsp+0E8h+var_78]
mov rdx, [rsp+0E8h+var_70]
call JS_FreeValue
loc_1CB5A:
mov [rsp+0E8h+var_24], 1
jmp short loc_1CB83
loc_1CB67:
mov rdi, [rsp+0E8h+var_20]
add rdi, 8
call _pthread_mutex_unlock
mov [rsp+0E8h+var_24], 0
loc_1CB83:
mov eax, [rsp+0E8h+var_24]
add rsp, 0E8h
retn
| long long handle_posted_message(long long a1, long long a2, long long a3)
{
long long v3; // rdx
long long v4; // rdx
long long v5; // rdx
long long v6; // rdx
_BYTE v8[16]; // [rsp+60h] [rbp-88h] BYREF
long long v9; // [rsp+70h] [rbp-78h]
long long v10; // [rsp+78h] [rbp-70h]
long long v11; // [rsp+80h] [rbp-68h]
long long v12; // [rsp+88h] [rbp-60h]
long long Object; // [rsp+90h] [rbp-58h]
long long v14; // [rsp+98h] [rbp-50h]
long long v15; // [rsp+A0h] [rbp-48h] BYREF
long long v16; // [rsp+A8h] [rbp-40h]
_QWORD *v17; // [rsp+B0h] [rbp-38h]
_QWORD *v18; // [rsp+B8h] [rbp-30h]
long long v20; // [rsp+C8h] [rbp-20h]
long long v21; // [rsp+D0h] [rbp-18h]
long long v22; // [rsp+D8h] [rbp-10h]
long long v23; // [rsp+E0h] [rbp-8h]
v23 = a1;
v22 = a2;
v21 = a3;
v20 = *(_QWORD *)(a3 + 16);
pthread_mutex_lock(v20 + 8);
if ( list_empty(v20 + 48) )
{
pthread_mutex_unlock(v20 + 8);
return 0;
}
v18 = *(_QWORD **)(v20 + 56);
v17 = v18;
list_del(v18);
if ( list_empty(v20 + 48) )
{
while ( (int)read(*(unsigned int *)(v20 + 64), v8, 16LL) < 0
&& (*(_DWORD *)__errno_location() == 11 || *(_DWORD *)__errno_location() == 4) )
;
}
pthread_mutex_unlock(v20 + 8);
Object = JS_ReadObject(v22, v17[2], v17[3], 12LL);
v14 = v3;
js_free_message(v17);
if ( !JS_IsException_0(Object, v14) )
{
v15 = JS_NewObject(v22);
v16 = v4;
if ( JS_IsException_0(v15, v4) )
{
JS_FreeValue(v22, Object, v14);
}
else
{
JS_DefinePropertyValueStr(v22, v15, v16, (unsigned int)"data", Object, v14, 7);
v11 = JS_DupValue(v22, *(_QWORD *)(v21 + 24), *(_QWORD *)(v21 + 32));
v12 = v5;
v9 = JS_Call(v22, v11, v5, 0, 3, 1, (long long)&v15);
v10 = v6;
JS_FreeValue(v22, v15, v16);
JS_FreeValue(v22, v11, v12);
if ( !JS_IsException_0(v9, v10) )
{
JS_FreeValue(v22, v9, v10);
return 1;
}
}
}
js_std_dump_error(v22);
return 1;
}
| handle_posted_message:
SUB RSP,0xe8
MOV qword ptr [RSP + 0xe0],RDI
MOV qword ptr [RSP + 0xd8],RSI
MOV qword ptr [RSP + 0xd0],RDX
MOV RAX,qword ptr [RSP + 0xd0]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0xc8],RAX
MOV RDI,qword ptr [RSP + 0xc8]
ADD RDI,0x8
CALL 0x0010e950
MOV RDI,qword ptr [RSP + 0xc8]
ADD RDI,0x30
CALL 0x00116440
CMP EAX,0x0
JNZ 0x0011cb67
MOV RAX,qword ptr [RSP + 0xc8]
MOV RAX,qword ptr [RAX + 0x38]
MOV qword ptr [RSP + 0xb8],RAX
MOV RAX,qword ptr [RSP + 0xb8]
MOV qword ptr [RSP + 0xb0],RAX
MOV RDI,qword ptr [RSP + 0xb0]
CALL 0x00115d90
MOV RDI,qword ptr [RSP + 0xc8]
ADD RDI,0x30
CALL 0x00116440
CMP EAX,0x0
JZ 0x0011c908
JMP 0x0011c8c7
LAB_0011c8c7:
MOV RAX,qword ptr [RSP + 0xc8]
MOV EDI,dword ptr [RAX + 0x40]
LEA RSI,[RSP + 0x60]
MOV EDX,0x10
CALL 0x0010e460
MOV dword ptr [RSP + 0x5c],EAX
CMP dword ptr [RSP + 0x5c],0x0
JL 0x0011c8ee
JMP 0x0011c906
LAB_0011c8ee:
CALL 0x0010e0b0
CMP dword ptr [RAX],0xb
JZ 0x0011c904
CALL 0x0010e0b0
CMP dword ptr [RAX],0x4
JZ 0x0011c904
JMP 0x0011c906
LAB_0011c904:
JMP 0x0011c8c7
LAB_0011c906:
JMP 0x0011c908
LAB_0011c908:
MOV RDI,qword ptr [RSP + 0xc8]
ADD RDI,0x8
CALL 0x0010e640
MOV RDI,qword ptr [RSP + 0xd8]
MOV RAX,qword ptr [RSP + 0xb0]
MOV RSI,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RSP + 0xb0]
MOV RDX,qword ptr [RAX + 0x18]
MOV ECX,0xc
CALL 0x0014b7f0
MOV qword ptr [RSP + 0x48],RAX
MOV qword ptr [RSP + 0x50],RDX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x90],RAX
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x98],RAX
MOV RDI,qword ptr [RSP + 0xb0]
CALL 0x0011c440
MOV RDI,qword ptr [RSP + 0x90]
MOV RSI,qword ptr [RSP + 0x98]
CALL 0x0010f0d0
CMP EAX,0x0
JZ 0x0011c993
JMP 0x0011cb34
LAB_0011c993:
MOV RDI,qword ptr [RSP + 0xd8]
CALL 0x001292b0
MOV qword ptr [RSP + 0x38],RAX
MOV qword ptr [RSP + 0x40],RDX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0xa0],RAX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0xa8],RAX
MOV RDI,qword ptr [RSP + 0xa0]
MOV RSI,qword ptr [RSP + 0xa8]
CALL 0x0010f0d0
CMP EAX,0x0
JZ 0x0011ca00
MOV RDI,qword ptr [RSP + 0xd8]
MOV RSI,qword ptr [RSP + 0x90]
MOV RDX,qword ptr [RSP + 0x98]
CALL 0x001229d0
JMP 0x0011cb34
LAB_0011ca00:
MOV RDI,qword ptr [RSP + 0xd8]
MOV RSI,qword ptr [RSP + 0xa0]
MOV RDX,qword ptr [RSP + 0xa8]
MOV R8,qword ptr [RSP + 0x90]
MOV R9,qword ptr [RSP + 0x98]
LEA RCX,[0x208ae9]
MOV dword ptr [RSP],0x7
CALL 0x00136220
MOV RDI,qword ptr [RSP + 0xd8]
MOV RAX,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RAX + 0x18]
MOV RDX,qword ptr [RAX + 0x20]
CALL 0x001203d0
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x30],RDX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x80],RAX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x88],RAX
MOV RDI,qword ptr [RSP + 0xd8]
MOV dword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP + 0x10],0x3
MOV RSI,qword ptr [RSP + 0x80]
MOV RDX,qword ptr [RSP + 0x88]
MOV RCX,qword ptr [RSP + 0x8]
MOV R8,qword ptr [RSP + 0x10]
MOV R9D,0x1
LEA RAX,[RSP + 0xa0]
MOV qword ptr [RSP],RAX
CALL 0x00138d90
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x20],RDX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x70],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x78],RAX
MOV RDI,qword ptr [RSP + 0xd8]
MOV RSI,qword ptr [RSP + 0xa0]
MOV RDX,qword ptr [RSP + 0xa8]
CALL 0x001229d0
MOV RDI,qword ptr [RSP + 0xd8]
MOV RSI,qword ptr [RSP + 0x80]
MOV RDX,qword ptr [RSP + 0x88]
CALL 0x001229d0
MOV RDI,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RSP + 0x78]
CALL 0x0010f0d0
CMP EAX,0x0
JZ 0x0011cb43
JMP 0x0011cb34
LAB_0011cb34:
MOV RDI,qword ptr [RSP + 0xd8]
CALL 0x00110690
JMP 0x0011cb5a
LAB_0011cb43:
MOV RDI,qword ptr [RSP + 0xd8]
MOV RSI,qword ptr [RSP + 0x70]
MOV RDX,qword ptr [RSP + 0x78]
CALL 0x001229d0
LAB_0011cb5a:
MOV dword ptr [RSP + 0xc4],0x1
JMP 0x0011cb83
LAB_0011cb67:
MOV RDI,qword ptr [RSP + 0xc8]
ADD RDI,0x8
CALL 0x0010e640
MOV dword ptr [RSP + 0xc4],0x0
LAB_0011cb83:
MOV EAX,dword ptr [RSP + 0xc4]
ADD RSP,0xe8
RET
|
int4 handle_posted_message(int8 param_1,int8 param_2,long param_3)
{
int iVar1;
ssize_t sVar2;
int *piVar3;
int8 in_stack_ffffffffffffff18;
int4 uVar4;
uint uStack_dc;
int1 local_88 [16];
int1 local_78 [16];
int1 local_68 [16];
int1 local_58 [16];
int1 local_48 [16];
long local_38;
long local_30;
long local_20;
long local_18;
int8 local_10;
int8 local_8;
local_20 = *(long *)(param_3 + 0x10);
local_18 = param_3;
local_10 = param_2;
local_8 = param_1;
pthread_mutex_lock((pthread_mutex_t *)(local_20 + 8));
iVar1 = list_empty(local_20 + 0x30);
if (iVar1 != 0) {
pthread_mutex_unlock((pthread_mutex_t *)(local_20 + 8));
return 0;
}
local_38 = *(long *)(local_20 + 0x38);
local_30 = local_38;
list_del(local_38);
iVar1 = list_empty(local_20 + 0x30);
uVar4 = (int4)((ulong)in_stack_ffffffffffffff18 >> 0x20);
if (iVar1 != 0) {
do {
do {
sVar2 = read(*(int *)(local_20 + 0x40),local_88,0x10);
uVar4 = (int4)((ulong)in_stack_ffffffffffffff18 >> 0x20);
if (-1 < (int)sVar2) goto LAB_0011c908;
piVar3 = __errno_location();
} while (*piVar3 == 0xb);
piVar3 = __errno_location();
uVar4 = (int4)((ulong)in_stack_ffffffffffffff18 >> 0x20);
} while (*piVar3 == 4);
}
LAB_0011c908:
pthread_mutex_unlock((pthread_mutex_t *)(local_20 + 8));
local_58 = JS_ReadObject(local_10,*(int8 *)(local_38 + 0x10),
*(int8 *)(local_38 + 0x18),0xc);
js_free_message(local_38);
iVar1 = JS_IsException(local_58._0_8_,local_58._8_8_);
if (iVar1 == 0) {
local_48 = JS_NewObject(local_10);
iVar1 = JS_IsException(local_48._0_8_,local_48._8_8_);
if (iVar1 == 0) {
JS_DefinePropertyValueStr
(local_10,local_48._0_8_,local_48._8_8_,&DAT_00208ae9,local_58._0_8_,local_58._8_8_,
CONCAT44(uVar4,7));
local_68 = JS_DupValue(local_10,*(int8 *)(local_18 + 0x18),
*(int8 *)(local_18 + 0x20));
local_78 = JS_Call(local_10,local_68._0_8_,local_68._8_8_,(ulong)uStack_dc << 0x20,3,1,
local_48);
JS_FreeValue(local_10,local_48._0_8_,local_48._8_8_);
JS_FreeValue(local_10,local_68._0_8_,local_68._8_8_);
iVar1 = JS_IsException(local_78._0_8_,local_78._8_8_);
if (iVar1 == 0) {
JS_FreeValue(local_10,local_78._0_8_,local_78._8_8_);
return 1;
}
}
else {
JS_FreeValue(local_10,local_58._0_8_,local_58._8_8_);
}
}
js_std_dump_error(local_10);
return 1;
}
| |
44,818 | common_chat_templates_from_model(llama_model const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/common.cpp | common_chat_templates common_chat_templates_from_model(const struct llama_model * model, const std::string & chat_template_override)
{
auto vocab = llama_model_get_vocab(model);
std::string default_template_src = chat_template_override;
std::string template_tool_use_src = chat_template_override;
bool has_explicit_template = !chat_template_override.empty();
if (chat_template_override.empty()) {
auto str = llama_model_chat_template(model, /* name */ nullptr);
if (str) {
default_template_src = str;
has_explicit_template = true;
}
str = llama_model_chat_template(model, /* name */ "tool_use");
if (str) {
template_tool_use_src = str;
has_explicit_template = true;
}
}
if (default_template_src.empty() || default_template_src == "chatml") {
if (!template_tool_use_src.empty()) {
default_template_src = template_tool_use_src;
} else {
default_template_src = R"(
{%- for message in messages -%}
{{- "<|im_start|>" + message.role + "\n" + message.content + "<|im_end|>\n" -}}
{%- endfor -%}
{%- if add_generation_prompt -%}
{{- "<|im_start|>assistant\n" -}}
{%- endif -%}
)";
}
}
const auto get_token = [&](llama_token token, const char * name, const char * jinja_variable_name) {
if (token == LLAMA_TOKEN_NULL) {
if (default_template_src.find(jinja_variable_name) != std::string::npos
|| template_tool_use_src.find(jinja_variable_name) != std::string::npos) {
LOG_WRN("%s: warning: vocab does not have a %s token, jinja template won't work as intended.\n", __func__, name);
}
return std::string();
} else {
return common_token_to_piece(vocab, token, true);
}
};
auto token_bos = get_token(llama_vocab_bos(vocab), "BOS", "bos_token");
auto token_eos = get_token(llama_vocab_eos(vocab), "EOS", "eos_token");
return {
has_explicit_template,
std::make_unique<minja::chat_template>(default_template_src, token_bos, token_eos),
template_tool_use_src.empty()
? nullptr
: std::make_unique<minja::chat_template>(template_tool_use_src, token_bos, token_eos)
};
} | O0 | cpp | common_chat_templates_from_model(llama_model const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
subq $0x118, %rsp # imm = 0x118
movq %rdi, 0x38(%rsp)
movq %rdi, %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0x110(%rsp)
movq %rsi, 0x108(%rsp)
movq %rdx, 0x100(%rsp)
movq 0x108(%rsp), %rdi
callq 0x5b2c0
movq %rax, 0xf8(%rsp)
movq 0x100(%rsp), %rsi
leaq 0xd8(%rsp), %rdi
callq 0x5a1f0
movq 0x100(%rsp), %rsi
leaq 0xb8(%rsp), %rdi
callq 0x5a1f0
jmp 0xf6a6d
movq 0x100(%rsp), %rdi
callq 0x5a4e0
xorb $-0x1, %al
andb $0x1, %al
movb %al, 0xab(%rsp)
movq 0x100(%rsp), %rdi
callq 0x5a4e0
testb $0x1, %al
jne 0xf6a9b
jmp 0xf6b72
movq 0x108(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5ae20
movq %rax, 0x30(%rsp)
jmp 0xf6ab3
movq 0x30(%rsp), %rax
movq %rax, 0xa0(%rsp)
cmpq $0x0, 0xa0(%rsp)
je 0xf6b1e
movq 0xa0(%rsp), %rsi
leaq 0xd8(%rsp), %rdi
callq 0x5a6f0
jmp 0xf6ae2
movb $0x1, 0xab(%rsp)
jmp 0xf6b1e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0xf6db6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0xf6da9
movq 0x108(%rsp), %rdi
leaq 0x11d820(%rip), %rsi # 0x21434d
callq 0x5ae20
movq %rax, 0x28(%rsp)
jmp 0xf6b39
movq 0x28(%rsp), %rax
movq %rax, 0xa0(%rsp)
cmpq $0x0, 0xa0(%rsp)
je 0xf6b70
movq 0xa0(%rsp), %rsi
leaq 0xb8(%rsp), %rdi
callq 0x5a6f0
jmp 0xf6b68
movb $0x1, 0xab(%rsp)
jmp 0xf6b72
leaq 0xd8(%rsp), %rdi
callq 0x5a4e0
testb $0x1, %al
jne 0xf6ba7
leaq 0x11d7cc(%rip), %rsi # 0x214356
leaq 0xd8(%rsp), %rdi
callq 0x91240
movb %al, 0x27(%rsp)
jmp 0xf6b9d
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0xf6ba7
jmp 0xf6beb
leaq 0xb8(%rsp), %rdi
callq 0x5a4e0
testb $0x1, %al
jne 0xf6bd1
leaq 0xd8(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x5b500
jmp 0xf6bcf
jmp 0xf6be9
leaq 0x11d785(%rip), %rsi # 0x21435d
leaq 0xd8(%rsp), %rdi
callq 0x5a6f0
jmp 0xf6be7
jmp 0xf6be9
jmp 0xf6beb
leaq 0xd8(%rsp), %rax
movq %rax, 0x88(%rsp)
leaq 0xb8(%rsp), %rax
movq %rax, 0x90(%rsp)
leaq 0xf8(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0xf8(%rsp), %rdi
callq 0x5b5b0
movl %eax, 0x20(%rsp)
jmp 0xf6c2e
movl 0x20(%rsp), %edx
leaq 0x11d86a(%rip), %rcx # 0x2144a3
leaq 0x11d867(%rip), %r8 # 0x2144a7
leaq 0x68(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0xf6dd0
jmp 0xf6c54
movq 0xf8(%rsp), %rdi
callq 0x5b010
movl %eax, 0x1c(%rsp)
jmp 0xf6c67
movl 0x1c(%rsp), %edx
leaq 0x11d83f(%rip), %rcx # 0x2144b1
leaq 0x11d83c(%rip), %r8 # 0x2144b5
leaq 0x48(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0xf6dd0
jmp 0xf6c8d
movq 0x38(%rsp), %rdi
movb 0xab(%rsp), %al
andb $0x1, %al
movb %al, (%rdi)
addq $0x8, %rdi
movq %rdi, 0x10(%rsp)
leaq 0xd8(%rsp), %rsi
leaq 0x68(%rsp), %rdx
leaq 0x48(%rsp), %rcx
callq 0x1050e0
jmp 0xf6cbf
movq 0x38(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x8(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0x5a4e0
testb $0x1, %al
jne 0xf6ce0
jmp 0xf6cf0
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x105170
jmp 0xf6d10
movq 0x8(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
leaq 0x68(%rsp), %rdx
leaq 0x48(%rsp), %rcx
callq 0x1050e0
jmp 0xf6d0e
jmp 0xf6d10
leaq 0x48(%rsp), %rdi
callq 0x5b648
leaq 0x68(%rsp), %rdi
callq 0x5b648
leaq 0xb8(%rsp), %rdi
callq 0x5b648
leaq 0xd8(%rsp), %rdi
callq 0x5b648
movq 0x40(%rsp), %rax
addq $0x118, %rsp # imm = 0x118
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0xf6d9f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0xf6d95
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
callq 0x1051b0
leaq 0x48(%rsp), %rdi
callq 0x5b648
leaq 0x68(%rsp), %rdi
callq 0x5b648
leaq 0xb8(%rsp), %rdi
callq 0x5b648
leaq 0xd8(%rsp), %rdi
callq 0x5b648
movq 0xb0(%rsp), %rdi
callq 0x5ac00
| _Z32common_chat_templates_from_modelPK11llama_modelRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
sub rsp, 118h
mov [rsp+118h+var_E0], rdi
mov rax, rdi
mov [rsp+118h+var_D8], rax
mov [rsp+118h+var_8], rdi
mov [rsp+118h+var_10], rsi
mov [rsp+118h+var_18], rdx
mov rdi, [rsp+118h+var_10]
call _llama_model_get_vocab
mov [rsp+118h+var_20], rax
mov rsi, [rsp+118h+var_18]
lea rdi, [rsp+118h+var_40]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1ERKS4_; std::string::basic_string(std::string const&)
mov rsi, [rsp+118h+var_18]
lea rdi, [rsp+118h+var_60]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1ERKS4_; std::string::basic_string(std::string const&)
jmp short $+2
loc_F6A6D:
mov rdi, [rsp+118h+var_18]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
xor al, 0FFh
and al, 1
mov [rsp+118h+var_6D], al
mov rdi, [rsp+118h+var_18]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
test al, 1
jnz short loc_F6A9B
jmp loc_F6B72
loc_F6A9B:
mov rdi, [rsp+118h+var_10]
xor eax, eax
mov esi, eax
call _llama_model_chat_template
mov [rsp+118h+var_E8], rax
jmp short $+2
loc_F6AB3:
mov rax, [rsp+118h+var_E8]
mov [rsp+118h+var_78], rax
cmp [rsp+118h+var_78], 0
jz short loc_F6B1E
mov rsi, [rsp+118h+var_78]
lea rdi, [rsp+118h+var_40]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc; std::string::operator=(char const*)
jmp short $+2
loc_F6AE2:
mov [rsp+118h+var_6D], 1
jmp short loc_F6B1E
mov rcx, rax
mov eax, edx
mov [rsp+arg_A8], rcx
mov [rsp+arg_A4], eax
jmp loc_F6DB6
mov rcx, rax
mov eax, edx
mov [rsp+arg_A8], rcx
mov [rsp+arg_A4], eax
jmp loc_F6DA9
loc_F6B1E:
mov rdi, [rsp+118h+var_10]
lea rsi, aToolUse; "tool_use"
call _llama_model_chat_template
mov [rsp+118h+var_F0], rax
jmp short $+2
loc_F6B39:
mov rax, [rsp+118h+var_F0]
mov [rsp+118h+var_78], rax
cmp [rsp+118h+var_78], 0
jz short loc_F6B70
mov rsi, [rsp+118h+var_78]
lea rdi, [rsp+118h+var_60]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc; std::string::operator=(char const*)
jmp short $+2
loc_F6B68:
mov [rsp+118h+var_6D], 1
loc_F6B70:
jmp short $+2
loc_F6B72:
lea rdi, [rsp+118h+var_40]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
test al, 1
jnz short loc_F6BA7
lea rsi, aChatml; "chatml"
lea rdi, [rsp+118h+var_40]
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
mov [rsp+118h+var_F1], al
jmp short $+2
loc_F6B9D:
mov al, [rsp+118h+var_F1]
test al, 1
jnz short loc_F6BA7
jmp short loc_F6BEB
loc_F6BA7:
lea rdi, [rsp+118h+var_60]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
test al, 1
jnz short loc_F6BD1
lea rdi, [rsp+118h+var_40]
lea rsi, [rsp+118h+var_60]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSERKS4_; std::string::operator=(std::string const&)
jmp short $+2
loc_F6BCF:
jmp short loc_F6BE9
loc_F6BD1:
lea rsi, aForMessageInMe; "\n {%- for message in me"...
lea rdi, [rsp+118h+var_40]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc; std::string::operator=(char const*)
jmp short $+2
loc_F6BE7:
jmp short $+2
loc_F6BE9:
jmp short $+2
loc_F6BEB:
lea rax, [rsp+118h+var_40]
mov [rsp+118h+var_90], rax
lea rax, [rsp+118h+var_60]
mov [rsp+118h+var_88], rax
lea rax, [rsp+118h+var_20]
mov [rsp+118h+var_80], rax
mov rdi, [rsp+118h+var_20]
call _llama_vocab_bos
mov [rsp+118h+var_F8], eax
jmp short $+2
loc_F6C2E:
mov edx, [rsp+118h+var_F8]
lea rcx, aBos; "BOS"
lea r8, aBosToken; "bos_token"
lea rdi, [rsp+118h+var_B0]
lea rsi, [rsp+118h+var_90]
call _ZZ32common_chat_templates_from_modelPK11llama_modelRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEENK3$_0clB5cxx11EiPKcSC_; common_chat_templates_from_model(llama_model const*,std::string const&)::$_0::operator()(int,char const*,char const*)
jmp short $+2
loc_F6C54:
mov rdi, [rsp+118h+var_20]
call _llama_vocab_eos
mov [rsp+118h+var_FC], eax
jmp short $+2
loc_F6C67:
mov edx, [rsp+118h+var_FC]
lea rcx, aEos; "EOS"
lea r8, aEosToken; "eos_token"
lea rdi, [rsp+118h+var_D0]
lea rsi, [rsp+118h+var_90]
call _ZZ32common_chat_templates_from_modelPK11llama_modelRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEENK3$_0clB5cxx11EiPKcSC_; common_chat_templates_from_model(llama_model const*,std::string const&)::$_0::operator()(int,char const*,char const*)
jmp short $+2
loc_F6C8D:
mov rdi, [rsp+118h+var_E0]
mov al, [rsp+118h+var_6D]
and al, 1
mov [rdi], al
add rdi, 8; int
mov qword ptr [rsp+118h+var_108], rdi; int
lea rsi, [rsp+118h+var_40]; int
lea rdx, [rsp+118h+var_B0]; int
lea rcx, [rsp+118h+var_D0]; int
call _ZSt11make_uniqueIN5minja13chat_templateEJRNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES8_S8_EENSt9_MakeUniqIT_E15__single_objectEDpOT0_; std::make_unique<minja::chat_template,std::string &,std::string &,std::string &>(std::string &,std::string &,std::string &)
jmp short $+2
loc_F6CBF:
mov rax, [rsp+118h+var_E0]
add rax, 10h
mov [rsp+118h+var_110], rax; void *
lea rdi, [rsp+118h+var_60]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
test al, 1
jnz short loc_F6CE0
jmp short loc_F6CF0
loc_F6CE0:
mov rdi, [rsp+118h+var_110]
xor eax, eax
mov esi, eax
call _ZNSt10unique_ptrIN5minja13chat_templateESt14default_deleteIS1_EEC2IS3_vEEDn; std::unique_ptr<minja::chat_template>::unique_ptr<std::default_delete<minja::chat_template>,void>(decltype(nullptr))
jmp short loc_F6D10
loc_F6CF0:
mov rdi, [rsp+118h+var_110]; int
lea rsi, [rsp+118h+var_60]; int
lea rdx, [rsp+118h+var_B0]; int
lea rcx, [rsp+118h+var_D0]; int
call _ZSt11make_uniqueIN5minja13chat_templateEJRNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES8_S8_EENSt9_MakeUniqIT_E15__single_objectEDpOT0_; std::make_unique<minja::chat_template,std::string &,std::string &,std::string &>(std::string &,std::string &,std::string &)
jmp short $+2
loc_F6D0E:
jmp short $+2
loc_F6D10:
lea rdi, [rsp+118h+var_D0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+118h+var_B0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+118h+var_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+118h+var_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov rax, [rsp+118h+var_D8]
add rsp, 118h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_A8], rcx
mov [rsp+arg_A4], eax
jmp short loc_F6D9F
mov rcx, rax
mov eax, edx
mov [rsp+arg_A8], rcx
mov [rsp+arg_A4], eax
jmp short loc_F6D95
mov rdi, [rsp+arg_8]
mov rcx, rax
mov eax, edx
mov [rsp+arg_A8], rcx
mov [rsp+arg_A4], eax
call _ZNSt10unique_ptrIN5minja13chat_templateESt14default_deleteIS1_EED2Ev; std::unique_ptr<minja::chat_template>::~unique_ptr()
loc_F6D95:
lea rdi, [rsp+arg_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_F6D9F:
lea rdi, [rsp+arg_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_F6DA9:
lea rdi, [rsp+arg_B0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_F6DB6:
lea rdi, [rsp+arg_D0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov rdi, [rsp+arg_A8]
call __Unwind_Resume
| bool * common_chat_templates_from_model(bool *a1, long long a2, long long a3)
{
int v3; // r8d
int v4; // r9d
int v5; // r8d
int v6; // r9d
int v8; // [rsp+0h] [rbp-118h]
int v9; // [rsp+0h] [rbp-118h]
void *v10; // [rsp+8h] [rbp-110h]
void *v11; // [rsp+8h] [rbp-110h]
int v12; // [rsp+10h] [rbp-108h]
long long v13; // [rsp+18h] [rbp-100h]
long long v14; // [rsp+18h] [rbp-100h]
unsigned int v15; // [rsp+20h] [rbp-F8h]
int v16[8]; // [rsp+48h] [rbp-D0h] BYREF
int v17[8]; // [rsp+68h] [rbp-B0h] BYREF
_QWORD v18[3]; // [rsp+88h] [rbp-90h] BYREF
const char *v19; // [rsp+A0h] [rbp-78h]
bool v20; // [rsp+ABh] [rbp-6Dh]
int v21[8]; // [rsp+B8h] [rbp-60h] BYREF
int v22[8]; // [rsp+D8h] [rbp-40h] BYREF
long long vocab; // [rsp+F8h] [rbp-20h] BYREF
long long v24; // [rsp+100h] [rbp-18h]
long long v25; // [rsp+108h] [rbp-10h]
bool *v26; // [rsp+110h] [rbp-8h]
v26 = a1;
v25 = a2;
v24 = a3;
vocab = llama_model_get_vocab(a2);
std::string::basic_string(v22, v24);
std::string::basic_string(v21, v24);
v20 = (std::string::empty(v24) & 1) == 0;
if ( (std::string::empty(v24) & 1) != 0 )
{
v19 = (const char *)llama_model_chat_template(v25, 0LL);
if ( v19 )
{
std::string::operator=(v22, v19);
v20 = 1;
}
v19 = (const char *)llama_model_chat_template(v25, "tool_use");
if ( v19 )
{
std::string::operator=(v21, v19);
v20 = 1;
}
}
if ( (std::string::empty(v22) & 1) != 0 || std::operator==<char>((long long)v22, (long long)"chatml") )
{
if ( (std::string::empty(v21) & 1) != 0 )
std::string::operator=(
v22,
"\n"
" {%- for message in messages -%}\n"
" {{- \"<|im_start|>\" + message.role + \"\\n\" + message.content + \"<|im_end|>\\n\" -}}\n"
" {%- endfor -%}\n"
" {%- if add_generation_prompt -%}\n"
" {{- \"<|im_start|>assistant\\n\" -}}\n"
" {%- endif -%}\n"
" ");
else
std::string::operator=(v22, v21);
}
v18[0] = v22;
v18[1] = v21;
v18[2] = &vocab;
v15 = llama_vocab_bos(vocab);
common_chat_templates_from_model(llama_model const*,std::string const&)::$_0::operator()[abi:cxx11](
v17,
v18,
v15,
"BOS",
"bos_token");
HIDWORD(v13) = llama_vocab_eos(vocab);
common_chat_templates_from_model(llama_model const*,std::string const&)::$_0::operator()[abi:cxx11](
v16,
v18,
HIDWORD(v13),
"EOS",
"eos_token");
*a1 = v20;
std::make_unique<minja::chat_template,std::string &,std::string &,std::string &>(
(_DWORD)a1 + 8,
(int)v22,
(int)v17,
(int)v16,
v3,
v4,
v8,
v10,
(_DWORD)a1 + 8,
v13);
v11 = a1 + 16;
if ( (std::string::empty(v21) & 1) != 0 )
std::unique_ptr<minja::chat_template>::unique_ptr<std::default_delete<minja::chat_template>,void>(v11, 0LL);
else
std::make_unique<minja::chat_template,std::string &,std::string &,std::string &>(
(int)v11,
(int)v21,
(int)v17,
(int)v16,
v5,
v6,
v9,
v11,
v12,
v14);
std::string::~string(v16);
std::string::~string(v17);
std::string::~string(v21);
std::string::~string(v22);
return a1;
}
| common_chat_templates_from_model:
SUB RSP,0x118
MOV qword ptr [RSP + 0x38],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x110],RDI
MOV qword ptr [RSP + 0x108],RSI
MOV qword ptr [RSP + 0x100],RDX
MOV RDI,qword ptr [RSP + 0x108]
CALL 0x0015b2c0
MOV qword ptr [RSP + 0xf8],RAX
MOV RSI,qword ptr [RSP + 0x100]
LEA RDI,[RSP + 0xd8]
CALL 0x0015a1f0
MOV RSI,qword ptr [RSP + 0x100]
LAB_001f6a5e:
LEA RDI,[RSP + 0xb8]
CALL 0x0015a1f0
JMP 0x001f6a6d
LAB_001f6a6d:
MOV RDI,qword ptr [RSP + 0x100]
CALL 0x0015a4e0
XOR AL,0xff
AND AL,0x1
MOV byte ptr [RSP + 0xab],AL
MOV RDI,qword ptr [RSP + 0x100]
CALL 0x0015a4e0
TEST AL,0x1
JNZ 0x001f6a9b
JMP 0x001f6b72
LAB_001f6a9b:
MOV RDI,qword ptr [RSP + 0x108]
LAB_001f6aa3:
XOR EAX,EAX
MOV ESI,EAX
CALL 0x0015ae20
MOV qword ptr [RSP + 0x30],RAX
JMP 0x001f6ab3
LAB_001f6ab3:
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0xa0],RAX
CMP qword ptr [RSP + 0xa0],0x0
JZ 0x001f6b1e
MOV RSI,qword ptr [RSP + 0xa0]
LEA RDI,[RSP + 0xd8]
CALL 0x0015a6f0
JMP 0x001f6ae2
LAB_001f6ae2:
MOV byte ptr [RSP + 0xab],0x1
JMP 0x001f6b1e
LAB_001f6b1e:
MOV RDI,qword ptr [RSP + 0x108]
LEA RSI,[0x31434d]
CALL 0x0015ae20
MOV qword ptr [RSP + 0x28],RAX
JMP 0x001f6b39
LAB_001f6b39:
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0xa0],RAX
CMP qword ptr [RSP + 0xa0],0x0
JZ 0x001f6b70
MOV RSI,qword ptr [RSP + 0xa0]
LEA RDI,[RSP + 0xb8]
CALL 0x0015a6f0
JMP 0x001f6b68
LAB_001f6b68:
MOV byte ptr [RSP + 0xab],0x1
LAB_001f6b70:
JMP 0x001f6b72
LAB_001f6b72:
LEA RDI,[RSP + 0xd8]
CALL 0x0015a4e0
TEST AL,0x1
JNZ 0x001f6ba7
LEA RSI,[0x314356]
LEA RDI,[RSP + 0xd8]
CALL 0x00191240
MOV byte ptr [RSP + 0x27],AL
JMP 0x001f6b9d
LAB_001f6b9d:
MOV AL,byte ptr [RSP + 0x27]
TEST AL,0x1
JNZ 0x001f6ba7
JMP 0x001f6beb
LAB_001f6ba7:
LEA RDI,[RSP + 0xb8]
CALL 0x0015a4e0
TEST AL,0x1
JNZ 0x001f6bd1
LEA RDI,[RSP + 0xd8]
LEA RSI,[RSP + 0xb8]
CALL 0x0015b500
JMP 0x001f6bcf
LAB_001f6bcf:
JMP 0x001f6be9
LAB_001f6bd1:
LEA RSI,[0x31435d]
LEA RDI,[RSP + 0xd8]
CALL 0x0015a6f0
JMP 0x001f6be7
LAB_001f6be7:
JMP 0x001f6be9
LAB_001f6be9:
JMP 0x001f6beb
LAB_001f6beb:
LEA RAX,[RSP + 0xd8]
MOV qword ptr [RSP + 0x88],RAX
LEA RAX,[RSP + 0xb8]
MOV qword ptr [RSP + 0x90],RAX
LEA RAX,[RSP + 0xf8]
MOV qword ptr [RSP + 0x98],RAX
MOV RDI,qword ptr [RSP + 0xf8]
CALL 0x0015b5b0
MOV dword ptr [RSP + 0x20],EAX
JMP 0x001f6c2e
LAB_001f6c2e:
MOV EDX,dword ptr [RSP + 0x20]
LEA RCX,[0x3144a3]
LEA R8,[0x3144a7]
LEA RDI,[RSP + 0x68]
LEA RSI,[RSP + 0x88]
CALL 0x001f6dd0
JMP 0x001f6c54
LAB_001f6c54:
MOV RDI,qword ptr [RSP + 0xf8]
LAB_001f6c5c:
CALL 0x0015b010
MOV dword ptr [RSP + 0x1c],EAX
JMP 0x001f6c67
LAB_001f6c67:
MOV EDX,dword ptr [RSP + 0x1c]
LEA RCX,[0x3144b1]
LEA R8,[0x3144b5]
LEA RDI,[RSP + 0x48]
LEA RSI,[RSP + 0x88]
CALL 0x001f6dd0
JMP 0x001f6c8d
LAB_001f6c8d:
MOV RDI,qword ptr [RSP + 0x38]
MOV AL,byte ptr [RSP + 0xab]
AND AL,0x1
MOV byte ptr [RDI],AL
ADD RDI,0x8
MOV qword ptr [RSP + 0x10],RDI
LAB_001f6ca6:
LEA RSI,[RSP + 0xd8]
LEA RDX,[RSP + 0x68]
LEA RCX,[RSP + 0x48]
CALL 0x002050e0
JMP 0x001f6cbf
LAB_001f6cbf:
MOV RAX,qword ptr [RSP + 0x38]
ADD RAX,0x10
MOV qword ptr [RSP + 0x8],RAX
LEA RDI,[RSP + 0xb8]
CALL 0x0015a4e0
TEST AL,0x1
JNZ 0x001f6ce0
JMP 0x001f6cf0
LAB_001f6ce0:
MOV RDI,qword ptr [RSP + 0x8]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x00205170
JMP 0x001f6d10
LAB_001f6cf0:
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[RSP + 0xb8]
LEA RDX,[RSP + 0x68]
LEA RCX,[RSP + 0x48]
CALL 0x002050e0
LAB_001f6d0c:
JMP 0x001f6d0e
LAB_001f6d0e:
JMP 0x001f6d10
LAB_001f6d10:
LEA RDI,[RSP + 0x48]
CALL 0x0015b648
LEA RDI,[RSP + 0x68]
CALL 0x0015b648
LEA RDI,[RSP + 0xb8]
CALL 0x0015b648
LEA RDI,[RSP + 0xd8]
CALL 0x0015b648
MOV RAX,qword ptr [RSP + 0x40]
ADD RSP,0x118
RET
|
/* common_chat_templates_from_model(llama_model const*, std::__cxx11::string const&) */
llama_model * common_chat_templates_from_model(llama_model *param_1,string *param_2)
{
byte bVar1;
bool bVar2;
uint uVar3;
ulong uVar4;
string *in_RDX;
string local_d0 [32];
string local_b0 [32];
string *local_90;
string *local_88;
int8 *local_80;
char *local_78;
byte local_6d;
string local_60 [32];
string local_40 [32];
int8 local_20;
string *local_18;
string *local_10;
llama_model *local_8;
local_18 = in_RDX;
local_10 = param_2;
local_8 = param_1;
local_20 = llama_model_get_vocab(param_2);
std::__cxx11::string::string(local_40,local_18);
/* try { // try from 001f6a5e to 001f6a6a has its CatchHandler @ 001f6aec */
std::__cxx11::string::string(local_60,local_18);
bVar1 = std::__cxx11::string::empty();
local_6d = (bVar1 ^ 0xff) & 1;
uVar4 = std::__cxx11::string::empty();
if ((uVar4 & 1) != 0) {
/* try { // try from 001f6aa3 to 001f6c51 has its CatchHandler @ 001f6b05 */
local_78 = (char *)llama_model_chat_template(local_10,0);
if (local_78 != (char *)0x0) {
std::__cxx11::string::operator=(local_40,local_78);
local_6d = 1;
}
local_78 = (char *)llama_model_chat_template(local_10,"tool_use");
if (local_78 != (char *)0x0) {
std::__cxx11::string::operator=(local_60,local_78);
local_6d = 1;
}
}
uVar4 = std::__cxx11::string::empty();
if (((uVar4 & 1) != 0) || (bVar2 = std::operator==(local_40,"chatml"), bVar2)) {
uVar4 = std::__cxx11::string::empty();
if ((uVar4 & 1) == 0) {
std::__cxx11::string::operator=(local_40,local_60);
}
else {
std::__cxx11::string::operator=
(local_40,
"\n {%- for message in messages -%}\n {{- \"<|im_start|>\" + message.role + \"\\n\" + message.content + \"<|im_end|>\\n\" -}}\n {%- endfor -%}\n {%- if add_generation_prompt -%}\n {{- \"<|im_start|>assistant\\n\" -}}\n {%- endif -%}\n "
);
}
}
local_90 = local_40;
local_88 = local_60;
local_80 = &local_20;
uVar3 = llama_vocab_bos(local_20);
common_chat_templates_from_model(llama_model_const*,std::__cxx11::string_const&)::$_0::
operator()[abi_cxx11_((int)local_b0,(char *)&local_90,(char *)(ulong)uVar3);
/* try { // try from 001f6c5c to 001f6c8a has its CatchHandler @ 001f6d4b */
uVar3 = llama_vocab_eos(local_20);
common_chat_templates_from_model(llama_model_const*,std::__cxx11::string_const&)::$_0::
operator()[abi_cxx11_((int)local_d0,(char *)&local_90,(char *)(ulong)uVar3);
*param_1 = (llama_model)(local_6d & 1);
/* try { // try from 001f6ca6 to 001f6cbc has its CatchHandler @ 001f6d61 */
std::
make_unique<minja::chat_template,std::__cxx11::string&,std::__cxx11::string&,std::__cxx11::string&>
((string *)(param_1 + 8),local_40,local_b0);
uVar4 = std::__cxx11::string::empty();
if ((uVar4 & 1) == 0) {
/* try { // try from 001f6cf0 to 001f6d0b has its CatchHandler @ 001f6d77 */
std::
make_unique<minja::chat_template,std::__cxx11::string&,std::__cxx11::string&,std::__cxx11::string&>
((string *)(param_1 + 0x10),local_60,local_b0);
}
else {
std::unique_ptr<minja::chat_template,std::default_delete<minja::chat_template>>::
unique_ptr<std::default_delete<minja::chat_template>,void>
((_func_decltype_nullptr *)(param_1 + 0x10));
}
std::__cxx11::string::~string(local_d0);
std::__cxx11::string::~string(local_b0);
std::__cxx11::string::~string(local_60);
std::__cxx11::string::~string(local_40);
return param_1;
}
| |
44,819 | common_chat_templates_from_model(llama_model const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/common.cpp | common_chat_templates common_chat_templates_from_model(const struct llama_model * model, const std::string & chat_template_override)
{
auto vocab = llama_model_get_vocab(model);
std::string default_template_src = chat_template_override;
std::string template_tool_use_src = chat_template_override;
bool has_explicit_template = !chat_template_override.empty();
if (chat_template_override.empty()) {
auto str = llama_model_chat_template(model, /* name */ nullptr);
if (str) {
default_template_src = str;
has_explicit_template = true;
}
str = llama_model_chat_template(model, /* name */ "tool_use");
if (str) {
template_tool_use_src = str;
has_explicit_template = true;
}
}
if (default_template_src.empty() || default_template_src == "chatml") {
if (!template_tool_use_src.empty()) {
default_template_src = template_tool_use_src;
} else {
default_template_src = R"(
{%- for message in messages -%}
{{- "<|im_start|>" + message.role + "\n" + message.content + "<|im_end|>\n" -}}
{%- endfor -%}
{%- if add_generation_prompt -%}
{{- "<|im_start|>assistant\n" -}}
{%- endif -%}
)";
}
}
const auto get_token = [&](llama_token token, const char * name, const char * jinja_variable_name) {
if (token == LLAMA_TOKEN_NULL) {
if (default_template_src.find(jinja_variable_name) != std::string::npos
|| template_tool_use_src.find(jinja_variable_name) != std::string::npos) {
LOG_WRN("%s: warning: vocab does not have a %s token, jinja template won't work as intended.\n", __func__, name);
}
return std::string();
} else {
return common_token_to_piece(vocab, token, true);
}
};
auto token_bos = get_token(llama_vocab_bos(vocab), "BOS", "bos_token");
auto token_eos = get_token(llama_vocab_eos(vocab), "EOS", "eos_token");
return {
has_explicit_template,
std::make_unique<minja::chat_template>(default_template_src, token_bos, token_eos),
template_tool_use_src.empty()
? nullptr
: std::make_unique<minja::chat_template>(template_tool_use_src, token_bos, token_eos)
};
} | O1 | cpp | common_chat_templates_from_model(llama_model const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1c220
movq %rax, 0x48(%rsp)
leaq 0x38(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x2437a
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x2437a
cmpq $0x0, 0x8(%r13)
setne %r15b
jne 0x793c0
movq %r12, %rdi
xorl %esi, %esi
callq 0x1b3e0
movq %rax, %r13
testq %rax, %rax
je 0x79380
leaq 0x28(%rsp), %rbp
movq 0x8(%rbp), %r14
movq %r13, %rdi
callq 0x1b3f0
movb $0x1, %r15b
movq %rbp, %rdi
leaq 0x38(%rsp), %rbp
xorl %esi, %esi
movq %r14, %rdx
leaq 0x28(%rsp), %r14
movq %r13, %rcx
movq %rax, %r8
callq 0x1bdf0
leaq 0x7b60e(%rip), %rsi # 0xf4995
movq %r12, %rdi
callq 0x1b3e0
movq %rax, %r12
testq %rax, %rax
je 0x793c0
leaq 0x8(%rsp), %rax
movq 0x8(%rax), %r13
movq %r12, %rdi
callq 0x1b3f0
movb $0x1, %r15b
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r12, %rcx
movq %rax, %r8
callq 0x1bdf0
cmpq $0x0, 0x30(%rsp)
je 0x793dd
leaq 0x7b5cf(%rip), %rsi # 0xf499e
leaq 0x28(%rsp), %rdi
callq 0x1b210
testl %eax, %eax
jne 0x79413
cmpq $0x0, 0x10(%rsp)
je 0x793f6
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1b4b0
jmp 0x79413
leaq 0x28(%rsp), %rdi
movq 0x8(%rdi), %rdx
leaq 0x7b59f(%rip), %rcx # 0xf49a5
movl $0x145, %r8d # imm = 0x145
xorl %esi, %esi
callq 0x1bdf0
movq %r14, 0x90(%rsp)
leaq 0x8(%rsp), %rax
movq %rax, 0x98(%rsp)
leaq 0x48(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq (%rax), %rdi
callq 0x1b780
leaq 0x7b6a7(%rip), %rcx # 0xf4aeb
leaq 0x7b6a4(%rip), %r8 # 0xf4aef
leaq 0x70(%rsp), %rdi
leaq 0x90(%rsp), %rsi
movl %eax, %edx
callq 0x7964c
movq 0x48(%rsp), %rdi
callq 0x1b0a0
leaq 0x7b689(%rip), %rcx # 0xf4af9
leaq 0x7b686(%rip), %r8 # 0xf4afd
leaq 0x50(%rsp), %rdi
leaq 0x90(%rsp), %rsi
movl %eax, %edx
callq 0x7964c
movb %r15b, (%rbx)
movl $0x80, %edi
callq 0x1b8b0
movq %rax, %r15
leaq 0x28(%rsp), %rsi
leaq 0x70(%rsp), %rdx
leaq 0x50(%rsp), %rcx
movq %rax, %rdi
callq 0x7b4b6
movq %r15, 0x8(%rbx)
cmpq $0x0, 0x10(%rsp)
je 0x794e4
movl $0x80, %edi
callq 0x1b8b0
movq %rax, %r15
leaq 0x8(%rsp), %rsi
leaq 0x70(%rsp), %rdx
leaq 0x50(%rsp), %rcx
movq %rax, %rdi
callq 0x7b4b6
jmp 0x794ef
movq $0x0, 0x10(%rbx)
xorl %r15d, %r15d
movq %r15, 0x10(%rbx)
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7950e
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1b8e0
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7952f
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x1b8e0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x7954b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8e0
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x79562
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1b8e0
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7960d
movq %rax, %r14
movl $0x80, %esi
movq %r15, %rdi
callq 0x1b8e0
jmp 0x79591
movq %rax, %r14
addq $0x8, %rbx
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x795a5
movq %rbx, %rdi
callq 0xbd6fe
movq $0x0, (%rbx)
jmp 0x795c3
movq %rax, %r14
movl $0x80, %esi
movq %r15, %rdi
callq 0x1b8e0
jmp 0x795c3
movq %rax, %r14
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x795ea
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1b8e0
jmp 0x795ea
movq %rax, %r14
jmp 0x7962c
jmp 0x7960d
movq %rax, %r14
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x79610
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x1b8e0
jmp 0x79610
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x7962c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8e0
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x79643
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1b8e0
movq %r14, %rdi
callq 0x1c030
nop
| _Z32common_chat_templates_from_modelPK11llama_modelRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp; int
push r15; __int64
push r14; int
push r13; void *
push r12; int
push rbx; int
sub rsp, 0A8h
mov r13, rdx
mov r12, rsi
mov rbx, rdi
mov rdi, rsi
call _llama_model_get_vocab
mov qword ptr [rsp+0D8h+var_90], rax; int
lea rbp, [rsp+0D8h+var_A0]
mov [rbp-10h], rbp
mov rsi, [r13+0]
mov rdx, [r13+8]
add rdx, rsi
lea r14, [rsp+0D8h+var_B0]
mov rdi, r14
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea rax, [rsp+0D8h+var_C0]
mov [rax-10h], rax
mov rsi, [r13+0]
mov rdx, [r13+8]
add rdx, rsi
lea rdi, [rsp+0D8h+var_D0]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
cmp qword ptr [r13+8], 0
setnz r15b
jnz loc_793C0
mov rdi, r12
xor esi, esi
call _llama_model_chat_template
mov r13, rax
test rax, rax
jz short loc_79380
lea rbp, [rsp+0D8h+var_B0]
mov r14, [rbp+8]
mov rdi, r13
call _strlen
mov r15b, 1
mov rdi, rbp
lea rbp, [rsp+0D8h+var_A0]
xor esi, esi
mov rdx, r14
lea r14, [rsp+0D8h+var_B0]
mov rcx, r13
mov r8, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
loc_79380:
lea rsi, aToolUse; "tool_use"
mov rdi, r12
call _llama_model_chat_template
mov r12, rax
test rax, rax
jz short loc_793C0
lea rax, [rsp+0D8h+var_D0]
mov r13, [rax+8]
mov rdi, r12
call _strlen
mov r15b, 1
lea rdi, [rsp+0D8h+var_D0]
xor esi, esi
mov rdx, r13
mov rcx, r12
mov r8, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
loc_793C0:
cmp [rsp+0D8h+var_A8], 0
jz short loc_793DD
lea rsi, aChatml; "chatml"
lea rdi, [rsp+0D8h+var_B0]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jnz short loc_79413
loc_793DD:
cmp [rsp+0D8h+var_C8], 0
jz short loc_793F6
lea rdi, [rsp+0D8h+var_B0]
lea rsi, [rsp+0D8h+var_D0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_assignERKS4_; std::string::_M_assign(std::string const&)
jmp short loc_79413
loc_793F6:
lea rdi, [rsp+0D8h+var_B0]
mov rdx, [rdi+8]
lea rcx, aForMessageInMe; "\n {%- for message in me"...
mov r8d, 145h
xor esi, esi
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
loc_79413:
mov qword ptr [rsp+0D8h+var_48], r14; int
lea rax, [rsp+0D8h+var_D0]
mov qword ptr [rsp+0D8h+var_40], rax; int
lea rax, [rsp+0D8h+var_90]
mov qword ptr [rsp+0D8h+var_38], rax; int
mov rdi, [rax]
call _llama_vocab_bos
lea rcx, aBos; "BOS"
lea r8, aBosToken; "bos_token"
lea rdi, [rsp+0D8h+var_68]
lea rsi, [rsp+0D8h+var_48]
mov edx, eax
call _ZZ32common_chat_templates_from_modelPK11llama_modelRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEENK3$_0clB5cxx11EiPKcSC_; common_chat_templates_from_model(llama_model const*,std::string const&)::$_0::operator()(int,char const*,char const*)
mov rdi, qword ptr [rsp+0D8h+var_90]
call _llama_vocab_eos
lea rcx, aEos; "EOS"
lea r8, aEosToken; "eos_token"
lea rdi, [rsp+0D8h+var_88]
lea rsi, [rsp+0D8h+var_48]
mov edx, eax
call _ZZ32common_chat_templates_from_modelPK11llama_modelRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEENK3$_0clB5cxx11EiPKcSC_; common_chat_templates_from_model(llama_model const*,std::string const&)::$_0::operator()(int,char const*,char const*)
mov [rbx], r15b
mov edi, 80h; unsigned __int64
call __Znwm; operator new(ulong)
mov r15, rax
lea rsi, [rsp+0D8h+var_B0]; int
lea rdx, [rsp+0D8h+var_68]; int
lea rcx, [rsp+0D8h+var_88]; int
mov rdi, rax; int
call _ZN5minja13chat_templateC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES8_S8_; minja::chat_template::chat_template(std::string const&,std::string const&,std::string const&)
mov [rbx+8], r15
cmp [rsp+0D8h+var_C8], 0
jz short loc_794E4
mov edi, 80h; unsigned __int64
call __Znwm; operator new(ulong)
mov r15, rax
lea rsi, [rsp+0D8h+var_D0]; int
lea rdx, [rsp+0D8h+var_68]; int
lea rcx, [rsp+0D8h+var_88]; int
mov rdi, rax; int
call _ZN5minja13chat_templateC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES8_S8_; minja::chat_template::chat_template(std::string const&,std::string const&,std::string const&)
jmp short loc_794EF
loc_794E4:
mov qword ptr [rbx+10h], 0
xor r15d, r15d
loc_794EF:
mov [rbx+10h], r15
lea rax, [rsp+0D8h+var_78]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_7950E
mov rsi, [rsp+0D8h+var_78]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7950E:
lea rax, [rsp+0D8h+var_58]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_7952F
mov rsi, [rsp+0D8h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7952F:
mov rdi, [rsp+0D8h+var_D0]; void *
lea rax, [rsp+0D8h+var_C0]
cmp rdi, rax
jz short loc_7954B
mov rsi, [rsp+0D8h+var_C0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7954B:
mov rdi, [rsp+0D8h+var_B0]; void *
cmp rdi, rbp
jz short loc_79562
mov rsi, [rsp+0D8h+var_A0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_79562:
mov rax, rbx
add rsp, 0A8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp loc_7960D
mov r14, rax
mov esi, 80h; unsigned __int64
mov rdi, r15; void *
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_79591
mov r14, rax
loc_79591:
add rbx, 8
mov rsi, [rbx]
test rsi, rsi
jz short loc_795A5
mov rdi, rbx
call _ZNKSt14default_deleteIN5minja13chat_templateEEclEPS1_; std::default_delete<minja::chat_template>::operator()(minja::chat_template*)
loc_795A5:
mov qword ptr [rbx], 0
jmp short loc_795C3
mov r14, rax
mov esi, 80h; unsigned __int64
mov rdi, r15; void *
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_795C3
mov r14, rax
loc_795C3:
lea rax, [rsp+arg_58]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_795EA
mov rsi, [rsp+arg_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_795EA
mov r14, rax
jmp short loc_7962C
jmp short loc_7960D
mov r14, rax
loc_795EA:
lea rax, [rsp+arg_78]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_79610
mov rsi, [rsp+arg_78]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_79610
loc_7960D:
mov r14, rax
loc_79610:
mov rdi, [rsp+arg_0]; void *
lea rax, [rsp+arg_10]
cmp rdi, rax
jz short loc_7962C
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7962C:
mov rdi, [rsp+arg_20]; void *
cmp rdi, rbp
jz short loc_79643
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_79643:
mov rdi, r14
call __Unwind_Resume
| long long common_chat_templates_from_model(long long a1, long long a2, _BYTE **a3)
{
bool v4; // r15
long long v5; // rax
long long v6; // r13
long long v7; // r14
long long v8; // rax
long long v9; // r12
long long v10; // r13
long long v11; // rax
unsigned int v12; // eax
unsigned int v13; // eax
long long v14; // r15
long long v15; // r15
void *v17; // [rsp+8h] [rbp-D0h] BYREF
long long v18; // [rsp+10h] [rbp-C8h]
_QWORD v19[2]; // [rsp+18h] [rbp-C0h] BYREF
void *v20; // [rsp+28h] [rbp-B0h] BYREF
long long v21; // [rsp+30h] [rbp-A8h]
_QWORD v22[2]; // [rsp+38h] [rbp-A0h] BYREF
int v23[2]; // [rsp+48h] [rbp-90h] BYREF
int v24[4]; // [rsp+50h] [rbp-88h] BYREF
long long v25; // [rsp+60h] [rbp-78h] BYREF
int v26[4]; // [rsp+70h] [rbp-68h] BYREF
long long v27; // [rsp+80h] [rbp-58h] BYREF
int v28[2]; // [rsp+90h] [rbp-48h] BYREF
int v29[2]; // [rsp+98h] [rbp-40h]
int v30[2]; // [rsp+A0h] [rbp-38h]
*(_QWORD *)v23 = llama_model_get_vocab(a2, a2);
v20 = v22;
std::string::_M_construct<char *>(&v20, *a3, (long long)&a3[1][(_QWORD)*a3]);
v17 = v19;
std::string::_M_construct<char *>(&v17, *a3, (long long)&a3[1][(_QWORD)*a3]);
v4 = a3[1] != 0LL;
if ( !a3[1] )
{
v5 = llama_model_chat_template(a2, 0LL);
v6 = v5;
if ( v5 )
{
v7 = v21;
v8 = strlen(v5);
v4 = 1;
std::string::_M_replace(&v20, 0LL, v7, v6, v8);
}
v9 = llama_model_chat_template(a2, "tool_use");
if ( v9 )
{
v10 = v18;
v11 = strlen(v9);
v4 = 1;
std::string::_M_replace(&v17, 0LL, v10, v9, v11);
}
}
if ( !v21 || !(unsigned int)std::string::compare(&v20, "chatml") )
{
if ( v18 )
std::string::_M_assign(&v20, &v17);
else
std::string::_M_replace(
&v20,
0LL,
v21,
"\n"
" {%- for message in messages -%}\n"
" {{- \"<|im_start|>\" + message.role + \"\\n\" + message.content + \"<|im_end|>\\n\" -}}\n"
" {%- endfor -%}\n"
" {%- if add_generation_prompt -%}\n"
" {{- \"<|im_start|>assistant\\n\" -}}\n"
" {%- endif -%}\n"
" ",
325LL);
}
*(_QWORD *)v28 = &v20;
*(_QWORD *)v29 = &v17;
*(_QWORD *)v30 = v23;
v12 = llama_vocab_bos(*(_QWORD *)v23);
common_chat_templates_from_model(llama_model const*,std::string const&)::$_0::operator()[abi:cxx11](
v26,
v28,
v12,
"BOS",
"bos_token");
v13 = llama_vocab_eos(*(_QWORD *)v23);
common_chat_templates_from_model(llama_model const*,std::string const&)::$_0::operator()[abi:cxx11](
v24,
v28,
v13,
"EOS",
"eos_token");
*(_BYTE *)a1 = v4;
v14 = operator new(0x80uLL);
minja::chat_template::chat_template(v14, &v20, v26, v24);
*(_QWORD *)(a1 + 8) = v14;
if ( v18 )
{
v15 = operator new(0x80uLL);
minja::chat_template::chat_template(v15, &v17, v26, v24);
}
else
{
*(_QWORD *)(a1 + 16) = 0LL;
v15 = 0LL;
}
*(_QWORD *)(a1 + 16) = v15;
if ( *(long long **)v24 != &v25 )
operator delete(*(void **)v24, v25 + 1);
if ( *(long long **)v26 != &v27 )
operator delete(*(void **)v26, v27 + 1);
if ( v17 != v19 )
operator delete(v17, v19[0] + 1LL);
if ( v20 != v22 )
operator delete(v20, v22[0] + 1LL);
return a1;
}
| common_chat_templates_from_model:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xa8
MOV R13,RDX
MOV R12,RSI
MOV RBX,RDI
MOV RDI,RSI
CALL 0x0011c220
MOV qword ptr [RSP + 0x48],RAX
LEA RBP,[RSP + 0x38]
MOV qword ptr [RBP + -0x10],RBP
MOV RSI,qword ptr [R13]
MOV RDX,qword ptr [R13 + 0x8]
ADD RDX,RSI
LEA R14,[RSP + 0x28]
MOV RDI,R14
CALL 0x0012437a
LEA RAX,[RSP + 0x18]
MOV qword ptr [RAX + -0x10],RAX
MOV RSI,qword ptr [R13]
MOV RDX,qword ptr [R13 + 0x8]
ADD RDX,RSI
LAB_00179324:
LEA RDI,[RSP + 0x8]
CALL 0x0012437a
CMP qword ptr [R13 + 0x8],0x0
SETNZ R15B
JNZ 0x001793c0
LAB_0017933d:
MOV RDI,R12
XOR ESI,ESI
CALL 0x0011b3e0
MOV R13,RAX
TEST RAX,RAX
JZ 0x00179380
LEA RBP,[RSP + 0x28]
MOV R14,qword ptr [RBP + 0x8]
MOV RDI,R13
CALL 0x0011b3f0
MOV R15B,0x1
MOV RDI,RBP
LEA RBP,[RSP + 0x38]
XOR ESI,ESI
MOV RDX,R14
LEA R14,[RSP + 0x28]
MOV RCX,R13
MOV R8,RAX
CALL 0x0011bdf0
LAB_00179380:
LEA RSI,[0x1f4995]
MOV RDI,R12
CALL 0x0011b3e0
MOV R12,RAX
TEST RAX,RAX
JZ 0x001793c0
LEA RAX,[RSP + 0x8]
MOV R13,qword ptr [RAX + 0x8]
MOV RDI,R12
CALL 0x0011b3f0
MOV R15B,0x1
LEA RDI,[RSP + 0x8]
XOR ESI,ESI
MOV RDX,R13
MOV RCX,R12
MOV R8,RAX
CALL 0x0011bdf0
LAB_001793c0:
CMP qword ptr [RSP + 0x30],0x0
JZ 0x001793dd
LEA RSI,[0x1f499e]
LEA RDI,[RSP + 0x28]
CALL 0x0011b210
TEST EAX,EAX
JNZ 0x00179413
LAB_001793dd:
CMP qword ptr [RSP + 0x10],0x0
JZ 0x001793f6
LAB_001793e5:
LEA RDI,[RSP + 0x28]
LEA RSI,[RSP + 0x8]
CALL 0x0011b4b0
JMP 0x00179413
LAB_001793f6:
LEA RDI,[RSP + 0x28]
MOV RDX,qword ptr [RDI + 0x8]
LEA RCX,[0x1f49a5]
MOV R8D,0x145
XOR ESI,ESI
CALL 0x0011bdf0
LAB_00179413:
MOV qword ptr [RSP + 0x90],R14
LEA RAX,[RSP + 0x8]
MOV qword ptr [RSP + 0x98],RAX
LEA RAX,[RSP + 0x48]
MOV qword ptr [RSP + 0xa0],RAX
MOV RDI,qword ptr [RAX]
LAB_00179438:
CALL 0x0011b780
LEA RCX,[0x1f4aeb]
LEA R8,[0x1f4aef]
LEA RDI,[RSP + 0x70]
LEA RSI,[RSP + 0x90]
MOV EDX,EAX
CALL 0x0017964c
MOV RDI,qword ptr [RSP + 0x48]
LAB_00179464:
CALL 0x0011b0a0
LEA RCX,[0x1f4af9]
LEA R8,[0x1f4afd]
LEA RDI,[RSP + 0x50]
LEA RSI,[RSP + 0x90]
MOV EDX,EAX
CALL 0x0017964c
MOV byte ptr [RBX],R15B
LAB_0017948e:
MOV EDI,0x80
CALL 0x0011b8b0
LAB_00179498:
MOV R15,RAX
LEA RSI,[RSP + 0x28]
LEA RDX,[RSP + 0x70]
LEA RCX,[RSP + 0x50]
MOV RDI,RAX
CALL 0x0017b4b6
MOV qword ptr [RBX + 0x8],R15
CMP qword ptr [RSP + 0x10],0x0
JZ 0x001794e4
LAB_001794be:
MOV EDI,0x80
CALL 0x0011b8b0
LAB_001794c8:
MOV R15,RAX
LEA RSI,[RSP + 0x8]
LEA RDX,[RSP + 0x70]
LEA RCX,[RSP + 0x50]
MOV RDI,RAX
CALL 0x0017b4b6
LAB_001794e2:
JMP 0x001794ef
LAB_001794e4:
MOV qword ptr [RBX + 0x10],0x0
XOR R15D,R15D
LAB_001794ef:
MOV qword ptr [RBX + 0x10],R15
LEA RAX,[RSP + 0x60]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0017950e
MOV RSI,qword ptr [RSP + 0x60]
INC RSI
CALL 0x0011b8e0
LAB_0017950e:
LEA RAX,[RSP + 0x80]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0017952f
MOV RSI,qword ptr [RSP + 0x80]
INC RSI
CALL 0x0011b8e0
LAB_0017952f:
MOV RDI,qword ptr [RSP + 0x8]
LEA RAX,[RSP + 0x18]
CMP RDI,RAX
JZ 0x0017954b
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011b8e0
LAB_0017954b:
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,RBP
JZ 0x00179562
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x0011b8e0
LAB_00179562:
MOV RAX,RBX
ADD RSP,0xa8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* common_chat_templates_from_model(llama_model const*, std::__cxx11::string const&) */
llama_model * common_chat_templates_from_model(llama_model *param_1,string *param_2)
{
char *pcVar1;
int iVar2;
uint uVar3;
char *pcVar4;
chat_template *pcVar5;
long *in_RDX;
llama_model lVar6;
long *local_d0;
char *local_c8;
long local_c0 [2];
long *local_b0;
char *local_a8;
long local_a0 [2];
int8 local_90;
long *local_88 [2];
long local_78 [2];
long *local_68 [2];
long local_58 [2];
int8 **local_48;
int8 **local_40;
int8 *local_38;
local_90 = llama_model_get_vocab(param_2);
local_b0 = local_a0;
std::__cxx11::string::_M_construct<char*>(&local_b0,*in_RDX,in_RDX[1] + *in_RDX);
local_d0 = local_c0;
/* try { // try from 00179324 to 0017932d has its CatchHandler @ 001795e0 */
std::__cxx11::string::_M_construct<char*>(&local_d0,*in_RDX,in_RDX[1] + *in_RDX);
lVar6 = (llama_model)(in_RDX[1] != 0);
if (!(bool)lVar6) {
/* try { // try from 0017933d to 001793bf has its CatchHandler @ 001795e5 */
pcVar4 = (char *)llama_model_chat_template(param_2);
pcVar1 = local_a8;
if (pcVar4 != (char *)0x0) {
strlen(pcVar4);
std::__cxx11::string::_M_replace((ulong)&local_b0,0,pcVar1,(ulong)pcVar4);
}
lVar6 = (llama_model)(pcVar4 != (char *)0x0 || (bool)lVar6);
pcVar4 = (char *)llama_model_chat_template(param_2);
pcVar1 = local_c8;
if (pcVar4 != (char *)0x0) {
strlen(pcVar4);
lVar6 = (llama_model)0x1;
std::__cxx11::string::_M_replace((ulong)&local_d0,0,pcVar1,(ulong)pcVar4);
}
}
if (local_a8 != (char *)0x0) {
iVar2 = std::__cxx11::string::compare((char *)&local_b0);
if (iVar2 != 0) goto LAB_00179413;
}
if (local_c8 == (char *)0x0) {
std::__cxx11::string::_M_replace((ulong)&local_b0,0,local_a8,0x1f49a5);
}
else {
/* try { // try from 001793e5 to 00179412 has its CatchHandler @ 00179577 */
std::__cxx11::string::_M_assign((string *)&local_b0);
}
LAB_00179413:
local_40 = &local_d0;
local_38 = &local_90;
local_48 = &local_b0;
/* try { // try from 00179438 to 0017945e has its CatchHandler @ 0017960d */
uVar3 = llama_vocab_bos(local_90);
common_chat_templates_from_model(llama_model_const*,std::__cxx11::string_const&)::$_0::
operator()[abi_cxx11_((int)local_68,(char *)&local_48,(char *)(ulong)uVar3);
/* try { // try from 00179464 to 0017948a has its CatchHandler @ 001795e7 */
uVar3 = llama_vocab_eos(local_90);
common_chat_templates_from_model(llama_model_const*,std::__cxx11::string_const&)::$_0::
operator()[abi_cxx11_((int)local_88,(char *)&local_48,(char *)(ulong)uVar3);
*param_1 = lVar6;
/* try { // try from 0017948e to 00179497 has its CatchHandler @ 001795c0 */
pcVar5 = (chat_template *)operator_new(0x80);
/* try { // try from 00179498 to 001794b1 has its CatchHandler @ 001795ae */
minja::chat_template::chat_template
(pcVar5,(string *)&local_b0,(string *)local_68,(string *)local_88);
*(chat_template **)(param_1 + 8) = pcVar5;
if (local_c8 == (char *)0x0) {
*(int8 *)(param_1 + 0x10) = 0;
pcVar5 = (chat_template *)0x0;
}
else {
/* try { // try from 001794be to 001794c7 has its CatchHandler @ 0017958e */
pcVar5 = (chat_template *)operator_new(0x80);
/* try { // try from 001794c8 to 001794e1 has its CatchHandler @ 0017957c */
minja::chat_template::chat_template
(pcVar5,(string *)&local_d0,(string *)local_68,(string *)local_88);
}
*(chat_template **)(param_1 + 0x10) = pcVar5;
if (local_88[0] != local_78) {
operator_delete(local_88[0],local_78[0] + 1);
}
if (local_68[0] != local_58) {
operator_delete(local_68[0],local_58[0] + 1);
}
if (local_d0 != local_c0) {
operator_delete(local_d0,local_c0[0] + 1);
}
if (local_b0 != local_a0) {
operator_delete(local_b0,local_a0[0] + 1);
}
return param_1;
}
| |
44,820 | translog_finish_page | eloqsql/storage/maria/ma_loghandler.c | static void translog_finish_page(TRANSLOG_ADDRESS *horizon,
struct st_buffer_cursor *cursor)
{
uint16 left= TRANSLOG_PAGE_SIZE - cursor->current_page_fill;
uchar *page= cursor->ptr - cursor->current_page_fill;
DBUG_ENTER("translog_finish_page");
DBUG_PRINT("enter", ("Buffer: #%u %p "
"Buffer addr: " LSN_FMT " "
"Page addr: " LSN_FMT " "
"size:%u (%u) Pg:%u left:%u",
(uint) cursor->buffer_no, cursor->buffer,
LSN_IN_PARTS(cursor->buffer->offset),
(uint)LSN_FILE_NO(*horizon),
(uint)(LSN_OFFSET(*horizon) -
cursor->current_page_fill),
(uint) cursor->buffer->size,
(uint) (cursor->ptr -cursor->buffer->buffer),
(uint) cursor->current_page_fill, (uint) left));
DBUG_ASSERT(LSN_FILE_NO(*horizon) == LSN_FILE_NO(cursor->buffer->offset)
|| translog_status == TRANSLOG_UNINITED);
if ((LSN_FILE_NO(*horizon) != LSN_FILE_NO(cursor->buffer->offset)))
DBUG_VOID_RETURN; // everything wrong do not write to awoid more problems
translog_check_cursor(cursor);
if (cursor->protected)
{
DBUG_PRINT("info", ("Already protected and finished"));
DBUG_VOID_RETURN;
}
cursor->protected= 1;
DBUG_ASSERT(left < TRANSLOG_PAGE_SIZE);
if (left != 0)
{
DBUG_PRINT("info", ("left: %u", (uint) left));
memset(cursor->ptr, TRANSLOG_FILLER, left);
cursor->ptr+= left;
(*horizon)+= left; /* offset increasing */
if (!cursor->chaser)
cursor->buffer->size+= left;
/* We are finishing the page so reset the counter */
cursor->current_page_fill= 0;
DBUG_PRINT("info", ("Finish Page buffer #%u: %p "
"chaser: %d Size: %lu (%lu)",
(uint) cursor->buffer->buffer_no,
cursor->buffer, cursor->chaser,
(ulong) cursor->buffer->size,
(ulong) (cursor->ptr - cursor->buffer->buffer)));
translog_check_cursor(cursor);
}
/*
When we are finishing the page other thread might not finish the page
header yet (in case if we started from the middle of the page) so we
have to read log_descriptor.flags but not the flags from the page.
*/
if (log_descriptor.flags & TRANSLOG_SECTOR_PROTECTION)
{
translog_put_sector_protection(page, cursor);
DBUG_PRINT("info", ("drop write_counter"));
cursor->write_counter= 0;
cursor->previous_offset= 0;
}
if (log_descriptor.flags & TRANSLOG_PAGE_CRC)
{
uint32 crc= translog_crc(page + log_descriptor.page_overhead,
TRANSLOG_PAGE_SIZE -
log_descriptor.page_overhead);
DBUG_PRINT("info", ("CRC: %lx", (ulong) crc));
/* We have page number, file number and flag before crc */
int4store(page + 3 + 3 + 1, crc);
}
DBUG_VOID_RETURN;
} | O0 | c | translog_finish_page:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x30(%rax), %ecx
movl $0x2000, %eax # imm = 0x2000
subl %ecx, %eax
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movzwl 0x30(%rcx), %ecx
movslq %ecx, %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x8e704
jmp 0x8e706
jmp 0x8e708
movq -0x8(%rbp), %rax
movq (%rax), %rax
sarq $0x20, %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq 0x100010(%rcx), %rcx
sarq $0x20, %rcx
cmpl %ecx, %eax
je 0x8e731
jmp 0x8e72c
jmp 0x8e867
movq -0x10(%rbp), %rdi
callq 0x8d4c0
movq -0x10(%rbp), %rax
cmpb $0x0, 0x38(%rax)
je 0x8e74f
jmp 0x8e746
jmp 0x8e748
jmp 0x8e74a
jmp 0x8e867
movq -0x10(%rbp), %rax
movb $0x1, 0x38(%rax)
jmp 0x8e759
movzwl -0x12(%rbp), %eax
cmpl $0x0, %eax
je 0x8e7db
jmp 0x8e764
jmp 0x8e766
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movzwl -0x12(%rbp), %eax
movl %eax, %edx
movl $0xff, %esi
callq 0x2a2a0
movzwl -0x12(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x20(%rax)
movzwl -0x12(%rbp), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x37(%rax)
jne 0x8e7c6
movzwl -0x12(%rbp), %ecx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
addl 0x100030(%rax), %ecx
movl %ecx, 0x100030(%rax)
movq -0x10(%rbp), %rax
movw $0x0, 0x30(%rax)
jmp 0x8e7d2
movq -0x10(%rbp), %rdi
callq 0x8d4c0
movl 0x3f8f77(%rip), %eax # 0x487758
andl $0x2, %eax
cmpl $0x0, %eax
je 0x8e80c
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x943e0
jmp 0x8e7f8
movq -0x10(%rbp), %rax
movw $0x0, 0x32(%rax)
movq -0x10(%rbp), %rax
movw $0x0, 0x34(%rax)
movl 0x3f8f46(%rip), %eax # 0x487758
andl $0x1, %eax
cmpl $0x0, %eax
je 0x8e863
movq -0x20(%rbp), %rdi
movzwl 0x3f8f4f(%rip), %eax # 0x487774
cltq
addq %rax, %rdi
movzwl 0x3f8f43(%rip), %eax # 0x487774
movl $0x2000, %esi # imm = 0x2000
subl %eax, %esi
callq 0x93730
movl %eax, -0x24(%rbp)
jmp 0x8e842
jmp 0x8e844
movq -0x20(%rbp), %rax
addq $0x3, %rax
addq $0x3, %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
jmp 0x8e863
jmp 0x8e865
jmp 0x8e867
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| translog_finish_page:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
movzx ecx, word ptr [rax+30h]
mov eax, 2000h
sub eax, ecx
mov [rbp+var_12], ax
mov rax, [rbp+var_10]
mov rax, [rax+20h]
mov rcx, [rbp+var_10]
movzx ecx, word ptr [rcx+30h]
movsxd rdx, ecx
xor ecx, ecx
sub rcx, rdx
add rax, rcx
mov [rbp+var_20], rax
jmp short $+2
loc_8E704:
jmp short $+2
loc_8E706:
jmp short $+2
loc_8E708:
mov rax, [rbp+var_8]
mov rax, [rax]
sar rax, 20h
mov rcx, [rbp+var_10]
mov rcx, [rcx+28h]
mov rcx, [rcx+100010h]
sar rcx, 20h
cmp eax, ecx
jz short loc_8E731
jmp short $+2
loc_8E72C:
jmp loc_8E867
loc_8E731:
mov rdi, [rbp+var_10]
call translog_check_cursor
mov rax, [rbp+var_10]
cmp byte ptr [rax+38h], 0
jz short loc_8E74F
jmp short $+2
loc_8E746:
jmp short $+2
loc_8E748:
jmp short $+2
loc_8E74A:
jmp loc_8E867
loc_8E74F:
mov rax, [rbp+var_10]
mov byte ptr [rax+38h], 1
jmp short $+2
loc_8E759:
movzx eax, [rbp+var_12]
cmp eax, 0
jz short loc_8E7DB
jmp short $+2
loc_8E764:
jmp short $+2
loc_8E766:
mov rax, [rbp+var_10]
mov rdi, [rax+20h]
movzx eax, [rbp+var_12]
mov edx, eax
mov esi, 0FFh
call _memset
movzx edx, [rbp+var_12]
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
movsxd rdx, edx
add rcx, rdx
mov [rax+20h], rcx
movzx eax, [rbp+var_12]
mov ecx, eax
mov rax, [rbp+var_8]
add rcx, [rax]
mov [rax], rcx
mov rax, [rbp+var_10]
cmp byte ptr [rax+37h], 0
jnz short loc_8E7C6
movzx ecx, [rbp+var_12]
mov rax, [rbp+var_10]
mov rax, [rax+28h]
add ecx, dword ptr ds:loc_100030[rax]
mov dword ptr ds:loc_100030[rax], ecx
loc_8E7C6:
mov rax, [rbp+var_10]
mov word ptr [rax+30h], 0
jmp short $+2
loc_8E7D2:
mov rdi, [rbp+var_10]
call translog_check_cursor
loc_8E7DB:
mov eax, cs:dword_487758
and eax, 2
cmp eax, 0
jz short loc_8E80C
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_10]
call translog_put_sector_protection
jmp short $+2
loc_8E7F8:
mov rax, [rbp+var_10]
mov word ptr [rax+32h], 0
mov rax, [rbp+var_10]
mov word ptr [rax+34h], 0
loc_8E80C:
mov eax, cs:dword_487758
and eax, 1
cmp eax, 0
jz short loc_8E863
mov rdi, [rbp+var_20]
movzx eax, cs:word_487774
cdqe
add rdi, rax
movzx eax, cs:word_487774
mov esi, 2000h
sub esi, eax
call translog_crc
mov [rbp+var_24], eax
jmp short $+2
loc_8E842:
jmp short $+2
loc_8E844:
mov rax, [rbp+var_20]
add rax, 3
add rax, 3
add rax, 1
mov [rbp+var_30], rax
mov ecx, [rbp+var_24]
mov rax, [rbp+var_30]
mov [rax], ecx
jmp short $+2
loc_8E863:
jmp short $+2
loc_8E865:
jmp short $+2
loc_8E867:
add rsp, 30h
pop rbp
retn
| long long translog_finish_page(long long *a1, long long a2)
{
long long result; // rax
int v3; // [rsp+Ch] [rbp-24h]
long long v4; // [rsp+10h] [rbp-20h]
unsigned __int16 v5; // [rsp+1Eh] [rbp-12h]
v5 = 0x2000 - *(_WORD *)(a2 + 48);
v4 = *(_QWORD *)(a2 + 32) - *(unsigned __int16 *)(a2 + 48);
result = *a1 >> 32;
if ( (_DWORD)result == HIDWORD(*(_QWORD *)(*(_QWORD *)(a2 + 40) + 1048592LL)) )
{
translog_check_cursor();
result = a2;
if ( !*(_BYTE *)(a2 + 56) )
{
*(_BYTE *)(a2 + 56) = 1;
if ( v5 )
{
memset(*(_QWORD *)(a2 + 32), 255LL, v5);
*(_QWORD *)(a2 + 32) += v5;
*a1 += v5;
if ( !*(_BYTE *)(a2 + 55) )
*(_DWORD *)((char *)&loc_100030 + *(_QWORD *)(a2 + 40)) += v5;
*(_WORD *)(a2 + 48) = 0;
translog_check_cursor();
}
if ( (dword_487758 & 2) != 0 )
{
translog_put_sector_protection(v4, a2);
*(_WORD *)(a2 + 50) = 0;
*(_WORD *)(a2 + 52) = 0;
}
result = dword_487758 & 1;
if ( (dword_487758 & 1) != 0 )
{
v3 = translog_crc((unsigned __int16)word_487774 + v4, 0x2000 - (unsigned int)(unsigned __int16)word_487774);
result = v4 + 7;
*(_DWORD *)(v4 + 7) = v3;
}
}
}
return result;
}
| translog_finish_page:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOVZX ECX,word ptr [RAX + 0x30]
MOV EAX,0x2000
SUB EAX,ECX
MOV word ptr [RBP + -0x12],AX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,word ptr [RCX + 0x30]
MOVSXD RDX,ECX
XOR ECX,ECX
SUB RCX,RDX
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0018e704
LAB_0018e704:
JMP 0x0018e706
LAB_0018e706:
JMP 0x0018e708
LAB_0018e708:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
SAR RAX,0x20
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x28]
MOV RCX,qword ptr [RCX + 0x100010]
SAR RCX,0x20
CMP EAX,ECX
JZ 0x0018e731
JMP 0x0018e72c
LAB_0018e72c:
JMP 0x0018e867
LAB_0018e731:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0018d4c0
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX + 0x38],0x0
JZ 0x0018e74f
JMP 0x0018e746
LAB_0018e746:
JMP 0x0018e748
LAB_0018e748:
JMP 0x0018e74a
LAB_0018e74a:
JMP 0x0018e867
LAB_0018e74f:
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x38],0x1
JMP 0x0018e759
LAB_0018e759:
MOVZX EAX,word ptr [RBP + -0x12]
CMP EAX,0x0
JZ 0x0018e7db
JMP 0x0018e764
LAB_0018e764:
JMP 0x0018e766
LAB_0018e766:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x20]
MOVZX EAX,word ptr [RBP + -0x12]
MOV EDX,EAX
MOV ESI,0xff
CALL 0x0012a2a0
MOVZX EDX,word ptr [RBP + -0x12]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x20]
MOVSXD RDX,EDX
ADD RCX,RDX
MOV qword ptr [RAX + 0x20],RCX
MOVZX EAX,word ptr [RBP + -0x12]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RCX,qword ptr [RAX]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX + 0x37],0x0
JNZ 0x0018e7c6
MOVZX ECX,word ptr [RBP + -0x12]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x28]
ADD ECX,dword ptr [RAX + 0x100030]
MOV dword ptr [RAX + 0x100030],ECX
LAB_0018e7c6:
MOV RAX,qword ptr [RBP + -0x10]
MOV word ptr [RAX + 0x30],0x0
JMP 0x0018e7d2
LAB_0018e7d2:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0018d4c0
LAB_0018e7db:
MOV EAX,dword ptr [0x00587758]
AND EAX,0x2
CMP EAX,0x0
JZ 0x0018e80c
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x001943e0
JMP 0x0018e7f8
LAB_0018e7f8:
MOV RAX,qword ptr [RBP + -0x10]
MOV word ptr [RAX + 0x32],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV word ptr [RAX + 0x34],0x0
LAB_0018e80c:
MOV EAX,dword ptr [0x00587758]
AND EAX,0x1
CMP EAX,0x0
JZ 0x0018e863
MOV RDI,qword ptr [RBP + -0x20]
MOVZX EAX,word ptr [0x00587774]
CDQE
ADD RDI,RAX
MOVZX EAX,word ptr [0x00587774]
MOV ESI,0x2000
SUB ESI,EAX
CALL 0x00193730
MOV dword ptr [RBP + -0x24],EAX
JMP 0x0018e842
LAB_0018e842:
JMP 0x0018e844
LAB_0018e844:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x3
ADD RAX,0x3
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
MOV ECX,dword ptr [RBP + -0x24]
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],ECX
JMP 0x0018e863
LAB_0018e863:
JMP 0x0018e865
LAB_0018e865:
JMP 0x0018e867
LAB_0018e867:
ADD RSP,0x30
POP RBP
RET
|
void translog_finish_page(long *param_1,long param_2)
{
ushort uVar1;
int4 uVar2;
long lVar3;
uVar1 = 0x2000 - *(short *)(param_2 + 0x30);
lVar3 = *(long *)(param_2 + 0x20) - (long)(int)(uint)*(ushort *)(param_2 + 0x30);
if (((int)((ulong)*param_1 >> 0x20) ==
(int)((ulong)*(int8 *)(Elf64_Ehdr_00100000.e_ident_pad + *(long *)(param_2 + 0x28) + 7)
>> 0x20)) && (translog_check_cursor(param_2), *(char *)(param_2 + 0x38) == '\0')) {
*(int1 *)(param_2 + 0x38) = 1;
if (uVar1 != 0) {
memset(*(void **)(param_2 + 0x20),0xff,(ulong)uVar1);
*(long *)(param_2 + 0x20) = *(long *)(param_2 + 0x20) + (long)(int)(uint)uVar1;
*param_1 = (ulong)uVar1 + *param_1;
if (*(char *)(param_2 + 0x37) == '\0') {
*(uint *)(Elf64_Ehdr_00100000.e_ident_pad + *(long *)(param_2 + 0x28) + 0x27) =
(uint)uVar1 +
*(int *)(Elf64_Ehdr_00100000.e_ident_pad + *(long *)(param_2 + 0x28) + 0x27);
}
*(int2 *)(param_2 + 0x30) = 0;
translog_check_cursor(param_2);
}
if ((DAT_00587758 & 2) != 0) {
translog_put_sector_protection(lVar3,param_2);
*(int2 *)(param_2 + 0x32) = 0;
*(int2 *)(param_2 + 0x34) = 0;
}
if ((DAT_00587758 & 1) != 0) {
uVar2 = translog_crc(lVar3 + (int)(uint)DAT_00587774,0x2000 - (uint)DAT_00587774);
*(int4 *)(lVar3 + 7) = uVar2;
}
}
return;
}
| |
44,821 | common_context_params_to_llama(common_params const&) | llama.cpp/common/common.cpp | struct llama_context_params common_context_params_to_llama(const common_params & params) {
auto cparams = llama_context_default_params();
cparams.n_ctx = params.n_ctx;
cparams.n_seq_max = params.n_parallel;
cparams.n_batch = params.n_batch;
cparams.n_ubatch = params.n_ubatch;
cparams.n_threads = params.cpuparams.n_threads;
cparams.n_threads_batch = params.cpuparams_batch.n_threads == -1 ?
params.cpuparams.n_threads : params.cpuparams_batch.n_threads;
cparams.logits_all = params.logits_all;
cparams.embeddings = params.embedding;
cparams.rope_scaling_type = params.rope_scaling_type;
cparams.rope_freq_base = params.rope_freq_base;
cparams.rope_freq_scale = params.rope_freq_scale;
cparams.yarn_ext_factor = params.yarn_ext_factor;
cparams.yarn_attn_factor = params.yarn_attn_factor;
cparams.yarn_beta_fast = params.yarn_beta_fast;
cparams.yarn_beta_slow = params.yarn_beta_slow;
cparams.yarn_orig_ctx = params.yarn_orig_ctx;
cparams.pooling_type = params.pooling_type;
cparams.attention_type = params.attention_type;
cparams.defrag_thold = params.defrag_thold;
cparams.cb_eval = params.cb_eval;
cparams.cb_eval_user_data = params.cb_eval_user_data;
cparams.offload_kqv = !params.no_kv_offload;
cparams.flash_attn = params.flash_attn;
cparams.no_perf = params.no_perf;
if (params.reranking) {
cparams.embeddings = true;
cparams.pooling_type = LLAMA_POOLING_TYPE_RANK;
}
cparams.type_k = params.cache_type_k;
cparams.type_v = params.cache_type_v;
return cparams;
} | O3 | cpp | common_context_params_to_llama(common_params const&):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x21480
movl 0x18(%r14), %eax
movl %eax, 0xc(%rbx)
movq 0x4(%r14), %rax
movq %rax, (%rbx)
movl 0xc(%r14), %eax
movl %eax, 0x8(%rbx)
movl 0x274(%r14), %eax
movl %eax, 0x10(%rbx)
movl 0x488(%r14), %ecx
cmpl $-0x1, %ecx
cmovel %eax, %ecx
movl %ecx, 0x14(%rbx)
movb 0x1029(%r14), %al
movb %al, 0x60(%rbx)
movb 0x10d8(%r14), %al
movb %al, 0x61(%rbx)
movups 0x2c(%r14), %xmm0
movups %xmm0, 0x24(%rbx)
movsd 0x3c(%r14), %xmm0
movsd %xmm0, 0x34(%rbx)
movl 0x44(%r14), %eax
movl %eax, 0x3c(%rbx)
movq 0x6b4(%r14), %rax
movq %rax, 0x18(%rbx)
movl 0x6bc(%r14), %eax
movl %eax, 0x20(%rbx)
movss 0x48(%r14), %xmm0
movss %xmm0, 0x40(%rbx)
movups 0x6a0(%r14), %xmm0
movups %xmm0, 0x48(%rbx)
movb 0x102f(%r14), %al
xorb $0x1, %al
movb %al, 0x62(%rbx)
movb 0x1025(%r14), %al
movb %al, 0x63(%rbx)
movb 0x1026(%r14), %al
movb %al, 0x64(%rbx)
cmpb $0x1, 0x1120(%r14)
jne 0xf9461
movb $0x1, 0x61(%rbx)
movl $0x4, 0x1c(%rbx)
movq 0x1034(%r14), %rax
movq %rax, 0x58(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| _Z30common_context_params_to_llamaRK13common_params:
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
call _llama_context_default_params
mov eax, [r14+18h]
mov [rbx+0Ch], eax
mov rax, [r14+4]
mov [rbx], rax
mov eax, [r14+0Ch]
mov [rbx+8], eax
mov eax, [r14+274h]
mov [rbx+10h], eax
mov ecx, [r14+488h]
cmp ecx, 0FFFFFFFFh
cmovz ecx, eax
mov [rbx+14h], ecx
mov al, [r14+1029h]
mov [rbx+60h], al
mov al, [r14+10D8h]
mov [rbx+61h], al
movups xmm0, xmmword ptr [r14+2Ch]
movups xmmword ptr [rbx+24h], xmm0
movsd xmm0, qword ptr [r14+3Ch]
movsd qword ptr [rbx+34h], xmm0
mov eax, [r14+44h]
mov [rbx+3Ch], eax
mov rax, [r14+6B4h]
mov [rbx+18h], rax
mov eax, [r14+6BCh]
mov [rbx+20h], eax
movss xmm0, dword ptr [r14+48h]
movss dword ptr [rbx+40h], xmm0
movups xmm0, xmmword ptr [r14+6A0h]
movups xmmword ptr [rbx+48h], xmm0
mov al, [r14+102Fh]
xor al, 1
mov [rbx+62h], al
mov al, [r14+1025h]
mov [rbx+63h], al
mov al, [r14+1026h]
mov [rbx+64h], al
cmp byte ptr [r14+1120h], 1
jnz short loc_F9461
mov byte ptr [rbx+61h], 1
mov dword ptr [rbx+1Ch], 4
loc_F9461:
mov rax, [r14+1034h]
mov [rbx+58h], rax
mov rax, rbx
add rsp, 8
pop rbx
pop r14
retn
| const common_params * common_context_params_to_llama(const common_params *a1, long long a2)
{
int v2; // eax
int v3; // ecx
llama_context_default_params(a1);
*((_DWORD *)a1 + 3) = *(_DWORD *)(a2 + 24);
*(_QWORD *)a1 = *(_QWORD *)(a2 + 4);
*((_DWORD *)a1 + 2) = *(_DWORD *)(a2 + 12);
v2 = *(_DWORD *)(a2 + 628);
*((_DWORD *)a1 + 4) = v2;
v3 = *(_DWORD *)(a2 + 1160);
if ( v3 == -1 )
v3 = v2;
*((_DWORD *)a1 + 5) = v3;
*((_BYTE *)a1 + 96) = *(_BYTE *)(a2 + 4137);
*((_BYTE *)a1 + 97) = *(_BYTE *)(a2 + 4312);
*(_OWORD *)((char *)a1 + 36) = *(_OWORD *)(a2 + 44);
*(_QWORD *)((char *)a1 + 52) = *(_QWORD *)(a2 + 60);
*((_DWORD *)a1 + 15) = *(_DWORD *)(a2 + 68);
*((_QWORD *)a1 + 3) = *(_QWORD *)(a2 + 1716);
*((_DWORD *)a1 + 8) = *(_DWORD *)(a2 + 1724);
*((_DWORD *)a1 + 16) = *(_DWORD *)(a2 + 72);
*(_OWORD *)((char *)a1 + 72) = *(_OWORD *)(a2 + 1696);
*((_BYTE *)a1 + 98) = *(_BYTE *)(a2 + 4143) ^ 1;
*((_BYTE *)a1 + 99) = *(_BYTE *)(a2 + 4133);
*((_BYTE *)a1 + 100) = *(_BYTE *)(a2 + 4134);
if ( *(_BYTE *)(a2 + 4384) == 1 )
{
*((_BYTE *)a1 + 97) = 1;
*((_DWORD *)a1 + 7) = 4;
}
*((_QWORD *)a1 + 11) = *(_QWORD *)(a2 + 4148);
return a1;
}
| common_context_params_to_llama:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
CALL 0x00121480
MOV EAX,dword ptr [R14 + 0x18]
MOV dword ptr [RBX + 0xc],EAX
MOV RAX,qword ptr [R14 + 0x4]
MOV qword ptr [RBX],RAX
MOV EAX,dword ptr [R14 + 0xc]
MOV dword ptr [RBX + 0x8],EAX
MOV EAX,dword ptr [R14 + 0x274]
MOV dword ptr [RBX + 0x10],EAX
MOV ECX,dword ptr [R14 + 0x488]
CMP ECX,-0x1
CMOVZ ECX,EAX
MOV dword ptr [RBX + 0x14],ECX
MOV AL,byte ptr [R14 + 0x1029]
MOV byte ptr [RBX + 0x60],AL
MOV AL,byte ptr [R14 + 0x10d8]
MOV byte ptr [RBX + 0x61],AL
MOVUPS XMM0,xmmword ptr [R14 + 0x2c]
MOVUPS xmmword ptr [RBX + 0x24],XMM0
MOVSD XMM0,qword ptr [R14 + 0x3c]
MOVSD qword ptr [RBX + 0x34],XMM0
MOV EAX,dword ptr [R14 + 0x44]
MOV dword ptr [RBX + 0x3c],EAX
MOV RAX,qword ptr [R14 + 0x6b4]
MOV qword ptr [RBX + 0x18],RAX
MOV EAX,dword ptr [R14 + 0x6bc]
MOV dword ptr [RBX + 0x20],EAX
MOVSS XMM0,dword ptr [R14 + 0x48]
MOVSS dword ptr [RBX + 0x40],XMM0
MOVUPS XMM0,xmmword ptr [R14 + 0x6a0]
MOVUPS xmmword ptr [RBX + 0x48],XMM0
MOV AL,byte ptr [R14 + 0x102f]
XOR AL,0x1
MOV byte ptr [RBX + 0x62],AL
MOV AL,byte ptr [R14 + 0x1025]
MOV byte ptr [RBX + 0x63],AL
MOV AL,byte ptr [R14 + 0x1026]
MOV byte ptr [RBX + 0x64],AL
CMP byte ptr [R14 + 0x1120],0x1
JNZ 0x001f9461
MOV byte ptr [RBX + 0x61],0x1
MOV dword ptr [RBX + 0x1c],0x4
LAB_001f9461:
MOV RAX,qword ptr [R14 + 0x1034]
MOV qword ptr [RBX + 0x58],RAX
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* common_context_params_to_llama(common_params const&) */
common_params * common_context_params_to_llama(common_params *param_1)
{
int iVar1;
int8 uVar2;
int iVar3;
long in_RSI;
llama_context_default_params();
*(int4 *)(param_1 + 0xc) = *(int4 *)(in_RSI + 0x18);
*(int8 *)param_1 = *(int8 *)(in_RSI + 4);
*(int4 *)(param_1 + 8) = *(int4 *)(in_RSI + 0xc);
iVar1 = *(int *)(in_RSI + 0x274);
*(int *)(param_1 + 0x10) = iVar1;
iVar3 = *(int *)(in_RSI + 0x488);
if (*(int *)(in_RSI + 0x488) == -1) {
iVar3 = iVar1;
}
*(int *)(param_1 + 0x14) = iVar3;
param_1[0x60] = *(common_params *)(in_RSI + 0x1029);
param_1[0x61] = *(common_params *)(in_RSI + 0x10d8);
uVar2 = *(int8 *)(in_RSI + 0x34);
*(int8 *)(param_1 + 0x24) = *(int8 *)(in_RSI + 0x2c);
*(int8 *)(param_1 + 0x2c) = uVar2;
*(int8 *)(param_1 + 0x34) = *(int8 *)(in_RSI + 0x3c);
*(int4 *)(param_1 + 0x3c) = *(int4 *)(in_RSI + 0x44);
*(int8 *)(param_1 + 0x18) = *(int8 *)(in_RSI + 0x6b4);
*(int4 *)(param_1 + 0x20) = *(int4 *)(in_RSI + 0x6bc);
*(int4 *)(param_1 + 0x40) = *(int4 *)(in_RSI + 0x48);
uVar2 = *(int8 *)(in_RSI + 0x6a8);
*(int8 *)(param_1 + 0x48) = *(int8 *)(in_RSI + 0x6a0);
*(int8 *)(param_1 + 0x50) = uVar2;
param_1[0x62] = (common_params)(*(byte *)(in_RSI + 0x102f) ^ 1);
param_1[99] = *(common_params *)(in_RSI + 0x1025);
param_1[100] = *(common_params *)(in_RSI + 0x1026);
if (*(char *)(in_RSI + 0x1120) == '\x01') {
param_1[0x61] = (common_params)0x1;
*(int4 *)(param_1 + 0x1c) = 4;
}
*(int8 *)(param_1 + 0x58) = *(int8 *)(in_RSI + 0x1034);
return param_1;
}
| |
44,822 | minja::Parser::consumeToken(std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char>> const&, minja::SpaceHandling) | llama.cpp/common/minja/minja.hpp | std::string consumeToken(const std::regex & regex, SpaceHandling space_handling = SpaceHandling::Strip) {
auto start = it;
consumeSpaces(space_handling);
std::smatch match;
if (std::regex_search(it, end, match, regex) && match.position() == 0) {
it += match[0].length();
return match[0].str();
}
it = start;
return "";
} | O3 | cpp | minja::Parser::consumeToken(std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char>> const&, minja::SpaceHandling):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rsi), %r12
movq %rsi, %rdi
movl %ecx, %esi
callq 0xdeaf0
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq 0x18(%r14), %rsi
movq 0x20(%r14), %rdi
movl $0x0, (%rsp)
movq %r15, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x6f7ba
testb %al, %al
je 0xddc80
movq 0x28(%rsp), %rsi
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, %rdx
subq %rax, %rdx
je 0xddc67
movq (%rax), %r8
cmpq $0x48, %rdx
jne 0xddc78
cmpq %rsi, %r8
jne 0xddc80
jmp 0xddc6e
cmpq %rsi, -0x48(%rax,%rdx)
jne 0xddc80
leaq (%rax,%rdx), %rdi
addq $-0x48, %rdi
jmp 0xddcc3
movq %rax, %rdi
cmpq %rsi, %r8
je 0xddcc3
movq %r12, 0x20(%r14)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x4093f(%rip), %rdx # 0x11e5d1
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x27960
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xddcb4
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x20190
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%rdi), %r8
subq %rsi, %r8
xorl %esi, %esi
cmpb $0x0, 0x10(%rdi)
cmovneq %r8, %rsi
addq %rsi, 0x20(%r14)
cmpq $0x48, %rdx
leaq -0x48(%rax,%rdx), %rdx
movq %rax, %rsi
cmoveq %rdx, %rsi
cmpq %rcx, %rax
cmoveq %rdx, %rsi
movq %rbx, %rdi
callq 0x65092
jmp 0xddc9d
jmp 0xddcfb
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xddd15
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x20190
movq %rbx, %rdi
callq 0x20b00
nop
| _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE:
push r15
push r14
push r12
push rbx
sub rsp, 38h
mov r15, rdx
mov r14, rsi
mov rbx, rdi
mov r12, [rsi+20h]
mov rdi, rsi
mov esi, ecx
call _ZN5minja6Parser13consumeSpacesENS_13SpaceHandlingE; minja::Parser::consumeSpaces(minja::SpaceHandling)
xorps xmm0, xmm0
lea rdx, [rsp+58h+var_48]
movaps xmmword ptr [rdx+10h], xmm0
movaps xmmword ptr [rdx], xmm0
mov rsi, [r14+18h]
mov rdi, [r14+20h]
mov [rsp+58h+var_58], 0
mov rcx, r15
xor r8d, r8d
xor r9d, r9d
call _ZNSt8__detail17__regex_algo_implIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEEcNS5_12regex_traitsIcEEEEbT_SH_RNS5_13match_resultsISH_T0_EERKNS5_11basic_regexIT1_T2_EENSt15regex_constants15match_flag_typeENS_20_RegexExecutorPolicyEb; std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>> &,std::basic_regex<char,std::regex_traits<char>> const&,std::regex_constants::match_flag_type,std::__detail::_RegexExecutorPolicy,bool)
test al, al
jz short loc_DDC80
mov rsi, [rsp+58h+var_30]
mov rax, [rsp+58h+var_48]
mov rcx, [rsp+58h+var_40]
mov rdx, rcx
sub rdx, rax
jz short loc_DDC67
mov r8, [rax]
cmp rdx, 48h ; 'H'
jnz short loc_DDC78
cmp r8, rsi
jnz short loc_DDC80
jmp short loc_DDC6E
loc_DDC67:
cmp [rax+rdx-48h], rsi
jnz short loc_DDC80
loc_DDC6E:
lea rdi, [rax+rdx]
add rdi, 0FFFFFFFFFFFFFFB8h
jmp short loc_DDCC3
loc_DDC78:
mov rdi, rax
cmp r8, rsi
jz short loc_DDCC3
loc_DDC80:
mov [r14+20h], r12
lea rax, [rbx+10h]
mov [rbx], rax
lea rdx, aExampleToolCal+1Dh; ""
mov rdi, rbx
mov rsi, rdx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
loc_DDC9D:
mov rdi, [rsp+58h+var_48]; void *
test rdi, rdi
jz short loc_DDCB4
mov rsi, [rsp+58h+var_38]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_DDCB4:
mov rax, rbx
add rsp, 38h
pop rbx
pop r12
pop r14
pop r15
retn
loc_DDCC3:
mov r8, [rdi+8]
sub r8, rsi
xor esi, esi
cmp byte ptr [rdi+10h], 0
cmovnz rsi, r8
add [r14+20h], rsi
cmp rdx, 48h ; 'H'
lea rdx, [rax+rdx-48h]
mov rsi, rax
cmovz rsi, rdx
cmp rax, rcx
cmovz rsi, rdx
mov rdi, rbx
call _ZNKSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEEE3strEv; std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>::str(void)
jmp short loc_DDC9D
jmp short $+2
loc_DDCFB:
mov rbx, rax
mov rdi, [rsp+arg_8]; void *
test rdi, rdi
jz short loc_DDD15
mov rsi, [rsp+arg_18]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_DDD15:
mov rdi, rbx
call __Unwind_Resume
| _QWORD * minja::Parser::consumeToken(_QWORD *a1, long long a2, long long a3, unsigned int a4)
{
long long v7; // r12
__int128 v8; // kr00_16
long long v9; // rdx
long long v10; // r8
long long v11; // rdi
long long v13; // rsi
bool v14; // zf
long long v15; // rdx
long long *v16; // rsi
__int128 v17; // [rsp+10h] [rbp-48h] BYREF
__int128 v18; // [rsp+20h] [rbp-38h]
v7 = *(_QWORD *)(a2 + 32);
minja::Parser::consumeSpaces(a2, a4);
v18 = 0LL;
v17 = 0LL;
if ( !std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>>(
*(long long **)(a2 + 32),
*(_QWORD *)(a2 + 24),
(char **)&v17,
a3,
0,
0,
0) )
goto LABEL_9;
v8 = v17;
v9 = *((_QWORD *)&v17 + 1) - v17;
if ( *((_QWORD *)&v17 + 1) != (_QWORD)v17 )
{
v10 = *(_QWORD *)v17;
if ( v9 == 72 )
{
if ( v10 == *((_QWORD *)&v18 + 1) )
goto LABEL_7;
}
else
{
v11 = v17;
if ( v10 == *((_QWORD *)&v18 + 1) )
goto LABEL_13;
}
LABEL_9:
*(_QWORD *)(a2 + 32) = v7;
*a1 = a1 + 2;
std::string::_M_construct<char const*>((long long)a1, "", (long long)"");
goto LABEL_10;
}
if ( *(_QWORD *)(*((_QWORD *)&v17 + 1) - 72LL) != *((_QWORD *)&v18 + 1) )
goto LABEL_9;
LABEL_7:
v11 = *((_QWORD *)&v17 + 1) - 72LL;
LABEL_13:
v13 = 0LL;
if ( *(_BYTE *)(v11 + 16) )
v13 = *(_QWORD *)(v11 + 8) - *((_QWORD *)&v18 + 1);
*(_QWORD *)(a2 + 32) += v13;
v14 = v9 == 72;
v15 = v8 + v9 - 72;
v16 = (long long *)v8;
if ( v14 )
v16 = (long long *)v15;
if ( (_QWORD)v8 == *((_QWORD *)&v8 + 1) )
v16 = (long long *)v15;
std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>::str((long long)a1, v16);
LABEL_10:
if ( (_QWORD)v17 )
operator delete((void *)v17, v18 - v17);
return a1;
}
| consumeToken:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
MOV R12,qword ptr [RSI + 0x20]
MOV RDI,RSI
MOV ESI,ECX
CALL 0x001deaf0
XORPS XMM0,XMM0
LEA RDX,[RSP + 0x10]
MOVAPS xmmword ptr [RDX + 0x10],XMM0
MOVAPS xmmword ptr [RDX],XMM0
MOV RSI,qword ptr [R14 + 0x18]
MOV RDI,qword ptr [R14 + 0x20]
LAB_001ddc27:
MOV dword ptr [RSP],0x0
MOV RCX,R15
XOR R8D,R8D
XOR R9D,R9D
CALL 0x0016f7ba
TEST AL,AL
JZ 0x001ddc80
MOV RSI,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x18]
MOV RDX,RCX
SUB RDX,RAX
JZ 0x001ddc67
MOV R8,qword ptr [RAX]
CMP RDX,0x48
JNZ 0x001ddc78
CMP R8,RSI
JNZ 0x001ddc80
JMP 0x001ddc6e
LAB_001ddc67:
CMP qword ptr [RAX + RDX*0x1 + -0x48],RSI
JNZ 0x001ddc80
LAB_001ddc6e:
LEA RDI,[RAX + RDX*0x1]
ADD RDI,-0x48
JMP 0x001ddcc3
LAB_001ddc78:
MOV RDI,RAX
CMP R8,RSI
JZ 0x001ddcc3
LAB_001ddc80:
MOV qword ptr [R14 + 0x20],R12
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LAB_001ddc8b:
LEA RDX,[0x21e5d1]
MOV RDI,RBX
MOV RSI,RDX
CALL 0x00127960
LAB_001ddc9d:
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x001ddcb4
MOV RSI,qword ptr [RSP + 0x20]
SUB RSI,RDI
CALL 0x00120190
LAB_001ddcb4:
MOV RAX,RBX
ADD RSP,0x38
POP RBX
POP R12
POP R14
POP R15
RET
LAB_001ddcc3:
MOV R8,qword ptr [RDI + 0x8]
SUB R8,RSI
XOR ESI,ESI
CMP byte ptr [RDI + 0x10],0x0
CMOVNZ RSI,R8
ADD qword ptr [R14 + 0x20],RSI
CMP RDX,0x48
LEA RDX,[RAX + RDX*0x1 + -0x48]
MOV RSI,RAX
CMOVZ RSI,RDX
CMP RAX,RCX
CMOVZ RSI,RDX
LAB_001ddcef:
MOV RDI,RBX
CALL 0x00165092
LAB_001ddcf7:
JMP 0x001ddc9d
|
/* minja::Parser::consumeToken(std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char> >
const&, minja::SpaceHandling) */
long * minja::Parser::consumeToken
(long *param_1,Parser *param_2,int8 param_3,int4 param_4)
{
int8 uVar1;
long lVar2;
bool bVar3;
long lVar4;
long *plVar5;
long *local_48;
long lStack_40;
long local_38;
long lStack_30;
uVar1 = *(int8 *)(param_2 + 0x20);
consumeSpaces(param_2,param_4);
local_38 = 0;
lStack_30 = 0;
local_48 = (long *)0x0;
lStack_40 = 0;
/* try { // try from 001ddc27 to 001ddc3b has its CatchHandler @ 001ddcfb */
bVar3 = std::__detail::
__regex_algo_impl<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>,char,std::__cxx11::regex_traits<char>>
(*(int8 *)(param_2 + 0x20),*(int8 *)(param_2 + 0x18),&local_48,
param_3,0,0,0);
if (bVar3) {
lVar4 = lStack_40 - (long)local_48;
if (lVar4 == 0) {
lVar2 = local_48[-9];
joined_r0x001ddc6c:
if (lVar2 != lStack_30) goto LAB_001ddc80;
plVar5 = (long *)((long)local_48 + lVar4 + -0x48);
}
else {
lVar2 = *local_48;
if (lVar4 == 0x48) goto joined_r0x001ddc6c;
plVar5 = local_48;
if (lVar2 != lStack_30) goto LAB_001ddc80;
}
lVar4 = 0;
if ((char)plVar5[2] != '\0') {
lVar4 = plVar5[1] - lStack_30;
}
*(long *)(param_2 + 0x20) = *(long *)(param_2 + 0x20) + lVar4;
/* try { // try from 001ddcef to 001ddcf6 has its CatchHandler @ 001ddcfb */
std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>::str();
}
else {
LAB_001ddc80:
*(int8 *)(param_2 + 0x20) = uVar1;
*param_1 = (long)(param_1 + 2);
/* try { // try from 001ddc8b to 001ddc9c has its CatchHandler @ 001ddcf9 */
std::__cxx11::string::_M_construct<char_const*>(param_1,"");
}
if (local_48 != (long *)0x0) {
operator_delete(local_48,local_38 - (long)local_48);
}
return param_1;
}
| |
44,823 | cs_copy_data | eloqsql/mysys/charset.c | static int cs_copy_data(struct charset_info_st *to, CHARSET_INFO *from)
{
to->number= from->number ? from->number : to->number;
/* Don't replace csname if already set */
if (from->cs_name.str && !to->cs_name.str)
{
if (!(to->cs_name.str= my_once_memdup(from->cs_name.str,
from->cs_name.length + 1,
MYF(MY_WME))))
goto err;
to->cs_name.length= from->cs_name.length;
}
if (from->coll_name.str)
{
if (!(to->coll_name.str= my_once_memdup(from->coll_name.str,
from->coll_name.length + 1,
MYF(MY_WME))))
goto err;
to->coll_name.length= from->coll_name.length;
}
if (from->comment)
if (!(to->comment= my_once_strdup(from->comment,MYF(MY_WME))))
goto err;
if (from->m_ctype)
{
if (!(to->m_ctype= (uchar*) my_once_memdup((char*) from->m_ctype,
MY_CS_CTYPE_TABLE_SIZE,
MYF(MY_WME))))
goto err;
if (init_state_maps(to))
goto err;
}
if (from->to_lower)
if (!(to->to_lower= (uchar*) my_once_memdup((char*) from->to_lower,
MY_CS_TO_LOWER_TABLE_SIZE,
MYF(MY_WME))))
goto err;
if (from->to_upper)
if (!(to->to_upper= (uchar*) my_once_memdup((char*) from->to_upper,
MY_CS_TO_UPPER_TABLE_SIZE,
MYF(MY_WME))))
goto err;
if (from->sort_order)
{
if (!(to->sort_order= (uchar*) my_once_memdup((char*) from->sort_order,
MY_CS_SORT_ORDER_TABLE_SIZE,
MYF(MY_WME))))
goto err;
}
if (from->tab_to_uni)
{
uint sz= MY_CS_TO_UNI_TABLE_SIZE*sizeof(uint16);
if (!(to->tab_to_uni= (uint16*) my_once_memdup((char*)from->tab_to_uni,
sz, MYF(MY_WME))))
goto err;
}
if (from->tailoring)
if (!(to->tailoring= my_once_strdup(from->tailoring,MYF(MY_WME))))
goto err;
return 0;
err:
return 1;
} | O0 | c | cs_copy_data:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0xdca24
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
jmp 0xdca2d
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xdca8d
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xdca8d
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
addq $0x1, %rsi
movl $0x10, %edx
callq 0xf4160
movq -0x10(%rbp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jne 0xdca7d
jmp 0xdcc69
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xdcad9
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
addq $0x1, %rsi
movl $0x10, %edx
callq 0xf4160
movq -0x10(%rbp), %rcx
movq %rax, 0x20(%rcx)
cmpq $0x0, %rax
jne 0xdcac9
jmp 0xdcc69
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0xdcb0b
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movl $0x10, %esi
callq 0xf4100
movq -0x10(%rbp), %rcx
movq %rax, 0x30(%rcx)
cmpq $0x0, %rax
jne 0xdcb09
jmp 0xdcc69
jmp 0xdcb0b
movq -0x18(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0xdcb54
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rdi
movl $0x101, %esi # imm = 0x101
movl $0x10, %edx
callq 0xf4160
movq -0x10(%rbp), %rcx
movq %rax, 0x40(%rcx)
cmpq $0x0, %rax
jne 0xdcb40
jmp 0xdcc69
movq -0x10(%rbp), %rdi
callq 0xdcd80
cmpb $0x0, %al
je 0xdcb52
jmp 0xdcc69
jmp 0xdcb54
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xdcb8b
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rdi
movl $0x100, %esi # imm = 0x100
movl $0x10, %edx
callq 0xf4160
movq -0x10(%rbp), %rcx
movq %rax, 0x48(%rcx)
cmpq $0x0, %rax
jne 0xdcb89
jmp 0xdcc69
jmp 0xdcb8b
movq -0x18(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0xdcbc2
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rdi
movl $0x100, %esi # imm = 0x100
movl $0x10, %edx
callq 0xf4160
movq -0x10(%rbp), %rcx
movq %rax, 0x50(%rcx)
cmpq $0x0, %rax
jne 0xdcbc0
jmp 0xdcc69
jmp 0xdcbc2
movq -0x18(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0xdcbf6
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rdi
movl $0x100, %esi # imm = 0x100
movl $0x10, %edx
callq 0xf4160
movq -0x10(%rbp), %rcx
movq %rax, 0x58(%rcx)
cmpq $0x0, %rax
jne 0xdcbf4
jmp 0xdcc69
jmp 0xdcbf6
movq -0x18(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0xdcc31
movl $0x200, -0x1c(%rbp) # imm = 0x200
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
movl $0x10, %edx
callq 0xf4160
movq -0x10(%rbp), %rcx
movq %rax, 0x68(%rcx)
cmpq $0x0, %rax
jne 0xdcc2f
jmp 0xdcc69
jmp 0xdcc31
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0xdcc60
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
movl $0x10, %esi
callq 0xf4100
movq -0x10(%rbp), %rcx
movq %rax, 0x38(%rcx)
cmpq $0x0, %rax
jne 0xdcc5e
jmp 0xdcc69
jmp 0xdcc60
movl $0x0, -0x4(%rbp)
jmp 0xdcc70
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| cs_copy_data:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_18]
cmp dword ptr [rax], 0
jz short loc_DCA24
mov rax, [rbp+var_18]
mov eax, [rax]
mov [rbp+var_20], eax
jmp short loc_DCA2D
loc_DCA24:
mov rax, [rbp+var_10]
mov eax, [rax]
mov [rbp+var_20], eax
loc_DCA2D:
mov ecx, [rbp+var_20]
mov rax, [rbp+var_10]
mov [rax], ecx
mov rax, [rbp+var_18]
cmp qword ptr [rax+10h], 0
jz short loc_DCA8D
mov rax, [rbp+var_10]
cmp qword ptr [rax+10h], 0
jnz short loc_DCA8D
mov rax, [rbp+var_18]
mov rdi, [rax+10h]
mov rax, [rbp+var_18]
mov rsi, [rax+18h]
add rsi, 1
mov edx, 10h
call my_once_memdup
mov rcx, [rbp+var_10]
mov [rcx+10h], rax
cmp rax, 0
jnz short loc_DCA7D
jmp loc_DCC69
loc_DCA7D:
mov rax, [rbp+var_18]
mov rcx, [rax+18h]
mov rax, [rbp+var_10]
mov [rax+18h], rcx
loc_DCA8D:
mov rax, [rbp+var_18]
cmp qword ptr [rax+20h], 0
jz short loc_DCAD9
mov rax, [rbp+var_18]
mov rdi, [rax+20h]
mov rax, [rbp+var_18]
mov rsi, [rax+28h]
add rsi, 1
mov edx, 10h
call my_once_memdup
mov rcx, [rbp+var_10]
mov [rcx+20h], rax
cmp rax, 0
jnz short loc_DCAC9
jmp loc_DCC69
loc_DCAC9:
mov rax, [rbp+var_18]
mov rcx, [rax+28h]
mov rax, [rbp+var_10]
mov [rax+28h], rcx
loc_DCAD9:
mov rax, [rbp+var_18]
cmp qword ptr [rax+30h], 0
jz short loc_DCB0B
mov rax, [rbp+var_18]
mov rdi, [rax+30h]
mov esi, 10h
call my_once_strdup
mov rcx, [rbp+var_10]
mov [rcx+30h], rax
cmp rax, 0
jnz short loc_DCB09
jmp loc_DCC69
loc_DCB09:
jmp short $+2
loc_DCB0B:
mov rax, [rbp+var_18]
cmp qword ptr [rax+40h], 0
jz short loc_DCB54
mov rax, [rbp+var_18]
mov rdi, [rax+40h]
mov esi, 101h
mov edx, 10h
call my_once_memdup
mov rcx, [rbp+var_10]
mov [rcx+40h], rax
cmp rax, 0
jnz short loc_DCB40
jmp loc_DCC69
loc_DCB40:
mov rdi, [rbp+var_10]
call init_state_maps
cmp al, 0
jz short loc_DCB52
jmp loc_DCC69
loc_DCB52:
jmp short $+2
loc_DCB54:
mov rax, [rbp+var_18]
cmp qword ptr [rax+48h], 0
jz short loc_DCB8B
mov rax, [rbp+var_18]
mov rdi, [rax+48h]
mov esi, 100h
mov edx, 10h
call my_once_memdup
mov rcx, [rbp+var_10]
mov [rcx+48h], rax
cmp rax, 0
jnz short loc_DCB89
jmp loc_DCC69
loc_DCB89:
jmp short $+2
loc_DCB8B:
mov rax, [rbp+var_18]
cmp qword ptr [rax+50h], 0
jz short loc_DCBC2
mov rax, [rbp+var_18]
mov rdi, [rax+50h]
mov esi, 100h
mov edx, 10h
call my_once_memdup
mov rcx, [rbp+var_10]
mov [rcx+50h], rax
cmp rax, 0
jnz short loc_DCBC0
jmp loc_DCC69
loc_DCBC0:
jmp short $+2
loc_DCBC2:
mov rax, [rbp+var_18]
cmp qword ptr [rax+58h], 0
jz short loc_DCBF6
mov rax, [rbp+var_18]
mov rdi, [rax+58h]
mov esi, 100h
mov edx, 10h
call my_once_memdup
mov rcx, [rbp+var_10]
mov [rcx+58h], rax
cmp rax, 0
jnz short loc_DCBF4
jmp short loc_DCC69
loc_DCBF4:
jmp short $+2
loc_DCBF6:
mov rax, [rbp+var_18]
cmp qword ptr [rax+68h], 0
jz short loc_DCC31
mov [rbp+var_1C], 200h
mov rax, [rbp+var_18]
mov rdi, [rax+68h]
mov eax, [rbp+var_1C]
mov esi, eax
mov edx, 10h
call my_once_memdup
mov rcx, [rbp+var_10]
mov [rcx+68h], rax
cmp rax, 0
jnz short loc_DCC2F
jmp short loc_DCC69
loc_DCC2F:
jmp short $+2
loc_DCC31:
mov rax, [rbp+var_18]
cmp qword ptr [rax+38h], 0
jz short loc_DCC60
mov rax, [rbp+var_18]
mov rdi, [rax+38h]
mov esi, 10h
call my_once_strdup
mov rcx, [rbp+var_10]
mov [rcx+38h], rax
cmp rax, 0
jnz short loc_DCC5E
jmp short loc_DCC69
loc_DCC5E:
jmp short $+2
loc_DCC60:
mov [rbp+var_4], 0
jmp short loc_DCC70
loc_DCC69:
mov [rbp+var_4], 1
loc_DCC70:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
| long long cs_copy_data(int *a1, int *a2)
{
long long v2; // rax
long long v3; // rax
long long v4; // rax
long long v5; // rax
long long v6; // rax
long long v7; // rax
long long v8; // rax
long long v9; // rax
long long v10; // rax
int v12; // [rsp+0h] [rbp-20h]
if ( *a2 )
v12 = *a2;
else
v12 = *a1;
*a1 = v12;
if ( *((_QWORD *)a2 + 2) && !*((_QWORD *)a1 + 2) )
{
v2 = my_once_memdup(*((_QWORD *)a2 + 2), *((_QWORD *)a2 + 3) + 1LL, 16LL);
*((_QWORD *)a1 + 2) = v2;
if ( !v2 )
return 1;
*((_QWORD *)a1 + 3) = *((_QWORD *)a2 + 3);
}
if ( !*((_QWORD *)a2 + 4) )
goto LABEL_11;
v3 = my_once_memdup(*((_QWORD *)a2 + 4), *((_QWORD *)a2 + 5) + 1LL, 16LL);
*((_QWORD *)a1 + 4) = v3;
if ( !v3 )
return 1;
*((_QWORD *)a1 + 5) = *((_QWORD *)a2 + 5);
LABEL_11:
if ( *((_QWORD *)a2 + 6) )
{
v4 = my_once_strdup(*((_QWORD *)a2 + 6), 16LL);
*((_QWORD *)a1 + 6) = v4;
if ( !v4 )
return 1;
}
if ( *((_QWORD *)a2 + 8) )
{
v5 = my_once_memdup(*((_QWORD *)a2 + 8), 257LL, 16LL);
*((_QWORD *)a1 + 8) = v5;
if ( !v5 || (unsigned __int8)init_state_maps(a1) )
return 1;
}
if ( *((_QWORD *)a2 + 9) )
{
v6 = my_once_memdup(*((_QWORD *)a2 + 9), 256LL, 16LL);
*((_QWORD *)a1 + 9) = v6;
if ( !v6 )
return 1;
}
if ( *((_QWORD *)a2 + 10) )
{
v7 = my_once_memdup(*((_QWORD *)a2 + 10), 256LL, 16LL);
*((_QWORD *)a1 + 10) = v7;
if ( !v7 )
return 1;
}
if ( *((_QWORD *)a2 + 11) )
{
v8 = my_once_memdup(*((_QWORD *)a2 + 11), 256LL, 16LL);
*((_QWORD *)a1 + 11) = v8;
if ( !v8 )
return 1;
}
if ( *((_QWORD *)a2 + 13) )
{
v9 = my_once_memdup(*((_QWORD *)a2 + 13), 512LL, 16LL);
*((_QWORD *)a1 + 13) = v9;
if ( !v9 )
return 1;
}
if ( *((_QWORD *)a2 + 7) )
{
v10 = my_once_strdup(*((_QWORD *)a2 + 7), 16LL);
*((_QWORD *)a1 + 7) = v10;
if ( !v10 )
return 1;
}
return 0;
}
| cs_copy_data:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX],0x0
JZ 0x001dca24
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x20],EAX
JMP 0x001dca2d
LAB_001dca24:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x20],EAX
LAB_001dca2d:
MOV ECX,dword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x10],0x0
JZ 0x001dca8d
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x10],0x0
JNZ 0x001dca8d
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RAX + 0x18]
ADD RSI,0x1
MOV EDX,0x10
CALL 0x001f4160
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x10],RAX
CMP RAX,0x0
JNZ 0x001dca7d
JMP 0x001dcc69
LAB_001dca7d:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x18],RCX
LAB_001dca8d:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x20],0x0
JZ 0x001dcad9
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RAX + 0x28]
ADD RSI,0x1
MOV EDX,0x10
CALL 0x001f4160
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x20],RAX
CMP RAX,0x0
JNZ 0x001dcac9
JMP 0x001dcc69
LAB_001dcac9:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX + 0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x28],RCX
LAB_001dcad9:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x30],0x0
JZ 0x001dcb0b
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x30]
MOV ESI,0x10
CALL 0x001f4100
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x30],RAX
CMP RAX,0x0
JNZ 0x001dcb09
JMP 0x001dcc69
LAB_001dcb09:
JMP 0x001dcb0b
LAB_001dcb0b:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x40],0x0
JZ 0x001dcb54
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x40]
MOV ESI,0x101
MOV EDX,0x10
CALL 0x001f4160
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x40],RAX
CMP RAX,0x0
JNZ 0x001dcb40
JMP 0x001dcc69
LAB_001dcb40:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001dcd80
CMP AL,0x0
JZ 0x001dcb52
JMP 0x001dcc69
LAB_001dcb52:
JMP 0x001dcb54
LAB_001dcb54:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x48],0x0
JZ 0x001dcb8b
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x48]
MOV ESI,0x100
MOV EDX,0x10
CALL 0x001f4160
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x48],RAX
CMP RAX,0x0
JNZ 0x001dcb89
JMP 0x001dcc69
LAB_001dcb89:
JMP 0x001dcb8b
LAB_001dcb8b:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x50],0x0
JZ 0x001dcbc2
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x50]
MOV ESI,0x100
MOV EDX,0x10
CALL 0x001f4160
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x50],RAX
CMP RAX,0x0
JNZ 0x001dcbc0
JMP 0x001dcc69
LAB_001dcbc0:
JMP 0x001dcbc2
LAB_001dcbc2:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x58],0x0
JZ 0x001dcbf6
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x58]
MOV ESI,0x100
MOV EDX,0x10
CALL 0x001f4160
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x58],RAX
CMP RAX,0x0
JNZ 0x001dcbf4
JMP 0x001dcc69
LAB_001dcbf4:
JMP 0x001dcbf6
LAB_001dcbf6:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x68],0x0
JZ 0x001dcc31
MOV dword ptr [RBP + -0x1c],0x200
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x68]
MOV EAX,dword ptr [RBP + -0x1c]
MOV ESI,EAX
MOV EDX,0x10
CALL 0x001f4160
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x68],RAX
CMP RAX,0x0
JNZ 0x001dcc2f
JMP 0x001dcc69
LAB_001dcc2f:
JMP 0x001dcc31
LAB_001dcc31:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x38],0x0
JZ 0x001dcc60
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x38]
MOV ESI,0x10
CALL 0x001f4100
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x38],RAX
CMP RAX,0x0
JNZ 0x001dcc5e
JMP 0x001dcc69
LAB_001dcc5e:
JMP 0x001dcc60
LAB_001dcc60:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001dcc70
LAB_001dcc69:
MOV dword ptr [RBP + -0x4],0x1
LAB_001dcc70:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int4 cs_copy_data(int *param_1,int *param_2)
{
char cVar1;
long lVar2;
int local_28;
int4 local_c;
if (*param_2 == 0) {
local_28 = *param_1;
}
else {
local_28 = *param_2;
}
*param_1 = local_28;
if ((*(long *)(param_2 + 4) == 0) || (*(long *)(param_1 + 4) != 0)) {
LAB_001dca8d:
if (*(long *)(param_2 + 8) != 0) {
lVar2 = my_once_memdup(*(int8 *)(param_2 + 8),*(long *)(param_2 + 10) + 1,0x10);
*(long *)(param_1 + 8) = lVar2;
if (lVar2 == 0) goto LAB_001dcc69;
*(int8 *)(param_1 + 10) = *(int8 *)(param_2 + 10);
}
if (*(long *)(param_2 + 0xc) != 0) {
lVar2 = my_once_strdup(*(int8 *)(param_2 + 0xc),0x10);
*(long *)(param_1 + 0xc) = lVar2;
if (lVar2 == 0) goto LAB_001dcc69;
}
if (*(long *)(param_2 + 0x10) != 0) {
lVar2 = my_once_memdup(*(int8 *)(param_2 + 0x10),0x101,0x10);
*(long *)(param_1 + 0x10) = lVar2;
if ((lVar2 == 0) || (cVar1 = init_state_maps(param_1), cVar1 != '\0')) goto LAB_001dcc69;
}
if (*(long *)(param_2 + 0x12) != 0) {
lVar2 = my_once_memdup(*(int8 *)(param_2 + 0x12),0x100,0x10);
*(long *)(param_1 + 0x12) = lVar2;
if (lVar2 == 0) goto LAB_001dcc69;
}
if (*(long *)(param_2 + 0x14) != 0) {
lVar2 = my_once_memdup(*(int8 *)(param_2 + 0x14),0x100,0x10);
*(long *)(param_1 + 0x14) = lVar2;
if (lVar2 == 0) goto LAB_001dcc69;
}
if (*(long *)(param_2 + 0x16) != 0) {
lVar2 = my_once_memdup(*(int8 *)(param_2 + 0x16),0x100,0x10);
*(long *)(param_1 + 0x16) = lVar2;
if (lVar2 == 0) goto LAB_001dcc69;
}
if (*(long *)(param_2 + 0x1a) != 0) {
lVar2 = my_once_memdup(*(int8 *)(param_2 + 0x1a),0x200,0x10);
*(long *)(param_1 + 0x1a) = lVar2;
if (lVar2 == 0) goto LAB_001dcc69;
}
if (*(long *)(param_2 + 0xe) != 0) {
lVar2 = my_once_strdup(*(int8 *)(param_2 + 0xe),0x10);
*(long *)(param_1 + 0xe) = lVar2;
if (lVar2 == 0) goto LAB_001dcc69;
}
local_c = 0;
}
else {
lVar2 = my_once_memdup(*(int8 *)(param_2 + 4),*(long *)(param_2 + 6) + 1,0x10);
*(long *)(param_1 + 4) = lVar2;
if (lVar2 != 0) {
*(int8 *)(param_1 + 6) = *(int8 *)(param_2 + 6);
goto LAB_001dca8d;
}
LAB_001dcc69:
local_c = 1;
}
return local_c;
}
| |
44,824 | ma_service_thread_control_init | eloqsql/storage/maria/ma_servicethread.c | int ma_service_thread_control_init(MA_SERVICE_THREAD_CONTROL *control)
{
int res= 0;
DBUG_ENTER("ma_service_thread_control_init");
DBUG_PRINT("init", ("control %p", control));
control->inited= TRUE;
control->killed= FALSE;
res= (mysql_mutex_init(key_SERVICE_THREAD_CONTROL_lock,
control->LOCK_control, MY_MUTEX_INIT_SLOW) ||
mysql_cond_init(key_SERVICE_THREAD_CONTROL_cond,
control->COND_control, 0));
DBUG_PRINT("info", ("init: %s", (res ? "Error" : "OK")));
DBUG_RETURN(res);
} | O0 | c | ma_service_thread_control_init:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
jmp 0x43395
movq -0x8(%rbp), %rax
movb $0x1, 0x9(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x8(%rax)
leaq 0x4365c0(%rip), %rax # 0x47996c
movl (%rax), %edi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x43410
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0xd(%rbp)
jne 0x433ee
leaq 0x4365aa(%rip), %rax # 0x47997c
movl (%rax), %edi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x43480
cmpl $0x0, %eax
setne %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xc(%rbp)
jmp 0x433fb
jmp 0x433fd
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| ma_service_thread_control_init:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_C], 0
jmp short $+2
loc_43395:
mov rax, [rbp+var_8]
mov byte ptr [rax+9], 1
mov rax, [rbp+var_8]
mov byte ptr [rax+8], 0
lea rax, key_SERVICE_THREAD_CONTROL_lock
mov edi, [rax]
mov rax, [rbp+var_8]
mov rsi, [rax+10h]
xor eax, eax
mov edx, eax
call inline_mysql_mutex_init_1
mov ecx, eax
mov al, 1
cmp ecx, 0
mov [rbp+var_D], al
jnz short loc_433EE
lea rax, key_SERVICE_THREAD_CONTROL_cond
mov edi, [rax]
mov rax, [rbp+var_8]
mov rsi, [rax+18h]
xor eax, eax
mov edx, eax
call inline_mysql_cond_init_0
cmp eax, 0
setnz al
mov [rbp+var_D], al
loc_433EE:
mov al, [rbp+var_D]
and al, 1
movzx eax, al
mov [rbp+var_C], eax
jmp short $+2
loc_433FB:
jmp short $+2
loc_433FD:
mov eax, [rbp+var_C]
mov [rbp+var_14], eax
mov eax, [rbp+var_14]
add rsp, 20h
pop rbp
retn
| _BOOL8 ma_service_thread_control_init(long long a1)
{
bool v2; // [rsp+13h] [rbp-Dh]
*(_BYTE *)(a1 + 9) = 1;
*(_BYTE *)(a1 + 8) = 0;
v2 = 1;
if ( !(unsigned int)inline_mysql_mutex_init_1(key_SERVICE_THREAD_CONTROL_lock, *(_QWORD *)(a1 + 16), 0LL) )
return (unsigned int)inline_mysql_cond_init_0(key_SERVICE_THREAD_CONTROL_cond, *(_QWORD *)(a1 + 24), 0LL) != 0;
return v2;
}
| ma_service_thread_control_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00143395
LAB_00143395:
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x9],0x1
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x8],0x0
LEA RAX,[0x57996c]
MOV EDI,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RAX + 0x10]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x00143410
MOV ECX,EAX
MOV AL,0x1
CMP ECX,0x0
MOV byte ptr [RBP + -0xd],AL
JNZ 0x001433ee
LEA RAX,[0x57997c]
MOV EDI,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RAX + 0x18]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x00143480
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0xd],AL
LAB_001433ee:
MOV AL,byte ptr [RBP + -0xd]
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RBP + -0xc],EAX
JMP 0x001433fb
LAB_001433fb:
JMP 0x001433fd
LAB_001433fd:
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x14]
ADD RSP,0x20
POP RBP
RET
|
bool ma_service_thread_control_init(long param_1)
{
int iVar1;
bool local_15;
*(int1 *)(param_1 + 9) = 1;
*(int1 *)(param_1 + 8) = 0;
iVar1 = inline_mysql_mutex_init(key_SERVICE_THREAD_CONTROL_lock,*(int8 *)(param_1 + 0x10),0)
;
local_15 = true;
if (iVar1 == 0) {
iVar1 = inline_mysql_cond_init
(key_SERVICE_THREAD_CONTROL_cond,*(int8 *)(param_1 + 0x18),0);
local_15 = iVar1 != 0;
}
return local_15;
}
| |
44,825 | ma_write_undo_key_insert | eloqsql/storage/maria/ma_write.c | int _ma_write_undo_key_insert(MARIA_HA *info, const MARIA_KEY *key,
my_off_t *root, my_off_t new_root, LSN *res_lsn)
{
MARIA_SHARE *share= info->s;
MARIA_KEYDEF *keyinfo= key->keyinfo;
uchar log_data[LSN_STORE_SIZE + FILEID_STORE_SIZE +
KEY_NR_STORE_SIZE];
const uchar *key_value;
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 2];
struct st_msg_to_write_hook_for_undo_key msg;
uint key_length;
/* Save if we need to write a clr record */
lsn_store(log_data, info->trn->undo_lsn);
key_nr_store(log_data + LSN_STORE_SIZE + FILEID_STORE_SIZE,
keyinfo->key_nr);
key_length= key->data_length + key->ref_length;
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= log_data;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= sizeof(log_data);
log_array[TRANSLOG_INTERNAL_PARTS + 1].str= key->data;
log_array[TRANSLOG_INTERNAL_PARTS + 1].length= key_length;
msg.root= root;
msg.value= new_root;
msg.auto_increment= 0;
key_value= key->data;
if (share->base.auto_key == ((uint) keyinfo->key_nr + 1))
{
const HA_KEYSEG *keyseg= keyinfo->seg;
uchar reversed[MARIA_MAX_KEY_BUFF];
if (keyseg->flag & HA_SWAP_KEY)
{
/* We put key from log record to "data record" packing format... */
const uchar *key_ptr= key->data, *key_end= key->data + keyseg->length;
uchar *to= reversed + keyseg->length;
do
{
*--to= *key_ptr++;
} while (key_ptr != key_end);
key_value= to;
}
/* ... so that we can read it with: */
msg.auto_increment=
ma_retrieve_auto_increment(key_value, keyseg->type);
/* and write_hook_for_undo_key_insert() will pick this. */
}
return translog_write_record(res_lsn, LOGREC_UNDO_KEY_INSERT,
info->trn, info,
(translog_size_t)
log_array[TRANSLOG_INTERNAL_PARTS + 0].length +
key_length,
TRANSLOG_INTERNAL_PARTS + 2, log_array,
log_data + LSN_STORE_SIZE, &msg) ? -1 : 0;
} | O0 | c | ma_write_undo_key_insert:
pushq %rbp
movq %rsp, %rbp
subq $0xae0, %rsp # imm = 0xAE0
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x9f8(%rbp)
movq %rsi, -0xa00(%rbp)
movq %rdx, -0xa08(%rbp)
movq %rcx, -0xa10(%rbp)
movq %r8, -0xa18(%rbp)
movq -0x9f8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xa20(%rbp)
movq -0xa00(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xa28(%rbp)
jmp 0x69700
movq -0x9f8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x98(%rax), %rax
sarq $0x20, %rax
movb %al, -0x12(%rbp)
movq -0x9f8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x98(%rax), %rax
sarq $0x20, %rax
shrl $0x8, %eax
movb %al, -0x11(%rbp)
movq -0x9f8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x98(%rax), %rax
sarq $0x20, %rax
shrl $0x10, %eax
movb %al, -0x10(%rbp)
jmp 0x69753
leaq -0x12(%rbp), %rax
addq $0x3, %rax
movq %rax, -0xaa0(%rbp)
movq -0x9f8(%rbp), %rax
movq 0x8(%rax), %rcx
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq 0x98(%rcx), %rax
movl %eax, %ecx
movq -0xaa0(%rbp), %rax
movl %ecx, (%rax)
jmp 0x6978b
movq -0xa28(%rbp), %rax
movb 0xa5(%rax), %al
movb %al, -0x9(%rbp)
movq -0xa00(%rbp), %rax
movl 0x10(%rax), %eax
movq -0xa00(%rbp), %rcx
addl 0x14(%rcx), %eax
movl %eax, -0xa94(%rbp)
leaq -0x12(%rbp), %rax
movq %rax, -0xa50(%rbp)
movq $0xa, -0xa48(%rbp)
movq -0xa00(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xa40(%rbp)
movl -0xa94(%rbp), %eax
movq %rax, -0xa38(%rbp)
movq -0xa08(%rbp), %rax
movq %rax, -0xa90(%rbp)
movq -0xa10(%rbp), %rax
movq %rax, -0xa88(%rbp)
movq $0x0, -0xa78(%rbp)
movq -0xa00(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xa30(%rbp)
movq -0xa20(%rbp), %rax
movl 0x3ec(%rax), %eax
movq -0xa28(%rbp), %rcx
movzbl 0xa5(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jne 0x69930
movq -0xa28(%rbp), %rax
movq 0xc0(%rax), %rax
movq %rax, -0xaa8(%rbp)
movq -0xaa8(%rbp), %rax
movzwl 0x12(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x69912
movq -0xa00(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xab0(%rbp)
movq -0xa00(%rbp), %rax
movq (%rax), %rax
movq -0xaa8(%rbp), %rcx
movzwl 0x14(%rcx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0xab8(%rbp)
leaq -0x9f0(%rbp), %rax
movq -0xaa8(%rbp), %rcx
movzwl 0x14(%rcx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0xac0(%rbp)
movq -0xab0(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xab0(%rbp)
movb (%rax), %cl
movq -0xac0(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0xac0(%rbp)
movb %cl, -0x1(%rax)
movq -0xab0(%rbp), %rax
cmpq -0xab8(%rbp), %rax
jne 0x698c5
movq -0xac0(%rbp), %rax
movq %rax, -0xa30(%rbp)
movq -0xa30(%rbp), %rdi
movq -0xaa8(%rbp), %rax
movzbl 0x18(%rax), %esi
callq 0x46710
movq %rax, -0xa78(%rbp)
movq -0xa18(%rbp), %rdi
movq -0x9f8(%rbp), %rcx
movq 0x8(%rcx), %rdx
movl -0xa48(%rbp), %r8d
movl -0xa94(%rbp), %eax
addl %eax, %r8d
leaq -0xb(%rbp), %rsi
movq %rsp, %rax
leaq -0xa90(%rbp), %r9
movq %r9, 0x10(%rax)
movq %rsi, 0x8(%rax)
leaq -0xa70(%rbp), %rsi
movq %rsi, (%rax)
movl $0x15, %esi
movl $0x4, %r9d
callq 0x302c0
movb %al, %cl
xorl %eax, %eax
negb %cl
sbbl %eax, %eax
movl %eax, -0xac4(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x699b1
movl -0xac4(%rbp), %eax
addq $0xae0, %rsp # imm = 0xAE0
popq %rbp
retq
callq 0x2a250
nopw %cs:(%rax,%rax)
| _ma_write_undo_key_insert:
push rbp
mov rbp, rsp
sub rsp, 0AE0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_9F8], rdi
mov [rbp+var_A00], rsi
mov [rbp+var_A08], rdx
mov [rbp+var_A10], rcx
mov [rbp+var_A18], r8
mov rax, [rbp+var_9F8]
mov rax, [rax]
mov [rbp+var_A20], rax
mov rax, [rbp+var_A00]
mov rax, [rax+8]
mov [rbp+var_A28], rax
jmp short $+2
loc_69700:
mov rax, [rbp+var_9F8]
mov rax, [rax+8]
mov rax, [rax+98h]
sar rax, 20h
mov [rbp+var_12], al
mov rax, [rbp+var_9F8]
mov rax, [rax+8]
mov rax, [rax+98h]
sar rax, 20h
shr eax, 8
mov [rbp+var_11], al
mov rax, [rbp+var_9F8]
mov rax, [rax+8]
mov rax, [rax+98h]
sar rax, 20h
shr eax, 10h
mov [rbp+var_10], al
jmp short $+2
loc_69753:
lea rax, [rbp+var_12]
add rax, 3
mov [rbp+var_AA0], rax
mov rax, [rbp+var_9F8]
mov rcx, [rax+8]
mov rax, 0FFFFFFFFh
and rax, [rcx+98h]
mov ecx, eax
mov rax, [rbp+var_AA0]
mov [rax], ecx
jmp short $+2
loc_6978B:
mov rax, [rbp+var_A28]
mov al, [rax+0A5h]
mov [rbp+var_9], al
mov rax, [rbp+var_A00]
mov eax, [rax+10h]
mov rcx, [rbp+var_A00]
add eax, [rcx+14h]
mov [rbp+var_A94], eax
lea rax, [rbp+var_12]
mov [rbp+var_A50], rax
mov [rbp+var_A48], 0Ah
mov rax, [rbp+var_A00]
mov rax, [rax]
mov [rbp+var_A40], rax
mov eax, [rbp+var_A94]
mov [rbp+var_A38], rax
mov rax, [rbp+var_A08]
mov [rbp+var_A90], rax
mov rax, [rbp+var_A10]
mov [rbp+var_A88], rax
mov [rbp+var_A78], 0
mov rax, [rbp+var_A00]
mov rax, [rax]
mov [rbp+var_A30], rax
mov rax, [rbp+var_A20]
mov eax, [rax+3ECh]
mov rcx, [rbp+var_A28]
movzx ecx, byte ptr [rcx+0A5h]
add ecx, 1
cmp eax, ecx
jnz loc_69930
mov rax, [rbp+var_A28]
mov rax, [rax+0C0h]
mov [rbp+var_AA8], rax
mov rax, [rbp+var_AA8]
movzx eax, word ptr [rax+12h]
and eax, 40h
cmp eax, 0
jz loc_69912
mov rax, [rbp+var_A00]
mov rax, [rax]
mov [rbp+var_AB0], rax
mov rax, [rbp+var_A00]
mov rax, [rax]
mov rcx, [rbp+var_AA8]
movzx ecx, word ptr [rcx+14h]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_AB8], rax
lea rax, [rbp+var_9F0]
mov rcx, [rbp+var_AA8]
movzx ecx, word ptr [rcx+14h]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_AC0], rax
loc_698C5:
mov rax, [rbp+var_AB0]
mov rcx, rax
add rcx, 1
mov [rbp+var_AB0], rcx
mov cl, [rax]
mov rax, [rbp+var_AC0]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_AC0], rdx
mov [rax-1], cl
mov rax, [rbp+var_AB0]
cmp rax, [rbp+var_AB8]
jnz short loc_698C5
mov rax, [rbp+var_AC0]
mov [rbp+var_A30], rax
loc_69912:
mov rdi, [rbp+var_A30]
mov rax, [rbp+var_AA8]
movzx esi, byte ptr [rax+18h]
call ma_retrieve_auto_increment
mov [rbp+var_A78], rax
loc_69930:
mov rdi, [rbp+var_A18]
mov rcx, [rbp+var_9F8]
mov rdx, [rcx+8]
mov r8d, dword ptr [rbp+var_A48]
mov eax, [rbp+var_A94]
add r8d, eax
lea rsi, [rbp+var_B]
mov rax, rsp
lea r9, [rbp+var_A90]
mov [rax+10h], r9
mov [rax+8], rsi
lea rsi, [rbp+var_A70]
mov [rax], rsi
mov esi, 15h
mov r9d, 4
call translog_write_record
mov cl, al
xor eax, eax
neg cl
sbb eax, eax
mov [rbp+var_AC4], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_699B1
mov eax, [rbp+var_AC4]
add rsp, 0AE0h
pop rbp
retn
loc_699B1:
call ___stack_chk_fail
| long long ma_write_undo_key_insert(long long *a1, float **a2, long long a3, long long a4, long long a5)
{
float *v5; // rax
char v6; // cl
float *v7; // rax
float *v9; // [rsp+20h] [rbp-AC0h]
float *v10; // [rsp+28h] [rbp-AB8h]
float *v11; // [rsp+30h] [rbp-AB0h]
long long v12; // [rsp+38h] [rbp-AA8h]
unsigned int v13; // [rsp+4Ch] [rbp-A94h]
_QWORD v14[3]; // [rsp+50h] [rbp-A90h] BYREF
long long auto_increment; // [rsp+68h] [rbp-A78h]
_QWORD v16[5]; // [rsp+70h] [rbp-A70h] BYREF
long long v17; // [rsp+98h] [rbp-A48h]
float *v18; // [rsp+A0h] [rbp-A40h]
long long v19; // [rsp+A8h] [rbp-A38h]
float *v20; // [rsp+B0h] [rbp-A30h]
float *v21; // [rsp+B8h] [rbp-A28h]
long long v22; // [rsp+C0h] [rbp-A20h]
long long v23; // [rsp+C8h] [rbp-A18h]
long long v24; // [rsp+D0h] [rbp-A10h]
long long v25; // [rsp+D8h] [rbp-A08h]
float **v26; // [rsp+E0h] [rbp-A00h]
long long *v27; // [rsp+E8h] [rbp-9F8h]
_BYTE v28[2526]; // [rsp+F0h] [rbp-9F0h] BYREF
_BYTE v29[3]; // [rsp+ACEh] [rbp-12h] BYREF
int v30; // [rsp+AD1h] [rbp-Fh]
__int16 v31; // [rsp+AD5h] [rbp-Bh] BYREF
char v32; // [rsp+AD7h] [rbp-9h]
unsigned long long v33; // [rsp+AD8h] [rbp-8h]
v33 = __readfsqword(0x28u);
v27 = a1;
v26 = a2;
v25 = a3;
v24 = a4;
v23 = a5;
v22 = *a1;
v21 = a2[1];
v29[0] = BYTE4(*(_QWORD *)(a1[1] + 152));
v29[1] = (unsigned __int16)WORD2(*(_QWORD *)(a1[1] + 152)) >> 8;
v29[2] = BYTE6(*(_QWORD *)(a1[1] + 152));
v30 = *(_QWORD *)(a1[1] + 152);
v32 = *((_BYTE *)v21 + 165);
v13 = *((_DWORD *)v26 + 5) + *((_DWORD *)v26 + 4);
v16[4] = v29;
v17 = 10LL;
v18 = *a2;
v19 = v13;
v14[0] = a3;
v14[1] = a4;
auto_increment = 0LL;
v20 = *a2;
if ( *(_DWORD *)(v22 + 1004) == *((unsigned __int8 *)v21 + 165) + 1 )
{
v12 = *((_QWORD *)v21 + 24);
if ( (*(_WORD *)(v12 + 18) & 0x40) != 0 )
{
v11 = *v26;
v10 = (float *)((char *)*v26 + *(unsigned __int16 *)(v12 + 20));
v9 = (float *)&v28[*(unsigned __int16 *)(v12 + 20)];
do
{
v5 = v11;
v11 = (float *)((char *)v11 + 1);
v6 = *(_BYTE *)v5;
v7 = v9;
v9 = (float *)((char *)v9 - 1);
*((_BYTE *)v7 - 1) = v6;
}
while ( v11 != v10 );
v20 = v9;
}
auto_increment = ma_retrieve_auto_increment(v20, *(_BYTE *)(v12 + 24));
}
return (unsigned int)-(translog_write_record(v23, 0x15u, v27[1], v27, v13 + v17, 4u, v16, &v31, (long long)v14) != 0);
}
| _ma_write_undo_key_insert:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xae0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x9f8],RDI
MOV qword ptr [RBP + -0xa00],RSI
MOV qword ptr [RBP + -0xa08],RDX
MOV qword ptr [RBP + -0xa10],RCX
MOV qword ptr [RBP + -0xa18],R8
MOV RAX,qword ptr [RBP + -0x9f8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0xa20],RAX
MOV RAX,qword ptr [RBP + -0xa00]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0xa28],RAX
JMP 0x00169700
LAB_00169700:
MOV RAX,qword ptr [RBP + -0x9f8]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x98]
SAR RAX,0x20
MOV byte ptr [RBP + -0x12],AL
MOV RAX,qword ptr [RBP + -0x9f8]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x98]
SAR RAX,0x20
SHR EAX,0x8
MOV byte ptr [RBP + -0x11],AL
MOV RAX,qword ptr [RBP + -0x9f8]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x98]
SAR RAX,0x20
SHR EAX,0x10
MOV byte ptr [RBP + -0x10],AL
JMP 0x00169753
LAB_00169753:
LEA RAX,[RBP + -0x12]
ADD RAX,0x3
MOV qword ptr [RBP + -0xaa0],RAX
MOV RAX,qword ptr [RBP + -0x9f8]
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,0xffffffff
AND RAX,qword ptr [RCX + 0x98]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0xaa0]
MOV dword ptr [RAX],ECX
JMP 0x0016978b
LAB_0016978b:
MOV RAX,qword ptr [RBP + -0xa28]
MOV AL,byte ptr [RAX + 0xa5]
MOV byte ptr [RBP + -0x9],AL
MOV RAX,qword ptr [RBP + -0xa00]
MOV EAX,dword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0xa00]
ADD EAX,dword ptr [RCX + 0x14]
MOV dword ptr [RBP + -0xa94],EAX
LEA RAX,[RBP + -0x12]
MOV qword ptr [RBP + -0xa50],RAX
MOV qword ptr [RBP + -0xa48],0xa
MOV RAX,qword ptr [RBP + -0xa00]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0xa40],RAX
MOV EAX,dword ptr [RBP + -0xa94]
MOV qword ptr [RBP + -0xa38],RAX
MOV RAX,qword ptr [RBP + -0xa08]
MOV qword ptr [RBP + -0xa90],RAX
MOV RAX,qword ptr [RBP + -0xa10]
MOV qword ptr [RBP + -0xa88],RAX
MOV qword ptr [RBP + -0xa78],0x0
MOV RAX,qword ptr [RBP + -0xa00]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0xa30],RAX
MOV RAX,qword ptr [RBP + -0xa20]
MOV EAX,dword ptr [RAX + 0x3ec]
MOV RCX,qword ptr [RBP + -0xa28]
MOVZX ECX,byte ptr [RCX + 0xa5]
ADD ECX,0x1
CMP EAX,ECX
JNZ 0x00169930
MOV RAX,qword ptr [RBP + -0xa28]
MOV RAX,qword ptr [RAX + 0xc0]
MOV qword ptr [RBP + -0xaa8],RAX
MOV RAX,qword ptr [RBP + -0xaa8]
MOVZX EAX,word ptr [RAX + 0x12]
AND EAX,0x40
CMP EAX,0x0
JZ 0x00169912
MOV RAX,qword ptr [RBP + -0xa00]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0xab0],RAX
MOV RAX,qword ptr [RBP + -0xa00]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0xaa8]
MOVZX ECX,word ptr [RCX + 0x14]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0xab8],RAX
LEA RAX,[RBP + -0x9f0]
MOV RCX,qword ptr [RBP + -0xaa8]
MOVZX ECX,word ptr [RCX + 0x14]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0xac0],RAX
LAB_001698c5:
MOV RAX,qword ptr [RBP + -0xab0]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0xab0],RCX
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0xac0]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RBP + -0xac0],RDX
MOV byte ptr [RAX + -0x1],CL
MOV RAX,qword ptr [RBP + -0xab0]
CMP RAX,qword ptr [RBP + -0xab8]
JNZ 0x001698c5
MOV RAX,qword ptr [RBP + -0xac0]
MOV qword ptr [RBP + -0xa30],RAX
LAB_00169912:
MOV RDI,qword ptr [RBP + -0xa30]
MOV RAX,qword ptr [RBP + -0xaa8]
MOVZX ESI,byte ptr [RAX + 0x18]
CALL 0x00146710
MOV qword ptr [RBP + -0xa78],RAX
LAB_00169930:
MOV RDI,qword ptr [RBP + -0xa18]
MOV RCX,qword ptr [RBP + -0x9f8]
MOV RDX,qword ptr [RCX + 0x8]
MOV R8D,dword ptr [RBP + -0xa48]
MOV EAX,dword ptr [RBP + -0xa94]
ADD R8D,EAX
LEA RSI,[RBP + -0xb]
MOV RAX,RSP
LEA R9,[RBP + -0xa90]
MOV qword ptr [RAX + 0x10],R9
MOV qword ptr [RAX + 0x8],RSI
LEA RSI,[RBP + -0xa70]
MOV qword ptr [RAX],RSI
MOV ESI,0x15
MOV R9D,0x4
CALL 0x001302c0
MOV CL,AL
XOR EAX,EAX
NEG CL
SBB EAX,EAX
MOV dword ptr [RBP + -0xac4],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001699b1
MOV EAX,dword ptr [RBP + -0xac4]
ADD RSP,0xae0
POP RBP
RET
LAB_001699b1:
CALL 0x0012a250
|
int _ma_write_undo_key_insert
(long *param_1,long *param_2,int8 param_3,int8 param_4,int8 param_5)
{
ushort uVar1;
long lVar2;
long lVar3;
char cVar4;
uint uVar5;
int1 *puVar6;
long in_FS_OFFSET;
int1 *local_ac8;
int1 *local_ab8;
int8 local_a98;
int8 local_a90;
int8 local_a80;
int1 local_a78 [32];
int1 *local_a58;
int8 local_a50;
long local_a48;
ulong local_a40;
int1 *local_a38;
long local_a30;
long local_a28;
int8 local_a20;
int8 local_a18;
int8 local_a10;
long *local_a08;
long *local_a00;
int1 local_9f8 [2526];
int1 local_1a;
int1 local_19;
int1 local_18;
int4 local_17;
int1 local_13 [2];
int1 local_11;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_a28 = *param_1;
local_a30 = param_2[1];
local_1a = (int1)((ulong)*(int8 *)(param_1[1] + 0x98) >> 0x20);
local_19 = (int1)((ulong)*(int8 *)(param_1[1] + 0x98) >> 0x28);
local_18 = (int1)((ulong)*(int8 *)(param_1[1] + 0x98) >> 0x30);
local_17 = (int4)*(int8 *)(param_1[1] + 0x98);
local_11 = *(int1 *)(local_a30 + 0xa5);
uVar5 = (int)param_2[2] + *(int *)((long)param_2 + 0x14);
local_a58 = &local_1a;
local_a50 = 10;
local_a48 = *param_2;
local_a40 = (ulong)uVar5;
local_a80 = 0;
local_a38 = (int1 *)*param_2;
local_a98 = param_3;
local_a90 = param_4;
local_a20 = param_5;
local_a18 = param_4;
local_a10 = param_3;
local_a08 = param_2;
local_a00 = param_1;
if (*(int *)(local_a28 + 0x3ec) == *(byte *)(local_a30 + 0xa5) + 1) {
lVar2 = *(long *)(local_a30 + 0xc0);
if ((*(ushort *)(lVar2 + 0x12) & 0x40) != 0) {
lVar3 = *param_2;
uVar1 = *(ushort *)(lVar2 + 0x14);
local_ac8 = local_9f8 + (int)(uint)*(ushort *)(lVar2 + 0x14);
local_ab8 = (int1 *)*param_2;
do {
puVar6 = local_ab8 + 1;
local_a38 = local_ac8 + -1;
local_ac8[-1] = *local_ab8;
local_ac8 = local_a38;
local_ab8 = puVar6;
} while (puVar6 != (int1 *)(lVar3 + (int)(uint)uVar1));
}
local_a80 = ma_retrieve_auto_increment(local_a38,*(int1 *)(lVar2 + 0x18));
}
cVar4 = translog_write_record
(local_a20,0x15,local_a00[1],local_a00,(int)local_a50 + uVar5,4,local_a78,
local_13,&local_a98);
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return -(uint)(cVar4 != '\0');
}
| |
44,826 | ftxui::(anonymous namespace)::InputBase::HandleArrowLeft() | Andrewchistyakov[P]flashcards_lyc/build_O1/_deps/ftxui-src/src/ftxui/component/input.cpp | bool HandleArrowLeft() {
if (cursor_position() == 0) {
return false;
}
cursor_position() = GlyphPrevious(content(), cursor_position());
return true;
} | O1 | cpp | ftxui::(anonymous namespace)::InputBase::HandleArrowLeft():
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0xf8(%rdi), %rbx
movq %rbx, %rdi
callq 0x2cdc2
movl (%rax), %ebp
testl %ebp, %ebp
je 0x2bfe6
addq $0x28, %r14
movq %r14, %rdi
callq 0x2c944
movq %rax, %r14
movq %rbx, %rdi
callq 0x2cdc2
movslq (%rax), %rsi
movq %r14, %rdi
callq 0x3b8e3
movq %rax, %r14
movq %rbx, %rdi
callq 0x2cdc2
movl %r14d, (%rax)
testl %ebp, %ebp
setne %al
popq %rbx
popq %r14
popq %rbp
retq
| _ZN5ftxui12_GLOBAL__N_19InputBase15HandleArrowLeftEv:
push rbp
push r14
push rbx
mov r14, rdi
lea rbx, [rdi+0F8h]
mov rdi, rbx
call _ZN5ftxui3RefIiE7AddressEv; ftxui::Ref<int>::Address(void)
mov ebp, [rax]
test ebp, ebp
jz short loc_2BFE6
add r14, 28h ; '('
mov rdi, r14
call _ZN5ftxui3RefINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE7AddressEv; ftxui::Ref<std::string>::Address(void)
mov r14, rax
mov rdi, rbx
call _ZN5ftxui3RefIiE7AddressEv; ftxui::Ref<int>::Address(void)
movsxd rsi, dword ptr [rax]
mov rdi, r14
call _ZN5ftxui13GlyphPreviousERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEm; ftxui::GlyphPrevious(std::string const&,ulong)
mov r14, rax
mov rdi, rbx
call _ZN5ftxui3RefIiE7AddressEv; ftxui::Ref<int>::Address(void)
mov [rax], r14d
loc_2BFE6:
test ebp, ebp
setnz al
pop rbx
pop r14
pop rbp
retn
| bool ftxui::`anonymous namespace'::InputBase::HandleArrowLeft(ftxui::_anonymous_namespace_::InputBase *this)
{
char *v1; // rbx
int v2; // ebp
long long v3; // r14
int *v4; // rax
v1 = (char *)this + 248;
v2 = *(_DWORD *)ftxui::Ref<int>::Address((char *)this + 248);
if ( v2 )
{
v3 = ftxui::Ref<std::string>::Address((char *)this + 40);
v4 = (int *)ftxui::Ref<int>::Address(v1);
LODWORD(v3) = ftxui::GlyphPrevious(v3, *v4);
*(_DWORD *)ftxui::Ref<int>::Address(v1) = v3;
}
return v2 != 0;
}
| HandleArrowLeft:
PUSH RBP
PUSH R14
PUSH RBX
MOV R14,RDI
LEA RBX,[RDI + 0xf8]
MOV RDI,RBX
CALL 0x0012cdc2
MOV EBP,dword ptr [RAX]
TEST EBP,EBP
JZ 0x0012bfe6
ADD R14,0x28
MOV RDI,R14
CALL 0x0012c944
MOV R14,RAX
MOV RDI,RBX
CALL 0x0012cdc2
MOVSXD RSI,dword ptr [RAX]
MOV RDI,R14
CALL 0x0013b8e3
MOV R14,RAX
MOV RDI,RBX
CALL 0x0012cdc2
MOV dword ptr [RAX],R14D
LAB_0012bfe6:
TEST EBP,EBP
SETNZ AL
POP RBX
POP R14
POP RBP
RET
|
/* ftxui::(anonymous namespace)::InputBase::HandleArrowLeft() */
bool __thiscall ftxui::(anonymous_namespace)::InputBase::HandleArrowLeft(InputBase *this)
{
Ref<int> *this_00;
int iVar1;
int *piVar2;
string *psVar3;
int4 uVar4;
int4 *puVar5;
this_00 = (Ref<int> *)(this + 0xf8);
piVar2 = (int *)Ref<int>::Address(this_00);
iVar1 = *piVar2;
if (iVar1 != 0) {
psVar3 = (string *)
Ref<std::__cxx11::string>::Address((Ref<std::__cxx11::string> *)(this + 0x28));
piVar2 = (int *)Ref<int>::Address(this_00);
uVar4 = GlyphPrevious(psVar3,(long)*piVar2);
puVar5 = (int4 *)Ref<int>::Address(this_00);
*puVar5 = uVar4;
}
return iVar1 != 0;
}
| |
44,827 | thr_print_locks | eloqsql/mysys/thr_lock.c | void thr_print_locks(void)
{
LIST *list;
uint count=0;
mysql_mutex_lock(&THR_LOCK_lock);
puts("Current active THR (table level locks):");
for (list= thr_lock_thread_list; list && count++ < MAX_THREADS;
list= list_rest(list))
{
THR_LOCK *lock=(THR_LOCK*) list->data;
mysql_mutex_lock(&lock->mutex);
if ((lock->write.data || lock->read.data ||
lock->write_wait.data || lock->read_wait.data))
{
printf("lock: %p:", lock);
if ((lock->write_wait.data || lock->read_wait.data) &&
(! lock->read.data && ! lock->write.data))
printf(" WARNING: ");
if (lock->write.data)
printf(" write");
if (lock->write_wait.data)
printf(" write_wait");
if (lock->read.data)
printf(" read");
if (lock->read_wait.data)
printf(" read_wait");
puts("");
thr_print_lock("write",&lock->write);
thr_print_lock("write_wait",&lock->write_wait);
thr_print_lock("read",&lock->read);
thr_print_lock("read_wait",&lock->read_wait);
puts("");
}
mysql_mutex_unlock(&lock->mutex);
}
fflush(stdout);
mysql_mutex_unlock(&THR_LOCK_lock);
} | O0 | c | thr_print_locks:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0xc(%rbp)
leaq 0x379f5a(%rip), %rdi # 0x3ae0d0
leaq 0x53cf1(%rip), %rsi # 0x87e6e
movl $0x61b, %edx # imm = 0x61B
callq 0x321b0
leaq 0x53d1a(%rip), %rdi # 0x87ea8
callq 0x24480
leaq 0x37a1e6(%rip), %rax # 0x3ae380
movq (%rax), %rax
movq %rax, -0x8(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x19(%rbp)
je 0x341c3
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x3e8, %eax # imm = 0x3E8
setb %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x341cf
jmp 0x34372
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
leaq 0x53c84(%rip), %rsi # 0x87e6e
movl $0x621, %edx # imm = 0x621
callq 0x321b0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x90(%rax)
jne 0x3422a
movq -0x18(%rbp), %rax
cmpq $0x0, 0x70(%rax)
jne 0x3422a
movq -0x18(%rbp), %rax
cmpq $0x0, 0x80(%rax)
jne 0x3422a
movq -0x18(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x34354
movq -0x18(%rbp), %rsi
leaq 0x53c9b(%rip), %rdi # 0x87ed0
movb $0x0, %al
callq 0x24050
movq -0x18(%rbp), %rax
cmpq $0x0, 0x80(%rax)
jne 0x34255
movq -0x18(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x3427c
movq -0x18(%rbp), %rax
cmpq $0x0, 0x70(%rax)
jne 0x3427c
movq -0x18(%rbp), %rax
cmpq $0x0, 0x90(%rax)
jne 0x3427c
leaq 0x53c65(%rip), %rdi # 0x87eda
movb $0x0, %al
callq 0x24050
movq -0x18(%rbp), %rax
cmpq $0x0, 0x90(%rax)
je 0x34298
leaq 0x53c54(%rip), %rdi # 0x87ee5
movb $0x0, %al
callq 0x24050
movq -0x18(%rbp), %rax
cmpq $0x0, 0x80(%rax)
je 0x342b4
leaq 0x53c3f(%rip), %rdi # 0x87eec
movb $0x0, %al
callq 0x24050
movq -0x18(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0x342cd
leaq 0x57b12(%rip), %rdi # 0x8bdd8
movb $0x0, %al
callq 0x24050
movq -0x18(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x342e6
leaq 0x53c19(%rip), %rdi # 0x87ef8
movb $0x0, %al
callq 0x24050
leaq 0x5726f(%rip), %rdi # 0x8b55c
callq 0x24480
movq -0x18(%rbp), %rsi
addq $0x90, %rsi
leaq 0x53be2(%rip), %rdi # 0x87ee6
callq 0x343a0
movq -0x18(%rbp), %rsi
addq $0x80, %rsi
leaq 0x53bd2(%rip), %rdi # 0x87eed
callq 0x343a0
movq -0x18(%rbp), %rsi
addq $0x70, %rsi
leaq 0x57aaa(%rip), %rdi # 0x8bdd9
callq 0x343a0
movq -0x18(%rbp), %rsi
addq $0x60, %rsi
leaq 0x53bb6(%rip), %rdi # 0x87ef9
callq 0x343a0
leaq 0x5720d(%rip), %rdi # 0x8b55c
callq 0x24480
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x32220
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x341a1
movq 0x1a8c3f(%rip), %rax # 0x1dcfb8
movq (%rax), %rdi
callq 0x24300
leaq 0x379d48(%rip), %rdi # 0x3ae0d0
callq 0x32220
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| thr_print_locks:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_C], 0
lea rdi, THR_LOCK_lock
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 61Bh
call inline_mysql_mutex_lock_4
lea rdi, aCurrentActiveT; "Current active THR (table level locks):"
call _puts
lea rax, thr_lock_thread_list
mov rax, [rax]
mov [rbp+var_8], rax
loc_341A1:
xor eax, eax
cmp [rbp+var_8], 0
mov [rbp+var_19], al
jz short loc_341C3
mov eax, [rbp+var_C]
mov ecx, eax
add ecx, 1
mov [rbp+var_C], ecx
cmp eax, 3E8h
setb al
mov [rbp+var_19], al
loc_341C3:
mov al, [rbp+var_19]
test al, 1
jnz short loc_341CF
jmp loc_34372
loc_341CF:
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov [rbp+var_18], rax
mov rdi, [rbp+var_18]
add rdi, 18h
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 621h
call inline_mysql_mutex_lock_4
mov rax, [rbp+var_18]
cmp qword ptr [rax+90h], 0
jnz short loc_3422A
mov rax, [rbp+var_18]
cmp qword ptr [rax+70h], 0
jnz short loc_3422A
mov rax, [rbp+var_18]
cmp qword ptr [rax+80h], 0
jnz short loc_3422A
mov rax, [rbp+var_18]
cmp qword ptr [rax+60h], 0
jz loc_34354
loc_3422A:
mov rsi, [rbp+var_18]
lea rdi, aLockP; "lock: %p:"
mov al, 0
call _printf
mov rax, [rbp+var_18]
cmp qword ptr [rax+80h], 0
jnz short loc_34255
mov rax, [rbp+var_18]
cmp qword ptr [rax+60h], 0
jz short loc_3427C
loc_34255:
mov rax, [rbp+var_18]
cmp qword ptr [rax+70h], 0
jnz short loc_3427C
mov rax, [rbp+var_18]
cmp qword ptr [rax+90h], 0
jnz short loc_3427C
lea rdi, aWarning; " WARNING: "
mov al, 0
call _printf
loc_3427C:
mov rax, [rbp+var_18]
cmp qword ptr [rax+90h], 0
jz short loc_34298
lea rdi, aWrite; " write"
mov al, 0
call _printf
loc_34298:
mov rax, [rbp+var_18]
cmp qword ptr [rax+80h], 0
jz short loc_342B4
lea rdi, aWriteWait; " write_wait"
mov al, 0
call _printf
loc_342B4:
mov rax, [rbp+var_18]
cmp qword ptr [rax+70h], 0
jz short loc_342CD
lea rdi, aTheEventWasCor+34h; " read"
mov al, 0
call _printf
loc_342CD:
mov rax, [rbp+var_18]
cmp qword ptr [rax+60h], 0
jz short loc_342E6
lea rdi, aReadWait; " read_wait"
mov al, 0
call _printf
loc_342E6:
lea rdi, asc_8B558+4; ""
call _puts
mov rsi, [rbp+var_18]
add rsi, 90h
lea rdi, aWrite+1; "write"
call thr_print_lock
mov rsi, [rbp+var_18]
add rsi, 80h
lea rdi, aWriteWait+1; "write_wait"
call thr_print_lock
mov rsi, [rbp+var_18]
add rsi, 70h ; 'p'
lea rdi, aTheEventWasCor+35h; "read"
call thr_print_lock
mov rsi, [rbp+var_18]
add rsi, 60h ; '`'
lea rdi, aReadWait+1; "read_wait"
call thr_print_lock
lea rdi, asc_8B558+4; ""
call _puts
loc_34354:
mov rdi, [rbp+var_18]
add rdi, 18h
call inline_mysql_mutex_unlock_4
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov [rbp+var_8], rax
jmp loc_341A1
loc_34372:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
lea rdi, THR_LOCK_lock
call inline_mysql_mutex_unlock_4
add rsp, 20h
pop rbp
retn
| long long thr_print_locks()
{
unsigned int v0; // eax
bool v2; // [rsp+7h] [rbp-19h]
_QWORD *v3; // [rsp+8h] [rbp-18h]
unsigned int v4; // [rsp+14h] [rbp-Ch]
long long i; // [rsp+18h] [rbp-8h]
v4 = 0;
inline_mysql_mutex_lock_4(
(long long)&THR_LOCK_lock,
(long long)"/workspace/llm4binary/github2025/eloqsql/mysys/thr_lock.c",
0x61Bu);
puts("Current active THR (table level locks):");
for ( i = thr_lock_thread_list; ; i = *(_QWORD *)(i + 8) )
{
v2 = 0;
if ( i )
{
v0 = v4++;
v2 = v0 < 0x3E8;
}
if ( !v2 )
break;
v3 = *(_QWORD **)(i + 16);
inline_mysql_mutex_lock_4(
(long long)(v3 + 3),
(long long)"/workspace/llm4binary/github2025/eloqsql/mysys/thr_lock.c",
0x621u);
if ( v3[18] || v3[14] || v3[16] || v3[12] )
{
printf("lock: %p:", v3);
if ( (v3[16] || v3[12]) && !v3[14] && !v3[18] )
printf(" WARNING: ");
if ( v3[18] )
printf(" write");
if ( v3[16] )
printf(" write_wait");
if ( v3[14] )
printf(" read");
if ( v3[12] )
printf(" read_wait");
puts("");
thr_print_lock("write", v3 + 18);
thr_print_lock("write_wait", v3 + 16);
thr_print_lock("read", v3 + 14);
thr_print_lock("read_wait", v3 + 12);
puts("");
}
inline_mysql_mutex_unlock_4((long long)(v3 + 3));
}
fflush(stdout);
return inline_mysql_mutex_unlock_4((long long)&THR_LOCK_lock);
}
| thr_print_locks:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0xc],0x0
LEA RDI,[0x4ae0d0]
LEA RSI,[0x187e6e]
MOV EDX,0x61b
CALL 0x001321b0
LEA RDI,[0x187ea8]
CALL 0x00124480
LEA RAX,[0x4ae380]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x8],RAX
LAB_001341a1:
XOR EAX,EAX
CMP qword ptr [RBP + -0x8],0x0
MOV byte ptr [RBP + -0x19],AL
JZ 0x001341c3
MOV EAX,dword ptr [RBP + -0xc]
MOV ECX,EAX
ADD ECX,0x1
MOV dword ptr [RBP + -0xc],ECX
CMP EAX,0x3e8
SETC AL
MOV byte ptr [RBP + -0x19],AL
LAB_001341c3:
MOV AL,byte ptr [RBP + -0x19]
TEST AL,0x1
JNZ 0x001341cf
JMP 0x00134372
LAB_001341cf:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x18],RAX
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x18
LEA RSI,[0x187e6e]
MOV EDX,0x621
CALL 0x001321b0
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x90],0x0
JNZ 0x0013422a
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x70],0x0
JNZ 0x0013422a
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x80],0x0
JNZ 0x0013422a
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x60],0x0
JZ 0x00134354
LAB_0013422a:
MOV RSI,qword ptr [RBP + -0x18]
LEA RDI,[0x187ed0]
MOV AL,0x0
CALL 0x00124050
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x80],0x0
JNZ 0x00134255
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x60],0x0
JZ 0x0013427c
LAB_00134255:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x70],0x0
JNZ 0x0013427c
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x90],0x0
JNZ 0x0013427c
LEA RDI,[0x187eda]
MOV AL,0x0
CALL 0x00124050
LAB_0013427c:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x90],0x0
JZ 0x00134298
LEA RDI,[0x187ee5]
MOV AL,0x0
CALL 0x00124050
LAB_00134298:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x80],0x0
JZ 0x001342b4
LEA RDI,[0x187eec]
MOV AL,0x0
CALL 0x00124050
LAB_001342b4:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x70],0x0
JZ 0x001342cd
LEA RDI,[0x18bdd8]
MOV AL,0x0
CALL 0x00124050
LAB_001342cd:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x60],0x0
JZ 0x001342e6
LEA RDI,[0x187ef8]
MOV AL,0x0
CALL 0x00124050
LAB_001342e6:
LEA RDI,[0x18b55c]
CALL 0x00124480
MOV RSI,qword ptr [RBP + -0x18]
ADD RSI,0x90
LEA RDI,[0x187ee6]
CALL 0x001343a0
MOV RSI,qword ptr [RBP + -0x18]
ADD RSI,0x80
LEA RDI,[0x187eed]
CALL 0x001343a0
MOV RSI,qword ptr [RBP + -0x18]
ADD RSI,0x70
LEA RDI,[0x18bdd9]
CALL 0x001343a0
MOV RSI,qword ptr [RBP + -0x18]
ADD RSI,0x60
LEA RDI,[0x187ef9]
CALL 0x001343a0
LEA RDI,[0x18b55c]
CALL 0x00124480
LAB_00134354:
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x18
CALL 0x00132220
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001341a1
LAB_00134372:
MOV RAX,qword ptr [0x002dcfb8]
MOV RDI,qword ptr [RAX]
CALL 0x00124300
LEA RDI,[0x4ae0d0]
CALL 0x00132220
ADD RSP,0x20
POP RBP
RET
|
void thr_print_locks(void)
{
long lVar1;
uint uVar2;
uint local_14;
long local_10;
local_14 = 0;
inline_mysql_mutex_lock
(THR_LOCK_lock,"/workspace/llm4binary/github2025/eloqsql/mysys/thr_lock.c",0x61b);
puts("Current active THR (table level locks):");
local_10 = thr_lock_thread_list;
while( true ) {
uVar2 = local_14;
if (local_10 != 0) {
local_14 = local_14 + 1;
}
if (local_10 == 0 || 999 < uVar2) break;
lVar1 = *(long *)(local_10 + 0x10);
inline_mysql_mutex_lock
(lVar1 + 0x18,"/workspace/llm4binary/github2025/eloqsql/mysys/thr_lock.c",0x621);
if ((((*(long *)(lVar1 + 0x90) != 0) || (*(long *)(lVar1 + 0x70) != 0)) ||
(*(long *)(lVar1 + 0x80) != 0)) || (*(long *)(lVar1 + 0x60) != 0)) {
printf("lock: %p:",lVar1);
if (((*(long *)(lVar1 + 0x80) != 0) || (*(long *)(lVar1 + 0x60) != 0)) &&
((*(long *)(lVar1 + 0x70) == 0 && (*(long *)(lVar1 + 0x90) == 0)))) {
printf(" WARNING: ");
}
if (*(long *)(lVar1 + 0x90) != 0) {
printf(" write");
}
if (*(long *)(lVar1 + 0x80) != 0) {
printf(" write_wait");
}
if (*(long *)(lVar1 + 0x70) != 0) {
printf(" read");
}
if (*(long *)(lVar1 + 0x60) != 0) {
printf(" read_wait");
}
puts("");
thr_print_lock("write",lVar1 + 0x90);
thr_print_lock("write_wait",lVar1 + 0x80);
thr_print_lock("read",lVar1 + 0x70);
thr_print_lock("read_wait",lVar1 + 0x60);
puts("");
}
inline_mysql_mutex_unlock(lVar1 + 0x18);
local_10 = *(long *)(local_10 + 8);
}
fflush(*(FILE **)PTR_stdout_002dcfb8);
inline_mysql_mutex_unlock(THR_LOCK_lock);
return;
}
| |
44,828 | ma_hashtbl_update | eloqsql/libmariadb/libmariadb/ma_hashtbl.c | my_bool ma_hashtbl_update(MA_HASHTBL *hash,uchar *record,uchar *old_key,uint old_key_length)
{
uint idx,new_index,new_pos_index,blength,records,empty;
MA_HASHTBL_LINK org_link,*data,*previous,*pos;
data=dynamic_element(&hash->array,0,MA_HASHTBL_LINK*);
blength=hash->blength; records=hash->records;
/* Search after record with key */
idx=hash_mask((*hash->calc_hashnr)(old_key,(old_key_length ?
old_key_length :
hash->key_length)),
blength,records);
new_index=hash_mask(rec_hashnr(hash,record),blength,records);
if (idx == new_index)
return(0); /* Nothing to do (No record check) */
previous=0;
for (;;)
{
if ((pos= data+idx)->data == record)
break;
previous=pos;
if ((idx=pos->next) == NO_RECORD)
return(1); /* Not found in links */
}
hash->current_record= NO_RECORD;
org_link= *pos;
empty=idx;
/* Relink record from current chain */
if (!previous)
{
if (pos->next != NO_RECORD)
{
empty=pos->next;
*pos= data[pos->next];
}
}
else
previous->next=pos->next; /* unlink pos */
/* Move data to correct position */
pos=data+new_index;
new_pos_index=hash_rec_mask(hash,pos,blength,records);
if (new_index != new_pos_index)
{ /* Other record in wrong position */
data[empty] = *pos;
movelink(data,new_index,new_pos_index,empty);
org_link.next=NO_RECORD;
data[new_index]= org_link;
}
else
{ /* Link in chain at right position */
org_link.next=data[new_index].next;
data[empty]=org_link;
data[new_index].next=empty;
}
return(0);
} | O3 | c | ma_hashtbl_update:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r13
movq %rdi, %r8
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movl 0x8(%rdi), %eax
movl %eax, -0x44(%rbp)
movl 0xc(%rdi), %r14d
movq 0x40(%rdi), %rax
testl %ecx, %ecx
jne 0x33397
movl 0x4(%r8), %ecx
movq 0x18(%r8), %r12
movq %rdx, %rdi
movl %ecx, %esi
movq %r8, -0x50(%rbp)
callq *%rax
movq -0x50(%rbp), %rcx
movl %eax, %ebx
leal -0x1(%r14), %r15d
andl %r15d, %eax
movq %r14, -0x58(%rbp)
shrl %r14d
decl %r14d
andl %r14d, %ebx
cmpl -0x44(%rbp), %eax
cmovbl %eax, %ebx
movq 0x30(%rcx), %rax
testq %rax, %rax
je 0x333e9
leaq -0x40(%rbp), %rsi
movq %r13, %rdi
xorl %edx, %edx
callq *%rax
movq -0x50(%rbp), %rcx
movq %rax, %rdi
leaq -0x40(%rbp), %rax
movl (%rax), %esi
jmp 0x333f4
movl 0x4(%rcx), %esi
movl %esi, -0x40(%rbp)
movl (%rcx), %edi
addq %r13, %rdi
callq *0x40(%rcx)
andl %eax, %r15d
andl %eax, %r14d
movl -0x44(%rbp), %ecx
cmpl %ecx, %r15d
cmovbl %r15d, %r14d
cmpl %r14d, %ebx
je 0x33518
movl %ebx, %edx
shlq $0x4, %rdx
leaq (%r12,%rdx), %rax
cmpq %r13, 0x8(%r12,%rdx)
je 0x33466
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
movq -0x50(%rbp), %rdi
movl (%rax), %ebx
cmpq %rdx, %rbx
je 0x33538
movq %rax, %r8
movq %rbx, %rsi
shlq $0x4, %rsi
leaq (%r12,%rsi), %rax
cmpq %r13, 0x8(%r12,%rsi)
jne 0x3342a
movl $0xffffffff, 0x10(%rdi) # imm = 0xFFFFFFFF
movl 0xc(%rax), %edx
movl %edx, -0x38(%rbp)
movq 0x4(%rax), %rdx
movq %rdx, -0x40(%rbp)
movl (%rax), %eax
movl %eax, (%r8)
jmp 0x3349c
movq -0x50(%rbp), %rdi
movl $0xffffffff, 0x10(%rdi) # imm = 0xFFFFFFFF
movl 0xc(%rax), %edx
movl %edx, -0x38(%rbp)
movq 0x4(%rax), %rdx
movq %rdx, -0x40(%rbp)
movl (%rax), %esi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
cmpq %rdx, %rsi
je 0x3349c
movq %rsi, %rdx
shlq $0x4, %rdx
movups (%r12,%rdx), %xmm0
movups %xmm0, (%rax)
movl %esi, %ebx
movl %r14d, %eax
shlq $0x4, %rax
leaq (%r12,%rax), %r15
movq 0x8(%r12,%rax), %rsi
movq -0x58(%rbp), %rdx
callq 0x32ca8
cmpl %eax, %r14d
jne 0x334dd
movl (%r15), %eax
movl %ebx, %ecx
shlq $0x4, %rcx
movl %eax, (%r12,%rcx)
movq -0x40(%rbp), %rax
movq %rax, 0x4(%r12,%rcx)
movl -0x38(%rbp), %eax
movl %eax, 0xc(%r12,%rcx)
movl %ebx, (%r15)
jmp 0x33518
movl %ebx, %ecx
shlq $0x4, %rcx
movups (%r15), %xmm0
movups %xmm0, (%r12,%rcx)
movl %eax, %ecx
shlq $0x4, %rcx
movl (%r12,%rcx), %eax
cmpl %r14d, %eax
jne 0x334ec
addq %rcx, %r12
movl %ebx, (%r12)
movl $0xffffffff, (%r15) # imm = 0xFFFFFFFF
movq -0x40(%rbp), %rax
movq %rax, 0x4(%r15)
movl -0x38(%rbp), %eax
movl %eax, 0xc(%r15)
xorl %eax, %eax
movq %fs:0x28, %rcx
cmpq -0x30(%rbp), %rcx
jne 0x3353c
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %al
jmp 0x3351a
callq 0x13500
| ma_hashtbl_update:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r13, rsi
mov r8, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov eax, [rdi+8]
mov [rbp+var_44], eax
mov r14d, [rdi+0Ch]
mov rax, [rdi+40h]
test ecx, ecx
jnz short loc_33397
mov ecx, [r8+4]
loc_33397:
mov r12, [r8+18h]
mov rdi, rdx
mov esi, ecx
mov [rbp+var_50], r8
call rax
mov rcx, [rbp+var_50]
mov ebx, eax
lea r15d, [r14-1]
and eax, r15d
mov [rbp+var_58], r14
shr r14d, 1
dec r14d
and ebx, r14d
cmp eax, [rbp+var_44]
cmovb ebx, eax
mov rax, [rcx+30h]
test rax, rax
jz short loc_333E9
lea rsi, [rbp+var_40]
mov rdi, r13
xor edx, edx
call rax
mov rcx, [rbp+var_50]
mov rdi, rax
lea rax, [rbp+var_40]
mov esi, [rax]
jmp short loc_333F4
loc_333E9:
mov esi, [rcx+4]
mov dword ptr [rbp+var_40], esi
mov edi, [rcx]
add rdi, r13
loc_333F4:
call qword ptr [rcx+40h]
and r15d, eax
and r14d, eax
mov ecx, [rbp+var_44]
cmp r15d, ecx
cmovb r14d, r15d
cmp ebx, r14d
jz loc_33518
mov edx, ebx
shl rdx, 4
lea rax, [r12+rdx]
cmp [r12+rdx+8], r13
jz short loc_33466
mov edx, 0FFFFFFFFh
mov rdi, [rbp+var_50]
loc_3342A:
mov ebx, [rax]
cmp rbx, rdx
jz loc_33538
mov r8, rax
mov rsi, rbx
shl rsi, 4
lea rax, [r12+rsi]
cmp [r12+rsi+8], r13
jnz short loc_3342A
mov dword ptr [rdi+10h], 0FFFFFFFFh
mov edx, [rax+0Ch]
mov [rbp+var_38], edx
mov rdx, [rax+4]
mov [rbp+var_40], rdx
mov eax, [rax]
mov [r8], eax
jmp short loc_3349C
loc_33466:
mov rdi, [rbp+var_50]
mov dword ptr [rdi+10h], 0FFFFFFFFh
mov edx, [rax+0Ch]
mov [rbp+var_38], edx
mov rdx, [rax+4]
mov [rbp+var_40], rdx
mov esi, [rax]
mov edx, 0FFFFFFFFh
cmp rsi, rdx
jz short loc_3349C
mov rdx, rsi
shl rdx, 4
movups xmm0, xmmword ptr [r12+rdx]
movups xmmword ptr [rax], xmm0
mov ebx, esi
loc_3349C:
mov eax, r14d
shl rax, 4
lea r15, [r12+rax]
mov rsi, [r12+rax+8]
mov rdx, [rbp+var_58]
call hash_rec_mask
cmp r14d, eax
jnz short loc_334DD
mov eax, [r15]
mov ecx, ebx
shl rcx, 4
mov [r12+rcx], eax
mov rax, [rbp+var_40]
mov [r12+rcx+4], rax
mov eax, [rbp+var_38]
mov [r12+rcx+0Ch], eax
mov [r15], ebx
jmp short loc_33518
loc_334DD:
mov ecx, ebx
shl rcx, 4
movups xmm0, xmmword ptr [r15]
movups xmmword ptr [r12+rcx], xmm0
loc_334EC:
mov ecx, eax
shl rcx, 4
mov eax, [r12+rcx]
cmp eax, r14d
jnz short loc_334EC
add r12, rcx
mov [r12], ebx
mov dword ptr [r15], 0FFFFFFFFh
mov rax, [rbp+var_40]
mov [r15+4], rax
mov eax, [rbp+var_38]
mov [r15+0Ch], eax
loc_33518:
xor eax, eax
loc_3351A:
mov rcx, fs:28h
cmp rcx, [rbp+var_30]
jnz short loc_3353C
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_33538:
mov al, 1
jmp short loc_3351A
loc_3353C:
call ___stack_chk_fail
| char ma_hashtbl_update(unsigned int *a1, long long a2, long long a3, unsigned int a4)
{
unsigned int v5; // r14d
long long v6; // r12
int v7; // eax
long long ( **v8)(long long, long long); // rcx
int v9; // ebx
unsigned int v10; // r15d
unsigned int v11; // eax
int v12; // r14d
long long v13; // rbx
long long ( *v14)(long long, long long *, _QWORD, unsigned int *); // rax
long long v15; // rax
long long v16; // rdi
long long v17; // rsi
int v18; // eax
unsigned int v19; // r15d
unsigned int v20; // r14d
unsigned int *v21; // rax
unsigned int *v22; // rdi
_DWORD *v23; // r8
long long v24; // rsi
long long v25; // r15
unsigned int v26; // eax
long long v27; // rcx
long long v28; // rcx
unsigned int v30; // [rsp+8h] [rbp-58h]
unsigned int v32; // [rsp+1Ch] [rbp-44h]
long long v33; // [rsp+20h] [rbp-40h] BYREF
unsigned int v34; // [rsp+28h] [rbp-38h]
unsigned long long v35; // [rsp+30h] [rbp-30h]
v35 = __readfsqword(0x28u);
v32 = a1[2];
v5 = a1[3];
if ( !a4 )
a4 = a1[1];
v6 = *((_QWORD *)a1 + 3);
v7 = (*((long long ( **)(long long, _QWORD))a1 + 8))(a3, a4);
v8 = (long long ( **)(long long, long long))a1;
v9 = v7;
v10 = v5 - 1;
v11 = (v5 - 1) & v7;
v30 = v5;
v12 = (v5 >> 1) - 1;
LODWORD(v13) = v12 & v9;
if ( v11 < v32 )
LODWORD(v13) = v11;
v14 = (long long ( *)(long long, long long *, _QWORD, unsigned int *))*((_QWORD *)a1 + 6);
if ( v14 )
{
v15 = v14(a2, &v33, 0LL, a1);
v8 = (long long ( **)(long long, long long))a1;
v16 = v15;
v17 = (unsigned int)v33;
}
else
{
v17 = a1[1];
LODWORD(v33) = a1[1];
v16 = a2 + *a1;
}
v18 = v8[8](v16, v17);
v19 = v18 & v10;
v20 = v18 & v12;
if ( v19 < v32 )
v20 = v19;
if ( (_DWORD)v13 == v20 )
return 0;
v21 = (unsigned int *)(v6 + 16LL * (unsigned int)v13);
if ( *((_QWORD *)v21 + 1) == a2 )
{
v22 = a1;
a1[4] = -1;
v34 = v21[3];
v33 = *(_QWORD *)(v21 + 1);
v24 = *v21;
if ( v24 != 0xFFFFFFFFLL )
{
*(_OWORD *)v21 = *(_OWORD *)(v6 + 16 * v24);
LODWORD(v13) = v24;
}
LABEL_18:
v25 = v6 + 16LL * v20;
v26 = hash_rec_mask(v22, *(_QWORD *)(v25 + 8), v30, v32);
if ( v20 == v26 )
{
v27 = 16LL * (unsigned int)v13;
*(_DWORD *)(v6 + v27) = *(_DWORD *)v25;
*(_QWORD *)(v6 + v27 + 4) = v33;
*(_DWORD *)(v6 + v27 + 12) = v34;
*(_DWORD *)v25 = v13;
}
else
{
*(_OWORD *)(v6 + 16LL * (unsigned int)v13) = *(_OWORD *)v25;
do
{
v28 = 16LL * v26;
v26 = *(_DWORD *)(v6 + v28);
}
while ( v26 != v20 );
*(_DWORD *)(v28 + v6) = v13;
*(_DWORD *)v25 = -1;
*(_QWORD *)(v25 + 4) = v33;
*(_DWORD *)(v25 + 12) = v34;
}
return 0;
}
v22 = a1;
while ( 1 )
{
v13 = *v21;
if ( v13 == 0xFFFFFFFFLL )
return 1;
v23 = v21;
v21 = (unsigned int *)(v6 + 16 * v13);
if ( *((_QWORD *)v21 + 1) == a2 )
{
a1[4] = -1;
v34 = v21[3];
v33 = *(_QWORD *)(v21 + 1);
*v23 = *v21;
goto LABEL_18;
}
}
}
| ma_hashtbl_update:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R13,RSI
MOV R8,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV EAX,dword ptr [RDI + 0x8]
MOV dword ptr [RBP + -0x44],EAX
MOV R14D,dword ptr [RDI + 0xc]
MOV RAX,qword ptr [RDI + 0x40]
TEST ECX,ECX
JNZ 0x00133397
MOV ECX,dword ptr [R8 + 0x4]
LAB_00133397:
MOV R12,qword ptr [R8 + 0x18]
MOV RDI,RDX
MOV ESI,ECX
MOV qword ptr [RBP + -0x50],R8
CALL RAX
MOV RCX,qword ptr [RBP + -0x50]
MOV EBX,EAX
LEA R15D,[R14 + -0x1]
AND EAX,R15D
MOV qword ptr [RBP + -0x58],R14
SHR R14D,0x1
DEC R14D
AND EBX,R14D
CMP EAX,dword ptr [RBP + -0x44]
CMOVC EBX,EAX
MOV RAX,qword ptr [RCX + 0x30]
TEST RAX,RAX
JZ 0x001333e9
LEA RSI,[RBP + -0x40]
MOV RDI,R13
XOR EDX,EDX
CALL RAX
MOV RCX,qword ptr [RBP + -0x50]
MOV RDI,RAX
LEA RAX,[RBP + -0x40]
MOV ESI,dword ptr [RAX]
JMP 0x001333f4
LAB_001333e9:
MOV ESI,dword ptr [RCX + 0x4]
MOV dword ptr [RBP + -0x40],ESI
MOV EDI,dword ptr [RCX]
ADD RDI,R13
LAB_001333f4:
CALL qword ptr [RCX + 0x40]
AND R15D,EAX
AND R14D,EAX
MOV ECX,dword ptr [RBP + -0x44]
CMP R15D,ECX
CMOVC R14D,R15D
CMP EBX,R14D
JZ 0x00133518
MOV EDX,EBX
SHL RDX,0x4
LEA RAX,[R12 + RDX*0x1]
CMP qword ptr [R12 + RDX*0x1 + 0x8],R13
JZ 0x00133466
MOV EDX,0xffffffff
MOV RDI,qword ptr [RBP + -0x50]
LAB_0013342a:
MOV EBX,dword ptr [RAX]
CMP RBX,RDX
JZ 0x00133538
MOV R8,RAX
MOV RSI,RBX
SHL RSI,0x4
LEA RAX,[R12 + RSI*0x1]
CMP qword ptr [R12 + RSI*0x1 + 0x8],R13
JNZ 0x0013342a
MOV dword ptr [RDI + 0x10],0xffffffff
MOV EDX,dword ptr [RAX + 0xc]
MOV dword ptr [RBP + -0x38],EDX
MOV RDX,qword ptr [RAX + 0x4]
MOV qword ptr [RBP + -0x40],RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [R8],EAX
JMP 0x0013349c
LAB_00133466:
MOV RDI,qword ptr [RBP + -0x50]
MOV dword ptr [RDI + 0x10],0xffffffff
MOV EDX,dword ptr [RAX + 0xc]
MOV dword ptr [RBP + -0x38],EDX
MOV RDX,qword ptr [RAX + 0x4]
MOV qword ptr [RBP + -0x40],RDX
MOV ESI,dword ptr [RAX]
MOV EDX,0xffffffff
CMP RSI,RDX
JZ 0x0013349c
MOV RDX,RSI
SHL RDX,0x4
MOVUPS XMM0,xmmword ptr [R12 + RDX*0x1]
MOVUPS xmmword ptr [RAX],XMM0
MOV EBX,ESI
LAB_0013349c:
MOV EAX,R14D
SHL RAX,0x4
LEA R15,[R12 + RAX*0x1]
MOV RSI,qword ptr [R12 + RAX*0x1 + 0x8]
MOV RDX,qword ptr [RBP + -0x58]
CALL 0x00132ca8
CMP R14D,EAX
JNZ 0x001334dd
MOV EAX,dword ptr [R15]
MOV ECX,EBX
SHL RCX,0x4
MOV dword ptr [R12 + RCX*0x1],EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [R12 + RCX*0x1 + 0x4],RAX
MOV EAX,dword ptr [RBP + -0x38]
MOV dword ptr [R12 + RCX*0x1 + 0xc],EAX
MOV dword ptr [R15],EBX
JMP 0x00133518
LAB_001334dd:
MOV ECX,EBX
SHL RCX,0x4
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [R12 + RCX*0x1],XMM0
LAB_001334ec:
MOV ECX,EAX
SHL RCX,0x4
MOV EAX,dword ptr [R12 + RCX*0x1]
CMP EAX,R14D
JNZ 0x001334ec
ADD R12,RCX
MOV dword ptr [R12],EBX
MOV dword ptr [R15],0xffffffff
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [R15 + 0x4],RAX
MOV EAX,dword ptr [RBP + -0x38]
MOV dword ptr [R15 + 0xc],EAX
LAB_00133518:
XOR EAX,EAX
LAB_0013351a:
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x30]
JNZ 0x0013353c
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00133538:
MOV AL,0x1
JMP 0x0013351a
LAB_0013353c:
CALL 0x00113500
|
int8 ma_hashtbl_update(uint *param_1,long param_2,int8 param_3,uint param_4)
{
uint *puVar1;
int4 *puVar2;
int4 *puVar3;
uint uVar4;
long lVar5;
int4 uVar6;
int4 uVar7;
int4 uVar8;
uint uVar9;
uint uVar10;
uint uVar11;
long lVar12;
uint *puVar13;
int8 uVar14;
ulong uVar15;
ulong uVar16;
uint uVar17;
uint uVar18;
long in_FS_OFFSET;
int8 local_48;
uint local_40;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
uVar11 = param_1[2];
uVar4 = param_1[3];
if (param_4 == 0) {
param_4 = param_1[1];
}
lVar5 = *(long *)(param_1 + 6);
uVar9 = (**(code **)(param_1 + 0x10))(param_3,param_4);
uVar10 = uVar9 & uVar4 - 1;
uVar17 = (uVar4 >> 1) - 1;
uVar9 = uVar9 & uVar17;
if (uVar10 < uVar11) {
uVar9 = uVar10;
}
if (*(code **)(param_1 + 0xc) == (code *)0x0) {
uVar10 = param_1[1];
local_48 = CONCAT44(local_48._4_4_,uVar10);
lVar12 = (ulong)*param_1 + param_2;
}
else {
lVar12 = (**(code **)(param_1 + 0xc))(param_2,&local_48,0);
uVar10 = (uint)local_48;
}
uVar10 = (**(code **)(param_1 + 0x10))(lVar12,uVar10);
uVar18 = uVar4 - 1 & uVar10;
uVar10 = uVar17 & uVar10;
if (uVar18 < uVar11) {
uVar10 = uVar18;
}
if (uVar9 != uVar10) {
puVar1 = (uint *)(lVar5 + (ulong)uVar9 * 0x10);
if (*(long *)(lVar5 + 8 + (ulong)uVar9 * 0x10) == param_2) {
param_1[4] = 0xffffffff;
local_40 = puVar1[3];
local_48 = *(int8 *)(puVar1 + 1);
uVar15 = (ulong)*puVar1;
uVar16 = (ulong)uVar9;
if (uVar15 != 0xffffffff) {
puVar13 = (uint *)(lVar5 + uVar15 * 0x10);
uVar11 = puVar13[1];
uVar9 = puVar13[2];
uVar17 = puVar13[3];
*puVar1 = *puVar13;
puVar1[1] = uVar11;
puVar1[2] = uVar9;
puVar1[3] = uVar17;
uVar16 = uVar15;
}
}
else {
do {
puVar13 = puVar1;
uVar16 = (ulong)*puVar13;
if (uVar16 == 0xffffffff) {
uVar14 = CONCAT71((int7)((ulong)puVar13 >> 8),1);
goto LAB_0013351a;
}
puVar1 = (uint *)(lVar5 + uVar16 * 0x10);
} while (*(long *)(lVar5 + 8 + uVar16 * 0x10) != param_2);
param_1[4] = 0xffffffff;
local_40 = puVar1[3];
local_48 = *(int8 *)(puVar1 + 1);
*puVar13 = *puVar1;
}
puVar2 = (int4 *)(lVar5 + (ulong)uVar10 * 0x10);
uVar11 = hash_rec_mask(param_1,*(int8 *)(lVar5 + 8 + (ulong)uVar10 * 0x10),uVar4);
if (uVar10 == uVar11) {
lVar12 = uVar16 * 0x10;
*(int4 *)(lVar5 + lVar12) = *puVar2;
*(int8 *)(lVar5 + 4 + lVar12) = local_48;
*(uint *)(lVar5 + 0xc + lVar12) = local_40;
*puVar2 = (int)uVar16;
}
else {
uVar6 = puVar2[1];
uVar7 = puVar2[2];
uVar8 = puVar2[3];
puVar3 = (int4 *)(lVar5 + uVar16 * 0x10);
*puVar3 = *puVar2;
puVar3[1] = uVar6;
puVar3[2] = uVar7;
puVar3[3] = uVar8;
do {
uVar15 = (ulong)uVar11;
uVar11 = *(uint *)(lVar5 + uVar15 * 0x10);
} while (uVar11 != uVar10);
*(int *)(lVar5 + uVar15 * 0x10) = (int)uVar16;
*puVar2 = 0xffffffff;
*(int8 *)(puVar2 + 1) = local_48;
puVar2[3] = local_40;
}
}
uVar14 = 0;
LAB_0013351a:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar14;
}
| |
44,829 | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::operator++() | monkey531[P]llama/common/json.hpp | iter_impl& operator++()
{
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_data.m_type)
{
case value_t::object:
{
std::advance(m_it.object_iterator, 1);
break;
}
case value_t::array:
{
std::advance(m_it.array_iterator, 1);
break;
}
case value_t::null:
case value_t::string:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::binary:
case value_t::discarded:
default:
{
++m_it.primitive_iterator;
break;
}
}
return *this;
} | O0 | cpp | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::operator++():
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, (%rax)
jne 0xb9c5a
leaq 0x15a50c(%rip), %rdi # 0x21414c
movl $0x33c0, %esi # imm = 0x33C0
leaq 0x1538ed(%rip), %rdx # 0x20d539
leaq 0x15fbb9(%rip), %rcx # 0x21980c
movb $0x0, %al
callq 0x5b030
movq 0x8(%rsp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
movq %rax, (%rsp)
subq $0x9, %rax
ja 0xb9cb3
movq (%rsp), %rax
leaq 0x154ee6(%rip), %rcx # 0x20eb60
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xbfa60
jmp 0xb9cc5
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xbfab0
jmp 0xb9cc5
jmp 0xb9cb3
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
addq $0x10, %rdi
callq 0xbfb00
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
| _ZN8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEppEv:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov rax, [rsp+18h+var_8]
mov [rsp+18h+var_10], rax
cmp qword ptr [rax], 0
jnz short loc_B9C5A
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
mov esi, 33C0h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aAnchorMObjectN+7; "m_object != nullptr"
mov al, 0
call _ggml_abort
loc_B9C5A:
mov rax, [rsp+18h+var_10]
mov rax, [rax]
movzx eax, byte ptr [rax]
mov [rsp+18h+var_18], rax
sub rax, 9; switch 10 cases
ja short def_B9C81; jumptable 00000000000B9C81 default case
mov rax, [rsp+18h+var_18]
lea rcx, jpt_B9C81
movsxd rax, ds:(jpt_B9C81 - 20EB60h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_B9C83:
mov rdi, [rsp+18h+var_10]; jumptable 00000000000B9C81 case 1
add rdi, 8
mov esi, 1
call _ZSt7advanceIN9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSB_11ordered_mapESt6vectorS8_blmdSaNSB_14adl_serializerESE_IhSaIhEEvEEESE_ISJ_SaISJ_EEEEiEvRT_T0_; std::advance<__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>,int>(__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>> &,int)
jmp short loc_B9CC5
loc_B9C98:
mov rdi, [rsp+18h+var_10]; jumptable 00000000000B9C81 case 2
add rdi, 8
add rdi, 8
mov esi, 1
call _ZSt7advanceIN9__gnu_cxx17__normal_iteratorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEES6_ISG_SaISG_EEEEiEvRT_T0_; std::advance<__gnu_cxx::__normal_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::vector<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>>>,int>(__gnu_cxx::__normal_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::vector<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>>> &,int)
jmp short loc_B9CC5
loc_B9CB1:
jmp short $+2; jumptable 00000000000B9C81 cases 0,3-9
def_B9C81:
mov rdi, [rsp+18h+var_10]; jumptable 00000000000B9C81 default case
add rdi, 8
add rdi, 10h
call _ZN8nlohmann16json_abi_v3_11_36detail20primitive_iterator_tppEv; nlohmann::json_abi_v3_11_3::detail::primitive_iterator_t::operator++(void)
loc_B9CC5:
mov rax, [rsp+18h+var_10]
add rsp, 18h
retn
| _QWORD * nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::operator++(
_QWORD *a1)
{
if ( !*a1 )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
13248LL,
"GGML_ASSERT(%s) failed",
"m_object != nullptr");
switch ( *(_BYTE *)*a1 )
{
case 1:
std::advance<__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>,int>(
a1 + 1,
1LL);
break;
case 2:
std::advance<__gnu_cxx::__normal_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::vector<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>>>,int>(
a1 + 2,
1LL);
break;
default:
nlohmann::json_abi_v3_11_3::detail::primitive_iterator_t::operator++(a1 + 3);
break;
}
return a1;
}
| operator++:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RAX],0x0
JNZ 0x001b9c5a
LEA RDI,[0x31414c]
MOV ESI,0x33c0
LEA RDX,[0x30d539]
LEA RCX,[0x31980c]
MOV AL,0x0
CALL 0x0015b030
LAB_001b9c5a:
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX]
MOVZX EAX,byte ptr [RAX]
MOV qword ptr [RSP],RAX
SUB RAX,0x9
JA 0x001b9cb3
MOV RAX,qword ptr [RSP]
LEA RCX,[0x30eb60]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x8
MOV ESI,0x1
CALL 0x001bfa60
JMP 0x001b9cc5
caseD_2:
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x8
ADD RDI,0x8
MOV ESI,0x1
CALL 0x001bfab0
JMP 0x001b9cc5
caseD_0:
JMP 0x001b9cb3
default:
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x8
ADD RDI,0x10
CALL 0x001bfb00
LAB_001b9cc5:
MOV RAX,qword ptr [RSP + 0x8]
ADD RSP,0x18
RET
|
/* nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::TEMPNAMEPLACEHOLDERVALUE() */
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
* __thiscall
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::operator++(iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this)
{
if (*(long *)this == 0) {
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x33c0,
"GGML_ASSERT(%s) failed","m_object != nullptr");
}
switch(**(int1 **)this) {
case 0:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:
default:
primitive_iterator_t::operator++((primitive_iterator_t *)(this + 0x18));
break;
case 1:
std::
advance<__gnu_cxx::__normal_iterator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>*,std::vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>>,int>
((__normal_iterator *)(this + 8),1);
break;
case 2:
std::
advance<__gnu_cxx::__normal_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>,int>
((__normal_iterator *)(this + 0x10),1);
}
return this;
}
| |
44,830 | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::operator++() | monkey531[P]llama/common/json.hpp | iter_impl& operator++()
{
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_data.m_type)
{
case value_t::object:
{
std::advance(m_it.object_iterator, 1);
break;
}
case value_t::array:
{
std::advance(m_it.array_iterator, 1);
break;
}
case value_t::null:
case value_t::string:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::binary:
case value_t::discarded:
default:
{
++m_it.primitive_iterator;
break;
}
}
return *this;
} | O2 | cpp | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::operator++():
movq (%rdi), %rax
testq %rax, %rax
je 0x6ada7
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x6ad98
cmpl $0x1, %eax
jne 0x6ad9f
addq $0x30, 0x8(%rdi)
jmp 0x6ada3
addq $0x10, 0x10(%rdi)
jmp 0x6ada3
incq 0x18(%rdi)
movq %rdi, %rax
retq
pushq %rax
leaq 0x48ded(%rip), %rdi # 0xb3b9c
leaq 0x4283f(%rip), %rdx # 0xad5f5
leaq 0x4e044(%rip), %rcx # 0xb8e01
movl $0x33c0, %esi # imm = 0x33C0
xorl %eax, %eax
callq 0x23fe0
| _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEppEv:
mov rax, [rdi]
test rax, rax
jz short loc_6ADA7
movzx eax, byte ptr [rax]
cmp eax, 2
jz short loc_6AD98
cmp eax, 1
jnz short loc_6AD9F
add qword ptr [rdi+8], 30h ; '0'
jmp short loc_6ADA3
loc_6AD98:
add qword ptr [rdi+10h], 10h
jmp short loc_6ADA3
loc_6AD9F:
inc qword ptr [rdi+18h]
loc_6ADA3:
mov rax, rdi
retn
loc_6ADA7:
push rax
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aAnchorMObjectN+7; "m_object != nullptr"
mov esi, 33C0h
xor eax, eax
call _ggml_abort
| long long nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator++(
unsigned __int8 **a1)
{
int v1; // eax
if ( *a1 )
{
v1 = **a1;
if ( v1 == 2 )
{
a1[2] += 16;
}
else if ( v1 == 1 )
{
a1[1] += 48;
}
else
{
++a1[3];
}
return (long long)a1;
}
else
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
13248LL,
"GGML_ASSERT(%s) failed",
"m_object != nullptr");
return std::make_shared<std::vector<minja::Value>>(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
13248LL);
}
}
| operator++:
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x0016ada7
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x2
JZ 0x0016ad98
CMP EAX,0x1
JNZ 0x0016ad9f
ADD qword ptr [RDI + 0x8],0x30
JMP 0x0016ada3
LAB_0016ad98:
ADD qword ptr [RDI + 0x10],0x10
JMP 0x0016ada3
LAB_0016ad9f:
INC qword ptr [RDI + 0x18]
LAB_0016ada3:
MOV RAX,RDI
RET
LAB_0016ada7:
PUSH RAX
LEA RDI,[0x1b3b9c]
LEA RDX,[0x1ad5f5]
LEA RCX,[0x1b8e01]
MOV ESI,0x33c0
XOR EAX,EAX
CALL 0x00123fe0
|
/* nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const>::TEMPNAMEPLACEHOLDERVALUE() */
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
* __thiscall
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::operator++(iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*this)
{
char cVar1;
int8 in_R8;
int8 in_R9;
if (*(char **)this != (char *)0x0) {
cVar1 = **(char **)this;
if (cVar1 == '\x02') {
*(long *)(this + 0x10) = *(long *)(this + 0x10) + 0x10;
}
else if (cVar1 == '\x01') {
*(long *)(this + 8) = *(long *)(this + 8) + 0x30;
}
else {
*(long *)(this + 0x18) = *(long *)(this + 0x18) + 1;
}
return this;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x33c0,
"GGML_ASSERT(%s) failed","m_object != nullptr",in_R8,in_R9,0);
}
| |
44,831 | Cache::isPolicyValid() | DanielDanyang[P]CSC3050-2025-Spring-Project-4/src/Cache.cpp | bool Cache::isPolicyValid() {
if (!this->isPowerOfTwo(policy.cacheSize)) {
fprintf(stderr, "Invalid Cache Size %d\n", policy.cacheSize);
return false;
}
if (!this->isPowerOfTwo(policy.blockSize)) {
fprintf(stderr, "Invalid Block Size %d\n", policy.blockSize);
return false;
}
if (policy.cacheSize % policy.blockSize != 0) {
fprintf(stderr, "cacheSize %% blockSize != 0\n");
return false;
}
if (policy.blockNum * policy.blockSize != policy.cacheSize) {
fprintf(stderr, "blockNum * blockSize != cacheSize\n");
return false;
}
if (policy.blockNum % policy.associativity != 0) {
fprintf(stderr, "blockNum %% associativity != 0\n");
return false;
}
return true;
} | O1 | cpp | Cache::isPolicyValid():
pushq %rbx
movl 0x38(%rdi), %ecx
leal -0x1(%rcx), %eax
movl %ecx, %edx
xorl %eax, %edx
cmpl %eax, %edx
jbe 0x3750
movl 0x3c(%rdi), %r8d
leal -0x1(%r8), %eax
movl %r8d, %edx
xorl %eax, %edx
cmpl %eax, %edx
jbe 0x3767
movl %ecx, %eax
xorl %edx, %edx
divl %r8d
testl %edx, %edx
jne 0x3786
movl 0x40(%rdi), %eax
imull %eax, %r8d
cmpl %ecx, %r8d
jne 0x378d
xorl %edx, %edx
divl 0x44(%rdi)
movb $0x1, %bl
testl %edx, %edx
jne 0x3794
movl %ebx, %eax
popq %rbx
retq
movq 0x4871(%rip), %rax # 0x7fc8
movq (%rax), %rdi
leaq 0x1cc1(%rip), %rsi # 0x5422
xorl %ebx, %ebx
movl %ecx, %edx
jmp 0x377d
movq 0x485a(%rip), %rax # 0x7fc8
movq (%rax), %rdi
leaq 0x1cc1(%rip), %rsi # 0x5439
xorl %ebx, %ebx
movl %r8d, %edx
xorl %eax, %eax
callq 0x2230
jmp 0x374c
callq 0x2402
jmp 0x3799
callq 0x241a
jmp 0x3799
callq 0x2436
xorl %ebx, %ebx
jmp 0x374c
nop
| _ZN5Cache13isPolicyValidEv:
push rbx
mov ecx, [rdi+38h]
lea eax, [rcx-1]
mov edx, ecx
xor edx, eax
cmp edx, eax
jbe short loc_3750
mov r8d, [rdi+3Ch]
lea eax, [r8-1]
mov edx, r8d
xor edx, eax
cmp edx, eax
jbe short loc_3767
mov eax, ecx
xor edx, edx
div r8d
test edx, edx
jnz short loc_3786
mov eax, [rdi+40h]
imul r8d, eax
cmp r8d, ecx
jnz short loc_378D
xor edx, edx
div dword ptr [rdi+44h]
mov bl, 1
test edx, edx
jnz short loc_3794
loc_374C:
mov eax, ebx
pop rbx
retn
loc_3750:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aInvalidCacheSi; "Invalid Cache Size %d\n"
xor ebx, ebx
mov edx, ecx
jmp short loc_377D
loc_3767:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aInvalidBlockSi; "Invalid Block Size %d\n"
xor ebx, ebx
mov edx, r8d
loc_377D:
xor eax, eax
call _fprintf
jmp short loc_374C
loc_3786:
call _ZN5Cache13isPolicyValidEv_cold_1; Cache::isPolicyValid(void) [clone]
jmp short loc_3799
loc_378D:
call _ZN5Cache13isPolicyValidEv_cold_2; Cache::isPolicyValid(void) [clone]
jmp short loc_3799
loc_3794:
call _ZN5Cache13isPolicyValidEv_cold_3; Cache::isPolicyValid(void) [clone]
loc_3799:
xor ebx, ebx
jmp short loc_374C
| long long Cache::isPolicyValid(Cache *this)
{
unsigned int v1; // ebx
unsigned int v2; // ecx
unsigned int v3; // r8d
unsigned int v4; // eax
v2 = *((_DWORD *)this + 14);
if ( ((v2 - 1) ^ v2) <= v2 - 1 )
{
v1 = 0;
fprintf(stderr, "Invalid Cache Size %d\n", v2);
return v1;
}
v3 = *((_DWORD *)this + 15);
if ( ((v3 - 1) ^ v3) <= v3 - 1 )
{
v1 = 0;
fprintf(stderr, "Invalid Block Size %d\n", v3);
return v1;
}
if ( v2 % v3 )
{
Cache::isPolicyValid();
return 0;
}
v4 = *((_DWORD *)this + 16);
if ( v4 * v3 != v2 )
{
Cache::isPolicyValid();
return 0;
}
LOBYTE(v1) = 1;
if ( v4 % *((_DWORD *)this + 17) )
{
Cache::isPolicyValid();
return 0;
}
return v1;
}
| isPolicyValid:
PUSH RBX
MOV ECX,dword ptr [RDI + 0x38]
LEA EAX,[RCX + -0x1]
MOV EDX,ECX
XOR EDX,EAX
CMP EDX,EAX
JBE 0x00103750
MOV R8D,dword ptr [RDI + 0x3c]
LEA EAX,[R8 + -0x1]
MOV EDX,R8D
XOR EDX,EAX
CMP EDX,EAX
JBE 0x00103767
MOV EAX,ECX
XOR EDX,EDX
DIV R8D
TEST EDX,EDX
JNZ 0x00103786
MOV EAX,dword ptr [RDI + 0x40]
IMUL R8D,EAX
CMP R8D,ECX
JNZ 0x0010378d
XOR EDX,EDX
DIV dword ptr [RDI + 0x44]
MOV BL,0x1
TEST EDX,EDX
JNZ 0x00103794
LAB_0010374c:
MOV EAX,EBX
POP RBX
RET
LAB_00103750:
MOV RAX,qword ptr [0x00107fc8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x105422]
XOR EBX,EBX
MOV EDX,ECX
JMP 0x0010377d
LAB_00103767:
MOV RAX,qword ptr [0x00107fc8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x105439]
XOR EBX,EBX
MOV EDX,R8D
LAB_0010377d:
XOR EAX,EAX
CALL 0x00102230
JMP 0x0010374c
LAB_00103786:
CALL 0x00102402
JMP 0x00103799
LAB_0010378d:
CALL 0x0010241a
JMP 0x00103799
LAB_00103794:
CALL 0x00102436
LAB_00103799:
XOR EBX,EBX
JMP 0x0010374c
|
/* Cache::isPolicyValid() */
ulong __thiscall Cache::isPolicyValid(Cache *this)
{
uint uVar1;
uint uVar2;
int8 unaff_RBX;
ulong uVar3;
char *__format;
FILE *__stream;
uVar1 = *(uint *)(this + 0x38);
if (uVar1 - 1 < (uVar1 ^ uVar1 - 1)) {
uVar2 = *(uint *)(this + 0x3c);
if (uVar2 - 1 < (uVar2 ^ uVar2 - 1)) {
if (uVar1 % uVar2 == 0) {
if (uVar2 * *(uint *)(this + 0x40) == uVar1) {
uVar3 = CONCAT71((int7)((ulong)unaff_RBX >> 8),1);
if (*(uint *)(this + 0x40) % *(uint *)(this + 0x44) == 0) goto LAB_0010374c;
isPolicyValid();
}
else {
isPolicyValid();
}
}
else {
isPolicyValid();
}
uVar3 = 0;
goto LAB_0010374c;
}
__stream = *(FILE **)PTR_stderr_00107fc8;
__format = "Invalid Block Size %d\n";
uVar1 = uVar2;
}
else {
__stream = *(FILE **)PTR_stderr_00107fc8;
__format = "Invalid Cache Size %d\n";
}
uVar3 = 0;
fprintf(__stream,__format,(ulong)uVar1);
LAB_0010374c:
return uVar3 & 0xffffffff;
}
| |
44,832 | Cache::isPolicyValid() | DanielDanyang[P]CSC3050-2025-Spring-Project-4/src/Cache.cpp | bool Cache::isPolicyValid() {
if (!this->isPowerOfTwo(policy.cacheSize)) {
fprintf(stderr, "Invalid Cache Size %d\n", policy.cacheSize);
return false;
}
if (!this->isPowerOfTwo(policy.blockSize)) {
fprintf(stderr, "Invalid Block Size %d\n", policy.blockSize);
return false;
}
if (policy.cacheSize % policy.blockSize != 0) {
fprintf(stderr, "cacheSize %% blockSize != 0\n");
return false;
}
if (policy.blockNum * policy.blockSize != policy.cacheSize) {
fprintf(stderr, "blockNum * blockSize != cacheSize\n");
return false;
}
if (policy.blockNum % policy.associativity != 0) {
fprintf(stderr, "blockNum %% associativity != 0\n");
return false;
}
return true;
} | O2 | cpp | Cache::isPolicyValid():
pushq %rbx
movl 0x38(%rdi), %ecx
leal -0x1(%rcx), %eax
movl %ecx, %edx
xorl %eax, %edx
cmpl %eax, %edx
jbe 0x351a
movl 0x3c(%rdi), %r8d
leal -0x1(%r8), %eax
movl %r8d, %edx
xorl %eax, %edx
cmpl %eax, %edx
jbe 0x3531
movl %ecx, %eax
xorl %edx, %edx
divl %r8d
testl %edx, %edx
jne 0x3550
movl 0x40(%rdi), %eax
imull %eax, %r8d
cmpl %ecx, %r8d
jne 0x3563
xorl %edx, %edx
divl 0x44(%rdi)
movb $0x1, %bl
testl %edx, %edx
jne 0x3583
movl %ebx, %eax
popq %rbx
retq
movq 0x4aa7(%rip), %rax # 0x7fc8
movq (%rax), %rdi
leaq 0x1ee4(%rip), %rsi # 0x540f
xorl %ebx, %ebx
movl %ecx, %edx
jmp 0x3547
movq 0x4a90(%rip), %rax # 0x7fc8
movq (%rax), %rdi
leaq 0x1ee4(%rip), %rsi # 0x5426
xorl %ebx, %ebx
movl %r8d, %edx
xorl %eax, %eax
callq 0x2210
jmp 0x3516
movq 0x4a71(%rip), %rax # 0x7fc8
movq (%rax), %rdi
leaq 0x1edc(%rip), %rsi # 0x543d
jmp 0x3594
movq 0x4a5e(%rip), %rax # 0x7fc8
movq (%rax), %rcx
leaq 0x1ee6(%rip), %rdi # 0x545a
pushq $0x22
popq %rsi
pushq $0x1
popq %rdx
callq 0x22d0
xorl %ebx, %ebx
jmp 0x3516
movq 0x4a3e(%rip), %rax # 0x7fc8
movq (%rax), %rdi
leaq 0x1ee9(%rip), %rsi # 0x547d
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2210
jmp 0x3516
| _ZN5Cache13isPolicyValidEv:
push rbx
mov ecx, [rdi+38h]
lea eax, [rcx-1]
mov edx, ecx
xor edx, eax
cmp edx, eax
jbe short loc_351A
mov r8d, [rdi+3Ch]
lea eax, [r8-1]
mov edx, r8d
xor edx, eax
cmp edx, eax
jbe short loc_3531
mov eax, ecx
xor edx, edx
div r8d
test edx, edx
jnz short loc_3550
mov eax, [rdi+40h]
imul r8d, eax
cmp r8d, ecx
jnz short loc_3563
xor edx, edx
div dword ptr [rdi+44h]
mov bl, 1
test edx, edx
jnz short loc_3583
loc_3516:
mov eax, ebx
pop rbx
retn
loc_351A:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aInvalidCacheSi; "Invalid Cache Size %d\n"
xor ebx, ebx
mov edx, ecx
jmp short loc_3547
loc_3531:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aInvalidBlockSi; "Invalid Block Size %d\n"
xor ebx, ebx
mov edx, r8d
loc_3547:
xor eax, eax
call _fprintf
jmp short loc_3516
loc_3550:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aCachesizeBlock; "cacheSize %% blockSize != 0\n"
jmp short loc_3594
loc_3563:
mov rax, cs:stderr_ptr
mov rcx, [rax]
lea rdi, aBlocknumBlocks; "blockNum * blockSize != cacheSize\n"
push 22h ; '"'
pop rsi
push 1
pop rdx
call _fwrite
xor ebx, ebx
jmp short loc_3516
loc_3583:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aBlocknumAssoci; "blockNum %% associativity != 0\n"
loc_3594:
xor ebx, ebx
xor eax, eax
call _fprintf
jmp loc_3516
| long long Cache::isPolicyValid(Cache *this)
{
unsigned int v1; // ebx
unsigned int v2; // ecx
unsigned int v3; // r8d
long long v4; // rdx
unsigned int v5; // eax
long long v7; // rdi
const char *v8; // rsi
long long v9; // rdx
long long v10; // rdi
const char *v11; // rsi
v2 = *((_DWORD *)this + 14);
if ( ((v2 - 1) ^ v2) <= v2 - 1 )
{
v7 = stderr;
v8 = "Invalid Cache Size %d\n";
v1 = 0;
v9 = v2;
LABEL_9:
fprintf(v7, v8, v9);
return v1;
}
v3 = *((_DWORD *)this + 15);
if ( ((v3 - 1) ^ v3) <= v3 - 1 )
{
v7 = stderr;
v8 = "Invalid Block Size %d\n";
v1 = 0;
v9 = v3;
goto LABEL_9;
}
v4 = v2 % v3;
if ( v2 % v3 )
{
v10 = stderr;
v11 = "cacheSize %% blockSize != 0\n";
LABEL_13:
v1 = 0;
fprintf(v10, v11, v4);
return v1;
}
v5 = *((_DWORD *)this + 16);
if ( v5 * v3 != v2 )
{
fwrite("blockNum * blockSize != cacheSize\n", 34LL, 1LL, stderr);
return 0;
}
v4 = v5 % *((_DWORD *)this + 17);
LOBYTE(v1) = 1;
if ( (_DWORD)v4 )
{
v10 = stderr;
v11 = "blockNum %% associativity != 0\n";
goto LABEL_13;
}
return v1;
}
| isPolicyValid:
PUSH RBX
MOV ECX,dword ptr [RDI + 0x38]
LEA EAX,[RCX + -0x1]
MOV EDX,ECX
XOR EDX,EAX
CMP EDX,EAX
JBE 0x0010351a
MOV R8D,dword ptr [RDI + 0x3c]
LEA EAX,[R8 + -0x1]
MOV EDX,R8D
XOR EDX,EAX
CMP EDX,EAX
JBE 0x00103531
MOV EAX,ECX
XOR EDX,EDX
DIV R8D
TEST EDX,EDX
JNZ 0x00103550
MOV EAX,dword ptr [RDI + 0x40]
IMUL R8D,EAX
CMP R8D,ECX
JNZ 0x00103563
XOR EDX,EDX
DIV dword ptr [RDI + 0x44]
MOV BL,0x1
TEST EDX,EDX
JNZ 0x00103583
LAB_00103516:
MOV EAX,EBX
POP RBX
RET
LAB_0010351a:
MOV RAX,qword ptr [0x00107fc8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x10540f]
XOR EBX,EBX
MOV EDX,ECX
JMP 0x00103547
LAB_00103531:
MOV RAX,qword ptr [0x00107fc8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x105426]
XOR EBX,EBX
MOV EDX,R8D
LAB_00103547:
XOR EAX,EAX
CALL 0x00102210
JMP 0x00103516
LAB_00103550:
MOV RAX,qword ptr [0x00107fc8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x10543d]
JMP 0x00103594
LAB_00103563:
MOV RAX,qword ptr [0x00107fc8]
MOV RCX,qword ptr [RAX]
LEA RDI,[0x10545a]
PUSH 0x22
POP RSI
PUSH 0x1
POP RDX
CALL 0x001022d0
XOR EBX,EBX
JMP 0x00103516
LAB_00103583:
MOV RAX,qword ptr [0x00107fc8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x10547d]
LAB_00103594:
XOR EBX,EBX
XOR EAX,EAX
CALL 0x00102210
JMP 0x00103516
|
/* Cache::isPolicyValid() */
ulong __thiscall Cache::isPolicyValid(Cache *this)
{
uint uVar1;
uint uVar2;
int8 unaff_RBX;
ulong uVar3;
char *pcVar4;
FILE *pFVar5;
uVar1 = *(uint *)(this + 0x38);
if (uVar1 - 1 < (uVar1 ^ uVar1 - 1)) {
uVar2 = *(uint *)(this + 0x3c);
if (uVar2 - 1 < (uVar2 ^ uVar2 - 1)) {
if (uVar1 % uVar2 == 0) {
if (uVar2 * *(uint *)(this + 0x40) != uVar1) {
fwrite("blockNum * blockSize != cacheSize\n",0x22,1,*(FILE **)PTR_stderr_00107fc8);
uVar3 = 0;
goto LAB_00103516;
}
uVar3 = CONCAT71((int7)((ulong)unaff_RBX >> 8),1);
if (*(uint *)(this + 0x40) % *(uint *)(this + 0x44) == 0) goto LAB_00103516;
pFVar5 = *(FILE **)PTR_stderr_00107fc8;
pcVar4 = "blockNum %% associativity != 0\n";
}
else {
pFVar5 = *(FILE **)PTR_stderr_00107fc8;
pcVar4 = "cacheSize %% blockSize != 0\n";
}
uVar3 = 0;
fprintf(pFVar5,pcVar4);
goto LAB_00103516;
}
pFVar5 = *(FILE **)PTR_stderr_00107fc8;
pcVar4 = "Invalid Block Size %d\n";
uVar1 = uVar2;
}
else {
pFVar5 = *(FILE **)PTR_stderr_00107fc8;
pcVar4 = "Invalid Cache Size %d\n";
}
uVar3 = 0;
fprintf(pFVar5,pcVar4,(ulong)uVar1);
LAB_00103516:
return uVar3 & 0xffffffff;
}
| |
44,833 | Cache::isPolicyValid() | DanielDanyang[P]CSC3050-2025-Spring-Project-4/src/Cache.cpp | bool Cache::isPolicyValid() {
if (!this->isPowerOfTwo(policy.cacheSize)) {
fprintf(stderr, "Invalid Cache Size %d\n", policy.cacheSize);
return false;
}
if (!this->isPowerOfTwo(policy.blockSize)) {
fprintf(stderr, "Invalid Block Size %d\n", policy.blockSize);
return false;
}
if (policy.cacheSize % policy.blockSize != 0) {
fprintf(stderr, "cacheSize %% blockSize != 0\n");
return false;
}
if (policy.blockNum * policy.blockSize != policy.cacheSize) {
fprintf(stderr, "blockNum * blockSize != cacheSize\n");
return false;
}
if (policy.blockNum % policy.associativity != 0) {
fprintf(stderr, "blockNum %% associativity != 0\n");
return false;
}
return true;
} | O3 | cpp | Cache::isPolicyValid():
pushq %rbx
movl 0x38(%rdi), %ecx
leal -0x1(%rcx), %eax
movl %ecx, %edx
xorl %eax, %edx
cmpl %eax, %edx
jbe 0x3710
movl 0x3c(%rdi), %r8d
leal -0x1(%r8), %eax
movl %r8d, %edx
xorl %eax, %edx
cmpl %eax, %edx
jbe 0x3727
movl %ecx, %eax
xorl %edx, %edx
divl %r8d
testl %edx, %edx
jne 0x3746
movl 0x40(%rdi), %eax
imull %eax, %r8d
cmpl %ecx, %r8d
jne 0x374d
xorl %edx, %edx
divl 0x44(%rdi)
movb $0x1, %bl
testl %edx, %edx
jne 0x3754
movl %ebx, %eax
popq %rbx
retq
movq 0x48b1(%rip), %rax # 0x7fc8
movq (%rax), %rdi
leaq 0x1d01(%rip), %rsi # 0x5422
xorl %ebx, %ebx
movl %ecx, %edx
jmp 0x373d
movq 0x489a(%rip), %rax # 0x7fc8
movq (%rax), %rdi
leaq 0x1d01(%rip), %rsi # 0x5439
xorl %ebx, %ebx
movl %r8d, %edx
xorl %eax, %eax
callq 0x2230
jmp 0x370c
callq 0x2402
jmp 0x3759
callq 0x241a
jmp 0x3759
callq 0x2436
xorl %ebx, %ebx
jmp 0x370c
nop
| _ZN5Cache13isPolicyValidEv:
push rbx
mov ecx, [rdi+38h]
lea eax, [rcx-1]
mov edx, ecx
xor edx, eax
cmp edx, eax
jbe short loc_3710
mov r8d, [rdi+3Ch]
lea eax, [r8-1]
mov edx, r8d
xor edx, eax
cmp edx, eax
jbe short loc_3727
mov eax, ecx
xor edx, edx
div r8d
test edx, edx
jnz short loc_3746
mov eax, [rdi+40h]
imul r8d, eax
cmp r8d, ecx
jnz short loc_374D
xor edx, edx
div dword ptr [rdi+44h]
mov bl, 1
test edx, edx
jnz short loc_3754
loc_370C:
mov eax, ebx
pop rbx
retn
loc_3710:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aInvalidCacheSi; "Invalid Cache Size %d\n"
xor ebx, ebx
mov edx, ecx
jmp short loc_373D
loc_3727:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aInvalidBlockSi; "Invalid Block Size %d\n"
xor ebx, ebx
mov edx, r8d
loc_373D:
xor eax, eax
call _fprintf
jmp short loc_370C
loc_3746:
call _ZN5Cache13isPolicyValidEv_cold_1; Cache::isPolicyValid(void) [clone]
jmp short loc_3759
loc_374D:
call _ZN5Cache13isPolicyValidEv_cold_2; Cache::isPolicyValid(void) [clone]
jmp short loc_3759
loc_3754:
call _ZN5Cache13isPolicyValidEv_cold_3; Cache::isPolicyValid(void) [clone]
loc_3759:
xor ebx, ebx
jmp short loc_370C
| long long Cache::isPolicyValid(Cache *this)
{
unsigned int v1; // ebx
unsigned int v2; // ecx
unsigned int v3; // r8d
unsigned int v4; // eax
v2 = *((_DWORD *)this + 14);
if ( ((v2 - 1) ^ v2) <= v2 - 1 )
{
v1 = 0;
fprintf(stderr, "Invalid Cache Size %d\n", v2);
return v1;
}
v3 = *((_DWORD *)this + 15);
if ( ((v3 - 1) ^ v3) <= v3 - 1 )
{
v1 = 0;
fprintf(stderr, "Invalid Block Size %d\n", v3);
return v1;
}
if ( v2 % v3 )
{
Cache::isPolicyValid();
return 0;
}
v4 = *((_DWORD *)this + 16);
if ( v4 * v3 != v2 )
{
Cache::isPolicyValid();
return 0;
}
LOBYTE(v1) = 1;
if ( v4 % *((_DWORD *)this + 17) )
{
Cache::isPolicyValid();
return 0;
}
return v1;
}
| isPolicyValid:
PUSH RBX
MOV ECX,dword ptr [RDI + 0x38]
LEA EAX,[RCX + -0x1]
MOV EDX,ECX
XOR EDX,EAX
CMP EDX,EAX
JBE 0x00103710
MOV R8D,dword ptr [RDI + 0x3c]
LEA EAX,[R8 + -0x1]
MOV EDX,R8D
XOR EDX,EAX
CMP EDX,EAX
JBE 0x00103727
MOV EAX,ECX
XOR EDX,EDX
DIV R8D
TEST EDX,EDX
JNZ 0x00103746
MOV EAX,dword ptr [RDI + 0x40]
IMUL R8D,EAX
CMP R8D,ECX
JNZ 0x0010374d
XOR EDX,EDX
DIV dword ptr [RDI + 0x44]
MOV BL,0x1
TEST EDX,EDX
JNZ 0x00103754
LAB_0010370c:
MOV EAX,EBX
POP RBX
RET
LAB_00103710:
MOV RAX,qword ptr [0x00107fc8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x105422]
XOR EBX,EBX
MOV EDX,ECX
JMP 0x0010373d
LAB_00103727:
MOV RAX,qword ptr [0x00107fc8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x105439]
XOR EBX,EBX
MOV EDX,R8D
LAB_0010373d:
XOR EAX,EAX
CALL 0x00102230
JMP 0x0010370c
LAB_00103746:
CALL 0x00102402
JMP 0x00103759
LAB_0010374d:
CALL 0x0010241a
JMP 0x00103759
LAB_00103754:
CALL 0x00102436
LAB_00103759:
XOR EBX,EBX
JMP 0x0010370c
|
/* Cache::isPolicyValid() */
ulong __thiscall Cache::isPolicyValid(Cache *this)
{
uint uVar1;
uint uVar2;
int8 unaff_RBX;
ulong uVar3;
char *__format;
FILE *__stream;
uVar1 = *(uint *)(this + 0x38);
if (uVar1 - 1 < (uVar1 ^ uVar1 - 1)) {
uVar2 = *(uint *)(this + 0x3c);
if (uVar2 - 1 < (uVar2 ^ uVar2 - 1)) {
if (uVar1 % uVar2 == 0) {
if (uVar2 * *(uint *)(this + 0x40) == uVar1) {
uVar3 = CONCAT71((int7)((ulong)unaff_RBX >> 8),1);
if (*(uint *)(this + 0x40) % *(uint *)(this + 0x44) == 0) goto LAB_0010370c;
isPolicyValid();
}
else {
isPolicyValid();
}
}
else {
isPolicyValid();
}
uVar3 = 0;
goto LAB_0010370c;
}
__stream = *(FILE **)PTR_stderr_00107fc8;
__format = "Invalid Block Size %d\n";
uVar1 = uVar2;
}
else {
__stream = *(FILE **)PTR_stderr_00107fc8;
__format = "Invalid Cache Size %d\n";
}
uVar3 = 0;
fprintf(__stream,__format,(ulong)uVar1);
LAB_0010370c:
return uVar3 & 0xffffffff;
}
| |
44,834 | js_promise_finally_thrower | bluesky950520[P]quickjs/quickjs.c | static JSValue js_promise_finally_thrower(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv,
int magic, JSValue *func_data)
{
return JS_Throw(ctx, js_dup(func_data[0]));
} | O1 | c | js_promise_finally_thrower:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x30(%rsp), %rax
movq (%rax), %r14
movq 0x8(%rax), %r15
movq %r14, 0x8(%rsp)
cmpl $-0x9, %r15d
jb 0x538f0
movq 0x8(%rsp), %rax
incl (%rax)
movq 0x18(%rdi), %rbx
movq 0xf0(%rbx), %rsi
movq 0xf8(%rbx), %rdx
movq %rbx, %rdi
callq 0x1d8c6
movq %r14, 0xf0(%rbx)
movq %r15, 0xf8(%rbx)
movl $0x6, %edx
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
| js_promise_finally_thrower:
push r15
push r14
push rbx
sub rsp, 10h
mov rax, [rsp+28h+arg_0]
mov r14, [rax]
mov r15, [rax+8]
mov [rsp+28h+var_20], r14
cmp r15d, 0FFFFFFF7h
jb short loc_538F0
mov rax, [rsp+28h+var_20]
inc dword ptr [rax]
loc_538F0:
mov rbx, [rdi+18h]
mov rsi, [rbx+0F0h]
mov rdx, [rbx+0F8h]
mov rdi, rbx
call JS_FreeValueRT
mov [rbx+0F0h], r14
mov [rbx+0F8h], r15
mov edx, 6
xor eax, eax
add rsp, 10h
pop rbx
pop r14
pop r15
retn
| long long js_promise_finally_thrower(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
_QWORD *a7)
{
_DWORD *v7; // r14
long long v8; // r15
long long v9; // rbx
v7 = (_DWORD *)*a7;
v8 = a7[1];
if ( (unsigned int)v8 >= 0xFFFFFFF7 )
++*(_DWORD *)*a7;
v9 = *(_QWORD *)(a1 + 24);
JS_FreeValueRT(v9, *(_DWORD **)(v9 + 240), *(_QWORD *)(v9 + 248));
*(_QWORD *)(v9 + 240) = v7;
*(_QWORD *)(v9 + 248) = v8;
return 0LL;
}
| js_promise_finally_thrower:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr [RSP + 0x30]
MOV R14,qword ptr [RAX]
MOV R15,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],R14
CMP R15D,-0x9
JC 0x001538f0
MOV RAX,qword ptr [RSP + 0x8]
INC dword ptr [RAX]
LAB_001538f0:
MOV RBX,qword ptr [RDI + 0x18]
MOV RSI,qword ptr [RBX + 0xf0]
MOV RDX,qword ptr [RBX + 0xf8]
MOV RDI,RBX
CALL 0x0011d8c6
MOV qword ptr [RBX + 0xf0],R14
MOV qword ptr [RBX + 0xf8],R15
MOV EDX,0x6
XOR EAX,EAX
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
|
int1 [16] js_promise_finally_thrower(long param_1)
{
int *piVar1;
int8 uVar2;
long lVar3;
int8 *in_stack_00000008;
piVar1 = (int *)*in_stack_00000008;
uVar2 = in_stack_00000008[1];
if (0xfffffff6 < (uint)uVar2) {
*piVar1 = *piVar1 + 1;
}
lVar3 = *(long *)(param_1 + 0x18);
JS_FreeValueRT(lVar3,*(int8 *)(lVar3 + 0xf0),*(int8 *)(lVar3 + 0xf8));
*(int **)(lVar3 + 0xf0) = piVar1;
*(int8 *)(lVar3 + 0xf8) = uVar2;
return ZEXT816(6) << 0x40;
}
| |
44,835 | google::protobuf::compiler::cpp::Namespace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/cpp/helpers.cc | std::string Namespace(const std::string& package) {
if (package.empty()) return "";
return "::" + DotsToColons(package);
} | O0 | cpp | google::protobuf::compiler::cpp::Namespace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
subq $0x68, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0x212d0
testb $0x1, %al
jne 0x514eb
jmp 0x51538
leaq 0x57(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x21a00
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x35705e(%rip), %rsi # 0x3a8569
callq 0x21890
jmp 0x51512
leaq 0x57(%rsp), %rdi
callq 0x21cb0
jmp 0x51588
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x57(%rsp), %rdi
callq 0x21cb0
jmp 0x51592
movq 0x58(%rsp), %rsi
leaq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x515a0
movq 0x10(%rsp), %rdi
movq (%rsp), %rdx
leaq 0x3892b3(%rip), %rsi # 0x3da80e
callq 0x38890
jmp 0x51562
leaq 0x20(%rsp), %rdi
callq 0x21cc8
jmp 0x51588
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x21cc8
jmp 0x51592
movq 0x18(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x21700
nopl (%rax)
| _ZN6google8protobuf8compiler3cpp9NamespaceERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
sub rsp, 68h
mov qword ptr [rsp+68h+var_58], rdi; int
mov rax, rdi
mov qword ptr [rsp+68h+var_50], rax; int
mov qword ptr [rsp+68h+var_8], rdi; char
mov qword ptr [rsp+68h+var_10], rsi; int
mov rdi, qword ptr [rsp+68h+var_10]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
test al, 1
jnz short loc_514EB
jmp short loc_51538
loc_514EB:
lea rdi, [rsp+68h+var_11]
mov [rsp+68h+var_60], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdi, qword ptr [rsp+68h+var_58]
mov rdx, [rsp+68h+var_60]
lea rsi, asc_3A8567+2; ""
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1EPKcRKS3_; std::string::basic_string(char const*,std::allocator<char> const&)
jmp short $+2
loc_51512:
lea rdi, [rsp+68h+var_11]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_51588
mov rcx, rax
mov eax, edx
mov [rsp+arg_40], rcx
mov [rsp+arg_3C], eax
lea rdi, [rsp+arg_4F]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_51592
loc_51538:
mov rsi, qword ptr [rsp+68h+var_10]
lea rdi, [rsp+68h+var_48]; int
mov qword ptr [rsp+68h+var_68], rdi; int
call _ZN6google8protobuf8compiler3cpp12_GLOBAL__N_112DotsToColonsERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; google::protobuf::compiler::cpp::`anonymous namespace'::DotsToColons(std::string const&)
mov rdi, qword ptr [rsp+68h+var_58]
mov rdx, qword ptr [rsp+68h+var_68]
lea rsi, asc_3DA80C+2; "::"
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
jmp short $+2
loc_51562:
lea rdi, [rsp+68h+var_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_51588
mov rcx, rax
mov eax, edx
mov [rsp+arg_40], rcx
mov [rsp+arg_3C], eax
lea rdi, [rsp+arg_18]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_51592
loc_51588:
mov rax, qword ptr [rsp+68h+var_50]
add rsp, 68h
retn
loc_51592:
mov rdi, [rsp+arg_40]
call __Unwind_Resume
| long long google::protobuf::compiler::cpp::Namespace(long long a1, long long a2)
{
long long v3; // [rsp+0h] [rbp-68h]
int v4; // [rsp+8h] [rbp-60h]
long long v5; // [rsp+10h] [rbp-58h]
int v6[2]; // [rsp+18h] [rbp-50h]
int v7; // [rsp+20h] [rbp-48h] BYREF
char v8; // [rsp+28h] [rbp-40h]
int v9; // [rsp+30h] [rbp-38h]
int v10; // [rsp+38h] [rbp-30h]
int v11; // [rsp+40h] [rbp-28h]
int v12; // [rsp+48h] [rbp-20h]
long long v13; // [rsp+50h] [rbp-18h] BYREF
int v14[2]; // [rsp+58h] [rbp-10h]
char v15[8]; // [rsp+60h] [rbp-8h]
*(_QWORD *)v6 = a1;
*(_QWORD *)v15 = a1;
*(_QWORD *)v14 = a2;
if ( (std::string::empty(a2) & 1) != 0 )
{
std::allocator<char>::allocator();
std::string::basic_string(a1, "", (char *)&v13 + 7);
std::allocator<char>::~allocator((char *)&v13 + 7);
}
else
{
google::protobuf::compiler::cpp::`anonymous namespace'::DotsToColons(
(int)&v7,
(int)&v7,
v4,
a1,
a1,
v7,
v8,
v9,
v10,
v11,
v12,
v13,
v14[0],
v15[0]);
std::operator+<char>(v5, (long long)"::", v3);
std::string::~string(&v7);
}
return *(_QWORD *)v6;
}
| Namespace:
SUB RSP,0x68
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x60],RDI
MOV qword ptr [RSP + 0x58],RSI
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x001212d0
TEST AL,0x1
JNZ 0x001514eb
JMP 0x00151538
LAB_001514eb:
LEA RDI,[RSP + 0x57]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x00121a00
MOV RDI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x8]
LAB_00151504:
LEA RSI,[0x4a8569]
CALL 0x00121890
LAB_00151510:
JMP 0x00151512
LAB_00151512:
LEA RDI,[RSP + 0x57]
CALL 0x00121cb0
JMP 0x00151588
LAB_00151538:
MOV RSI,qword ptr [RSP + 0x58]
LEA RDI,[RSP + 0x20]
MOV qword ptr [RSP],RDI
CALL 0x001515a0
MOV RDI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP]
LAB_00151554:
LEA RSI,[0x4da80e]
CALL 0x00138890
LAB_00151560:
JMP 0x00151562
LAB_00151562:
LEA RDI,[RSP + 0x20]
CALL 0x00121cc8
JMP 0x00151588
LAB_00151588:
MOV RAX,qword ptr [RSP + 0x18]
ADD RSP,0x68
RET
|
/* google::protobuf::compiler::cpp::Namespace(std::__cxx11::string const&) */
cpp * __thiscall google::protobuf::compiler::cpp::Namespace(cpp *this,string *param_1)
{
ulong uVar1;
_anonymous_namespace_ local_48 [55];
allocator local_11;
string *local_10;
cpp *local_8;
local_10 = param_1;
local_8 = this;
uVar1 = std::__cxx11::string::empty();
if ((uVar1 & 1) == 0) {
(anonymous_namespace)::DotsToColons(local_48,local_10);
/* try { // try from 00151554 to 0015155f has its CatchHandler @ 0015156e */
std::operator+((char *)this,(string *)&DAT_004da80e);
std::__cxx11::string::~string((string *)local_48);
}
else {
std::allocator<char>::allocator();
/* try { // try from 00151504 to 0015150f has its CatchHandler @ 0015151e */
std::__cxx11::string::string((string *)this,"",&local_11);
std::allocator<char>::~allocator((allocator<char> *)&local_11);
}
return this;
}
| |
44,836 | my_convert_using_func | eloqsql/strings/ctype.c | uint32
my_convert_using_func(char *to, size_t to_length,
CHARSET_INFO *to_cs, my_charset_conv_wc_mb wc_mb,
const char *from, size_t from_length,
CHARSET_INFO *from_cs, my_charset_conv_mb_wc mb_wc,
uint *errors)
{
int cnvres;
my_wc_t wc;
const uchar *from_end= (const uchar*) from + from_length;
char *to_start= to;
uchar *to_end= (uchar*) to + to_length;
uint error_count= 0;
while (1)
{
if ((cnvres= (*mb_wc)(from_cs, &wc, (uchar*) from, from_end)) > 0)
from+= cnvres;
else if (cnvres == MY_CS_ILSEQ)
{
error_count++;
from++;
wc= '?';
}
else if (cnvres > MY_CS_TOOSMALL)
{
/*
A correct multibyte sequence detected
But it doesn't have Unicode mapping.
*/
error_count++;
from+= (-cnvres);
wc= '?';
}
else
{
if ((uchar *) from >= from_end)
break; /* End of line */
/* Incomplete byte sequence */
error_count++;
from++;
wc= '?';
}
outp:
if ((cnvres= (*wc_mb)(to_cs, wc, (uchar*) to, to_end)) > 0)
to+= cnvres;
else if (cnvres == MY_CS_ILUNI && wc != '?')
{
error_count++;
wc= '?';
goto outp;
}
else
break;
}
*errors= error_count;
return (uint32) (to - to_start);
} | O0 | c | my_convert_using_func:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x0, -0x5c(%rbp)
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x48(%rbp), %rcx
leaq -0x40(%rbp), %rsi
callq *%rax
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jle 0xa4304
movl -0x34(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0xa4382
cmpl $0x0, -0x34(%rbp)
jne 0xa4329
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq $0x3f, -0x40(%rbp)
jmp 0xa4380
cmpl $-0x65, -0x34(%rbp)
jle 0xa4355
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
xorl %ecx, %ecx
subl -0x34(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq $0x3f, -0x40(%rbp)
jmp 0xa437e
movq -0x28(%rbp), %rax
cmpq -0x48(%rbp), %rax
jb 0xa4361
jmp 0xa43dc
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq $0x3f, -0x40(%rbp)
jmp 0xa4380
jmp 0xa4382
jmp 0xa4384
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x8(%rbp), %rdx
movq -0x58(%rbp), %rcx
callq *%rax
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jle 0xa43b5
movl -0x34(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0xa43d7
cmpl $0x0, -0x34(%rbp)
jne 0xa43d5
cmpq $0x3f, -0x40(%rbp)
je 0xa43d5
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
movq $0x3f, -0x40(%rbp)
jmp 0xa4384
jmp 0xa43dc
jmp 0xa42d3
movl -0x5c(%rbp), %ecx
movq 0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq -0x50(%rbp), %rcx
subq %rcx, %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_convert_using_func:
push rbp
mov rbp, rsp
sub rsp, 60h
mov rax, [rbp+arg_10]
mov rax, [rbp+arg_8]
mov rax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_28]
add rax, [rbp+var_30]
mov [rbp+var_48], rax
mov rax, [rbp+var_8]
mov [rbp+var_50], rax
mov rax, [rbp+var_8]
add rax, [rbp+var_10]
mov [rbp+var_58], rax
mov [rbp+var_5C], 0
loc_A42D3:
mov rax, [rbp+arg_8]
mov rdi, [rbp+arg_0]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_48]
lea rsi, [rbp+var_40]
call rax
mov [rbp+var_34], eax
cmp eax, 0
jle short loc_A4304
mov ecx, [rbp+var_34]
mov rax, [rbp+var_28]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_28], rax
jmp short loc_A4382
loc_A4304:
cmp [rbp+var_34], 0
jnz short loc_A4329
mov eax, [rbp+var_5C]
add eax, 1
mov [rbp+var_5C], eax
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
mov [rbp+var_40], 3Fh ; '?'
jmp short loc_A4380
loc_A4329:
cmp [rbp+var_34], 0FFFFFF9Bh
jle short loc_A4355
mov eax, [rbp+var_5C]
add eax, 1
mov [rbp+var_5C], eax
xor ecx, ecx
sub ecx, [rbp+var_34]
mov rax, [rbp+var_28]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_28], rax
mov [rbp+var_40], 3Fh ; '?'
jmp short loc_A437E
loc_A4355:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_48]
jb short loc_A4361
jmp short loc_A43DC
loc_A4361:
mov eax, [rbp+var_5C]
add eax, 1
mov [rbp+var_5C], eax
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
mov [rbp+var_40], 3Fh ; '?'
loc_A437E:
jmp short $+2
loc_A4380:
jmp short $+2
loc_A4382:
jmp short $+2
loc_A4384:
mov rax, [rbp+var_20]
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_8]
mov rcx, [rbp+var_58]
call rax
mov [rbp+var_34], eax
cmp eax, 0
jle short loc_A43B5
mov ecx, [rbp+var_34]
mov rax, [rbp+var_8]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_8], rax
jmp short loc_A43D7
loc_A43B5:
cmp [rbp+var_34], 0
jnz short loc_A43D5
cmp [rbp+var_40], 3Fh ; '?'
jz short loc_A43D5
mov eax, [rbp+var_5C]
add eax, 1
mov [rbp+var_5C], eax
mov [rbp+var_40], 3Fh ; '?'
jmp short loc_A4384
loc_A43D5:
jmp short loc_A43DC
loc_A43D7:
jmp loc_A42D3
loc_A43DC:
mov ecx, [rbp+var_5C]
mov rax, [rbp+arg_10]
mov [rax], ecx
mov rax, [rbp+var_8]
mov rcx, [rbp+var_50]
sub rax, rcx
add rsp, 60h
pop rbp
retn
| long long my_convert_using_func(
long long a1,
long long a2,
long long a3,
long long ( *a4)(long long, long long, long long, long long),
unsigned long long a5,
long long a6,
long long a7,
long long ( *a8)(long long, long long *, unsigned long long, unsigned long long),
_DWORD *a9)
{
int v10; // [rsp+4h] [rbp-5Ch]
unsigned long long v11; // [rsp+18h] [rbp-48h]
long long v12; // [rsp+20h] [rbp-40h] BYREF
int v13; // [rsp+2Ch] [rbp-34h]
long long v14; // [rsp+30h] [rbp-30h]
unsigned long long v15; // [rsp+38h] [rbp-28h]
long long ( *v16)(long long, long long, long long, long long); // [rsp+40h] [rbp-20h]
long long v17; // [rsp+48h] [rbp-18h]
long long v18; // [rsp+50h] [rbp-10h]
long long v19; // [rsp+58h] [rbp-8h]
v19 = a1;
v18 = a2;
v17 = a3;
v16 = a4;
v15 = a5;
v14 = a6;
v11 = a6 + a5;
v10 = 0;
while ( 1 )
{
v13 = a8(a7, &v12, v15, v11);
if ( v13 > 0 )
{
v15 += v13;
goto LABEL_10;
}
if ( !v13 )
{
++v10;
++v15;
v12 = 63LL;
goto LABEL_10;
}
if ( v13 > -101 )
{
++v10;
v15 += -v13;
v12 = 63LL;
goto LABEL_10;
}
if ( v15 >= v11 )
break;
++v10;
++v15;
v12 = 63LL;
LABEL_10:
while ( 1 )
{
v13 = v16(v17, v12, v19, a2 + a1);
if ( v13 > 0 )
break;
if ( v13 || v12 == 63 )
goto LABEL_15;
++v10;
v12 = 63LL;
}
v19 += v13;
}
LABEL_15:
*a9 = v10;
return v19 - a1;
}
| my_convert_using_func:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV RAX,qword ptr [RBP + 0x20]
MOV RAX,qword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x58],RAX
MOV dword ptr [RBP + -0x5c],0x0
LAB_001a42d3:
MOV RAX,qword ptr [RBP + 0x18]
MOV RDI,qword ptr [RBP + 0x10]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x48]
LEA RSI,[RBP + -0x40]
CALL RAX
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
JLE 0x001a4304
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x28]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001a4382
LAB_001a4304:
CMP dword ptr [RBP + -0x34],0x0
JNZ 0x001a4329
MOV EAX,dword ptr [RBP + -0x5c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x5c],EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
MOV qword ptr [RBP + -0x40],0x3f
JMP 0x001a4380
LAB_001a4329:
CMP dword ptr [RBP + -0x34],-0x65
JLE 0x001a4355
MOV EAX,dword ptr [RBP + -0x5c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x5c],EAX
XOR ECX,ECX
SUB ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x28]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
MOV qword ptr [RBP + -0x40],0x3f
JMP 0x001a437e
LAB_001a4355:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x48]
JC 0x001a4361
JMP 0x001a43dc
LAB_001a4361:
MOV EAX,dword ptr [RBP + -0x5c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x5c],EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
MOV qword ptr [RBP + -0x40],0x3f
LAB_001a437e:
JMP 0x001a4380
LAB_001a4380:
JMP 0x001a4382
LAB_001a4382:
JMP 0x001a4384
LAB_001a4384:
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x58]
CALL RAX
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
JLE 0x001a43b5
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001a43d7
LAB_001a43b5:
CMP dword ptr [RBP + -0x34],0x0
JNZ 0x001a43d5
CMP qword ptr [RBP + -0x40],0x3f
JZ 0x001a43d5
MOV EAX,dword ptr [RBP + -0x5c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x5c],EAX
MOV qword ptr [RBP + -0x40],0x3f
JMP 0x001a4384
LAB_001a43d5:
JMP 0x001a43dc
LAB_001a43d7:
JMP 0x001a42d3
LAB_001a43dc:
MOV ECX,dword ptr [RBP + -0x5c]
MOV RAX,qword ptr [RBP + 0x20]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x50]
SUB RAX,RCX
ADD RSP,0x60
POP RBP
RET
|
long my_convert_using_func
(long param_1,long param_2,int8 param_3,code *param_4,ulong param_5,
long param_6,int8 param_7,code *param_8,int *param_9)
{
int local_64;
long local_48;
int local_3c;
long local_38;
ulong local_30;
code *local_28;
int8 local_20;
long local_18;
long local_10;
local_64 = 0;
local_38 = param_6;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
do {
local_3c = (*param_8)(param_7,&local_48,local_30);
if (local_3c < 1) {
if (local_3c == 0) {
local_30 = local_30 + 1;
}
else if (local_3c < -100) {
if (param_5 + param_6 <= local_30) {
LAB_001a43dc:
*param_9 = local_64;
return local_10 - param_1;
}
local_30 = local_30 + 1;
}
else {
local_30 = local_30 + (long)-local_3c;
}
local_64 = local_64 + 1;
local_48 = 0x3f;
}
else {
local_30 = local_30 + (long)local_3c;
}
while (local_3c = (*local_28)(local_20,local_48,local_10,param_1 + param_2), local_3c < 1) {
if ((local_3c != 0) || (local_48 == 0x3f)) goto LAB_001a43dc;
local_64 = local_64 + 1;
local_48 = 0x3f;
local_3c = 0;
}
local_10 = local_10 + local_3c;
} while( true );
}
| |
44,837 | nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>>::iteration_proxy_value(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>, unsigned long) | monkey531[P]llama/common/json.hpp | explicit iteration_proxy_value(IteratorType it, std::size_t array_index_ = 0)
noexcept(std::is_nothrow_move_constructible<IteratorType>::value
&& std::is_nothrow_default_constructible<string_type>::value)
: anchor(std::move(it))
, array_index(array_index_)
{} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>>::iteration_proxy_value(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>, unsigned long):
pushq %rbx
movq %rdi, %rbx
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rdx, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
addq $0x30, %rdi
leaq 0x40(%rbx), %rax
movq %rax, 0x30(%rbx)
leaq 0x3c32a(%rip), %rsi # 0xff899
leaq 0x3c324(%rip), %rdx # 0xff89a
callq 0x2d630
leaq 0x60(%rbx), %rax
movq %rax, 0x50(%rbx)
movq $0x0, 0x58(%rbx)
movb $0x0, 0x60(%rbx)
popq %rbx
retq
movq %rax, %rdi
callq 0x2d431
nop
| _ZN8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEEC2ESI_m:
push rbx
mov rbx, rdi
movups xmm0, xmmword ptr [rsi]
movups xmm1, xmmword ptr [rsi+10h]
movups xmmword ptr [rdi+10h], xmm1
movups xmmword ptr [rdi], xmm0
mov [rdi+20h], rdx
mov qword ptr [rdi+28h], 0
add rdi, 30h ; '0'
lea rax, [rbx+40h]
mov [rbx+30h], rax
lea rsi, aMinExp0+0Ah; "0"
lea rdx, aMinExp0+0Bh; ""
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+60h]
mov [rbx+50h], rax
mov qword ptr [rbx+58h], 0
mov byte ptr [rbx+60h], 0
pop rbx
retn
mov rdi, rax
call __clang_call_terminate
| long long nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>>::iteration_proxy_value(
long long a1,
__int128 *a2,
long long a3)
{
__int128 v3; // xmm0
long long result; // rax
v3 = *a2;
*(_OWORD *)(a1 + 16) = a2[1];
*(_OWORD *)a1 = v3;
*(_QWORD *)(a1 + 32) = a3;
*(_QWORD *)(a1 + 40) = 0LL;
*(_QWORD *)(a1 + 48) = a1 + 64;
std::string::_M_construct<char const*>(a1 + 48, "0", (long long)"");
result = a1 + 96;
*(_QWORD *)(a1 + 80) = a1 + 96;
*(_QWORD *)(a1 + 88) = 0LL;
*(_BYTE *)(a1 + 96) = 0;
return result;
}
| iteration_proxy_value:
PUSH RBX
MOV RBX,RDI
MOVUPS XMM0,xmmword ptr [RSI]
MOVUPS XMM1,xmmword ptr [RSI + 0x10]
MOVUPS xmmword ptr [RDI + 0x10],XMM1
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x20],RDX
MOV qword ptr [RDI + 0x28],0x0
ADD RDI,0x30
LEA RAX,[RBX + 0x40]
MOV qword ptr [RBX + 0x30],RAX
LAB_001c3568:
LEA RSI,[0x1ff899]
LEA RDX,[0x1ff89a]
CALL 0x0012d630
LEA RAX,[RBX + 0x60]
MOV qword ptr [RBX + 0x50],RAX
MOV qword ptr [RBX + 0x58],0x0
MOV byte ptr [RBX + 0x60],0x0
POP RBX
RET
|
/* nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const>
>::iteration_proxy_value(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const>, unsigned long) */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
::iteration_proxy_value
(iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
*this,int4 *param_2,int8 param_3)
{
int4 uVar1;
int4 uVar2;
int4 uVar3;
int4 uVar4;
int4 uVar5;
int4 uVar6;
int4 uVar7;
uVar1 = *param_2;
uVar2 = param_2[1];
uVar3 = param_2[2];
uVar4 = param_2[3];
uVar5 = param_2[5];
uVar6 = param_2[6];
uVar7 = param_2[7];
*(int4 *)(this + 0x10) = param_2[4];
*(int4 *)(this + 0x14) = uVar5;
*(int4 *)(this + 0x18) = uVar6;
*(int4 *)(this + 0x1c) = uVar7;
*(int4 *)this = uVar1;
*(int4 *)(this + 4) = uVar2;
*(int4 *)(this + 8) = uVar3;
*(int4 *)(this + 0xc) = uVar4;
*(int8 *)(this + 0x20) = param_3;
*(int8 *)(this + 0x28) = 0;
*(iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
**)(this + 0x30) = this + 0x40;
/* try { // try from 001c3568 to 001c357a has its CatchHandler @ 001c3591 */
std::__cxx11::string::_M_construct<char_const*>(this + 0x30,"0","");
*(iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
**)(this + 0x50) = this + 0x60;
*(int8 *)(this + 0x58) = 0;
this[0x60] = (iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
)0x0;
return;
}
| |
44,838 | my_caseup_utf32 | eloqsql/strings/ctype-ucs2.c | static size_t
my_caseup_utf32(CHARSET_INFO *cs, const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
int res;
const char *srcend= src + srclen;
char *dstend= dst + dstlen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(srclen <= dstlen);
while ((src < srcend) &&
(res= my_utf32_uni(cs, &wc, (uchar *)src, (uchar*) srcend)) > 0)
{
my_toupper_utf32(uni_plane, &wc);
if (res != my_uni_utf32(cs, wc, (uchar*) dst, (uchar*) dstend))
break;
src+= res;
dst+= res;
}
return srclen;
} | O3 | c | my_caseup_utf32:
movq %rdx, %rax
cmpq $0x4, %rdx
jl 0xc5245
pushq %rbp
movq %rsp, %rbp
pushq %rbx
leaq (%rsi,%rax), %rdx
addq %rcx, %r8
movq 0x78(%rdi), %rdi
addq $0x4, %rcx
movzbl (%rsi), %r9d
shll $0x18, %r9d
movzbl 0x1(%rsi), %r10d
shll $0x10, %r10d
orl %r9d, %r10d
cmpl $0x10ffff, %r10d # imm = 0x10FFFF
ja 0xc5243
movzbl 0x2(%rsi), %ebx
shll $0x8, %ebx
movzbl 0x3(%rsi), %r9d
orq %r9, %rbx
orq %r10, %rbx
cmpq (%rdi), %rbx
ja 0xc5204
movq 0x8(%rdi), %r10
movl %ebx, %r11d
shrl $0x8, %r11d
movq (%r10,%r11,8), %r10
testq %r10, %r10
je 0xc5204
leaq (%r9,%r9,2), %r9
movl (%r10,%r9,4), %ebx
cmpq %r8, %rcx
ja 0xc5243
cmpl $0x10ffff, %ebx # imm = 0x10FFFF
ja 0xc5243
movb $0x0, -0x4(%rcx)
movl %ebx, %r9d
shrl $0x10, %r9d
movb %r9b, -0x3(%rcx)
movb %bh, -0x2(%rcx)
movb %bl, -0x1(%rcx)
leaq 0x4(%rsi), %r9
cmpq %rdx, %r9
jae 0xc5243
addq $0x8, %rsi
addq $0x4, %rcx
cmpq %rdx, %rsi
movq %r9, %rsi
jbe 0xc51b4
popq %rbx
popq %rbp
retq
| my_caseup_utf32:
mov rax, rdx
cmp rdx, 4
jl locret_C5245
push rbp
mov rbp, rsp
push rbx
lea rdx, [rsi+rax]
add r8, rcx
mov rdi, [rdi+78h]
add rcx, 4
loc_C51B4:
movzx r9d, byte ptr [rsi]
shl r9d, 18h
movzx r10d, byte ptr [rsi+1]
shl r10d, 10h
or r10d, r9d
cmp r10d, offset unk_10FFFF
ja short loc_C5243
movzx ebx, byte ptr [rsi+2]
shl ebx, 8
movzx r9d, byte ptr [rsi+3]
or rbx, r9
or rbx, r10
cmp rbx, [rdi]
ja short loc_C5204
mov r10, [rdi+8]
mov r11d, ebx
shr r11d, 8
mov r10, [r10+r11*8]
test r10, r10
jz short loc_C5204
lea r9, [r9+r9*2]
mov ebx, [r10+r9*4]
loc_C5204:
cmp rcx, r8
ja short loc_C5243
cmp ebx, offset unk_10FFFF
ja short loc_C5243
mov byte ptr [rcx-4], 0
mov r9d, ebx
shr r9d, 10h
mov [rcx-3], r9b
mov [rcx-2], bh
mov [rcx-1], bl
lea r9, [rsi+4]
cmp r9, rdx
jnb short loc_C5243
add rsi, 8
add rcx, 4
cmp rsi, rdx
mov rsi, r9
jbe loc_C51B4
loc_C5243:
pop rbx
pop rbp
locret_C5245:
retn
| long long my_caseup_utf32(long long a1, unsigned __int8 *a2, long long a3, long long a4, long long a5)
{
long long result; // rax
unsigned long long v6; // rdx
unsigned long long v7; // r8
unsigned long long *v8; // rdi
unsigned long long v9; // rcx
long long v10; // r10
long long v11; // r9
unsigned long long v12; // rbx
long long v13; // r10
bool v14; // cc
result = a3;
if ( a3 >= 4 )
{
v6 = (unsigned long long)&a2[a3];
v7 = a4 + a5;
v8 = *(unsigned long long **)(a1 + 120);
v9 = a4 + 4;
do
{
v10 = (*a2 << 24) | (a2[1] << 16);
if ( (unsigned int)v10 > (unsigned int)&unk_10FFFF )
break;
v11 = a2[3];
v12 = v10 | v11 | (a2[2] << 8);
if ( v12 <= *v8 )
{
v13 = *(_QWORD *)(v8[1] + 8LL * ((unsigned int)v12 >> 8));
if ( v13 )
LODWORD(v12) = *(_DWORD *)(v13 + 12 * v11);
}
if ( v9 > v7 )
break;
if ( (unsigned int)v12 > (unsigned int)&unk_10FFFF )
break;
*(_BYTE *)(v9 - 4) = 0;
*(_BYTE *)(v9 - 3) = BYTE2(v12);
*(_BYTE *)(v9 - 2) = BYTE1(v12);
*(_BYTE *)(v9 - 1) = v12;
if ( (unsigned long long)(a2 + 4) >= v6 )
break;
v9 += 4LL;
v14 = (unsigned long long)(a2 + 8) <= v6;
a2 += 4;
}
while ( v14 );
}
return result;
}
| my_caseup_utf32:
MOV RAX,RDX
CMP RDX,0x4
JL 0x001c5245
PUSH RBP
MOV RBP,RSP
PUSH RBX
LEA RDX,[RSI + RAX*0x1]
ADD R8,RCX
MOV RDI,qword ptr [RDI + 0x78]
ADD RCX,0x4
LAB_001c51b4:
MOVZX R9D,byte ptr [RSI]
SHL R9D,0x18
MOVZX R10D,byte ptr [RSI + 0x1]
SHL R10D,0x10
OR R10D,R9D
CMP R10D,0x10ffff
JA 0x001c5243
MOVZX EBX,byte ptr [RSI + 0x2]
SHL EBX,0x8
MOVZX R9D,byte ptr [RSI + 0x3]
OR RBX,R9
OR RBX,R10
CMP RBX,qword ptr [RDI]
JA 0x001c5204
MOV R10,qword ptr [RDI + 0x8]
MOV R11D,EBX
SHR R11D,0x8
MOV R10,qword ptr [R10 + R11*0x8]
TEST R10,R10
JZ 0x001c5204
LEA R9,[R9 + R9*0x2]
MOV EBX,dword ptr [R10 + R9*0x4]
LAB_001c5204:
CMP RCX,R8
JA 0x001c5243
CMP EBX,0x10ffff
JA 0x001c5243
MOV byte ptr [RCX + -0x4],0x0
MOV R9D,EBX
SHR R9D,0x10
MOV byte ptr [RCX + -0x3],R9B
MOV byte ptr [RCX + -0x2],BH
MOV byte ptr [RCX + -0x1],BL
LEA R9,[RSI + 0x4]
CMP R9,RDX
JNC 0x001c5243
ADD RSI,0x8
ADD RCX,0x4
CMP RSI,RDX
MOV RSI,R9
JBE 0x001c51b4
LAB_001c5243:
POP RBX
POP RBP
LAB_001c5245:
RET
|
void my_caseup_utf32(long param_1,byte *param_2,long param_3,long param_4,long param_5)
{
ulong *puVar1;
long lVar2;
ulong uVar3;
ulong uVar4;
byte *pbVar5;
byte *pbVar6;
uint uVar7;
if (3 < param_3) {
puVar1 = *(ulong **)(param_1 + 0x78);
uVar3 = param_4 + 4;
pbVar5 = param_2;
while (uVar7 = (uint)pbVar5[1] << 0x10 | (uint)*pbVar5 << 0x18, uVar7 < 0x110000) {
uVar4 = (ulong)CONCAT11(pbVar5[2],pbVar5[3]) | (ulong)uVar7;
if ((uVar4 <= *puVar1) && (lVar2 = *(long *)(puVar1[1] + (uVar4 >> 8) * 8), lVar2 != 0)) {
uVar4 = (ulong)*(uint *)(lVar2 + (ulong)pbVar5[3] * 0xc);
}
if ((ulong)(param_5 + param_4) < uVar3) {
return;
}
if (0x10ffff < (uint)uVar4) {
return;
}
*(int1 *)(uVar3 - 4) = 0;
*(char *)(uVar3 - 3) = (char)(uVar4 >> 0x10);
*(char *)(uVar3 - 2) = (char)(uVar4 >> 8);
*(char *)(uVar3 - 1) = (char)uVar4;
if (param_2 + param_3 <= pbVar5 + 4) {
return;
}
pbVar6 = pbVar5 + 8;
uVar3 = uVar3 + 4;
pbVar5 = pbVar5 + 4;
if (param_2 + param_3 < pbVar6) {
return;
}
}
}
return;
}
| |
44,839 | minja::Value::dump(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, int, int, bool) const | monkey531[P]llama/common/minja.hpp | void dump(std::ostringstream & out, int indent = -1, int level = 0, bool to_json = false) const {
auto print_indent = [&](int level) {
if (indent > 0) {
out << "\n";
for (int i = 0, n = level * indent; i < n; ++i) out << ' ';
}
};
auto print_sub_sep = [&]() {
out << ',';
if (indent < 0) out << ' ';
else print_indent(level + 1);
};
auto string_quote = to_json ? '"' : '\'';
if (is_null()) out << "null";
else if (array_) {
out << "[";
print_indent(level + 1);
for (size_t i = 0; i < array_->size(); ++i) {
if (i) print_sub_sep();
(*array_)[i].dump(out, indent, level + 1, to_json);
}
print_indent(level);
out << "]";
} else if (object_) {
out << "{";
print_indent(level + 1);
for (auto begin = object_->begin(), it = begin; it != object_->end(); ++it) {
if (it != begin) print_sub_sep();
if (it->first.is_string()) {
dump_string(it->first, out, string_quote);
} else {
out << string_quote << it->first.dump() << string_quote;
}
out << ": ";
it->second.dump(out, indent, level + 1, to_json);
}
print_indent(level);
out << "}";
} else if (callable_) {
throw std::runtime_error("Cannot dump callable to JSON");
} else if (is_boolean() && !to_json) {
out << (this->to_bool() ? "True" : "False");
} else if (is_string() && !to_json) {
dump_string(primitive_, out, string_quote);
} else {
out << primitive_.dump();
}
} | O0 | cpp | minja::Value::dump(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, int, int, bool) const:
subq $0x118, %rsp # imm = 0x118
movb %r8b, %al
movq %rdi, 0x110(%rsp)
movq %rsi, 0x108(%rsp)
movl %edx, 0x104(%rsp)
movl %ecx, 0x100(%rsp)
andb $0x1, %al
movb %al, 0xff(%rsp)
movq 0x110(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x104(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0x108(%rsp), %rax
movq %rax, 0xf0(%rsp)
movq 0x108(%rsp), %rax
movq %rax, 0xc8(%rsp)
leaq 0x104(%rsp), %rax
movq %rax, 0xd0(%rsp)
leaq 0xe8(%rsp), %rax
movq %rax, 0xd8(%rsp)
leaq 0x100(%rsp), %rax
movq %rax, 0xe0(%rsp)
movb 0xff(%rsp), %cl
movb $0x22, %al
movb $0x27, %dl
movb %dl, 0x4e(%rsp)
testb $0x1, %cl
movb %al, 0x4f(%rsp)
jne 0xa22fe
movb 0x4e(%rsp), %al
movb %al, 0x4f(%rsp)
movq 0x40(%rsp), %rdi
movb 0x4f(%rsp), %al
movb %al, 0xc7(%rsp)
callq 0xa2830
testb $0x1, %al
jne 0xa2319
jmp 0xa2332
movq 0x108(%rsp), %rdi
leaq 0x117a48(%rip), %rsi # 0x1b9d70
callq 0x50840
jmp 0xa281b
movq 0x40(%rsp), %rdi
addq $0x10, %rdi
callq 0xa11a0
testb $0x1, %al
jne 0xa2349
jmp 0xa245a
movq 0x108(%rsp), %rdi
leaq 0x118826(%rip), %rsi # 0x1bab7e
callq 0x50840
movl 0x100(%rsp), %esi
addl $0x1, %esi
leaq 0xe8(%rsp), %rdi
callq 0xa28b0
movq $0x0, 0xb8(%rsp)
movq 0x40(%rsp), %rdi
movq 0xb8(%rsp), %rax
movq %rax, 0x38(%rsp)
addq $0x10, %rdi
callq 0xa2930
movq %rax, %rdi
callq 0xa2940
movq %rax, %rcx
movq 0x38(%rsp), %rax
cmpq %rcx, %rax
jae 0xa242d
cmpq $0x0, 0xb8(%rsp)
je 0xa23c8
leaq 0xc8(%rsp), %rdi
callq 0xa2960
movq 0x40(%rsp), %rdi
addq $0x10, %rdi
callq 0xa29c0
movq %rax, %rdi
movq 0xb8(%rsp), %rsi
callq 0xa29f0
movq %rax, %rdi
movq 0x108(%rsp), %rsi
movl 0x104(%rsp), %edx
movl 0x100(%rsp), %ecx
addl $0x1, %ecx
movb 0xff(%rsp), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0xa2240
movq 0xb8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xb8(%rsp)
jmp 0xa2380
movl 0x100(%rsp), %esi
leaq 0xe8(%rsp), %rdi
callq 0xa28b0
movq 0x108(%rsp), %rdi
leaq 0x1144bd(%rip), %rsi # 0x1b690d
callq 0x50840
jmp 0xa2819
movq 0x40(%rsp), %rdi
addq $0x20, %rdi
callq 0xa11c0
testb $0x1, %al
jne 0xa2471
jmp 0xa26aa
movq 0x108(%rsp), %rdi
leaq 0x115e4c(%rip), %rsi # 0x1b82cc
callq 0x50840
movl 0x100(%rsp), %esi
addl $0x1, %esi
leaq 0xe8(%rsp), %rdi
callq 0xa28b0
movq 0x40(%rsp), %rdi
addq $0x20, %rdi
callq 0xa2a10
movq %rax, %rdi
callq 0xa2a20
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0x40(%rsp), %rdi
addq $0x20, %rdi
callq 0xa2a10
movq %rax, %rdi
callq 0xa2a90
movq %rax, 0xa0(%rsp)
leaq 0xa8(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0xa2a50
testb $0x1, %al
jne 0xa2506
jmp 0xa267d
leaq 0xa8(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0xa2a50
testb $0x1, %al
jne 0xa2521
jmp 0xa252e
leaq 0xc8(%rsp), %rdi
callq 0xa2960
leaq 0xa8(%rsp), %rdi
callq 0xa2ac0
movq %rax, %rdi
callq 0xa2ad0
testb $0x1, %al
jne 0xa2549
jmp 0xa2573
leaq 0xa8(%rsp), %rdi
callq 0xa2ac0
movq %rax, %rdi
movq 0x108(%rsp), %rsi
movsbl 0xc7(%rsp), %edx
callq 0xa2af0
jmp 0xa2618
movq 0x108(%rsp), %rdi
movsbl 0xc7(%rsp), %esi
callq 0x50960
movq %rax, 0x20(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0xa2ac0
movq %rax, %rsi
leaq 0x80(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
movl $0x20, %ecx
xorl %r9d, %r9d
movl %r9d, %r8d
callq 0x72350
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x50410
movq %rax, 0x30(%rsp)
jmp 0xa25d5
movq 0x30(%rsp), %rdi
movsbl 0xc7(%rsp), %esi
callq 0x50960
jmp 0xa25e9
leaq 0x80(%rsp), %rdi
callq 0x510d0
jmp 0xa2618
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x510d0
jmp 0xa2823
movq 0x108(%rsp), %rdi
leaq 0x118566(%rip), %rsi # 0x1bab8d
callq 0x50840
leaq 0xa8(%rsp), %rdi
callq 0xa2ac0
movq %rax, %rdi
addq $0x10, %rdi
movq 0x108(%rsp), %rsi
movl 0x104(%rsp), %edx
movl 0x100(%rsp), %ecx
addl $0x1, %ecx
movb 0xff(%rsp), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0xa2240
leaq 0xa8(%rsp), %rdi
callq 0xa2e30
jmp 0xa24ca
movl 0x100(%rsp), %esi
leaq 0xe8(%rsp), %rdi
callq 0xa28b0
movq 0x108(%rsp), %rdi
leaq 0x11f8a7(%rip), %rsi # 0x1c1f47
callq 0x50840
jmp 0xa2817
movq 0x40(%rsp), %rdi
addq $0x30, %rdi
callq 0xa11e0
testb $0x1, %al
jne 0xa26be
jmp 0xa2716
movl $0x10, %edi
callq 0x50540
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
leaq 0x115bf4(%rip), %rsi # 0x1b82ce
callq 0x50340
jmp 0xa26e1
movq 0x18(%rsp), %rdi
movq 0x1948c3(%rip), %rsi # 0x236fb0
movq 0x194884(%rip), %rdx # 0x236f78
callq 0x508f0
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
callq 0x50c40
jmp 0xa2823
movq 0x40(%rsp), %rdi
callq 0xa2e50
testb $0x1, %al
jne 0xa2726
jmp 0xa276d
testb $0x1, 0xff(%rsp)
jne 0xa276d
movq 0x40(%rsp), %rdi
movq 0x108(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0xa08c0
movq 0x10(%rsp), %rdi
movb %al, %cl
leaq 0x115b9b(%rip), %rsi # 0x1b82f0
leaq 0x115b8f(%rip), %rax # 0x1b82eb
testb $0x1, %cl
cmovneq %rax, %rsi
callq 0x50840
jmp 0xa2813
movq 0x40(%rsp), %rdi
callq 0xa2e70
testb $0x1, %al
jne 0xa277d
jmp 0xa27a7
testb $0x1, 0xff(%rsp)
jne 0xa27a7
movq 0x40(%rsp), %rdi
addq $0x40, %rdi
movq 0x108(%rsp), %rsi
movsbl 0xc7(%rsp), %edx
callq 0xa2af0
jmp 0xa2811
movq 0x40(%rsp), %rsi
movq 0x108(%rsp), %rax
movq %rax, (%rsp)
addq $0x40, %rsi
leaq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
movl $0x20, %ecx
xorl %r9d, %r9d
movl %r9d, %r8d
callq 0x72350
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x50410
jmp 0xa27eb
leaq 0x50(%rsp), %rdi
callq 0x510d0
jmp 0xa2811
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x510d0
jmp 0xa2823
jmp 0xa2813
jmp 0xa2815
jmp 0xa2817
jmp 0xa2819
jmp 0xa281b
addq $0x118, %rsp # imm = 0x118
retq
movq 0x78(%rsp), %rdi
callq 0x50940
nopl (%rax)
| _ZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiib:
sub rsp, 118h
mov al, r8b
mov qword ptr [rsp+118h+var_8], rdi
mov qword ptr [rsp+118h+var_10], rsi
mov [rsp+118h+var_14], edx
mov [rsp+118h+var_18], ecx
and al, 1
mov [rsp+118h+var_19], al
mov rax, qword ptr [rsp+118h+var_8]
mov [rsp+118h+var_D8], rax; int
lea rax, [rsp+118h+var_14]
mov [rsp+118h+var_30], rax
mov rax, qword ptr [rsp+118h+var_10]
mov [rsp+118h+var_28], rax
mov rax, qword ptr [rsp+118h+var_10]
mov [rsp+118h+var_50], rax
lea rax, [rsp+118h+var_14]
mov [rsp+118h+var_48], rax
lea rax, [rsp+118h+var_30]
mov [rsp+118h+var_40], rax
lea rax, [rsp+118h+var_18]
mov [rsp+118h+var_38], rax
mov cl, [rsp+118h+var_19]
mov al, 22h ; '"'
mov dl, 27h ; '''
mov [rsp+118h+var_CA], dl
test cl, 1
mov [rsp+118h+var_C9], al
jnz short loc_A22FE
mov al, [rsp+118h+var_CA]
mov [rsp+118h+var_C9], al
loc_A22FE:
mov rdi, [rsp+118h+var_D8]; this
mov al, [rsp+118h+var_C9]
mov [rsp+118h+var_51], al
call _ZNK5minja5Value7is_nullEv; minja::Value::is_null(void)
test al, 1
jnz short loc_A2319
jmp short loc_A2332
loc_A2319:
mov rdi, qword ptr [rsp+118h+var_10]
lea rsi, aOnNull_0+5; "null"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp loc_A281B
loc_A2332:
mov rdi, [rsp+118h+var_D8]
add rdi, 10h
call _ZNKSt12__shared_ptrISt6vectorIN5minja5ValueESaIS2_EELN9__gnu_cxx12_Lock_policyE2EEcvbEv; std::__shared_ptr<std::vector<minja::Value>,(__gnu_cxx::_Lock_policy)2>::operator bool(void)
test al, 1
jnz short loc_A2349
jmp loc_A245A
loc_A2349:
mov rdi, qword ptr [rsp+118h+var_10]
lea rsi, aBytes+9; "["
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov esi, [rsp+118h+var_18]
add esi, 1
lea rdi, [rsp+118h+var_30]
call _ZZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiibENKUliE_clEi; minja::Value::dump(std::ostringstream &,int,int,bool)::{lambda(int)#1}::operator()(int)
mov qword ptr [rsp+118h+var_60], 0
loc_A2380:
mov rdi, [rsp+118h+var_D8]
mov rax, qword ptr [rsp+118h+var_60]
mov qword ptr [rsp+118h+var_E0], rax; char
add rdi, 10h
call _ZNKSt19__shared_ptr_accessISt6vectorIN5minja5ValueESaIS2_EELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<std::vector<minja::Value>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rdi, rax
call _ZNKSt6vectorIN5minja5ValueESaIS1_EE4sizeEv; std::vector<minja::Value>::size(void)
mov rcx, rax
mov rax, qword ptr [rsp+118h+var_E0]
cmp rax, rcx
jnb short loc_A242D
cmp qword ptr [rsp+118h+var_60], 0
jz short loc_A23C8
lea rdi, [rsp+118h+var_50]
call _ZZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiibENKUlvE_clEv; minja::Value::dump(std::ostringstream &,int,int,bool)::{lambda(void)#1}::operator()(void)
loc_A23C8:
mov rdi, [rsp+118h+var_D8]
add rdi, 10h
call _ZNKSt19__shared_ptr_accessISt6vectorIN5minja5ValueESaIS2_EELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEdeEv; std::__shared_ptr_access<std::vector<minja::Value>,(__gnu_cxx::_Lock_policy)2,false,false>::operator*(void)
mov rdi, rax
mov rsi, qword ptr [rsp+118h+var_60]
call _ZNSt6vectorIN5minja5ValueESaIS1_EEixEm; std::vector<minja::Value>::operator[](ulong)
mov rdi, rax
mov rsi, qword ptr [rsp+118h+var_10]
mov edx, [rsp+118h+var_14]
mov ecx, [rsp+118h+var_18]
add ecx, 1
mov al, [rsp+118h+var_19]
and al, 1
movzx r8d, al
call _ZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiib; minja::Value::dump(std::ostringstream &,int,int,bool)
mov rax, qword ptr [rsp+118h+var_60]
add rax, 1
mov qword ptr [rsp+118h+var_60], rax
jmp loc_A2380
loc_A242D:
mov esi, [rsp+118h+var_18]
lea rdi, [rsp+118h+var_30]
call _ZZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiibENKUliE_clEi; minja::Value::dump(std::ostringstream &,int,int,bool)::{lambda(int)#1}::operator()(int)
mov rdi, qword ptr [rsp+118h+var_10]
lea rsi, asc_1B690C+1; "]"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp loc_A2819
loc_A245A:
mov rdi, [rsp+118h+var_D8]
add rdi, 20h ; ' '
call _ZNKSt12__shared_ptrIN8nlohmann16json_abi_v3_11_311ordered_mapINS1_10basic_jsonIS2_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEN5minja5ValueESt4lessISE_ESaISt4pairIKSE_SG_EEEELN9__gnu_cxx12_Lock_policyE2EEcvbEv; std::__shared_ptr<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>,(__gnu_cxx::_Lock_policy)2>::operator bool(void)
test al, 1
jnz short loc_A2471
jmp loc_A26AA
loc_A2471:
mov rdi, qword ptr [rsp+118h+var_10]
lea rsi, asc_1B82CC; "{"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov esi, [rsp+118h+var_18]
add esi, 1
lea rdi, [rsp+118h+var_30]
call _ZZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiibENKUliE_clEi; minja::Value::dump(std::ostringstream &,int,int,bool)::{lambda(int)#1}::operator()(int)
mov rdi, [rsp+118h+var_D8]
add rdi, 20h ; ' '
call _ZNKSt19__shared_ptr_accessIN8nlohmann16json_abi_v3_11_311ordered_mapINS1_10basic_jsonIS2_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEN5minja5ValueESt4lessISE_ESaISt4pairIKSE_SG_EEEELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rdi, rax
call _ZNSt6vectorISt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES_IhSaIhEEvEEN5minja5ValueEESaISI_EE5beginEv; std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>::begin(void)
mov [rsp+118h+var_68], rax
mov rax, [rsp+118h+var_68]
mov [rsp+118h+var_70], rax
loc_A24CA:
mov rdi, [rsp+118h+var_D8]
add rdi, 20h ; ' '
call _ZNKSt19__shared_ptr_accessIN8nlohmann16json_abi_v3_11_311ordered_mapINS1_10basic_jsonIS2_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEN5minja5ValueESt4lessISE_ESaISt4pairIKSE_SG_EEEELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rdi, rax
call _ZNSt6vectorISt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES_IhSaIhEEvEEN5minja5ValueEESaISI_EE3endEv; std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>::end(void)
mov [rsp+118h+var_78], rax
lea rdi, [rsp+118h+var_70]
lea rsi, [rsp+118h+var_78]
call _ZN9__gnu_cxxneIPSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEN5minja5ValueEES6_ISK_SaISK_EEEEbRKNS_17__normal_iteratorIT_T0_EEST_; __gnu_cxx::operator!=<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>(__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>> const&,__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>> const&)
test al, 1
jnz short loc_A2506
jmp loc_A267D
loc_A2506:
lea rdi, [rsp+118h+var_70]
lea rsi, [rsp+118h+var_68]
call _ZN9__gnu_cxxneIPSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEN5minja5ValueEES6_ISK_SaISK_EEEEbRKNS_17__normal_iteratorIT_T0_EEST_; __gnu_cxx::operator!=<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>(__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>> const&,__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>> const&)
test al, 1
jnz short loc_A2521
jmp short loc_A252E
loc_A2521:
lea rdi, [rsp+118h+var_50]
call _ZZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiibENKUlvE_clEv; minja::Value::dump(std::ostringstream &,int,int,bool)::{lambda(void)#1}::operator()(void)
loc_A252E:
lea rdi, [rsp+118h+var_70]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEN5minja5ValueEES6_ISK_SaISK_EEEptEv; __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>::operator->(void)
mov rdi, rax
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9is_stringEv; 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_string(void)
test al, 1
jnz short loc_A2549
jmp short loc_A2573
loc_A2549:
lea rdi, [rsp+118h+var_70]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEN5minja5ValueEES6_ISK_SaISK_EEEptEv; __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>::operator->(void)
mov rdi, rax; int
mov rsi, qword ptr [rsp+118h+var_10]; int
movsx edx, [rsp+118h+var_51]; int
call _ZN5minja5Value11dump_stringERKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES5_IhSaIhEEvEERNS6_19basic_ostringstreamIcS9_SA_EEc; minja::Value::dump_string(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&,std::ostringstream &,char)
jmp loc_A2618
loc_A2573:
mov rdi, qword ptr [rsp+118h+var_10]
movsx esi, [rsp+118h+var_51]
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_c; std::operator<<<std::char_traits<char>>(std::ostream &,char)
mov [rsp+118h+var_F8], rax; __int64
lea rdi, [rsp+118h+var_70]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEN5minja5ValueEES6_ISK_SaISK_EEEptEv; __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>::operator->(void)
mov rsi, rax; int
lea rdi, [rsp+118h+var_98]; int
mov qword ptr [rsp+118h+var_F0], rdi; char
mov edx, 0FFFFFFFFh; int
mov ecx, 20h ; ' '; int
xor r9d, r9d; int
mov r8d, r9d; int
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dumpEicbNS0_6detail15error_handler_tE; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::dump(int,char,bool,nlohmann::json_abi_v3_11_3::detail::error_handler_t)
mov rdi, [rsp+118h+var_F8]
mov rsi, qword ptr [rsp+118h+var_F0]
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
mov [rsp+118h+var_E8], rax
jmp short $+2
loc_A25D5:
mov rdi, [rsp+118h+var_E8]
movsx esi, [rsp+118h+var_51]
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_c; std::operator<<<std::char_traits<char>>(std::ostream &,char)
jmp short $+2
loc_A25E9:
lea rdi, [rsp+118h+var_98]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_A2618
mov rcx, rax
mov eax, edx
mov [rsp+118h+var_A0], rcx
mov [rsp+118h+var_A4], eax
lea rdi, [rsp+118h+var_98]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp loc_A2823
loc_A2618:
mov rdi, qword ptr [rsp+118h+var_10]
lea rsi, aSubtype+9; ": "
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
lea rdi, [rsp+118h+var_70]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEN5minja5ValueEES6_ISK_SaISK_EEEptEv; __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>::operator->(void)
mov rdi, rax
add rdi, 10h
mov rsi, qword ptr [rsp+118h+var_10]
mov edx, [rsp+118h+var_14]
mov ecx, [rsp+118h+var_18]
add ecx, 1
mov al, [rsp+118h+var_19]
and al, 1
movzx r8d, al
call _ZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiib; minja::Value::dump(std::ostringstream &,int,int,bool)
lea rdi, [rsp+118h+var_70]
call _ZN9__gnu_cxx17__normal_iteratorIPSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEN5minja5ValueEES6_ISK_SaISK_EEEppEv; __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>::operator++(void)
jmp loc_A24CA
loc_A267D:
mov esi, [rsp+118h+var_18]
lea rdi, [rsp+118h+var_30]
call _ZZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiibENKUliE_clEi; minja::Value::dump(std::ostringstream &,int,int,bool)::{lambda(int)#1}::operator()(int)
mov rdi, qword ptr [rsp+118h+var_10]
lea rsi, aNT020+17h; "}"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp loc_A2817
loc_A26AA:
mov rdi, [rsp+118h+var_D8]
add rdi, 30h ; '0'
call _ZNKSt12__shared_ptrISt8functionIFN5minja5ValueERKSt10shared_ptrINS1_7ContextEERNS1_14ArgumentsValueEEELN9__gnu_cxx12_Lock_policyE2EEcvbEv; std::__shared_ptr<std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>,(__gnu_cxx::_Lock_policy)2>::operator bool(void)
test al, 1
jnz short loc_A26BE
jmp short loc_A2716
loc_A26BE:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+118h+var_100], rax
lea rsi, aCannotDumpCall; "Cannot dump callable to JSON"
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_A26E1:
mov rdi, [rsp+118h+var_100]; void *
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
mov rdi, [rsp+118h+var_100]; void *
mov rcx, rax
mov eax, edx
mov [rsp+118h+var_A0], rcx
mov [rsp+118h+var_A4], eax
call ___cxa_free_exception
jmp loc_A2823
loc_A2716:
mov rdi, [rsp+118h+var_D8]; this
call _ZNK5minja5Value10is_booleanEv; minja::Value::is_boolean(void)
test al, 1
jnz short loc_A2726
jmp short loc_A276D
loc_A2726:
test [rsp+118h+var_19], 1
jnz short loc_A276D
mov rdi, [rsp+118h+var_D8]; this
mov rax, qword ptr [rsp+118h+var_10]
mov [rsp+118h+var_108], rax
call _ZNK5minja5Value7to_boolEv; minja::Value::to_bool(void)
mov rdi, [rsp+118h+var_108]
mov cl, al
lea rsi, aFalse_0; "False"
lea rax, aTrue_0; "True"
test cl, 1
cmovnz rsi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp loc_A2813
loc_A276D:
mov rdi, [rsp+118h+var_D8]; this
call _ZNK5minja5Value9is_stringEv; minja::Value::is_string(void)
test al, 1
jnz short loc_A277D
jmp short loc_A27A7
loc_A277D:
test [rsp+118h+var_19], 1
jnz short loc_A27A7
mov rdi, [rsp+118h+var_D8]
add rdi, 40h ; '@'; int
mov rsi, qword ptr [rsp+118h+var_10]; int
movsx edx, [rsp+118h+var_51]; int
call _ZN5minja5Value11dump_stringERKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES5_IhSaIhEEvEERNS6_19basic_ostringstreamIcS9_SA_EEc; minja::Value::dump_string(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&,std::ostringstream &,char)
jmp short loc_A2811
loc_A27A7:
mov rsi, [rsp+118h+var_D8]
mov rax, qword ptr [rsp+118h+var_10]
mov qword ptr [rsp+118h+var_118], rax; int
add rsi, 40h ; '@'; int
lea rdi, [rsp+118h+var_C8]; int
mov qword ptr [rsp+118h+var_110], rdi; int
mov edx, 0FFFFFFFFh; int
mov ecx, 20h ; ' '; int
xor r9d, r9d; int
mov r8d, r9d; int
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dumpEicbNS0_6detail15error_handler_tE; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::dump(int,char,bool,nlohmann::json_abi_v3_11_3::detail::error_handler_t)
mov rdi, qword ptr [rsp+118h+var_118]
mov rsi, qword ptr [rsp+118h+var_110]
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
jmp short $+2
loc_A27EB:
lea rdi, [rsp+118h+var_C8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_A2811
mov rcx, rax
mov eax, edx
mov [rsp+118h+var_A0], rcx
mov [rsp+118h+var_A4], eax
lea rdi, [rsp+118h+var_C8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_A2823
loc_A2811:
jmp short $+2
loc_A2813:
jmp short $+2
loc_A2815:
jmp short $+2
loc_A2817:
jmp short $+2
loc_A2819:
jmp short $+2
loc_A281B:
add rsp, 118h
retn
loc_A2823:
mov rdi, [rsp+118h+var_A0]
call __Unwind_Resume
| void minja::Value::dump(minja::Value *a1, long long a2, unsigned int a3, unsigned int a4, char a5)
{
long long v5; // rax
long long v6; // rax
long long v7; // rax
long long v8; // rax
long long v9; // rax
long long v10; // rax
int v11; // eax
int v12; // ecx
int v13; // r8d
int v14; // r9d
long long v15; // rax
long long v16; // rax
long long v17; // rdi
const char *v18; // rsi
int v19; // ecx
int v20; // r8d
int v21; // r9d
int v22; // [rsp+0h] [rbp-118h]
int v23[2]; // [rsp+0h] [rbp-118h]
int v24; // [rsp+8h] [rbp-110h]
int v25; // [rsp+10h] [rbp-108h]
int v26; // [rsp+18h] [rbp-100h]
std::runtime_error *exception; // [rsp+18h] [rbp-100h]
long long v28; // [rsp+20h] [rbp-F8h]
int *v29; // [rsp+28h] [rbp-F0h]
long long v30; // [rsp+30h] [rbp-E8h]
int v31; // [rsp+38h] [rbp-E0h]
minja::Value *v32; // [rsp+40h] [rbp-D8h]
char v33; // [rsp+48h] [rbp-D0h]
char v34; // [rsp+4Fh] [rbp-C9h]
int v35; // [rsp+50h] [rbp-C8h] BYREF
int v36; // [rsp+58h] [rbp-C0h]
int v37; // [rsp+60h] [rbp-B8h]
__int16 v38; // [rsp+68h] [rbp-B0h]
long long v39; // [rsp+70h] [rbp-A8h]
long long v40; // [rsp+78h] [rbp-A0h]
int v41; // [rsp+80h] [rbp-98h] BYREF
int v42; // [rsp+88h] [rbp-90h]
int v43; // [rsp+90h] [rbp-88h]
char v44; // [rsp+98h] [rbp-80h]
long long v45; // [rsp+A0h] [rbp-78h] BYREF
long long i; // [rsp+A8h] [rbp-70h] BYREF
long long v47; // [rsp+B0h] [rbp-68h] BYREF
char v48[8]; // [rsp+B8h] [rbp-60h]
char v49; // [rsp+C7h] [rbp-51h]
_QWORD v50[4]; // [rsp+C8h] [rbp-50h] BYREF
_QWORD v51[2]; // [rsp+E8h] [rbp-30h] BYREF
char v52; // [rsp+FFh] [rbp-19h]
unsigned int v53; // [rsp+100h] [rbp-18h] BYREF
unsigned int v54; // [rsp+104h] [rbp-14h] BYREF
int v55[2]; // [rsp+108h] [rbp-10h]
int v56[2]; // [rsp+110h] [rbp-8h]
*(_QWORD *)v56 = a1;
*(_QWORD *)v55 = a2;
v54 = a3;
v53 = a4;
v52 = a5 & 1;
v32 = a1;
v51[0] = &v54;
v51[1] = a2;
v50[0] = a2;
v50[1] = &v54;
v50[2] = v51;
v50[3] = &v53;
v34 = 34;
if ( (a5 & 1) == 0 )
v34 = 39;
v49 = v34;
if ( (minja::Value::is_null(a1) & 1) != 0 )
{
std::operator<<<std::char_traits<char>>(*(_QWORD *)v55, "null");
}
else if ( std::__shared_ptr<std::vector<minja::Value>,(__gnu_cxx::_Lock_policy)2>::operator bool((_QWORD *)a1 + 2) )
{
std::operator<<<std::char_traits<char>>(*(_QWORD *)v55, "[");
minja::Value::dump(std::ostringstream &,int,int,bool)const::{lambda(int)#1}::operator()(v51, v53 + 1);
for ( *(_QWORD *)v48 = 0LL; ; ++*(_QWORD *)v48 )
{
v5 = std::__shared_ptr_access<std::vector<minja::Value>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->((char *)a1 + 16);
if ( *(_QWORD *)v48 >= (unsigned long long)std::vector<minja::Value>::size(v5) )
break;
if ( *(_QWORD *)v48 )
minja::Value::dump(std::ostringstream &,int,int,bool)const::{lambda(void)#1}::operator()(v50);
v6 = std::__shared_ptr_access<std::vector<minja::Value>,(__gnu_cxx::_Lock_policy)2,false,false>::operator*((char *)a1 + 16);
v7 = std::vector<minja::Value>::operator[](v6, *(_QWORD *)v48);
minja::Value::dump(v7, *(_QWORD *)v55, v54, v53 + 1, v52 & 1);
}
minja::Value::dump(std::ostringstream &,int,int,bool)const::{lambda(int)#1}::operator()(v51, v53);
std::operator<<<std::char_traits<char>>(*(_QWORD *)v55, "]");
}
else if ( std::__shared_ptr<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>,(__gnu_cxx::_Lock_policy)2>::operator bool((_QWORD *)a1 + 4) )
{
std::operator<<<std::char_traits<char>>(*(_QWORD *)v55, "{");
minja::Value::dump(std::ostringstream &,int,int,bool)const::{lambda(int)#1}::operator()(v51, v53 + 1);
v8 = std::__shared_ptr_access<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->((char *)a1 + 32);
v47 = std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>::begin(v8);
for ( i = v47;
;
__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>::operator++(&i) )
{
v9 = std::__shared_ptr_access<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->((char *)v32 + 32);
v45 = std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>::end(v9);
if ( (__gnu_cxx::operator!=<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>(
&i,
&v45) & 1) == 0 )
break;
if ( (__gnu_cxx::operator!=<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>(
&i,
&v47) & 1) != 0 )
minja::Value::dump(std::ostringstream &,int,int,bool)const::{lambda(void)#1}::operator()(v50);
v10 = __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>::operator->(&i);
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_string(v10) & 1) != 0 )
{
v11 = __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>::operator->(&i);
minja::Value::dump_string(
v11,
v55[0],
v49,
v12,
v13,
v14,
v22,
v24,
v25,
v26,
v28,
v29,
v30,
v31,
(int)v32,
v33,
v35,
v36,
v37,
v38,
v39,
v40,
v41,
v42,
v43,
v44);
}
else
{
v28 = std::operator<<<std::char_traits<char>>(*(_QWORD *)v55, (unsigned int)v49);
v15 = __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>::operator->(&i);
v29 = &v41;
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>::dump(
&v41,
v15,
-1,
32,
0,
0);
v30 = std::operator<<<char>(v28, &v41);
std::operator<<<std::char_traits<char>>(v30, (unsigned int)v49);
std::string::~string(&v41);
}
std::operator<<<std::char_traits<char>>(*(_QWORD *)v55, ": ");
v16 = __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>::operator->(&i);
minja::Value::dump(v16 + 16, *(_QWORD *)v55, v54, v53 + 1, v52 & 1);
}
minja::Value::dump(std::ostringstream &,int,int,bool)const::{lambda(int)#1}::operator()(v51, v53);
std::operator<<<std::char_traits<char>>(*(_QWORD *)v55, "}");
}
else
{
if ( std::__shared_ptr<std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>,(__gnu_cxx::_Lock_policy)2>::operator bool((_QWORD *)a1 + 6) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Cannot dump callable to JSON");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( (minja::Value::is_boolean(a1) & 1) == 0 || (v52 & 1) != 0 )
{
if ( (minja::Value::is_string(a1) & 1) == 0 || (v52 & 1) != 0 )
{
*(_QWORD *)v23 = *(_QWORD *)v55;
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>::dump(
&v35,
(long long)a1 + 64,
-1,
32,
0,
0);
std::operator<<<char>(*(_QWORD *)v23, &v35);
std::string::~string(&v35);
}
else
{
minja::Value::dump_string(
(_DWORD)a1 + 64,
v55[0],
v49,
v19,
v20,
v21,
v22,
v24,
v25,
v26,
v28,
v29,
v30,
v31,
(int)a1,
v33,
v35,
v36,
v37,
v38,
v39,
v40,
v41,
v42,
v43,
v44);
}
}
else
{
v17 = *(_QWORD *)v55;
v18 = "False";
if ( (minja::Value::to_bool(v32) & 1) != 0 )
v18 = "True";
std::operator<<<std::char_traits<char>>(v17, v18);
}
}
}
| dump:
SUB RSP,0x118
MOV AL,R8B
MOV qword ptr [RSP + 0x110],RDI
MOV qword ptr [RSP + 0x108],RSI
MOV dword ptr [RSP + 0x104],EDX
MOV dword ptr [RSP + 0x100],ECX
AND AL,0x1
MOV byte ptr [RSP + 0xff],AL
MOV RAX,qword ptr [RSP + 0x110]
MOV qword ptr [RSP + 0x40],RAX
LEA RAX,[RSP + 0x104]
MOV qword ptr [RSP + 0xe8],RAX
MOV RAX,qword ptr [RSP + 0x108]
MOV qword ptr [RSP + 0xf0],RAX
MOV RAX,qword ptr [RSP + 0x108]
MOV qword ptr [RSP + 0xc8],RAX
LEA RAX,[RSP + 0x104]
MOV qword ptr [RSP + 0xd0],RAX
LEA RAX,[RSP + 0xe8]
MOV qword ptr [RSP + 0xd8],RAX
LEA RAX,[RSP + 0x100]
MOV qword ptr [RSP + 0xe0],RAX
MOV CL,byte ptr [RSP + 0xff]
MOV AL,0x22
MOV DL,0x27
MOV byte ptr [RSP + 0x4e],DL
TEST CL,0x1
MOV byte ptr [RSP + 0x4f],AL
JNZ 0x001a22fe
MOV AL,byte ptr [RSP + 0x4e]
MOV byte ptr [RSP + 0x4f],AL
LAB_001a22fe:
MOV RDI,qword ptr [RSP + 0x40]
MOV AL,byte ptr [RSP + 0x4f]
MOV byte ptr [RSP + 0xc7],AL
CALL 0x001a2830
TEST AL,0x1
JNZ 0x001a2319
JMP 0x001a2332
LAB_001a2319:
MOV RDI,qword ptr [RSP + 0x108]
LEA RSI,[0x2b9d70]
CALL 0x00150840
JMP 0x001a281b
LAB_001a2332:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x10
CALL 0x001a11a0
TEST AL,0x1
JNZ 0x001a2349
JMP 0x001a245a
LAB_001a2349:
MOV RDI,qword ptr [RSP + 0x108]
LEA RSI,[0x2bab7e]
CALL 0x00150840
MOV ESI,dword ptr [RSP + 0x100]
ADD ESI,0x1
LEA RDI,[RSP + 0xe8]
CALL 0x001a28b0
MOV qword ptr [RSP + 0xb8],0x0
LAB_001a2380:
MOV RDI,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RSP + 0xb8]
MOV qword ptr [RSP + 0x38],RAX
ADD RDI,0x10
CALL 0x001a2930
MOV RDI,RAX
CALL 0x001a2940
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x38]
CMP RAX,RCX
JNC 0x001a242d
CMP qword ptr [RSP + 0xb8],0x0
JZ 0x001a23c8
LEA RDI,[RSP + 0xc8]
CALL 0x001a2960
LAB_001a23c8:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x10
CALL 0x001a29c0
MOV RDI,RAX
MOV RSI,qword ptr [RSP + 0xb8]
CALL 0x001a29f0
MOV RDI,RAX
MOV RSI,qword ptr [RSP + 0x108]
MOV EDX,dword ptr [RSP + 0x104]
MOV ECX,dword ptr [RSP + 0x100]
ADD ECX,0x1
MOV AL,byte ptr [RSP + 0xff]
AND AL,0x1
MOVZX R8D,AL
CALL 0x001a2240
MOV RAX,qword ptr [RSP + 0xb8]
ADD RAX,0x1
MOV qword ptr [RSP + 0xb8],RAX
JMP 0x001a2380
LAB_001a242d:
MOV ESI,dword ptr [RSP + 0x100]
LEA RDI,[RSP + 0xe8]
CALL 0x001a28b0
MOV RDI,qword ptr [RSP + 0x108]
LEA RSI,[0x2b690d]
CALL 0x00150840
JMP 0x001a2819
LAB_001a245a:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x20
CALL 0x001a11c0
TEST AL,0x1
JNZ 0x001a2471
JMP 0x001a26aa
LAB_001a2471:
MOV RDI,qword ptr [RSP + 0x108]
LEA RSI,[0x2b82cc]
CALL 0x00150840
MOV ESI,dword ptr [RSP + 0x100]
ADD ESI,0x1
LEA RDI,[RSP + 0xe8]
CALL 0x001a28b0
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x20
CALL 0x001a2a10
MOV RDI,RAX
CALL 0x001a2a20
MOV qword ptr [RSP + 0xb0],RAX
MOV RAX,qword ptr [RSP + 0xb0]
MOV qword ptr [RSP + 0xa8],RAX
LAB_001a24ca:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x20
CALL 0x001a2a10
MOV RDI,RAX
CALL 0x001a2a90
MOV qword ptr [RSP + 0xa0],RAX
LEA RDI,[RSP + 0xa8]
LEA RSI,[RSP + 0xa0]
CALL 0x001a2a50
TEST AL,0x1
JNZ 0x001a2506
JMP 0x001a267d
LAB_001a2506:
LEA RDI,[RSP + 0xa8]
LEA RSI,[RSP + 0xb0]
CALL 0x001a2a50
TEST AL,0x1
JNZ 0x001a2521
JMP 0x001a252e
LAB_001a2521:
LEA RDI,[RSP + 0xc8]
CALL 0x001a2960
LAB_001a252e:
LEA RDI,[RSP + 0xa8]
CALL 0x001a2ac0
MOV RDI,RAX
CALL 0x001a2ad0
TEST AL,0x1
JNZ 0x001a2549
JMP 0x001a2573
LAB_001a2549:
LEA RDI,[RSP + 0xa8]
CALL 0x001a2ac0
MOV RDI,RAX
MOV RSI,qword ptr [RSP + 0x108]
MOVSX EDX,byte ptr [RSP + 0xc7]
CALL 0x001a2af0
JMP 0x001a2618
LAB_001a2573:
MOV RDI,qword ptr [RSP + 0x108]
MOVSX ESI,byte ptr [RSP + 0xc7]
CALL 0x00150960
MOV qword ptr [RSP + 0x20],RAX
LEA RDI,[RSP + 0xa8]
CALL 0x001a2ac0
MOV RSI,RAX
LEA RDI,[RSP + 0x80]
MOV qword ptr [RSP + 0x28],RDI
MOV EDX,0xffffffff
MOV ECX,0x20
XOR R9D,R9D
MOV R8D,R9D
CALL 0x00172350
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x28]
LAB_001a25c9:
CALL 0x00150410
MOV qword ptr [RSP + 0x30],RAX
JMP 0x001a25d5
LAB_001a25d5:
MOV RDI,qword ptr [RSP + 0x30]
MOVSX ESI,byte ptr [RSP + 0xc7]
CALL 0x00150960
LAB_001a25e7:
JMP 0x001a25e9
LAB_001a25e9:
LEA RDI,[RSP + 0x80]
CALL 0x001510d0
JMP 0x001a2618
LAB_001a2618:
MOV RDI,qword ptr [RSP + 0x108]
LEA RSI,[0x2bab8d]
CALL 0x00150840
LEA RDI,[RSP + 0xa8]
CALL 0x001a2ac0
MOV RDI,RAX
ADD RDI,0x10
MOV RSI,qword ptr [RSP + 0x108]
MOV EDX,dword ptr [RSP + 0x104]
MOV ECX,dword ptr [RSP + 0x100]
ADD ECX,0x1
MOV AL,byte ptr [RSP + 0xff]
AND AL,0x1
MOVZX R8D,AL
CALL 0x001a2240
LEA RDI,[RSP + 0xa8]
CALL 0x001a2e30
JMP 0x001a24ca
LAB_001a267d:
MOV ESI,dword ptr [RSP + 0x100]
LEA RDI,[RSP + 0xe8]
CALL 0x001a28b0
MOV RDI,qword ptr [RSP + 0x108]
LEA RSI,[0x2c1f47]
CALL 0x00150840
JMP 0x001a2817
LAB_001a26aa:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x30
CALL 0x001a11e0
TEST AL,0x1
JNZ 0x001a26be
JMP 0x001a2716
LAB_001a26be:
MOV EDI,0x10
CALL 0x00150540
MOV RDI,RAX
MOV RAX,RDI
MOV qword ptr [RSP + 0x18],RAX
LAB_001a26d3:
LEA RSI,[0x2b82ce]
CALL 0x00150340
LAB_001a26df:
JMP 0x001a26e1
LAB_001a26e1:
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [0x00336fb0]
MOV RDX,qword ptr [0x00336f78]
CALL 0x001508f0
LAB_001a2716:
MOV RDI,qword ptr [RSP + 0x40]
CALL 0x001a2e50
TEST AL,0x1
JNZ 0x001a2726
JMP 0x001a276d
LAB_001a2726:
TEST byte ptr [RSP + 0xff],0x1
JNZ 0x001a276d
MOV RDI,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RSP + 0x108]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x001a08c0
MOV RDI,qword ptr [RSP + 0x10]
MOV CL,AL
LEA RSI,[0x2b82f0]
LEA RAX,[0x2b82eb]
TEST CL,0x1
CMOVNZ RSI,RAX
CALL 0x00150840
JMP 0x001a2813
LAB_001a276d:
MOV RDI,qword ptr [RSP + 0x40]
CALL 0x001a2e70
TEST AL,0x1
JNZ 0x001a277d
JMP 0x001a27a7
LAB_001a277d:
TEST byte ptr [RSP + 0xff],0x1
JNZ 0x001a27a7
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x40
MOV RSI,qword ptr [RSP + 0x108]
MOVSX EDX,byte ptr [RSP + 0xc7]
CALL 0x001a2af0
JMP 0x001a2811
LAB_001a27a7:
MOV RSI,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RSP + 0x108]
MOV qword ptr [RSP],RAX
ADD RSI,0x40
LEA RDI,[RSP + 0x50]
MOV qword ptr [RSP + 0x8],RDI
MOV EDX,0xffffffff
MOV ECX,0x20
XOR R9D,R9D
MOV R8D,R9D
CALL 0x00172350
MOV RDI,qword ptr [RSP]
MOV RSI,qword ptr [RSP + 0x8]
LAB_001a27e4:
CALL 0x00150410
LAB_001a27e9:
JMP 0x001a27eb
LAB_001a27eb:
LEA RDI,[RSP + 0x50]
CALL 0x001510d0
JMP 0x001a2811
LAB_001a2811:
JMP 0x001a2813
LAB_001a2813:
JMP 0x001a2815
LAB_001a2815:
JMP 0x001a2817
LAB_001a2817:
JMP 0x001a2819
LAB_001a2819:
JMP 0x001a281b
LAB_001a281b:
ADD RSP,0x118
RET
|
/* minja::Value::dump(std::__cxx11::ostringstream&, int, int, bool) const */
void __thiscall
minja::Value::dump(Value *this,ostringstream *param_1,int param_2,int param_3,bool param_4)
{
bool bVar1;
byte bVar2;
ulong uVar3;
vector<minja::Value,std::allocator<minja::Value>> *pvVar4;
ulong uVar5;
Value *this_00;
vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
*pvVar6;
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_01;
basic_json *pbVar7;
ostream *poVar8;
int8 uVar9;
long lVar10;
runtime_error *this_02;
char *pcVar11;
char local_c9;
string local_c8 [48];
string local_98 [32];
int8 local_78;
int8 local_70;
int8 local_68;
ulong local_60;
char local_51;
ostringstream *local_50;
int *local_48;
int **local_40;
int *local_38;
int *local_30;
ostringstream *local_28;
byte local_19;
int local_18;
int local_14;
ostream *local_10;
Value *local_8;
local_30 = &local_14;
local_48 = &local_14;
local_40 = &local_30;
local_38 = &local_18;
local_c9 = '\"';
if (!param_4) {
local_c9 = '\'';
}
local_51 = local_c9;
local_50 = param_1;
local_28 = param_1;
local_19 = param_4;
local_18 = param_3;
local_14 = param_2;
local_10 = (ostream *)param_1;
local_8 = this;
uVar3 = is_null(this);
if ((uVar3 & 1) == 0) {
bVar1 = std::__shared_ptr::operator_cast_to_bool((__shared_ptr *)(this + 0x10));
if (bVar1) {
std::operator<<(local_10,"[");
const::{lambda(int)#1}::operator()((_lambda_int__1_ *)&local_30,local_18 + 1);
local_60 = 0;
while( true ) {
uVar3 = local_60;
pvVar4 = (vector<minja::Value,std::allocator<minja::Value>> *)
std::
__shared_ptr_access<std::vector<minja::Value,std::allocator<minja::Value>>,(__gnu_cxx::_Lock_policy)2,false,false>
::operator->((__shared_ptr_access<std::vector<minja::Value,std::allocator<minja::Value>>,(__gnu_cxx::_Lock_policy)2,false,false>
*)(this + 0x10));
uVar5 = std::vector<minja::Value,std::allocator<minja::Value>>::size(pvVar4);
if (uVar5 <= uVar3) break;
if (local_60 != 0) {
const::{lambda()#1}::operator()((_lambda___1_ *)&local_50);
}
pvVar4 = (vector<minja::Value,std::allocator<minja::Value>> *)
std::
__shared_ptr_access<std::vector<minja::Value,std::allocator<minja::Value>>,(__gnu_cxx::_Lock_policy)2,false,false>
::operator*((__shared_ptr_access<std::vector<minja::Value,std::allocator<minja::Value>>,(__gnu_cxx::_Lock_policy)2,false,false>
*)(this + 0x10));
this_00 = (Value *)std::vector<minja::Value,std::allocator<minja::Value>>::operator[]
(pvVar4,local_60);
dump(this_00,(ostringstream *)local_10,local_14,local_18 + 1,(bool)(local_19 & 1));
local_60 = local_60 + 1;
}
const::{lambda(int)#1}::operator()((_lambda_int__1_ *)&local_30,local_18);
std::operator<<(local_10,"]");
}
else {
bVar1 = std::__shared_ptr::operator_cast_to_bool((__shared_ptr *)(this + 0x20));
if (bVar1) {
std::operator<<(local_10,"{");
const::{lambda(int)#1}::operator()((_lambda_int__1_ *)&local_30,local_18 + 1);
pvVar6 = (vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
*)std::
__shared_ptr_access<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>,(__gnu_cxx::_Lock_policy)2,false,false>
::operator->((__shared_ptr_access<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>,(__gnu_cxx::_Lock_policy)2,false,false>
*)(this + 0x20));
local_70 = std::
vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
::begin(pvVar6);
local_68 = local_70;
while( true ) {
pvVar6 = (vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
*)std::
__shared_ptr_access<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>,(__gnu_cxx::_Lock_policy)2,false,false>
::operator->((__shared_ptr_access<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>,(__gnu_cxx::_Lock_policy)2,false,false>
*)(this + 0x20));
local_78 = std::
vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
::end(pvVar6);
bVar1 = __gnu_cxx::operator!=
((__normal_iterator *)&local_70,(__normal_iterator *)&local_78);
if (!bVar1) break;
bVar1 = __gnu_cxx::operator!=
((__normal_iterator *)&local_70,(__normal_iterator *)&local_68);
if (bVar1) {
const::{lambda()#1}::operator()((_lambda___1_ *)&local_50);
}
this_01 = (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>
*)__gnu_cxx::
__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>>
::operator->((__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>>
*)&local_70);
uVar3 = 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>
::is_string(this_01);
if ((uVar3 & 1) == 0) {
poVar8 = std::operator<<(local_10,local_51);
uVar9 = __gnu_cxx::
__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>>
::operator->((__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>>
*)&local_70);
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>
::dump(local_98,uVar9,0xffffffff,0x20,0);
/* try { // try from 001a25c9 to 001a25e6 has its CatchHandler @ 001a25f8 */
poVar8 = std::operator<<(poVar8,local_98);
std::operator<<(poVar8,local_51);
std::__cxx11::string::~string(local_98);
}
else {
pbVar7 = (basic_json *)
__gnu_cxx::
__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>>
::operator->((__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>>
*)&local_70);
dump_string(pbVar7,(ostringstream *)local_10,local_51);
}
std::operator<<(local_10,": ");
lVar10 = __gnu_cxx::
__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>>
::operator->((__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>>
*)&local_70);
dump((Value *)(lVar10 + 0x10),(ostringstream *)local_10,local_14,local_18 + 1,
(bool)(local_19 & 1));
__gnu_cxx::
__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>>
::operator++((__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>>
*)&local_70);
}
const::{lambda(int)#1}::operator()((_lambda_int__1_ *)&local_30,local_18);
std::operator<<(local_10,"}");
}
else {
bVar1 = std::__shared_ptr::operator_cast_to_bool((__shared_ptr *)(this + 0x30));
if (bVar1) {
this_02 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001a26d3 to 001a26de has its CatchHandler @ 001a26f9 */
std::runtime_error::runtime_error(this_02,"Cannot dump callable to JSON");
/* WARNING: Subroutine does not return */
__cxa_throw(this_02,PTR_typeinfo_00336fb0,PTR__runtime_error_00336f78);
}
uVar3 = is_boolean(this);
poVar8 = local_10;
if (((uVar3 & 1) == 0) || ((local_19 & 1) != 0)) {
uVar3 = is_string(this);
poVar8 = local_10;
if (((uVar3 & 1) == 0) || ((local_19 & 1) != 0)) {
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::dump(local_c8,this + 0x40,0xffffffff,0x20,0);
/* try { // try from 001a27e4 to 001a27e8 has its CatchHandler @ 001a27f7 */
std::operator<<(poVar8,local_c8);
std::__cxx11::string::~string(local_c8);
}
else {
dump_string(this + 0x40,(ostringstream *)local_10,local_51);
}
}
else {
bVar2 = to_bool(this);
pcVar11 = "False";
if ((bVar2 & 1) != 0) {
pcVar11 = "True";
}
std::operator<<(poVar8,pcVar11);
}
}
}
}
else {
std::operator<<(local_10,"null");
}
return;
}
| |
44,840 | minja::Value::dump(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, int, int, bool) const | monkey531[P]llama/common/minja.hpp | void dump(std::ostringstream & out, int indent = -1, int level = 0, bool to_json = false) const {
auto print_indent = [&](int level) {
if (indent > 0) {
out << "\n";
for (int i = 0, n = level * indent; i < n; ++i) out << ' ';
}
};
auto print_sub_sep = [&]() {
out << ',';
if (indent < 0) out << ' ';
else print_indent(level + 1);
};
auto string_quote = to_json ? '"' : '\'';
if (is_null()) out << "null";
else if (array_) {
out << "[";
print_indent(level + 1);
for (size_t i = 0; i < array_->size(); ++i) {
if (i) print_sub_sep();
(*array_)[i].dump(out, indent, level + 1, to_json);
}
print_indent(level);
out << "]";
} else if (object_) {
out << "{";
print_indent(level + 1);
for (auto begin = object_->begin(), it = begin; it != object_->end(); ++it) {
if (it != begin) print_sub_sep();
if (it->first.is_string()) {
dump_string(it->first, out, string_quote);
} else {
out << string_quote << it->first.dump() << string_quote;
}
out << ": ";
it->second.dump(out, indent, level + 1, to_json);
}
print_indent(level);
out << "}";
} else if (callable_) {
throw std::runtime_error("Cannot dump callable to JSON");
} else if (is_boolean() && !to_json) {
out << (this->to_bool() ? "True" : "False");
} else if (is_string() && !to_json) {
dump_string(primitive_, out, string_quote);
} else {
out << primitive_.dump();
}
} | O2 | cpp | minja::Value::dump(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, int, int, bool) const:
pushq %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rax
cmpl $0x0, (%rax)
jle 0x3d256
movl %esi, %ebp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x4fac8(%rip), %rsi # 0x8ccf4
callq 0x20690
movq (%rbx), %rax
imull (%rax), %ebp
xorl %r14d, %r14d
testl %ebp, %ebp
cmovgl %ebp, %r14d
pushq $0x20
popq %rbp
subl $0x1, %r14d
jb 0x3d256
movq 0x8(%rbx), %rdi
movl %ebp, %esi
callq 0x207c0
jmp 0x3d243
popq %rbx
popq %r14
popq %rbp
retq
nop
| _ZZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiibENKUliE_clEi:
push rbp
push r14
push rbx
mov rax, [rdi]
cmp dword ptr [rax], 0
jle short loc_3D256
mov ebp, esi
mov rbx, rdi
mov rdi, [rdi+8]
lea rsi, aEndIndexOutOfB+18h; "\n"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rax, [rbx]
imul ebp, [rax]
xor r14d, r14d
test ebp, ebp
cmovg r14d, ebp
push 20h ; ' '
pop rbp
loc_3D243:
sub r14d, 1
jb short loc_3D256
mov rdi, [rbx+8]
mov esi, ebp
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_c; std::operator<<<std::char_traits<char>>(std::ostream &,char)
jmp short loc_3D243
loc_3D256:
pop rbx
pop r14
pop rbp
retn
| int * minja::Value::dump(std::ostringstream &,int,int,bool)const::{lambda(int)#1}::operator()(
int **a1,
int a2)
{
int *result; // rax
int v3; // r14d
result = *a1;
if ( **a1 > 0 )
{
std::operator<<<std::char_traits<char>>(a1[1], "\n");
result = *a1;
v3 = 0;
if ( **a1 * a2 > 0 )
v3 = **a1 * a2;
while ( v3-- != 0 )
result = (int *)std::operator<<<std::char_traits<char>>(a1[1], 32LL);
}
return result;
}
| operator():
PUSH RBP
PUSH R14
PUSH RBX
MOV RAX,qword ptr [RDI]
CMP dword ptr [RAX],0x0
JLE 0x0013d256
MOV EBP,ESI
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x8]
LEA RSI,[0x18ccf4]
CALL 0x00120690
MOV RAX,qword ptr [RBX]
IMUL EBP,dword ptr [RAX]
XOR R14D,R14D
TEST EBP,EBP
CMOVG R14D,EBP
PUSH 0x20
POP RBP
LAB_0013d243:
SUB R14D,0x1
JC 0x0013d256
MOV RDI,qword ptr [RBX + 0x8]
MOV ESI,EBP
CALL 0x001207c0
JMP 0x0013d243
LAB_0013d256:
POP RBX
POP R14
POP RBP
RET
|
/* minja::Value::dump(std::__cxx11::ostringstream&, int, int, bool)
const::{lambda(int)#1}::TEMPNAMEPLACEHOLDERVALUE(int) const */
_func_dump_ostringstream_ptr_int_int_bool * __thiscall
const::{lambda(int)#1}::operator()(_lambda_int__1_ *this,int param_1)
{
ostream *poVar1;
int iVar2;
poVar1 = *(ostream **)this;
if (0 < *(int *)poVar1) {
std::operator<<(*(ostream **)(this + 8),"\n");
poVar1 = *(ostream **)this;
iVar2 = 0;
if (0 < param_1 * *(int *)poVar1) {
iVar2 = param_1 * *(int *)poVar1;
}
while (iVar2 != 0) {
poVar1 = std::operator<<(*(ostream **)(this + 8),' ');
iVar2 = iVar2 + -1;
}
}
return (_func_dump_ostringstream_ptr_int_int_bool *)poVar1;
}
| |
44,841 | minja::Parser::parseVarNames[abi:cxx11]() | llama.cpp/common/minja/minja.hpp | std::vector<std::string> parseVarNames() {
static std::regex varnames_regex(R"(((?:\w+)(?:\s*,\s*(?:\w+))*)\s*)");
std::vector<std::string> group;
if ((group = consumeTokenGroups(varnames_regex)).empty()) throw std::runtime_error("Expected variable names");
std::vector<std::string> varnames;
std::istringstream iss(group[1]);
std::string varname;
while (std::getline(iss, varname, ',')) {
varnames.push_back(strip(varname));
}
return varnames;
} | O3 | cpp | minja::Parser::parseVarNames[abi:cxx11]():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
leaq 0x6d3d0(%rip), %rax # 0x101e90
movb (%rax), %al
testb %al, %al
je 0x94cbb
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
leaq 0x6d38e(%rip), %rdx # 0x101e70
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
movl $0x1, %ecx
callq 0x9448a
movq 0x20(%rsp), %rax
leaq 0x30(%rsp), %r14
movaps (%r14), %xmm0
movq 0x10(%r14), %rcx
movq %rcx, 0x20(%rsp)
movaps 0x10(%rsp), %xmm1
movaps %xmm0, 0x10(%rsp)
leaq 0x90(%rsp), %rdi
movaps %xmm1, (%rdi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
callq 0x2a79a
movq 0x10(%rsp), %rbx
movq 0x18(%rsp), %r15
movq %r14, %rdi
callq 0x2a79a
cmpq %r15, %rbx
je 0x94d12
xorps %xmm0, %xmm0
movq 0x8(%rsp), %rax
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq 0x10(%rsp), %rsi
addq $0x20, %rsi
leaq 0x90(%rsp), %rdi
movl $0x8, %edx
callq 0x1c580
leaq 0x40(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x60(%rsp), %rbx
leaq 0x90(%rsp), %r14
leaq 0x30(%rsp), %r15
leaq 0x3356b(%rip), %r12 # 0xc8119
leaq 0x50(%rsp), %r13
leaq 0x70(%rsp), %rbp
movq %r14, %rdi
movq %r15, %rsi
movl $0x2c, %edx
callq 0x1c030
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x94c5d
movq %rbx, 0x50(%rsp)
movq %r13, %rdi
movq %r12, %rsi
movq %r12, %rdx
callq 0x3fe82
movq 0x50(%rsp), %rdx
movq 0x58(%rsp), %rcx
movq %rbp, %rdi
movq %r15, %rsi
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x557c1
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x68ab4
movq 0x70(%rsp), %rdi
leaq 0x80(%rsp), %rax
cmpq %rax, %rdi
je 0x94c3d
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x1c110
movq 0x50(%rsp), %rdi
cmpq %rbx, %rdi
je 0x94bb8
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1c110
jmp 0x94bb8
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x94c79
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1c110
movq 0x6b348(%rip), %rsi # 0xfffc8
leaq 0x90(%rsp), %rdi
callq 0x1cb20
leaq 0x108(%rsp), %rdi
callq 0x1c8c0
leaq 0x10(%rsp), %rdi
callq 0x2a79a
movq 0x8(%rsp), %rax
addq $0x218, %rsp # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6d1ce(%rip), %rdi # 0x101e90
callq 0x1c3e0
testl %eax, %eax
je 0x94aca
leaq 0x6d19a(%rip), %rdi # 0x101e70
leaq 0x39c2c(%rip), %rsi # 0xce909
movl $0x10, %edx
callq 0x68a34
leaq -0x2c254(%rip), %rdi # 0x68a9a
leaq 0x6d17b(%rip), %rsi # 0x101e70
leaq 0x6ba1c(%rip), %rdx # 0x100718
callq 0x1ca80
leaq 0x6d188(%rip), %rdi # 0x101e90
callq 0x1c710
jmp 0x94aca
movl $0x10, %edi
callq 0x1c460
movq %rax, %rbx
leaq 0x39c03(%rip), %rsi # 0xce929
movq %rax, %rdi
callq 0x1c280
movq 0x6b283(%rip), %rsi # 0xfffb8
movq 0x6b23c(%rip), %rdx # 0xfff78
movq %rbx, %rdi
callq 0x1c7b0
movq %rax, %r14
leaq 0x6d142(%rip), %rdi # 0x101e90
callq 0x1c4f0
jmp 0x94e13
jmp 0x94d72
movq %rax, %r14
movq %rbx, %rdi
callq 0x1caa0
jmp 0x94e09
movq %rax, %r14
jmp 0x94dff
movq %rax, %r14
jmp 0x94e09
movq %rax, %r14
movq 0x70(%rsp), %rdi
leaq 0x80(%rsp), %rax
cmpq %rax, %rdi
je 0x94da4
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x1c110
jmp 0x94da4
movq %rax, %r14
movq 0x50(%rsp), %rdi
cmpq %rbx, %rdi
je 0x94dc2
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1c110
jmp 0x94dc2
jmp 0x94dbf
movq %rax, %r14
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x94dde
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1c110
movq 0x6b1e3(%rip), %rsi # 0xfffc8
leaq 0x90(%rsp), %rdi
callq 0x1cb20
leaq 0x108(%rsp), %rdi
callq 0x1c8c0
movq 0x8(%rsp), %rdi
callq 0x2a79a
leaq 0x10(%rsp), %rdi
callq 0x2a79a
movq %r14, %rdi
callq 0x1c7d0
nop
| _ZN5minja6Parser13parseVarNamesB5cxx11Ev:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 218h
mov r14, rsi
mov [rsp+248h+var_240], rdi; void *
lea rax, _ZGVZN5minja6Parser13parseVarNamesB5cxx11EvE14varnames_regexB5cxx11; `guard variable for'minja::Parser::parseVarNames(void)::varnames_regex
mov al, [rax]
test al, al
jz loc_94CBB
loc_94ACA:
xorps xmm0, xmm0
movaps xmmword ptr [rsp+248h+var_238], xmm0; int
mov qword ptr [rsp+248h+var_228], 0; int
lea rdx, _ZZN5minja6Parser13parseVarNamesB5cxx11EvE14varnames_regexB5cxx11; int
lea rdi, [rsp+248h+var_218]; int
mov rsi, r14; int
mov ecx, 1; int
call _ZN5minja6Parser18consumeTokenGroupsERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE; minja::Parser::consumeTokenGroups(std::basic_regex<char,std::regex_traits<char>> const&,minja::SpaceHandling)
mov rax, qword ptr [rsp+248h+var_228]
lea r14, [rsp+248h+var_218]
movaps xmm0, xmmword ptr [r14]
mov rcx, [r14+10h]
mov qword ptr [rsp+248h+var_228], rcx
movaps xmm1, xmmword ptr [rsp+248h+var_238]
movaps xmmword ptr [rsp+248h+var_238], xmm0
lea rdi, [rsp+248h+var_1B8]
movaps xmmword ptr [rdi], xmm1
mov [rdi+10h], rax
xorps xmm0, xmm0
movaps xmmword ptr [r14], xmm0
mov qword ptr [r14+10h], 0
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rbx, qword ptr [rsp+248h+var_238]
mov r15, qword ptr [rsp+248h+var_238+8]
mov rdi, r14
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
cmp rbx, r15
jz loc_94D12
xorps xmm0, xmm0
mov rax, [rsp+248h+var_240]
movups xmmword ptr [rax], xmm0
mov qword ptr [rax+10h], 0
mov rsi, qword ptr [rsp+248h+var_238]
add rsi, 20h ; ' '
lea rdi, [rsp+248h+var_1B8]
mov edx, 8
call __ZNSt7__cxx1119basic_istringstreamIcSt11char_traitsIcESaIcEEC1ERKNS_12basic_stringIcS2_S3_EESt13_Ios_Openmode; std::istringstream::basic_istringstream(std::string const&,std::_Ios_Openmode)
lea rax, [rsp+248h+var_208]
mov [rax-10h], rax
mov qword ptr [rax-8], 0
mov byte ptr [rax], 0
lea rbx, [rsp+248h+var_1E8]
lea r14, [rsp+248h+var_1B8]
lea r15, [rsp+248h+var_218]
lea r12, aFailedToMatchD+28h; ""
lea r13, [rsp+248h+var_1F8]
lea rbp, [rsp+248h+var_1D8]
loc_94BB8:
mov rdi, r14
mov rsi, r15
mov edx, 2Ch ; ','
call __ZSt7getlineIcSt11char_traitsIcESaIcEERSt13basic_istreamIT_T0_ES7_RNSt7__cxx1112basic_stringIS4_S5_T1_EES4_; std::getline<char,std::char_traits<char>,std::allocator<char>>(std::istream &,std::string &,char)
mov rcx, [rax]
mov rcx, [rcx-18h]
test byte ptr [rax+rcx+20h], 5
jnz loc_94C5D
mov [rsp+248h+var_1F8], rbx
mov rdi, r13
mov rsi, r12
mov rdx, r12
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rdx, [rsp+248h+var_1F8]
mov rcx, [rsp+248h+var_1F0]
mov rdi, rbp
mov rsi, r15
mov r8d, 1
mov r9d, 1
call _ZN5minjaL5stripERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES7_bb; minja::strip(std::string const&,std::string const&,bool,bool)
mov rdi, [rsp+248h+var_240]
mov rsi, rbp
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJS5_EEERS5_DpOT_; std::vector<std::string>::emplace_back<std::string>(std::string &&)
mov rdi, [rsp+248h+var_1D8]; void *
lea rax, [rsp+248h+var_1C8]
cmp rdi, rax
jz short loc_94C3D
mov rsi, [rsp+248h+var_1C8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_94C3D:
mov rdi, [rsp+248h+var_1F8]; void *
cmp rdi, rbx
jz loc_94BB8
mov rsi, [rsp+248h+var_1E8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp loc_94BB8
loc_94C5D:
mov rdi, [rsp+248h+var_218]; void *
lea rax, [rsp+248h+var_208]
cmp rdi, rax
jz short loc_94C79
mov rsi, [rsp+248h+var_208]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_94C79:
mov rsi, cs:_ZTTNSt7__cxx1119basic_istringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+248h+var_1B8]
call __ZNSt7__cxx1119basic_istringstreamIcSt11char_traitsIcESaIcEED2Ev; std::istringstream::~istringstream()
lea rdi, [rsp+248h+var_140]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
lea rdi, [rsp+248h+var_238]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rax, [rsp+248h+var_240]
add rsp, 218h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_94CBB:
lea rdi, _ZGVZN5minja6Parser13parseVarNamesB5cxx11EvE14varnames_regexB5cxx11; __guard *
call ___cxa_guard_acquire
test eax, eax
jz loc_94ACA
lea rdi, _ZZN5minja6Parser13parseVarNamesB5cxx11EvE14varnames_regexB5cxx11; minja::Parser::parseVarNames(void)::varnames_regex
lea rsi, aWSSWS; "((?:\\w+)(?:\\s*,\\s*(?:\\w+))*)\\s*"
mov edx, 10h
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2EPKcNSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex(char const*,std::regex_constants::syntax_option_type)
lea rdi, _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; lpfunc
lea rsi, _ZZN5minja6Parser13parseVarNamesB5cxx11EvE14varnames_regexB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZN5minja6Parser13parseVarNamesB5cxx11EvE14varnames_regexB5cxx11; __guard *
call ___cxa_guard_release
jmp loc_94ACA
loc_94D12:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aExpectedVariab; "Expected variable names"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rdi, _ZGVZN5minja6Parser13parseVarNamesB5cxx11EvE14varnames_regexB5cxx11; __guard *
call ___cxa_guard_abort
jmp loc_94E13
jmp short loc_94D72
mov r14, rax
mov rdi, rbx; void *
call ___cxa_free_exception
jmp loc_94E09
mov r14, rax
jmp loc_94DFF
loc_94D72:
mov r14, rax
jmp loc_94E09
mov r14, rax
mov rdi, [rsp+248h+var_1D8]; void *
lea rax, [rsp+248h+var_1C8]
cmp rdi, rax
jz short loc_94DA4
mov rsi, [rsp+248h+var_1C8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_94DA4
mov r14, rax
loc_94DA4:
mov rdi, [rsp+248h+var_1F8]; void *
cmp rdi, rbx
jz short loc_94DC2
mov rsi, [rsp+248h+var_1E8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_94DC2
jmp short $+2
loc_94DBF:
mov r14, rax
loc_94DC2:
mov rdi, [rsp+248h+var_218]; void *
lea rax, [rsp+248h+var_208]
cmp rdi, rax
jz short loc_94DDE
mov rsi, [rsp+248h+var_208]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_94DDE:
mov rsi, cs:_ZTTNSt7__cxx1119basic_istringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+248h+var_1B8]
call __ZNSt7__cxx1119basic_istringstreamIcSt11char_traitsIcESaIcEED2Ev; std::istringstream::~istringstream()
lea rdi, [rsp+248h+var_140]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
loc_94DFF:
mov rdi, [rsp+248h+var_240]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
loc_94E09:
lea rdi, [rsp+248h+var_238]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
loc_94E13:
mov rdi, r14
call __Unwind_Resume
| _QWORD * minja::Parser::parseVarNames[abi:cxx11](_QWORD *a1, long long a2)
{
_QWORD *v2; // rax
std::runtime_error *exception; // rbx
int v5[4]; // [rsp+10h] [rbp-238h] BYREF
int v6[2]; // [rsp+20h] [rbp-228h]
__int128 v7; // [rsp+30h] [rbp-218h] BYREF
_QWORD v8[2]; // [rsp+40h] [rbp-208h] BYREF
void *v9[2]; // [rsp+50h] [rbp-1F8h] BYREF
_QWORD v10[2]; // [rsp+60h] [rbp-1E8h] BYREF
void *v11[2]; // [rsp+70h] [rbp-1D8h] BYREF
long long v12; // [rsp+80h] [rbp-1C8h] BYREF
__int128 v13; // [rsp+90h] [rbp-1B8h] BYREF
long long v14; // [rsp+A0h] [rbp-1A8h]
_BYTE v15[320]; // [rsp+108h] [rbp-140h] BYREF
if ( !(_BYTE)`guard variable for'minja::Parser::parseVarNames[abi:cxx11](void)::varnames_regex[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'minja::Parser::parseVarNames[abi:cxx11](void)::varnames_regex[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&minja::Parser::parseVarNames[abi:cxx11](void)::varnames_regex[abi:cxx11],
(long long)"((?:\\w+)(?:\\s*,\\s*(?:\\w+))*)\\s*",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&minja::Parser::parseVarNames[abi:cxx11](void)::varnames_regex[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'minja::Parser::parseVarNames[abi:cxx11](void)::varnames_regex[abi:cxx11]);
}
minja::Parser::consumeTokenGroups(
(long long)&v7,
a2,
(long long)&minja::Parser::parseVarNames[abi:cxx11](void)::varnames_regex[abi:cxx11],
1u);
*(_QWORD *)v6 = v8[0];
*(_OWORD *)v5 = v7;
v13 = 0LL;
v14 = 0LL;
v7 = 0LL;
v8[0] = 0LL;
std::vector<std::string>::~vector((long long)&v13);
std::vector<std::string>::~vector((long long)&v7);
if ( *(_QWORD *)v5 == *(_QWORD *)&v5[2] )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Expected variable names");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
*(_OWORD *)a1 = 0LL;
a1[2] = 0LL;
std::istringstream::basic_istringstream(&v13, *(_QWORD *)v5 + 32LL, 8LL);
*(_QWORD *)&v7 = v8;
*((_QWORD *)&v7 + 1) = 0LL;
LOBYTE(v8[0]) = 0;
while ( 1 )
{
v2 = (_QWORD *)std::getline<char,std::char_traits<char>,std::allocator<char>>(&v13, &v7, 44LL);
if ( (*((_BYTE *)v2 + *(_QWORD *)(*v2 - 24LL) + 32) & 5) != 0 )
break;
v9[0] = v10;
std::string::_M_construct<char const*>((long long)v9, "", (long long)"");
minja::strip(v11, (long long)&v7, (_BYTE *)v9[0], (long long)v9[1], 1, 1);
std::vector<std::string>::emplace_back<std::string>((long long)a1, v11);
if ( v11[0] != &v12 )
operator delete(v11[0], v12 + 1);
if ( v9[0] != v10 )
operator delete(v9[0], v10[0] + 1LL);
}
if ( (_QWORD *)v7 != v8 )
operator delete((void *)v7, v8[0] + 1LL);
std::istringstream::~istringstream(&v13, &`VTT for'std::istringstream);
std::ios_base::~ios_base((std::ios_base *)v15);
std::vector<std::string>::~vector((long long)v5);
return a1;
}
| parseVarNames[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x218
MOV R14,RSI
MOV qword ptr [RSP + 0x8],RDI
LEA RAX,[0x201e90]
MOV AL,byte ptr [RAX]
TEST AL,AL
JZ 0x00194cbb
LAB_00194aca:
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOV qword ptr [RSP + 0x20],0x0
LAB_00194adb:
LEA RDX,[0x201e70]
LEA RDI,[RSP + 0x30]
MOV RSI,R14
MOV ECX,0x1
CALL 0x0019448a
MOV RAX,qword ptr [RSP + 0x20]
LEA R14,[RSP + 0x30]
MOVAPS XMM0,xmmword ptr [R14]
MOV RCX,qword ptr [R14 + 0x10]
MOV qword ptr [RSP + 0x20],RCX
MOVAPS XMM1,xmmword ptr [RSP + 0x10]
MOVAPS xmmword ptr [RSP + 0x10],XMM0
LEA RDI,[RSP + 0x90]
MOVAPS xmmword ptr [RDI],XMM1
MOV qword ptr [RDI + 0x10],RAX
XORPS XMM0,XMM0
MOVAPS xmmword ptr [R14],XMM0
MOV qword ptr [R14 + 0x10],0x0
CALL 0x0012a79a
MOV RBX,qword ptr [RSP + 0x10]
MOV R15,qword ptr [RSP + 0x18]
MOV RDI,R14
CALL 0x0012a79a
CMP RBX,R15
JZ 0x00194d12
XORPS XMM0,XMM0
MOV RAX,qword ptr [RSP + 0x8]
MOVUPS xmmword ptr [RAX],XMM0
MOV qword ptr [RAX + 0x10],0x0
MOV RSI,qword ptr [RSP + 0x10]
ADD RSI,0x20
LAB_00194b6f:
LEA RDI,[RSP + 0x90]
MOV EDX,0x8
CALL 0x0011c580
LEA RAX,[RSP + 0x40]
MOV qword ptr [RAX + -0x10],RAX
MOV qword ptr [RAX + -0x8],0x0
MOV byte ptr [RAX],0x0
LEA RBX,[RSP + 0x60]
LEA R14,[RSP + 0x90]
LEA R15,[RSP + 0x30]
LEA R12,[0x1c8119]
LEA R13,[RSP + 0x50]
LEA RBP,[RSP + 0x70]
LAB_00194bb8:
MOV RDI,R14
MOV RSI,R15
MOV EDX,0x2c
CALL 0x0011c030
MOV RCX,qword ptr [RAX]
MOV RCX,qword ptr [RCX + -0x18]
TEST byte ptr [RAX + RCX*0x1 + 0x20],0x5
JNZ 0x00194c5d
MOV qword ptr [RSP + 0x50],RBX
LAB_00194bdf:
MOV RDI,R13
MOV RSI,R12
MOV RDX,R12
CALL 0x0013fe82
MOV RDX,qword ptr [RSP + 0x50]
MOV RCX,qword ptr [RSP + 0x58]
LAB_00194bf7:
MOV RDI,RBP
MOV RSI,R15
MOV R8D,0x1
MOV R9D,0x1
CALL 0x001557c1
LAB_00194c0e:
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,RBP
CALL 0x00168ab4
MOV RDI,qword ptr [RSP + 0x70]
LEA RAX,[RSP + 0x80]
CMP RDI,RAX
JZ 0x00194c3d
MOV RSI,qword ptr [RSP + 0x80]
INC RSI
CALL 0x0011c110
LAB_00194c3d:
MOV RDI,qword ptr [RSP + 0x50]
CMP RDI,RBX
JZ 0x00194bb8
MOV RSI,qword ptr [RSP + 0x60]
INC RSI
CALL 0x0011c110
JMP 0x00194bb8
LAB_00194c5d:
MOV RDI,qword ptr [RSP + 0x30]
LEA RAX,[RSP + 0x40]
CMP RDI,RAX
JZ 0x00194c79
MOV RSI,qword ptr [RSP + 0x40]
INC RSI
CALL 0x0011c110
LAB_00194c79:
MOV RSI,qword ptr [0x001fffc8]
LEA RDI,[RSP + 0x90]
CALL 0x0011cb20
LEA RDI,[RSP + 0x108]
CALL 0x0011c8c0
LEA RDI,[RSP + 0x10]
CALL 0x0012a79a
MOV RAX,qword ptr [RSP + 0x8]
ADD RSP,0x218
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00194cbb:
LEA RDI,[0x201e90]
CALL 0x0011c3e0
TEST EAX,EAX
JZ 0x00194aca
LAB_00194ccf:
LEA RDI,[0x201e70]
LEA RSI,[0x1ce909]
MOV EDX,0x10
CALL 0x00168a34
LAB_00194ce7:
LEA RDI,[0x168a9a]
LEA RSI,[0x201e70]
LEA RDX,[0x200718]
CALL 0x0011ca80
LEA RDI,[0x201e90]
CALL 0x0011c710
JMP 0x00194aca
LAB_00194d12:
MOV EDI,0x10
CALL 0x0011c460
MOV RBX,RAX
LAB_00194d1f:
LEA RSI,[0x1ce929]
MOV RDI,RAX
CALL 0x0011c280
LAB_00194d2e:
MOV RSI,qword ptr [0x001fffb8]
MOV RDX,qword ptr [0x001fff78]
MOV RDI,RBX
CALL 0x0011c7b0
|
/* minja::Parser::parseVarNames[abi:cxx11]() */
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *
minja::Parser::parseVarNames_abi_cxx11_(void)
{
ulong *puVar1;
ulong *puVar2;
int iVar3;
istream *piVar4;
runtime_error *this;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *in_RDI;
ulong *local_238;
ulong *puStack_230;
ulong local_228;
ulong *local_218;
ulong *puStack_210;
ulong local_208 [2];
long *local_1f8 [2];
long local_1e8 [2];
long *local_1d8 [2];
long local_1c8 [2];
int8 local_1b8;
int8 uStack_1b0;
int8 local_1a8;
ios_base local_140 [272];
if (parseVarNames[abi:cxx11]()::varnames_regex_abi_cxx11_ == '\0') {
iVar3 = __cxa_guard_acquire(&parseVarNames[abi:cxx11]()::varnames_regex_abi_cxx11_);
if (iVar3 != 0) {
/* try { // try from 00194ccf to 00194ce6 has its CatchHandler @ 00194d44 */
std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::basic_regex
((basic_regex<char,std::__cxx11::regex_traits<char>> *)
parseVarNames[abi:cxx11]()::varnames_regex_abi_cxx11_,
"((?:\\w+)(?:\\s*,\\s*(?:\\w+))*)\\s*",0x10);
__cxa_atexit(std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::~basic_regex,
parseVarNames[abi:cxx11]()::varnames_regex_abi_cxx11_,&__dso_handle);
__cxa_guard_release(&parseVarNames[abi:cxx11]()::varnames_regex_abi_cxx11_);
}
}
local_238 = (ulong *)0x0;
puStack_230 = (ulong *)0x0;
local_228 = 0;
/* try { // try from 00194adb to 00194af3 has its CatchHandler @ 00194d72 */
consumeTokenGroups(&local_218);
local_1a8 = local_228;
uStack_1b0 = puStack_230;
local_1b8 = local_238;
local_228 = local_208[0];
local_238 = local_218;
puStack_230 = puStack_210;
local_218 = (ulong *)0x0;
puStack_210 = (ulong *)0x0;
local_208[0] = 0;
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)&local_1b8);
puVar2 = puStack_230;
puVar1 = local_238;
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)&local_218);
if (puVar1 != puVar2) {
*(int8 *)in_RDI = 0;
*(int8 *)(in_RDI + 8) = 0;
*(int8 *)(in_RDI + 0x10) = 0;
/* try { // try from 00194b6f to 00194b80 has its CatchHandler @ 00194d6a */
std::__cxx11::istringstream::istringstream((istringstream *)&local_1b8,local_238 + 4,8);
local_218 = local_208;
puStack_210 = (ulong *)0x0;
local_208[0] = local_208[0] & 0xffffffffffffff00;
while( true ) {
/* try { // try from 00194bb8 to 00194bc7 has its CatchHandler @ 00194dbf */
piVar4 = std::getline<char,std::char_traits<char>,std::allocator<char>>
((istream *)&local_1b8,(string *)&local_218,',');
if (((byte)piVar4[*(long *)(*(long *)piVar4 + -0x18) + 0x20] & 5) != 0) break;
local_1f8[0] = local_1e8;
/* try { // try from 00194bdf to 00194bec has its CatchHandler @ 00194dbd */
std::__cxx11::string::_M_construct<char_const*>(local_1f8,"","");
/* try { // try from 00194bf7 to 00194c0d has its CatchHandler @ 00194da1 */
strip((string *)local_1d8,(string *)&local_218,SUB81(local_1f8[0],0),SUB81(local_1f8[1],0));
/* try { // try from 00194c0e to 00194c1a has its CatchHandler @ 00194d7a */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<std::__cxx11::string>(in_RDI,(string *)local_1d8);
if (local_1d8[0] != local_1c8) {
operator_delete(local_1d8[0],local_1c8[0] + 1);
}
if (local_1f8[0] != local_1e8) {
operator_delete(local_1f8[0],local_1e8[0] + 1);
}
}
if (local_218 != local_208) {
operator_delete(local_218,local_208[0] + 1);
}
std::__cxx11::istringstream::~istringstream((istringstream *)&local_1b8);
std::ios_base::~ios_base(local_140);
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)&local_238);
return in_RDI;
}
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00194d1f to 00194d2d has its CatchHandler @ 00194d5a */
std::runtime_error::runtime_error(this,"Expected variable names");
/* try { // try from 00194d2e to 00194d43 has its CatchHandler @ 00194d58 */
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_001fffb8,PTR__runtime_error_001fff78);
}
| |
44,842 | testing::internal::Random::Generate(unsigned int) | giladroyz[P]FindPeaks/build_O3/_deps/googletest-src/googletest/src/gtest.cc | uint32_t Random::Generate(uint32_t range) {
// These constants are the same as are used in glibc's rand(3).
// Use wider types than necessary to prevent unsigned overflow diagnostics.
state_ = static_cast<uint32_t>(1103515245ULL * state_ + 12345U) % kMaxRange;
GTEST_CHECK_(range > 0) << "Cannot generate a number in the range [0, 0).";
GTEST_CHECK_(range <= kMaxRange)
<< "Generation of a number in [0, " << range << ") was requested, "
<< "but this can only generate numbers in [0, " << kMaxRange << ").";
// Converting via modulus introduces a bit of downward bias, but
// it's simple, and a linear congruential generator isn't too good
// to begin with.
return state_ % range;
} | O3 | cpp | testing::internal::Random::Generate(unsigned int):
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
imull $0x41c64e6d, (%rdi), %eax # imm = 0x41C64E6D
addl $0x3039, %eax # imm = 0x3039
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
movl %eax, (%rdi)
testl %esi, %esi
je 0x18b00
cmpl $0x80000001, %ebx # imm = 0x80000001
jb 0x18b55
leaq 0x29d52(%rip), %rdx # 0x427ad
leaq 0x8(%rsp), %rdi
movl $0x3, %esi
movl $0x19b, %ecx # imm = 0x19B
callq 0x16b08
movq 0x40572(%rip), %rdi # 0x58fe8
leaq 0x29def(%rip), %rsi # 0x4286c
movl $0x25, %edx
callq 0x85b0
movq 0x4055a(%rip), %rdi # 0x58fe8
leaq 0x29dfd(%rip), %rsi # 0x42892
movl $0x1e, %edx
callq 0x85b0
movl %ebx, %esi
movq 0x40540(%rip), %rdi # 0x58fe8
callq 0x8310
movq %rax, %r15
leaq 0x29dfa(%rip), %rsi # 0x428b1
movl $0x11, %edx
movq %rax, %rdi
callq 0x85b0
leaq 0x29df8(%rip), %rsi # 0x428c3
movl $0x2a, %edx
movq %r15, %rdi
callq 0x85b0
movl $0x80000000, %esi # imm = 0x80000000
movq %r15, %rdi
callq 0x8310
leaq 0x29d7d(%rip), %rsi # 0x42869
movl $0x2, %edx
movq %rax, %rdi
callq 0x85b0
leaq 0x8(%rsp), %rdi
jmp 0x18b50
leaq 0x29ca6(%rip), %rdx # 0x427ad
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x19a, %ecx # imm = 0x19A
callq 0x16b08
movq 0x404c6(%rip), %rdi # 0x58fe8
leaq 0x29cf8(%rip), %rsi # 0x42821
movl $0x1c, %edx
callq 0x85b0
movq 0x404ae(%rip), %rdi # 0x58fe8
leaq 0x29cfd(%rip), %rsi # 0x4283e
movl $0x2d, %edx
callq 0x85b0
leaq 0xc(%rsp), %rdi
callq 0x16c4a
movl (%r14), %eax
xorl %edx, %edx
divl %ebx
movl %edx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
jmp 0x18b7a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x16c4a
movq %rbx, %rdi
callq 0x8990
nop
| _ZN7testing8internal6Random8GenerateEj:
push r15
push r14
push rbx
sub rsp, 10h
mov ebx, esi
mov r14, rdi
imul eax, [rdi], 41C64E6Dh
add eax, 3039h
and eax, 7FFFFFFFh
mov [rdi], eax
test esi, esi
jz loc_18B00
cmp ebx, 80000001h
jb loc_18B55
lea rdx, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rdi, [rsp+28h+var_20]
mov esi, 3
mov ecx, 19Bh
call _ZN7testing8internal8GTestLogC2ENS0_16GTestLogSeverityEPKci; testing::internal::GTestLog::GTestLog(testing::internal::GTestLogSeverity,char const*,int)
mov rdi, cs:_ZSt4cerr_ptr
lea rsi, aConditionRange; "Condition range <= kMaxRange failed. "
mov edx, 25h ; '%'
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, cs:_ZSt4cerr_ptr
lea rsi, aGenerationOfAN; "Generation of a number in [0, "
mov edx, 1Eh
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov esi, ebx
mov rdi, cs:_ZSt4cerr_ptr
call __ZNSo9_M_insertImEERSoT_; std::ostream::_M_insert<ulong>(ulong)
mov r15, rax
lea rsi, aWasRequested; ") was requested, "
mov edx, 11h
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, aButThisCanOnly; "but this can only generate numbers in ["...
mov edx, 2Ah ; '*'
mov rdi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov esi, 80000000h
mov rdi, r15
call __ZNSo9_M_insertImEERSoT_; std::ostream::_M_insert<ulong>(ulong)
lea rsi, aCannotGenerate+2Bh; ")."
mov edx, 2
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rdi, [rsp+28h+var_20]
jmp short loc_18B50
loc_18B00:
lea rdx, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rdi, [rsp+28h+var_1C]
mov esi, 3
mov ecx, 19Ah
call _ZN7testing8internal8GTestLogC2ENS0_16GTestLogSeverityEPKci; testing::internal::GTestLog::GTestLog(testing::internal::GTestLogSeverity,char const*,int)
mov rdi, cs:_ZSt4cerr_ptr
lea rsi, aConditionRange_0; "Condition range > 0 failed. "
mov edx, 1Ch
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, cs:_ZSt4cerr_ptr
lea rsi, aCannotGenerate; "Cannot generate a number in the range ["...
mov edx, 2Dh ; '-'
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rdi, [rsp+28h+var_1C]; this
loc_18B50:
call _ZN7testing8internal8GTestLogD2Ev; testing::internal::GTestLog::~GTestLog()
loc_18B55:
mov eax, [r14]
xor edx, edx
div ebx
mov eax, edx
add rsp, 10h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+arg_4]
jmp short loc_18B7A
mov rbx, rax
lea rdi, [rsp+arg_0]; this
loc_18B7A:
call _ZN7testing8internal8GTestLogD2Ev; testing::internal::GTestLog::~GTestLog()
mov rdi, rbx
call __Unwind_Resume
| long long testing::internal::Random::Generate(testing::internal::Random *this, unsigned int a2)
{
long long v4; // r15
long long v5; // rax
char *v6; // rsi
long long v7; // rdx
long long v8; // rcx
testing::internal::GTestLog *v9; // rdi
int v11; // [rsp+8h] [rbp-20h] BYREF
_DWORD v12[7]; // [rsp+Ch] [rbp-1Ch] BYREF
*(_DWORD *)this = (1103515245 * *(_DWORD *)this + 12345) & 0x7FFFFFFF;
if ( !a2 )
{
testing::internal::GTestLog::GTestLog(
v12,
3,
"/workspace/llm4binary/github/2025_star3/giladroyz[P]FindPeaks/build_O3/_deps/googletest-src/googletest/src/gtest.cc",
410);
std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, "Condition range > 0 failed. ", 28LL);
v6 = "Cannot generate a number in the range [0, 0).";
std::__ostream_insert<char,std::char_traits<char>>(
&std::cerr,
"Cannot generate a number in the range [0, 0).",
45LL);
v9 = (testing::internal::GTestLog *)v12;
goto LABEL_5;
}
if ( a2 >= 0x80000001 )
{
testing::internal::GTestLog::GTestLog(
&v11,
3,
"/workspace/llm4binary/github/2025_star3/giladroyz[P]FindPeaks/build_O3/_deps/googletest-src/googletest/src/gtest.cc",
411);
std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, "Condition range <= kMaxRange failed. ", 37LL);
std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, "Generation of a number in [0, ", 30LL);
v4 = std::ostream::_M_insert<unsigned long>(&std::cerr, a2);
std::__ostream_insert<char,std::char_traits<char>>(v4, ") was requested, ", 17LL);
std::__ostream_insert<char,std::char_traits<char>>(v4, "but this can only generate numbers in [0, ", 42LL);
v5 = std::ostream::_M_insert<unsigned long>(v4, 0x80000000LL);
v6 = ").";
std::__ostream_insert<char,std::char_traits<char>>(v5, ").", 2LL);
v9 = (testing::internal::GTestLog *)&v11;
LABEL_5:
testing::internal::GTestLog::~GTestLog(v9, (long long)v6, v7, v8);
}
return *(_DWORD *)this % a2;
}
| Generate:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV EBX,ESI
MOV R14,RDI
IMUL EAX,dword ptr [RDI],0x41c64e6d
ADD EAX,0x3039
AND EAX,0x7fffffff
MOV dword ptr [RDI],EAX
TEST ESI,ESI
JZ 0x00118b00
CMP EBX,0x80000001
JC 0x00118b55
LEA RDX,[0x1427ad]
LEA RDI,[RSP + 0x8]
MOV ESI,0x3
MOV ECX,0x19b
CALL 0x00116b08
LAB_00118a6f:
MOV RDI,qword ptr [0x00158fe8]
LEA RSI,[0x14286c]
MOV EDX,0x25
CALL 0x001085b0
MOV RDI,qword ptr [0x00158fe8]
LEA RSI,[0x142892]
MOV EDX,0x1e
CALL 0x001085b0
MOV ESI,EBX
MOV RDI,qword ptr [0x00158fe8]
CALL 0x00108310
MOV R15,RAX
LEA RSI,[0x1428b1]
MOV EDX,0x11
MOV RDI,RAX
CALL 0x001085b0
LEA RSI,[0x1428c3]
MOV EDX,0x2a
MOV RDI,R15
CALL 0x001085b0
MOV ESI,0x80000000
MOV RDI,R15
CALL 0x00108310
LEA RSI,[0x142869]
MOV EDX,0x2
MOV RDI,RAX
CALL 0x001085b0
LAB_00118af9:
LEA RDI,[RSP + 0x8]
JMP 0x00118b50
LAB_00118b00:
LEA RDX,[0x1427ad]
LEA RDI,[RSP + 0xc]
MOV ESI,0x3
MOV ECX,0x19a
CALL 0x00116b08
LAB_00118b1b:
MOV RDI,qword ptr [0x00158fe8]
LEA RSI,[0x142821]
MOV EDX,0x1c
CALL 0x001085b0
MOV RDI,qword ptr [0x00158fe8]
LEA RSI,[0x14283e]
MOV EDX,0x2d
CALL 0x001085b0
LAB_00118b4b:
LEA RDI,[RSP + 0xc]
LAB_00118b50:
CALL 0x00116c4a
LAB_00118b55:
MOV EAX,dword ptr [R14]
XOR EDX,EDX
DIV EBX
MOV EAX,EDX
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
|
/* testing::internal::Random::Generate(unsigned int) */
ulong __thiscall testing::internal::Random::Generate(Random *this,uint param_1)
{
ostream *poVar1;
GTestLog *this_00;
GTestLog local_20 [4];
GTestLog local_1c [4];
*(uint *)this = *(int *)this * 0x41c64e6d + 0x3039U & 0x7fffffff;
if (param_1 == 0) {
GTestLog::GTestLog(local_1c,3,
"/workspace/llm4binary/github/2025_star3/giladroyz[P]FindPeaks/build_O3/_deps/googletest-src/googletest/src/gtest.cc"
,0x19a);
/* try { // try from 00118b1b to 00118b4a has its CatchHandler @ 00118b68 */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_00158fe8,"Condition range > 0 failed. ",0x1c);
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_00158fe8,"Cannot generate a number in the range [0, 0).",0x2d);
this_00 = local_1c;
}
else {
if (param_1 < 0x80000001) goto LAB_00118b55;
GTestLog::GTestLog(local_20,3,
"/workspace/llm4binary/github/2025_star3/giladroyz[P]FindPeaks/build_O3/_deps/googletest-src/googletest/src/gtest.cc"
,0x19b);
/* try { // try from 00118a6f to 00118af8 has its CatchHandler @ 00118b72 */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_00158fe8,"Condition range <= kMaxRange failed. ",0x25);
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_00158fe8,"Generation of a number in [0, ",0x1e);
poVar1 = std::ostream::_M_insert<unsigned_long>((ulong)PTR_cerr_00158fe8);
std::__ostream_insert<char,std::char_traits<char>>(poVar1,") was requested, ",0x11);
std::__ostream_insert<char,std::char_traits<char>>
(poVar1,"but this can only generate numbers in [0, ",0x2a);
poVar1 = std::ostream::_M_insert<unsigned_long>((ulong)poVar1);
std::__ostream_insert<char,std::char_traits<char>>(poVar1,").",2);
this_00 = local_20;
}
GTestLog::~GTestLog(this_00);
LAB_00118b55:
return (ulong)*(uint *)this % (ulong)param_1;
}
| |
44,843 | my_wc_mb_big5 | eloqsql/strings/ctype-big5.c | static int
my_wc_mb_big5(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
int code;
if (s >= e)
return MY_CS_TOOSMALL;
if ((int) wc < 0x80)
{
s[0]= (uchar) wc;
return 1;
}
if (!(code=func_uni_big5_onechar(wc)))
return MY_CS_ILUNI;
if (s+2>e)
return MY_CS_TOOSMALL;
s[0]=code>>8;
s[1]=code&0xFF;
return 2;
} | O0 | c | my_wc_mb_big5:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x3473b
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x347b4
movq -0x18(%rbp), %rax
cmpl $0x80, %eax
jge 0x3475b
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x347b4
movq -0x18(%rbp), %rax
movl %eax, %edi
callq 0x34ab0
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jne 0x34777
movl $0x0, -0x4(%rbp)
jmp 0x347b4
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0x3478e
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x347b4
movl -0x2c(%rbp), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl -0x2c(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| my_wc_mb_big5:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jb short loc_3473B
mov [rbp+var_4], 0FFFFFF9Bh
jmp short loc_347B4
loc_3473B:
mov rax, [rbp+var_18]
cmp eax, 80h
jge short loc_3475B
mov rax, [rbp+var_18]
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov [rbp+var_4], 1
jmp short loc_347B4
loc_3475B:
mov rax, [rbp+var_18]
mov edi, eax
call func_uni_big5_onechar
mov [rbp+var_2C], eax
cmp eax, 0
jnz short loc_34777
mov [rbp+var_4], 0
jmp short loc_347B4
loc_34777:
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_3478E
mov [rbp+var_4], 0FFFFFF9Bh
jmp short loc_347B4
loc_3478E:
mov eax, [rbp+var_2C]
sar eax, 8
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov eax, [rbp+var_2C]
and eax, 0FFh
mov cl, al
mov rax, [rbp+var_20]
mov [rax+1], cl
mov [rbp+var_4], 2
loc_347B4:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long my_wc_mb_big5(long long a1, int a2, _BYTE *a3, unsigned long long a4)
{
int v5; // [rsp+4h] [rbp-2Ch]
if ( (unsigned long long)a3 < a4 )
{
if ( a2 >= 128 )
{
v5 = func_uni_big5_onechar((unsigned int)a2);
if ( v5 )
{
if ( (unsigned long long)(a3 + 2) <= a4 )
{
*a3 = BYTE1(v5);
a3[1] = v5;
return 2;
}
else
{
return (unsigned int)-101;
}
}
else
{
return 0;
}
}
else
{
*a3 = a2;
return 1;
}
}
else
{
return (unsigned int)-101;
}
}
| my_wc_mb_big5:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x0013473b
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x001347b4
LAB_0013473b:
MOV RAX,qword ptr [RBP + -0x18]
CMP EAX,0x80
JGE 0x0013475b
MOV RAX,qword ptr [RBP + -0x18]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001347b4
LAB_0013475b:
MOV RAX,qword ptr [RBP + -0x18]
MOV EDI,EAX
CALL 0x00134ab0
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JNZ 0x00134777
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001347b4
LAB_00134777:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x0013478e
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x001347b4
LAB_0013478e:
MOV EAX,dword ptr [RBP + -0x2c]
SAR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV EAX,dword ptr [RBP + -0x2c]
AND EAX,0xff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x1],CL
MOV dword ptr [RBP + -0x4],0x2
LAB_001347b4:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 my_wc_mb_big5(int8 param_1,int param_2,int1 *param_3,int1 *param_4)
{
int iVar1;
int4 local_c;
if (param_3 < param_4) {
if (param_2 < 0x80) {
*param_3 = (char)param_2;
local_c = 1;
}
else {
iVar1 = func_uni_big5_onechar(param_2);
if (iVar1 == 0) {
local_c = 0;
}
else if (param_4 < param_3 + 2) {
local_c = 0xffffff9b;
}
else {
*param_3 = (char)((uint)iVar1 >> 8);
param_3[1] = (char)iVar1;
local_c = 2;
}
}
}
else {
local_c = 0xffffff9b;
}
return local_c;
}
| |
44,844 | testing::internal::PrintTo(char32_t, std::ostream*) | giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/src/gtest-printers.cc | void PrintTo(char32_t c, ::std::ostream* os) {
*os << std::hex << "U+" << std::uppercase << std::setfill('0') << std::setw(4)
<< static_cast<uint32_t>(c);
} | O1 | cpp | testing::internal::PrintTo(char32_t, std::ostream*):
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
movq (%rsi), %rax
movq -0x18(%rax), %rax
movl 0x18(%rsi,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rsi,%rax)
leaq 0x2aa7c(%rip), %rsi # 0x42529
movl $0x2, %edx
movq %rbx, %rdi
callq 0x85b0
movq (%rbx), %rax
movq -0x18(%rax), %rcx
orl $0x4000, 0x18(%rbx,%rcx) # imm = 0x4000
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %r14
cmpb $0x0, 0xe1(%rbx,%rax)
jne 0x17af7
movq %r14, %rdi
movl $0x20, %esi
callq 0x8490
movb %al, 0xe0(%r14)
movb $0x1, 0xe1(%r14)
movb $0x30, 0xe0(%r14)
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0x4, 0x10(%rbx,%rax)
movl %ebp, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x8310
| _ZN7testing8internal7PrintToEDiPSo:
push rbp
push r14
push rbx
mov rbx, rsi
mov ebp, edi
mov rax, [rsi]
mov rax, [rax-18h]
mov ecx, [rsi+rax+18h]
and ecx, 0FFFFFFB5h
or ecx, 8
mov [rsi+rax+18h], ecx
lea rsi, aU; "U+"
mov edx, 2
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rax, [rbx]
mov rcx, [rax-18h]
or dword ptr [rbx+rcx+18h], 4000h
mov rax, [rax-18h]
lea r14, [rbx+rax]
cmp byte ptr [rbx+rax+0E1h], 0
jnz short loc_17AF7
mov rdi, r14
mov esi, 20h ; ' '
call __ZNKSt9basic_iosIcSt11char_traitsIcEE5widenEc; std::ios::widen(char)
mov [r14+0E0h], al
mov byte ptr [r14+0E1h], 1
loc_17AF7:
mov byte ptr [r14+0E0h], 30h ; '0'
mov rax, [rbx]
mov rax, [rax-18h]
mov qword ptr [rbx+rax+10h], 4
mov esi, ebp
mov rdi, rbx
pop rbx
pop r14
pop rbp
jmp __ZNSo9_M_insertImEERSoT_; std::ostream::_M_insert<ulong>(ulong)
| long long testing::internal::PrintTo(unsigned int a1, _QWORD *a2)
{
long long v2; // rdx
long long v3; // rax
long long v4; // rcx
long long v5; // rax
char *v6; // r14
*(_DWORD *)((char *)a2 + *(_QWORD *)(*a2 - 24LL) + 24) = *(_DWORD *)((_BYTE *)a2 + *(_QWORD *)(*a2 - 24LL) + 24) & 0xFFFFFFB5 | 8;
std::__ostream_insert<char,std::char_traits<char>>(a2, "U+", 2LL);
v3 = *a2;
v4 = *(_QWORD *)(*a2 - 24LL);
*(_DWORD *)((char *)a2 + v4 + 24) |= 0x4000u;
v5 = *(_QWORD *)(v3 - 24);
v6 = (char *)a2 + v5;
if ( !*((_BYTE *)a2 + v5 + 225) )
{
v6[224] = std::ios::widen((char *)a2 + v5, 32LL, v2, v4);
v6[225] = 1;
}
v6[224] = 48;
*(_QWORD *)((char *)a2 + *(_QWORD *)(*a2 - 24LL) + 16) = 4LL;
return std::ostream::_M_insert<unsigned long>(a2, a1);
}
| PrintTo:
PUSH RBP
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV EBP,EDI
MOV RAX,qword ptr [RSI]
MOV RAX,qword ptr [RAX + -0x18]
MOV ECX,dword ptr [RSI + RAX*0x1 + 0x18]
AND ECX,0xffffffb5
OR ECX,0x8
MOV dword ptr [RSI + RAX*0x1 + 0x18],ECX
LEA RSI,[0x142529]
MOV EDX,0x2
MOV RDI,RBX
CALL 0x001085b0
MOV RAX,qword ptr [RBX]
MOV RCX,qword ptr [RAX + -0x18]
OR dword ptr [RBX + RCX*0x1 + 0x18],0x4000
MOV RAX,qword ptr [RAX + -0x18]
LEA R14,[RBX + RAX*0x1]
CMP byte ptr [RBX + RAX*0x1 + 0xe1],0x0
JNZ 0x00117af7
MOV RDI,R14
MOV ESI,0x20
CALL 0x00108490
MOV byte ptr [R14 + 0xe0],AL
MOV byte ptr [R14 + 0xe1],0x1
LAB_00117af7:
MOV byte ptr [R14 + 0xe0],0x30
MOV RAX,qword ptr [RBX]
MOV RAX,qword ptr [RAX + -0x18]
MOV qword ptr [RBX + RAX*0x1 + 0x10],0x4
MOV ESI,EBP
MOV RDI,RBX
POP RBX
POP R14
POP RBP
JMP 0x00108310
|
/* testing::internal::PrintTo(char32_t, std::ostream*) */
void testing::internal::PrintTo(wchar32 param_1,ostream *param_2)
{
ostream *poVar1;
long lVar2;
ostream oVar3;
*(uint *)(param_2 + *(long *)(*(long *)param_2 + -0x18) + 0x18) =
*(uint *)(param_2 + *(long *)(*(long *)param_2 + -0x18) + 0x18) & 0xffffffb5 | 8;
std::__ostream_insert<char,std::char_traits<char>>(param_2,"U+",2);
lVar2 = *(long *)param_2;
*(uint *)(param_2 + *(long *)(lVar2 + -0x18) + 0x18) =
*(uint *)(param_2 + *(long *)(lVar2 + -0x18) + 0x18) | 0x4000;
lVar2 = *(long *)(lVar2 + -0x18);
poVar1 = param_2 + lVar2;
if (param_2[lVar2 + 0xe1] == (ostream)0x0) {
oVar3 = (ostream)std::ios::widen((char)poVar1);
poVar1[0xe0] = oVar3;
poVar1[0xe1] = (ostream)0x1;
}
poVar1[0xe0] = (ostream)0x30;
*(int8 *)(param_2 + *(long *)(*(long *)param_2 + -0x18) + 0x10) = 4;
std::ostream::_M_insert<unsigned_long>((ulong)param_2);
return;
}
| |
44,845 | LefDefParser::lefiPin::addAntennaPartialMetalArea(double, char const*) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiMacro.cpp | void
lefiPin::addAntennaPartialMetalArea(double val,
const char *layer)
{
int len;
if (numAntennaPartialMetalArea_ == antennaPartialMetalAreaAllocated_) {
int i;
int max;
int lim = numAntennaPartialMetalArea_;
double *nd;
char **nl;
if (antennaPartialMetalAreaAllocated_ == 0)
max = antennaPartialMetalAreaAllocated_ = 2;
else
max = antennaPartialMetalAreaAllocated_ *= 2;
nd = (double*) lefMalloc(sizeof(double) * max);
nl = (char**) lefMalloc(sizeof(double) * max);
for (i = 0; i < lim; i++) {
nl[i] = antennaPartialMetalAreaLayer_[i];
nd[i] = antennaPartialMetalArea_[i];
}
lefFree((char*) (antennaPartialMetalAreaLayer_));
lefFree((char*) (antennaPartialMetalArea_));
antennaPartialMetalAreaLayer_ = nl;
antennaPartialMetalArea_ = nd;
}
antennaPartialMetalArea_[numAntennaPartialMetalArea_] = val;
if (layer) { // layer can be null, since it is optional
len = strlen(layer) + 1;
antennaPartialMetalAreaLayer_[numAntennaPartialMetalArea_] =
(char*) lefMalloc(len);
strcpy(antennaPartialMetalAreaLayer_[numAntennaPartialMetalArea_],
layer);
} else
antennaPartialMetalAreaLayer_[numAntennaPartialMetalArea_] = NULL;
numAntennaPartialMetalArea_ += 1;
} | O3 | cpp | LefDefParser::lefiPin::addAntennaPartialMetalArea(double, char const*):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x1c8(%rdi), %r13d
cmpl 0x1cc(%rdi), %r13d
jne 0x2a65c
movsd %xmm0, 0x8(%rsp)
leal (,%r13,2), %eax
testl %r13d, %r13d
movl $0x2, %ecx
cmovnel %eax, %ecx
movl %ecx, 0x1cc(%rbx)
movslq %ecx, %r12
shlq $0x3, %r12
movq %r12, %rdi
callq 0x24985
movq %rax, %r15
movq %r12, %rdi
callq 0x24985
movq %rax, %r12
testl %r13d, %r13d
jle 0x2a627
xorl %eax, %eax
movq 0x1d8(%rbx), %rcx
movq (%rcx,%rax,8), %rcx
movq %rcx, (%r12,%rax,8)
movq 0x1d0(%rbx), %rcx
movsd (%rcx,%rax,8), %xmm0
movsd %xmm0, (%r15,%rax,8)
incq %rax
cmpq %rax, %r13
jne 0x2a5fe
movq 0x1d8(%rbx), %rdi
callq 0x26040
movq 0x1d0(%rbx), %rdi
callq 0x26040
movq %r12, 0x1d8(%rbx)
movq %r15, 0x1d0(%rbx)
movl 0x1c8(%rbx), %r13d
movsd 0x8(%rsp), %xmm0
jmp 0x2a663
movq 0x1d0(%rbx), %r15
movslq %r13d, %rax
movsd %xmm0, (%r15,%rax,8)
testq %r14, %r14
je 0x2a6b1
movq %r14, %rdi
callq 0x20d0
incl %eax
movslq %eax, %rdi
callq 0x24985
movq 0x1d8(%rbx), %rcx
movslq 0x1c8(%rbx), %rdx
movq %rax, (%rcx,%rdx,8)
movq 0x1d8(%rbx), %rax
movq (%rax,%rdx,8), %rdi
movq %r14, %rsi
callq 0x21b0
movl 0x1c8(%rbx), %r13d
jmp 0x2a6c0
movq 0x1d8(%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
incl %r13d
movl %r13d, 0x1c8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| _ZN12LefDefParser7lefiPin26addAntennaPartialMetalAreaEdPKc:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov r14, rsi
mov rbx, rdi
mov r13d, [rdi+1C8h]
cmp r13d, [rdi+1CCh]
jnz loc_2A65C
movsd [rsp+38h+var_30], xmm0
lea eax, ds:0[r13*2]
test r13d, r13d
mov ecx, 2
cmovnz ecx, eax
mov [rbx+1CCh], ecx
movsxd r12, ecx
shl r12, 3
mov rdi, r12; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov r15, rax
mov rdi, r12; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov r12, rax
test r13d, r13d
jle short loc_2A627
xor eax, eax
loc_2A5FE:
mov rcx, [rbx+1D8h]
mov rcx, [rcx+rax*8]
mov [r12+rax*8], rcx
mov rcx, [rbx+1D0h]
movsd xmm0, qword ptr [rcx+rax*8]
movsd qword ptr [r15+rax*8], xmm0
inc rax
cmp r13, rax
jnz short loc_2A5FE
loc_2A627:
mov rdi, [rbx+1D8h]; this
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
mov rdi, [rbx+1D0h]; this
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
mov [rbx+1D8h], r12
mov [rbx+1D0h], r15
mov r13d, [rbx+1C8h]
movsd xmm0, [rsp+38h+var_30]
jmp short loc_2A663
loc_2A65C:
mov r15, [rbx+1D0h]
loc_2A663:
movsxd rax, r13d
movsd qword ptr [r15+rax*8], xmm0
test r14, r14
jz short loc_2A6B1
mov rdi, r14
call _strlen
inc eax
movsxd rdi, eax; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov rcx, [rbx+1D8h]
movsxd rdx, dword ptr [rbx+1C8h]
mov [rcx+rdx*8], rax
mov rax, [rbx+1D8h]
mov rdi, [rax+rdx*8]
mov rsi, r14
call _strcpy
mov r13d, [rbx+1C8h]
jmp short loc_2A6C0
loc_2A6B1:
mov rcx, [rbx+1D8h]
mov qword ptr [rcx+rax*8], 0
loc_2A6C0:
inc r13d
mov [rbx+1C8h], r13d
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| long long LefDefParser::lefiPin::addAntennaPartialMetalArea(LefDefParser::lefiPin *this, double a2, char *a3)
{
long long v3; // r13
int v4; // ecx
LefDefParser *v5; // r12
long long v6; // r15
long long v7; // r12
long long i; // rax
long long result; // rax
int v10; // eax
long long v11; // rax
long long v12; // rdx
v3 = *((unsigned int *)this + 114);
if ( (_DWORD)v3 == *((_DWORD *)this + 115) )
{
v4 = 2;
if ( (_DWORD)v3 )
v4 = 2 * v3;
*((_DWORD *)this + 115) = v4;
v5 = (LefDefParser *)(8LL * v4);
v6 = LefDefParser::lefMalloc(v5);
v7 = LefDefParser::lefMalloc(v5);
if ( (int)v3 > 0 )
{
for ( i = 0LL; i != v3; ++i )
{
*(_QWORD *)(v7 + 8 * i) = *(_QWORD *)(*((_QWORD *)this + 59) + 8 * i);
*(_QWORD *)(v6 + 8 * i) = *(_QWORD *)(*((_QWORD *)this + 58) + 8 * i);
}
}
LefDefParser::lefFree(*((LefDefParser **)this + 59), a3);
LefDefParser::lefFree(*((LefDefParser **)this + 58), a3);
*((_QWORD *)this + 59) = v7;
*((_QWORD *)this + 58) = v6;
LODWORD(v3) = *((_DWORD *)this + 114);
}
else
{
v6 = *((_QWORD *)this + 58);
}
result = (int)v3;
*(double *)(v6 + 8LL * (int)v3) = a2;
if ( a3 )
{
v10 = strlen(a3);
v11 = LefDefParser::lefMalloc((LefDefParser *)(v10 + 1));
v12 = *((int *)this + 114);
*(_QWORD *)(*((_QWORD *)this + 59) + 8 * v12) = v11;
result = strcpy(*(_QWORD *)(*((_QWORD *)this + 59) + 8 * v12), a3);
LODWORD(v3) = *((_DWORD *)this + 114);
}
else
{
*(_QWORD *)(*((_QWORD *)this + 59) + 8LL * (int)v3) = 0LL;
}
*((_DWORD *)this + 114) = v3 + 1;
return result;
}
| addAntennaPartialMetalArea:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R14,RSI
MOV RBX,RDI
MOV R13D,dword ptr [RDI + 0x1c8]
CMP R13D,dword ptr [RDI + 0x1cc]
JNZ 0x0012a65c
MOVSD qword ptr [RSP + 0x8],XMM0
LEA EAX,[R13*0x2]
TEST R13D,R13D
MOV ECX,0x2
CMOVNZ ECX,EAX
MOV dword ptr [RBX + 0x1cc],ECX
MOVSXD R12,ECX
SHL R12,0x3
MOV RDI,R12
CALL 0x00124985
MOV R15,RAX
MOV RDI,R12
CALL 0x00124985
MOV R12,RAX
TEST R13D,R13D
JLE 0x0012a627
XOR EAX,EAX
LAB_0012a5fe:
MOV RCX,qword ptr [RBX + 0x1d8]
MOV RCX,qword ptr [RCX + RAX*0x8]
MOV qword ptr [R12 + RAX*0x8],RCX
MOV RCX,qword ptr [RBX + 0x1d0]
MOVSD XMM0,qword ptr [RCX + RAX*0x8]
MOVSD qword ptr [R15 + RAX*0x8],XMM0
INC RAX
CMP R13,RAX
JNZ 0x0012a5fe
LAB_0012a627:
MOV RDI,qword ptr [RBX + 0x1d8]
CALL 0x00126040
MOV RDI,qword ptr [RBX + 0x1d0]
CALL 0x00126040
MOV qword ptr [RBX + 0x1d8],R12
MOV qword ptr [RBX + 0x1d0],R15
MOV R13D,dword ptr [RBX + 0x1c8]
MOVSD XMM0,qword ptr [RSP + 0x8]
JMP 0x0012a663
LAB_0012a65c:
MOV R15,qword ptr [RBX + 0x1d0]
LAB_0012a663:
MOVSXD RAX,R13D
MOVSD qword ptr [R15 + RAX*0x8],XMM0
TEST R14,R14
JZ 0x0012a6b1
MOV RDI,R14
CALL 0x001020d0
INC EAX
MOVSXD RDI,EAX
CALL 0x00124985
MOV RCX,qword ptr [RBX + 0x1d8]
MOVSXD RDX,dword ptr [RBX + 0x1c8]
MOV qword ptr [RCX + RDX*0x8],RAX
MOV RAX,qword ptr [RBX + 0x1d8]
MOV RDI,qword ptr [RAX + RDX*0x8]
MOV RSI,R14
CALL 0x001021b0
MOV R13D,dword ptr [RBX + 0x1c8]
JMP 0x0012a6c0
LAB_0012a6b1:
MOV RCX,qword ptr [RBX + 0x1d8]
MOV qword ptr [RCX + RAX*0x8],0x0
LAB_0012a6c0:
INC R13D
MOV dword ptr [RBX + 0x1c8],R13D
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* LefDefParser::lefiPin::addAntennaPartialMetalArea(double, char const*) */
void __thiscall
LefDefParser::lefiPin::addAntennaPartialMetalArea(lefiPin *this,double param_1,char *param_2)
{
long lVar1;
long lVar2;
ulong uVar3;
size_t sVar4;
int8 uVar5;
int iVar6;
char *pcVar7;
uint uVar8;
uVar8 = *(uint *)(this + 0x1c8);
pcVar7 = param_2;
if (uVar8 == *(uint *)(this + 0x1cc)) {
iVar6 = 2;
if (uVar8 != 0) {
iVar6 = uVar8 * 2;
}
*(int *)(this + 0x1cc) = iVar6;
lVar1 = lefMalloc((LefDefParser *)((long)iVar6 << 3),(ulong)param_2);
lVar2 = lefMalloc((LefDefParser *)((long)iVar6 << 3),(ulong)pcVar7);
if (0 < (int)uVar8) {
uVar3 = 0;
do {
*(int8 *)(lVar2 + uVar3 * 8) = *(int8 *)(*(long *)(this + 0x1d8) + uVar3 * 8);
*(int8 *)(lVar1 + uVar3 * 8) = *(int8 *)(*(long *)(this + 0x1d0) + uVar3 * 8);
uVar3 = uVar3 + 1;
} while (uVar8 != uVar3);
}
lefFree(*(void **)(this + 0x1d8));
lefFree(*(void **)(this + 0x1d0));
*(long *)(this + 0x1d8) = lVar2;
*(long *)(this + 0x1d0) = lVar1;
uVar8 = *(uint *)(this + 0x1c8);
}
else {
lVar1 = *(long *)(this + 0x1d0);
}
*(double *)(lVar1 + (long)(int)uVar8 * 8) = param_1;
if (param_2 == (char *)0x0) {
*(int8 *)(*(long *)(this + 0x1d8) + (long)(int)uVar8 * 8) = 0;
}
else {
sVar4 = strlen(param_2);
uVar5 = lefMalloc((LefDefParser *)(long)((int)sVar4 + 1),(ulong)pcVar7);
iVar6 = *(int *)(this + 0x1c8);
*(int8 *)(*(long *)(this + 0x1d8) + (long)iVar6 * 8) = uVar5;
strcpy(*(char **)(*(long *)(this + 0x1d8) + (long)iVar6 * 8),param_2);
uVar8 = *(uint *)(this + 0x1c8);
}
*(uint *)(this + 0x1c8) = uVar8 + 1;
return;
}
| |
44,846 | GetCodepointNext | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rtext.c | int GetCodepointNext(const char *text, int *codepointSize)
{
const char *ptr = text;
int codepoint = 0x3f; // Codepoint (defaults to '?')
*codepointSize = 1;
// Get current codepoint and bytes processed
if (0xf0 == (0xf8 & ptr[0]))
{
// 4 byte UTF-8 codepoint
if (((ptr[1] & 0xC0) ^ 0x80) || ((ptr[2] & 0xC0) ^ 0x80) || ((ptr[3] & 0xC0) ^ 0x80)) { return codepoint; } // 10xxxxxx checks
codepoint = ((0x07 & ptr[0]) << 18) | ((0x3f & ptr[1]) << 12) | ((0x3f & ptr[2]) << 6) | (0x3f & ptr[3]);
*codepointSize = 4;
}
else if (0xe0 == (0xf0 & ptr[0]))
{
// 3 byte UTF-8 codepoint */
if (((ptr[1] & 0xC0) ^ 0x80) || ((ptr[2] & 0xC0) ^ 0x80)) { return codepoint; } // 10xxxxxx checks
codepoint = ((0x0f & ptr[0]) << 12) | ((0x3f & ptr[1]) << 6) | (0x3f & ptr[2]);
*codepointSize = 3;
}
else if (0xc0 == (0xe0 & ptr[0]))
{
// 2 byte UTF-8 codepoint
if ((ptr[1] & 0xC0) ^ 0x80) { return codepoint; } // 10xxxxxx checks
codepoint = ((0x1f & ptr[0]) << 6) | (0x3f & ptr[1]);
*codepointSize = 2;
}
else if (0x00 == (0x80 & ptr[0]))
{
// 1 byte UTF-8 codepoint
codepoint = ptr[0];
*codepointSize = 1;
}
return codepoint;
} | O0 | c | GetCodepointNext:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x3f, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
andl $0xf8, %ecx
movl $0xf0, %eax
cmpl %ecx, %eax
jne 0xe60fb
movq -0x20(%rbp), %rax
movsbl 0x1(%rax), %eax
andl $0xc0, %eax
xorl $0x80, %eax
cmpl $0x0, %eax
jne 0xe60a4
movq -0x20(%rbp), %rax
movsbl 0x2(%rax), %eax
andl $0xc0, %eax
xorl $0x80, %eax
cmpl $0x0, %eax
jne 0xe60a4
movq -0x20(%rbp), %rax
movsbl 0x3(%rax), %eax
andl $0xc0, %eax
xorl $0x80, %eax
cmpl $0x0, %eax
je 0xe60af
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xe6217
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
andl $0x7, %eax
shll $0x12, %eax
movq -0x20(%rbp), %rcx
movsbl 0x1(%rcx), %ecx
andl $0x3f, %ecx
shll $0xc, %ecx
orl %ecx, %eax
movq -0x20(%rbp), %rcx
movsbl 0x2(%rcx), %ecx
andl $0x3f, %ecx
shll $0x6, %ecx
orl %ecx, %eax
movq -0x20(%rbp), %rcx
movsbl 0x3(%rcx), %ecx
andl $0x3f, %ecx
orl %ecx, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl $0x4, (%rax)
jmp 0xe6211
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
andl $0xf0, %ecx
movl $0xe0, %eax
cmpl %ecx, %eax
jne 0xe6186
movq -0x20(%rbp), %rax
movsbl 0x1(%rax), %eax
andl $0xc0, %eax
xorl $0x80, %eax
cmpl $0x0, %eax
jne 0xe613f
movq -0x20(%rbp), %rax
movsbl 0x2(%rax), %eax
andl $0xc0, %eax
xorl $0x80, %eax
cmpl $0x0, %eax
je 0xe614a
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xe6217
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
andl $0xf, %eax
shll $0xc, %eax
movq -0x20(%rbp), %rcx
movsbl 0x1(%rcx), %ecx
andl $0x3f, %ecx
shll $0x6, %ecx
orl %ecx, %eax
movq -0x20(%rbp), %rcx
movsbl 0x2(%rcx), %ecx
andl $0x3f, %ecx
orl %ecx, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl $0x3, (%rax)
jmp 0xe620f
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
andl $0xe0, %ecx
movl $0xc0, %eax
cmpl %ecx, %eax
jne 0xe61e4
movq -0x20(%rbp), %rax
movsbl 0x1(%rax), %eax
andl $0xc0, %eax
xorl $0x80, %eax
cmpl $0x0, %eax
je 0xe61bb
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xe6217
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
andl $0x1f, %eax
shll $0x6, %eax
movq -0x20(%rbp), %rcx
movsbl 0x1(%rcx), %ecx
andl $0x3f, %ecx
orl %ecx, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
jmp 0xe620d
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
andl $0x80, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0xe620b
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
jmp 0xe620d
jmp 0xe620f
jmp 0xe6211
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
| GetCodepointNext:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov [rbp+var_20], rax
mov [rbp+var_24], 3Fh ; '?'
mov rax, [rbp+var_18]
mov dword ptr [rax], 1
mov rax, [rbp+var_20]
movsx ecx, byte ptr [rax]
and ecx, 0F8h
mov eax, 0F0h
cmp eax, ecx
jnz loc_E60FB
mov rax, [rbp+var_20]
movsx eax, byte ptr [rax+1]
and eax, 0C0h
xor eax, 80h
cmp eax, 0
jnz short loc_E60A4
mov rax, [rbp+var_20]
movsx eax, byte ptr [rax+2]
and eax, 0C0h
xor eax, 80h
cmp eax, 0
jnz short loc_E60A4
mov rax, [rbp+var_20]
movsx eax, byte ptr [rax+3]
and eax, 0C0h
xor eax, 80h
cmp eax, 0
jz short loc_E60AF
loc_E60A4:
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
jmp loc_E6217
loc_E60AF:
mov rax, [rbp+var_20]
movsx eax, byte ptr [rax]
and eax, 7
shl eax, 12h
mov rcx, [rbp+var_20]
movsx ecx, byte ptr [rcx+1]
and ecx, 3Fh
shl ecx, 0Ch
or eax, ecx
mov rcx, [rbp+var_20]
movsx ecx, byte ptr [rcx+2]
and ecx, 3Fh
shl ecx, 6
or eax, ecx
mov rcx, [rbp+var_20]
movsx ecx, byte ptr [rcx+3]
and ecx, 3Fh
or eax, ecx
mov [rbp+var_24], eax
mov rax, [rbp+var_18]
mov dword ptr [rax], 4
jmp loc_E6211
loc_E60FB:
mov rax, [rbp+var_20]
movsx ecx, byte ptr [rax]
and ecx, 0F0h
mov eax, 0E0h
cmp eax, ecx
jnz short loc_E6186
mov rax, [rbp+var_20]
movsx eax, byte ptr [rax+1]
and eax, 0C0h
xor eax, 80h
cmp eax, 0
jnz short loc_E613F
mov rax, [rbp+var_20]
movsx eax, byte ptr [rax+2]
and eax, 0C0h
xor eax, 80h
cmp eax, 0
jz short loc_E614A
loc_E613F:
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
jmp loc_E6217
loc_E614A:
mov rax, [rbp+var_20]
movsx eax, byte ptr [rax]
and eax, 0Fh
shl eax, 0Ch
mov rcx, [rbp+var_20]
movsx ecx, byte ptr [rcx+1]
and ecx, 3Fh
shl ecx, 6
or eax, ecx
mov rcx, [rbp+var_20]
movsx ecx, byte ptr [rcx+2]
and ecx, 3Fh
or eax, ecx
mov [rbp+var_24], eax
mov rax, [rbp+var_18]
mov dword ptr [rax], 3
jmp loc_E620F
loc_E6186:
mov rax, [rbp+var_20]
movsx ecx, byte ptr [rax]
and ecx, 0E0h
mov eax, 0C0h
cmp eax, ecx
jnz short loc_E61E4
mov rax, [rbp+var_20]
movsx eax, byte ptr [rax+1]
and eax, 0C0h
xor eax, 80h
cmp eax, 0
jz short loc_E61BB
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
jmp short loc_E6217
loc_E61BB:
mov rax, [rbp+var_20]
movsx eax, byte ptr [rax]
and eax, 1Fh
shl eax, 6
mov rcx, [rbp+var_20]
movsx ecx, byte ptr [rcx+1]
and ecx, 3Fh
or eax, ecx
mov [rbp+var_24], eax
mov rax, [rbp+var_18]
mov dword ptr [rax], 2
jmp short loc_E620D
loc_E61E4:
mov rax, [rbp+var_20]
movsx ecx, byte ptr [rax]
and ecx, 80h
xor eax, eax
cmp eax, ecx
jnz short loc_E620B
mov rax, [rbp+var_20]
movsx eax, byte ptr [rax]
mov [rbp+var_24], eax
mov rax, [rbp+var_18]
mov dword ptr [rax], 1
loc_E620B:
jmp short $+2
loc_E620D:
jmp short $+2
loc_E620F:
jmp short $+2
loc_E6211:
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
loc_E6217:
mov eax, [rbp+var_4]
pop rbp
retn
| long long GetCodepointNext(char *a1, _DWORD *a2)
{
unsigned int v3; // [rsp+0h] [rbp-24h]
v3 = 63;
*a2 = 1;
if ( (*a1 & 0xF8) != 0xF0 )
{
if ( (*a1 & 0xF0) == 0xE0 )
{
if ( (a1[1] & 0xC0) != 0x80 || (a1[2] & 0xC0) != 0x80 )
return 63;
v3 = a1[2] & 0x3F | ((a1[1] & 0x3F) << 6) | ((*a1 & 0xF) << 12);
*a2 = 3;
}
else if ( (*a1 & 0xE0) == 0xC0 )
{
if ( (a1[1] & 0xC0) != 0x80 )
return 63;
v3 = a1[1] & 0x3F | ((*a1 & 0x1F) << 6);
*a2 = 2;
}
else if ( (*a1 & 0x80) == 0 )
{
v3 = *a1;
*a2 = 1;
}
return v3;
}
if ( (a1[1] & 0xC0) == 0x80 && (a1[2] & 0xC0) == 0x80 && (a1[3] & 0xC0) == 0x80 )
{
v3 = a1[3] & 0x3F | ((a1[2] & 0x3F) << 6) | ((a1[1] & 0x3F) << 12) | ((*a1 & 7) << 18);
*a2 = 4;
return v3;
}
return 63;
}
| GetCodepointNext:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x24],0x3f
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX],0x1
MOV RAX,qword ptr [RBP + -0x20]
MOVSX ECX,byte ptr [RAX]
AND ECX,0xf8
MOV EAX,0xf0
CMP EAX,ECX
JNZ 0x001e60fb
MOV RAX,qword ptr [RBP + -0x20]
MOVSX EAX,byte ptr [RAX + 0x1]
AND EAX,0xc0
XOR EAX,0x80
CMP EAX,0x0
JNZ 0x001e60a4
MOV RAX,qword ptr [RBP + -0x20]
MOVSX EAX,byte ptr [RAX + 0x2]
AND EAX,0xc0
XOR EAX,0x80
CMP EAX,0x0
JNZ 0x001e60a4
MOV RAX,qword ptr [RBP + -0x20]
MOVSX EAX,byte ptr [RAX + 0x3]
AND EAX,0xc0
XOR EAX,0x80
CMP EAX,0x0
JZ 0x001e60af
LAB_001e60a4:
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001e6217
LAB_001e60af:
MOV RAX,qword ptr [RBP + -0x20]
MOVSX EAX,byte ptr [RAX]
AND EAX,0x7
SHL EAX,0x12
MOV RCX,qword ptr [RBP + -0x20]
MOVSX ECX,byte ptr [RCX + 0x1]
AND ECX,0x3f
SHL ECX,0xc
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x20]
MOVSX ECX,byte ptr [RCX + 0x2]
AND ECX,0x3f
SHL ECX,0x6
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x20]
MOVSX ECX,byte ptr [RCX + 0x3]
AND ECX,0x3f
OR EAX,ECX
MOV dword ptr [RBP + -0x24],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX],0x4
JMP 0x001e6211
LAB_001e60fb:
MOV RAX,qword ptr [RBP + -0x20]
MOVSX ECX,byte ptr [RAX]
AND ECX,0xf0
MOV EAX,0xe0
CMP EAX,ECX
JNZ 0x001e6186
MOV RAX,qword ptr [RBP + -0x20]
MOVSX EAX,byte ptr [RAX + 0x1]
AND EAX,0xc0
XOR EAX,0x80
CMP EAX,0x0
JNZ 0x001e613f
MOV RAX,qword ptr [RBP + -0x20]
MOVSX EAX,byte ptr [RAX + 0x2]
AND EAX,0xc0
XOR EAX,0x80
CMP EAX,0x0
JZ 0x001e614a
LAB_001e613f:
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001e6217
LAB_001e614a:
MOV RAX,qword ptr [RBP + -0x20]
MOVSX EAX,byte ptr [RAX]
AND EAX,0xf
SHL EAX,0xc
MOV RCX,qword ptr [RBP + -0x20]
MOVSX ECX,byte ptr [RCX + 0x1]
AND ECX,0x3f
SHL ECX,0x6
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x20]
MOVSX ECX,byte ptr [RCX + 0x2]
AND ECX,0x3f
OR EAX,ECX
MOV dword ptr [RBP + -0x24],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX],0x3
JMP 0x001e620f
LAB_001e6186:
MOV RAX,qword ptr [RBP + -0x20]
MOVSX ECX,byte ptr [RAX]
AND ECX,0xe0
MOV EAX,0xc0
CMP EAX,ECX
JNZ 0x001e61e4
MOV RAX,qword ptr [RBP + -0x20]
MOVSX EAX,byte ptr [RAX + 0x1]
AND EAX,0xc0
XOR EAX,0x80
CMP EAX,0x0
JZ 0x001e61bb
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001e6217
LAB_001e61bb:
MOV RAX,qword ptr [RBP + -0x20]
MOVSX EAX,byte ptr [RAX]
AND EAX,0x1f
SHL EAX,0x6
MOV RCX,qword ptr [RBP + -0x20]
MOVSX ECX,byte ptr [RCX + 0x1]
AND ECX,0x3f
OR EAX,ECX
MOV dword ptr [RBP + -0x24],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX],0x2
JMP 0x001e620d
LAB_001e61e4:
MOV RAX,qword ptr [RBP + -0x20]
MOVSX ECX,byte ptr [RAX]
AND ECX,0x80
XOR EAX,EAX
CMP EAX,ECX
JNZ 0x001e620b
MOV RAX,qword ptr [RBP + -0x20]
MOVSX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x24],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX],0x1
LAB_001e620b:
JMP 0x001e620d
LAB_001e620d:
JMP 0x001e620f
LAB_001e620f:
JMP 0x001e6211
LAB_001e6211:
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
LAB_001e6217:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
uint GetCodepointNext(char *param_1,int4 *param_2)
{
uint local_2c;
local_2c = 0x3f;
*param_2 = 1;
if (((int)*param_1 & 0xf8U) == 0xf0) {
if (((((int)param_1[1] & 0xc0U) != 0x80) || (((int)param_1[2] & 0xc0U) != 0x80)) ||
(((int)param_1[3] & 0xc0U) != 0x80)) {
return 0x3f;
}
local_2c = ((int)*param_1 & 7U) << 0x12 | ((int)param_1[1] & 0x3fU) << 0xc |
((int)param_1[2] & 0x3fU) << 6 | (int)param_1[3] & 0x3fU;
*param_2 = 4;
}
else if (((int)*param_1 & 0xf0U) == 0xe0) {
if ((((int)param_1[1] & 0xc0U) != 0x80) || (((int)param_1[2] & 0xc0U) != 0x80)) {
return 0x3f;
}
local_2c = ((int)*param_1 & 0xfU) << 0xc | ((int)param_1[1] & 0x3fU) << 6 |
(int)param_1[2] & 0x3fU;
*param_2 = 3;
}
else if (((int)*param_1 & 0xe0U) == 0xc0) {
if (((int)param_1[1] & 0xc0U) != 0x80) {
return 0x3f;
}
local_2c = ((int)*param_1 & 0x1fU) << 6 | (int)param_1[1] & 0x3fU;
*param_2 = 2;
}
else if (((int)*param_1 & 0x80U) == 0) {
local_2c = (uint)*param_1;
*param_2 = 1;
}
return local_2c;
}
| |
44,847 | GetCodepointNext | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rtext.c | int GetCodepointNext(const char *text, int *codepointSize)
{
const char *ptr = text;
int codepoint = 0x3f; // Codepoint (defaults to '?')
*codepointSize = 1;
// Get current codepoint and bytes processed
if (0xf0 == (0xf8 & ptr[0]))
{
// 4 byte UTF-8 codepoint
if (((ptr[1] & 0xC0) ^ 0x80) || ((ptr[2] & 0xC0) ^ 0x80) || ((ptr[3] & 0xC0) ^ 0x80)) { return codepoint; } // 10xxxxxx checks
codepoint = ((0x07 & ptr[0]) << 18) | ((0x3f & ptr[1]) << 12) | ((0x3f & ptr[2]) << 6) | (0x3f & ptr[3]);
*codepointSize = 4;
}
else if (0xe0 == (0xf0 & ptr[0]))
{
// 3 byte UTF-8 codepoint */
if (((ptr[1] & 0xC0) ^ 0x80) || ((ptr[2] & 0xC0) ^ 0x80)) { return codepoint; } // 10xxxxxx checks
codepoint = ((0x0f & ptr[0]) << 12) | ((0x3f & ptr[1]) << 6) | (0x3f & ptr[2]);
*codepointSize = 3;
}
else if (0xc0 == (0xe0 & ptr[0]))
{
// 2 byte UTF-8 codepoint
if ((ptr[1] & 0xC0) ^ 0x80) { return codepoint; } // 10xxxxxx checks
codepoint = ((0x1f & ptr[0]) << 6) | (0x3f & ptr[1]);
*codepointSize = 2;
}
else if (0x00 == (0x80 & ptr[0]))
{
// 1 byte UTF-8 codepoint
codepoint = ptr[0];
*codepointSize = 1;
}
return codepoint;
} | O3 | c | GetCodepointNext:
movl $0x1, (%rsi)
movsbl (%rdi), %ecx
movl %ecx, %eax
andl $0xf8, %eax
cmpl $0xf0, %eax
jne 0x850d1
movsbl 0x1(%rdi), %edx
movl %edx, %r8d
andl $0xc0, %r8d
movl $0x3f, %eax
cmpl $0x80, %r8d
jne 0x85163
movsbl 0x2(%rdi), %r8d
movl %r8d, %r9d
andl $0xc0, %r9d
cmpl $0x80, %r9d
jne 0x85163
movzbl 0x3(%rdi), %edi
movl %edi, %r9d
andl $-0x40, %r9d
cmpl $0x80, %r9d
jne 0x85163
andl $0x7, %ecx
shll $0x12, %ecx
andl $0x3f, %edx
shll $0xc, %edx
orl %ecx, %edx
andl $0x3f, %r8d
shll $0x6, %r8d
orl %edx, %r8d
andl $0x3f, %edi
orl %r8d, %edi
movl $0x4, %ecx
jmp 0x85127
movl %ecx, %eax
andl $0xf0, %eax
cmpl $0xe0, %eax
jne 0x8512b
movsbl 0x1(%rdi), %edx
movl %edx, %r8d
andl $0xc0, %r8d
movl $0x3f, %eax
cmpl $0x80, %r8d
jne 0x85163
movzbl 0x2(%rdi), %edi
movl %edi, %r8d
andl $-0x40, %r8d
cmpl $0x80, %r8d
jne 0x85163
shll $0xc, %ecx
movzwl %cx, %eax
andl $0x3f, %edx
shll $0x6, %edx
orl %eax, %edx
andl $0x3f, %edi
orl %edx, %edi
movl $0x3, %ecx
movl %edi, %eax
jmp 0x85161
movl %ecx, %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0x85164
movzbl 0x1(%rdi), %edx
movl %edx, %edi
andl $-0x40, %edi
movl $0x3f, %eax
cmpl $0x80, %edi
jne 0x85163
andl $0x1f, %ecx
shll $0x6, %ecx
andl $0x3f, %edx
orl %ecx, %edx
movl $0x2, %ecx
movl %edx, %eax
movl %ecx, (%rsi)
retq
testb %cl, %cl
movl $0x3f, %eax
cmovnsl %ecx, %eax
retq
| GetCodepointNext:
mov dword ptr [rsi], 1
movsx ecx, byte ptr [rdi]
mov eax, ecx
and eax, 0F8h
cmp eax, 0F0h
jnz short loc_850D1
movsx edx, byte ptr [rdi+1]
mov r8d, edx
and r8d, 0C0h
mov eax, 3Fh ; '?'
cmp r8d, 80h
jnz locret_85163
movsx r8d, byte ptr [rdi+2]
mov r9d, r8d
and r9d, 0C0h
cmp r9d, 80h
jnz locret_85163
movzx edi, byte ptr [rdi+3]
mov r9d, edi
and r9d, 0FFFFFFC0h
cmp r9d, 80h
jnz locret_85163
and ecx, 7
shl ecx, 12h
and edx, 3Fh
shl edx, 0Ch
or edx, ecx
and r8d, 3Fh
shl r8d, 6
or r8d, edx
and edi, 3Fh
or edi, r8d
mov ecx, 4
jmp short loc_85127
loc_850D1:
mov eax, ecx
and eax, 0F0h
cmp eax, 0E0h
jnz short loc_8512B
movsx edx, byte ptr [rdi+1]
mov r8d, edx
and r8d, 0C0h
mov eax, 3Fh ; '?'
cmp r8d, 80h
jnz short locret_85163
movzx edi, byte ptr [rdi+2]
mov r8d, edi
and r8d, 0FFFFFFC0h
cmp r8d, 80h
jnz short locret_85163
shl ecx, 0Ch
movzx eax, cx
and edx, 3Fh
shl edx, 6
or edx, eax
and edi, 3Fh
or edi, edx
mov ecx, 3
loc_85127:
mov eax, edi
jmp short loc_85161
loc_8512B:
mov eax, ecx
and eax, 0E0h
cmp eax, 0C0h
jnz short loc_85164
movzx edx, byte ptr [rdi+1]
mov edi, edx
and edi, 0FFFFFFC0h
mov eax, 3Fh ; '?'
cmp edi, 80h
jnz short locret_85163
and ecx, 1Fh
shl ecx, 6
and edx, 3Fh
or edx, ecx
mov ecx, 2
mov eax, edx
loc_85161:
mov [rsi], ecx
locret_85163:
retn
loc_85164:
test cl, cl
mov eax, 3Fh ; '?'
cmovns eax, ecx
retn
| long long GetCodepointNext(char *a1, int *a2)
{
unsigned int v2; // ecx
char v3; // dl
long long result; // rax
char v5; // r8
int v6; // edi
unsigned int v7; // edi
int v8; // ecx
char v9; // dl
int v10; // edi
unsigned int v11; // edx
*a2 = 1;
v2 = *a1;
if ( (*a1 & 0xF8) == 0xF0 )
{
v3 = a1[1];
result = 63LL;
if ( (v3 & 0xC0) == 0x80 )
{
v5 = a1[2];
if ( (v5 & 0xC0) == 0x80 )
{
v6 = (unsigned __int8)a1[3];
if ( (v6 & 0xFFFFFFC0) == 0x80 )
{
v7 = ((v2 & 7) << 18) | ((v3 & 0x3F) << 12) | ((v5 & 0x3F) << 6) | v6 & 0x3F;
v8 = 4;
LABEL_10:
result = v7;
LABEL_14:
*a2 = v8;
}
}
}
}
else if ( (v2 & 0xF0) == 0xE0 )
{
v9 = a1[1];
result = 63LL;
if ( (v9 & 0xC0) == 0x80 )
{
v10 = (unsigned __int8)a1[2];
if ( (v10 & 0xFFFFFFC0) == 0x80 )
{
v7 = (unsigned __int16)((_WORD)v2 << 12) | ((v9 & 0x3F) << 6) | v10 & 0x3F;
v8 = 3;
goto LABEL_10;
}
}
}
else
{
if ( (v2 & 0xE0) == 0xC0 )
{
result = 63LL;
if ( (a1[1] & 0xC0) != 0x80 )
return result;
v11 = ((v2 & 0x1F) << 6) | a1[1] & 0x3F;
v8 = 2;
result = v11;
goto LABEL_14;
}
result = 63LL;
if ( (v2 & 0x80u) == 0 )
return v2;
}
return result;
}
| GetCodepointNext:
MOV dword ptr [RSI],0x1
MOVSX ECX,byte ptr [RDI]
MOV EAX,ECX
AND EAX,0xf8
CMP EAX,0xf0
JNZ 0x001850d1
MOVSX EDX,byte ptr [RDI + 0x1]
MOV R8D,EDX
AND R8D,0xc0
MOV EAX,0x3f
CMP R8D,0x80
JNZ 0x00185163
MOVSX R8D,byte ptr [RDI + 0x2]
MOV R9D,R8D
AND R9D,0xc0
CMP R9D,0x80
JNZ 0x00185163
MOVZX EDI,byte ptr [RDI + 0x3]
MOV R9D,EDI
AND R9D,0xffffffc0
CMP R9D,0x80
JNZ 0x00185163
AND ECX,0x7
SHL ECX,0x12
AND EDX,0x3f
SHL EDX,0xc
OR EDX,ECX
AND R8D,0x3f
SHL R8D,0x6
OR R8D,EDX
AND EDI,0x3f
OR EDI,R8D
MOV ECX,0x4
JMP 0x00185127
LAB_001850d1:
MOV EAX,ECX
AND EAX,0xf0
CMP EAX,0xe0
JNZ 0x0018512b
MOVSX EDX,byte ptr [RDI + 0x1]
MOV R8D,EDX
AND R8D,0xc0
MOV EAX,0x3f
CMP R8D,0x80
JNZ 0x00185163
MOVZX EDI,byte ptr [RDI + 0x2]
MOV R8D,EDI
AND R8D,0xffffffc0
CMP R8D,0x80
JNZ 0x00185163
SHL ECX,0xc
MOVZX EAX,CX
AND EDX,0x3f
SHL EDX,0x6
OR EDX,EAX
AND EDI,0x3f
OR EDI,EDX
MOV ECX,0x3
LAB_00185127:
MOV EAX,EDI
JMP 0x00185161
LAB_0018512b:
MOV EAX,ECX
AND EAX,0xe0
CMP EAX,0xc0
JNZ 0x00185164
MOVZX EDX,byte ptr [RDI + 0x1]
MOV EDI,EDX
AND EDI,0xffffffc0
MOV EAX,0x3f
CMP EDI,0x80
JNZ 0x00185163
AND ECX,0x1f
SHL ECX,0x6
AND EDX,0x3f
OR EDX,ECX
MOV ECX,0x2
MOV EAX,EDX
LAB_00185161:
MOV dword ptr [RSI],ECX
LAB_00185163:
RET
LAB_00185164:
TEST CL,CL
MOV EAX,0x3f
CMOVNS EAX,ECX
RET
|
uint GetCodepointNext(char *param_1,int4 *param_2)
{
uint uVar1;
uint uVar2;
int4 uVar3;
*param_2 = 1;
uVar2 = (uint)*param_1;
if ((uVar2 & 0xf8) == 0xf0) {
if (((int)param_1[1] & 0xc0U) != 0x80) {
return 0x3f;
}
if (((int)param_1[2] & 0xc0U) != 0x80) {
return 0x3f;
}
if (((byte)param_1[3] & 0xffffffc0) != 0x80) {
return 0x3f;
}
uVar2 = (byte)param_1[3] & 0x3f |
((int)param_1[2] & 0x3fU) << 6 | ((int)param_1[1] & 0x3fU) << 0xc | (uVar2 & 7) << 0x12;
uVar3 = 4;
}
else if ((uVar2 & 0xf0) == 0xe0) {
if (((int)param_1[1] & 0xc0U) != 0x80) {
return 0x3f;
}
if (((byte)param_1[2] & 0xffffffc0) != 0x80) {
return 0x3f;
}
uVar2 = (byte)param_1[2] & 0x3f | ((int)param_1[1] & 0x3fU) << 6 | (uVar2 & 0xf) << 0xc;
uVar3 = 3;
}
else {
if ((uVar2 & 0xe0) != 0xc0) {
uVar1 = 0x3f;
if (-1 < *param_1) {
uVar1 = uVar2;
}
return uVar1;
}
if (((byte)param_1[1] & 0xffffffc0) != 0x80) {
return 0x3f;
}
uVar2 = (byte)param_1[1] & 0x3f | (uVar2 & 0x1f) << 6;
uVar3 = 2;
}
*param_2 = uVar3;
return uVar2;
}
| |
44,848 | value_buffer_free | bluesky950520[P]quickjs/quickjs.c | static void value_buffer_free(ValueBuffer *b)
{
while (b->len > 0)
JS_FreeValue(b->ctx, b->arr[--b->len]);
if (b->arr != b->def)
js_free(b->ctx, b->arr);
b->arr = b->def;
b->size = 4;
} | O1 | c | value_buffer_free:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x50(%rdi), %eax
testl %eax, %eax
jle 0x4c585
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
decl %eax
movl %eax, 0x50(%rbx)
shlq $0x4, %rax
movq (%rdx,%rax), %rsi
movq 0x8(%rdx,%rax), %rdx
movq 0x18(%rcx), %rdi
callq 0x1d8c6
movl 0x50(%rbx), %eax
jmp 0x4c55a
movq 0x8(%rbx), %rsi
leaq 0x10(%rbx), %r14
cmpq %r14, %rsi
je 0x4c59a
movq (%rbx), %rdi
callq 0x1cb99
movq %r14, 0x8(%rbx)
movl $0x4, 0x54(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| value_buffer_free:
push r14
push rbx
push rax
mov rbx, rdi
mov eax, [rdi+50h]
loc_4C55A:
test eax, eax
jle short loc_4C585
mov rcx, [rbx]
mov rdx, [rbx+8]
dec eax
mov [rbx+50h], eax
shl rax, 4
mov rsi, [rdx+rax]
mov rdx, [rdx+rax+8]
mov rdi, [rcx+18h]
call JS_FreeValueRT
mov eax, [rbx+50h]
jmp short loc_4C55A
loc_4C585:
mov rsi, [rbx+8]
lea r14, [rbx+10h]
cmp rsi, r14
jz short loc_4C59A
mov rdi, [rbx]
call js_free
loc_4C59A:
mov [rbx+8], r14
mov dword ptr [rbx+54h], 4
add rsp, 8
pop rbx
pop r14
retn
| long long value_buffer_free(long long a1)
{
long long result; // rax
long long v2; // rcx
long long v3; // rdx
long long v4; // rax
long long v5; // rsi
for ( result = *(unsigned int *)(a1 + 80); (int)result > 0; result = *(unsigned int *)(a1 + 80) )
{
v2 = *(_QWORD *)a1;
v3 = *(_QWORD *)(a1 + 8);
v4 = (unsigned int)(result - 1);
*(_DWORD *)(a1 + 80) = v4;
JS_FreeValueRT(*(_QWORD *)(v2 + 24), *(_DWORD **)(v3 + 16 * v4), *(_QWORD *)(v3 + 16 * v4 + 8));
}
v5 = *(_QWORD *)(a1 + 8);
if ( v5 != a1 + 16 )
result = js_free(*(_QWORD *)a1, v5);
*(_QWORD *)(a1 + 8) = a1 + 16;
*(_DWORD *)(a1 + 84) = 4;
return result;
}
| value_buffer_free:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV EAX,dword ptr [RDI + 0x50]
LAB_0014c55a:
TEST EAX,EAX
JLE 0x0014c585
MOV RCX,qword ptr [RBX]
MOV RDX,qword ptr [RBX + 0x8]
DEC EAX
MOV dword ptr [RBX + 0x50],EAX
SHL RAX,0x4
MOV RSI,qword ptr [RDX + RAX*0x1]
MOV RDX,qword ptr [RDX + RAX*0x1 + 0x8]
MOV RDI,qword ptr [RCX + 0x18]
CALL 0x0011d8c6
MOV EAX,dword ptr [RBX + 0x50]
JMP 0x0014c55a
LAB_0014c585:
MOV RSI,qword ptr [RBX + 0x8]
LEA R14,[RBX + 0x10]
CMP RSI,R14
JZ 0x0014c59a
MOV RDI,qword ptr [RBX]
CALL 0x0011cb99
LAB_0014c59a:
MOV qword ptr [RBX + 0x8],R14
MOV dword ptr [RBX + 0x54],0x4
ADD RSP,0x8
POP RBX
POP R14
RET
|
void value_buffer_free(long *param_1)
{
int iVar1;
long lVar2;
iVar1 = (int)param_1[10];
while (0 < iVar1) {
*(uint *)(param_1 + 10) = iVar1 - 1U;
lVar2 = (ulong)(iVar1 - 1U) * 0x10;
JS_FreeValueRT(*(int8 *)(*param_1 + 0x18),*(int8 *)(param_1[1] + lVar2),
*(int8 *)(param_1[1] + 8 + lVar2));
iVar1 = (int)param_1[10];
}
if ((long *)param_1[1] != param_1 + 2) {
js_free(*param_1);
}
param_1[1] = (long)(param_1 + 2);
*(int4 *)((long)param_1 + 0x54) = 4;
return;
}
| |
44,849 | value_buffer_free | bluesky950520[P]quickjs/quickjs.c | static void value_buffer_free(ValueBuffer *b)
{
while (b->len > 0)
JS_FreeValue(b->ctx, b->arr[--b->len]);
if (b->arr != b->def)
js_free(b->ctx, b->arr);
b->arr = b->def;
b->size = 4;
} | O2 | c | value_buffer_free:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x50(%rbx), %eax
testl %eax, %eax
jle 0x41a00
movq (%rbx), %rdi
movq 0x8(%rbx), %rcx
decl %eax
movl %eax, 0x50(%rbx)
shlq $0x4, %rax
movq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rdx
callq 0x1801e
jmp 0x419d9
movq 0x8(%rbx), %rsi
leaq 0x10(%rbx), %r14
cmpq %r14, %rsi
je 0x41a15
movq (%rbx), %rdi
callq 0x1726e
movq %r14, 0x8(%rbx)
movl $0x4, 0x54(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| value_buffer_free:
push r14
push rbx
push rax
mov rbx, rdi
loc_419D9:
mov eax, [rbx+50h]
test eax, eax
jle short loc_41A00
mov rdi, [rbx]
mov rcx, [rbx+8]
dec eax
mov [rbx+50h], eax
shl rax, 4
mov rsi, [rcx+rax]
mov rdx, [rcx+rax+8]
call JS_FreeValue
jmp short loc_419D9
loc_41A00:
mov rsi, [rbx+8]
lea r14, [rbx+10h]
cmp rsi, r14
jz short loc_41A15
mov rdi, [rbx]
call js_free
loc_41A15:
mov [rbx+8], r14
mov dword ptr [rbx+54h], 4
add rsp, 8
pop rbx
pop r14
retn
| long long value_buffer_free(long long a1)
{
long long result; // rax
long long v3; // rdi
long long v4; // rcx
long long v5; // rax
long long v6; // rsi
while ( 1 )
{
result = *(unsigned int *)(a1 + 80);
if ( (int)result <= 0 )
break;
v3 = *(_QWORD *)a1;
v4 = *(_QWORD *)(a1 + 8);
v5 = (unsigned int)(result - 1);
*(_DWORD *)(a1 + 80) = v5;
JS_FreeValue(v3, *(_QWORD *)(v4 + 16 * v5), *(_QWORD *)(v4 + 16 * v5 + 8));
}
v6 = *(_QWORD *)(a1 + 8);
if ( v6 != a1 + 16 )
result = js_free(*(_QWORD *)a1, v6);
*(_QWORD *)(a1 + 8) = a1 + 16;
*(_DWORD *)(a1 + 84) = 4;
return result;
}
| value_buffer_free:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
LAB_001419d9:
MOV EAX,dword ptr [RBX + 0x50]
TEST EAX,EAX
JLE 0x00141a00
MOV RDI,qword ptr [RBX]
MOV RCX,qword ptr [RBX + 0x8]
DEC EAX
MOV dword ptr [RBX + 0x50],EAX
SHL RAX,0x4
MOV RSI,qword ptr [RCX + RAX*0x1]
MOV RDX,qword ptr [RCX + RAX*0x1 + 0x8]
CALL 0x0011801e
JMP 0x001419d9
LAB_00141a00:
MOV RSI,qword ptr [RBX + 0x8]
LEA R14,[RBX + 0x10]
CMP RSI,R14
JZ 0x00141a15
MOV RDI,qword ptr [RBX]
CALL 0x0011726e
LAB_00141a15:
MOV qword ptr [RBX + 0x8],R14
MOV dword ptr [RBX + 0x54],0x4
ADD RSP,0x8
POP RBX
POP R14
RET
|
void value_buffer_free(int8 *param_1)
{
uint uVar1;
long lVar2;
while (0 < *(int *)(param_1 + 10)) {
uVar1 = *(int *)(param_1 + 10) - 1;
*(uint *)(param_1 + 10) = uVar1;
lVar2 = (ulong)uVar1 * 0x10;
JS_FreeValue(*param_1,*(int8 *)(param_1[1] + lVar2),
*(int8 *)(param_1[1] + 8 + lVar2));
}
if ((int8 *)param_1[1] != param_1 + 2) {
js_free(*param_1);
}
param_1[1] = param_1 + 2;
*(int4 *)((long)param_1 + 0x54) = 4;
return;
}
| |
44,850 | dequantize_row_tq1_0 | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c | void dequantize_row_tq1_0(const block_tq1_0 * restrict x, float * restrict y, int64_t k) {
assert(k % QK_K == 0);
const int64_t nb = k / QK_K;
const uint8_t pow3[6] = {1, 3, 9, 27, 81, 243};
for (int64_t i = 0; i < nb; ++i) {
const float d = GGML_FP16_TO_FP32(x[i].d);
for (size_t j = 0; j < sizeof(x->qs) - sizeof(x->qs) % 32; j += 32) {
for (size_t n = 0; n < 5; ++n) {
for (size_t m = 0; m < 32; ++m) {
uint8_t q = x[i].qs[j + m] * pow3[n];
int16_t xi = ((uint16_t) q * 3) >> 8;
*y++ = (float) (xi - 1) * d;
}
}
}
for (size_t j = sizeof(x->qs) - sizeof(x->qs) % 32; j < sizeof(x->qs); j += 16) {
for (size_t n = 0; n < 5; ++n) {
for (size_t m = 0; m < 16; ++m) {
uint8_t q = x[i].qs[j + m] * pow3[n];
int16_t xi = ((uint16_t) q * 3) >> 8;
*y++ = (float) (xi - 1) * d;
}
}
}
for (size_t n = 0; n < 4; ++n) {
for (size_t j = 0; j < sizeof(x->qh); ++j) {
uint8_t q = x[i].qh[j] * pow3[n];
int16_t xi = ((uint16_t) q * 3) >> 8;
*y++ = (float) (xi - 1) * d;
}
}
}
} | O0 | c | dequantize_row_tq1_0:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x100, %ecx # imm = 0x100
cqto
idivq %rcx
cmpq $0x0, %rdx
jne 0x7823d
jmp 0x7825c
leaq 0x48f00(%rip), %rdi # 0xc1144
leaq 0x48b11(%rip), %rsi # 0xc0d5c
movl $0x85a, %edx # imm = 0x85A
leaq 0x492c1(%rip), %rcx # 0xc1518
callq 0x44810
movq -0x18(%rbp), %rax
movl $0x100, %ecx # imm = 0x100
cqto
idivq %rcx
movq %rax, -0x20(%rbp)
movl 0x3e1f8(%rip), %eax # 0xb646c
movl %eax, -0x26(%rbp)
movw 0x3e1f2(%rip), %ax # 0xb6470
movw %ax, -0x22(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x78506
movq -0x8(%rbp), %rax
imulq $0x36, -0x30(%rbp), %rcx
addq %rcx, %rax
movzwl 0x34(%rax), %edi
callq 0x6e6e0
movss %xmm0, -0x34(%rbp)
movq $0x0, -0x40(%rbp)
cmpq $0x20, -0x40(%rbp)
jae 0x78376
movq $0x0, -0x48(%rbp)
cmpq $0x5, -0x48(%rbp)
jae 0x78363
movq $0x0, -0x50(%rbp)
cmpq $0x20, -0x50(%rbp)
jae 0x78350
movq -0x8(%rbp), %rax
imulq $0x36, -0x30(%rbp), %rcx
addq %rcx, %rax
movq -0x40(%rbp), %rcx
addq -0x50(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x48(%rbp), %rcx
movzbl -0x26(%rbp,%rcx), %ecx
imull %ecx, %eax
movb %al, -0x51(%rbp)
movzbl -0x51(%rbp), %eax
movzwl %ax, %eax
imull $0x3, %eax, %eax
sarl $0x8, %eax
movw %ax, -0x54(%rbp)
movswl -0x54(%rbp), %eax
subl $0x1, %eax
cvtsi2ss %eax, %xmm0
mulss -0x34(%rbp), %xmm0
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x10(%rbp)
movss %xmm0, (%rax)
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x782e0
jmp 0x78352
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x782cd
jmp 0x78365
movq -0x40(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x40(%rbp)
jmp 0x782ba
movq $0x20, -0x60(%rbp)
cmpq $0x30, -0x60(%rbp)
jae 0x7843a
movq $0x0, -0x68(%rbp)
cmpq $0x5, -0x68(%rbp)
jae 0x78427
movq $0x0, -0x70(%rbp)
cmpq $0x10, -0x70(%rbp)
jae 0x78414
movq -0x8(%rbp), %rax
imulq $0x36, -0x30(%rbp), %rcx
addq %rcx, %rax
movq -0x60(%rbp), %rcx
addq -0x70(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x68(%rbp), %rcx
movzbl -0x26(%rbp,%rcx), %ecx
imull %ecx, %eax
movb %al, -0x71(%rbp)
movzbl -0x71(%rbp), %eax
movzwl %ax, %eax
imull $0x3, %eax, %eax
sarl $0x8, %eax
movw %ax, -0x74(%rbp)
movswl -0x74(%rbp), %eax
subl $0x1, %eax
cvtsi2ss %eax, %xmm0
mulss -0x34(%rbp), %xmm0
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x10(%rbp)
movss %xmm0, (%rax)
movq -0x70(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x70(%rbp)
jmp 0x783a4
jmp 0x78416
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
jmp 0x78391
jmp 0x78429
movq -0x60(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x60(%rbp)
jmp 0x7837e
movq $0x0, -0x80(%rbp)
cmpq $0x4, -0x80(%rbp)
jae 0x784f3
movq $0x0, -0x88(%rbp)
cmpq $0x4, -0x88(%rbp)
jae 0x784e0
movq -0x8(%rbp), %rax
imulq $0x36, -0x30(%rbp), %rcx
addq %rcx, %rax
movq -0x88(%rbp), %rcx
movzbl 0x30(%rax,%rcx), %eax
movq -0x80(%rbp), %rcx
movzbl -0x26(%rbp,%rcx), %ecx
imull %ecx, %eax
movb %al, -0x89(%rbp)
movzbl -0x89(%rbp), %eax
movzwl %ax, %eax
imull $0x3, %eax, %eax
sarl $0x8, %eax
movw %ax, -0x8c(%rbp)
movswl -0x8c(%rbp), %eax
subl $0x1, %eax
cvtsi2ss %eax, %xmm0
mulss -0x34(%rbp), %xmm0
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x10(%rbp)
movss %xmm0, (%rax)
movq -0x88(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x88(%rbp)
jmp 0x78458
jmp 0x784e2
movq -0x80(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x80(%rbp)
jmp 0x78442
jmp 0x784f5
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x7828a
addq $0x90, %rsp
popq %rbp
retq
nop
| dequantize_row_tq1_0:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_18]
mov ecx, 100h
cqo
idiv rcx
cmp rdx, 0
jnz short loc_7823D
jmp short loc_7825C
loc_7823D:
lea rdi, aKQkK0; "k % QK_K == 0"
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
mov edx, 85Ah
lea rcx, aVoidDequantize_9; "void dequantize_row_tq1_0(const block_t"...
call ___assert_fail
loc_7825C:
mov rax, [rbp+var_18]
mov ecx, 100h
cqo
idiv rcx
mov [rbp+var_20], rax
mov eax, cs:dword_B646C
mov [rbp+var_26], eax
mov ax, cs:word_B6470
mov [rbp+var_22], ax
mov [rbp+var_30], 0
loc_7828A:
mov rax, [rbp+var_30]
cmp rax, [rbp+var_20]
jge loc_78506
mov rax, [rbp+var_8]
imul rcx, [rbp+var_30], 36h ; '6'
add rax, rcx
movzx edi, word ptr [rax+34h]
call ggml_lookup_fp16_to_fp32_0
movss [rbp+var_34], xmm0
mov [rbp+var_40], 0
loc_782BA:
cmp [rbp+var_40], 20h ; ' '
jnb loc_78376
mov [rbp+var_48], 0
loc_782CD:
cmp [rbp+var_48], 5
jnb loc_78363
mov [rbp+var_50], 0
loc_782E0:
cmp [rbp+var_50], 20h ; ' '
jnb short loc_78350
mov rax, [rbp+var_8]
imul rcx, [rbp+var_30], 36h ; '6'
add rax, rcx
mov rcx, [rbp+var_40]
add rcx, [rbp+var_50]
movzx eax, byte ptr [rax+rcx]
mov rcx, [rbp+var_48]
movzx ecx, byte ptr [rbp+rcx+var_26]
imul eax, ecx
mov [rbp+var_51], al
movzx eax, [rbp+var_51]
movzx eax, ax
imul eax, 3
sar eax, 8
mov [rbp+var_54], ax
movsx eax, [rbp+var_54]
sub eax, 1
cvtsi2ss xmm0, eax
mulss xmm0, [rbp+var_34]
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 4
mov [rbp+var_10], rcx
movss dword ptr [rax], xmm0
mov rax, [rbp+var_50]
add rax, 1
mov [rbp+var_50], rax
jmp short loc_782E0
loc_78350:
jmp short $+2
loc_78352:
mov rax, [rbp+var_48]
add rax, 1
mov [rbp+var_48], rax
jmp loc_782CD
loc_78363:
jmp short $+2
loc_78365:
mov rax, [rbp+var_40]
add rax, 20h ; ' '
mov [rbp+var_40], rax
jmp loc_782BA
loc_78376:
mov [rbp+var_60], 20h ; ' '
loc_7837E:
cmp [rbp+var_60], 30h ; '0'
jnb loc_7843A
mov [rbp+var_68], 0
loc_78391:
cmp [rbp+var_68], 5
jnb loc_78427
mov [rbp+var_70], 0
loc_783A4:
cmp [rbp+var_70], 10h
jnb short loc_78414
mov rax, [rbp+var_8]
imul rcx, [rbp+var_30], 36h ; '6'
add rax, rcx
mov rcx, [rbp+var_60]
add rcx, [rbp+var_70]
movzx eax, byte ptr [rax+rcx]
mov rcx, [rbp+var_68]
movzx ecx, byte ptr [rbp+rcx+var_26]
imul eax, ecx
mov [rbp+var_71], al
movzx eax, [rbp+var_71]
movzx eax, ax
imul eax, 3
sar eax, 8
mov [rbp+var_74], ax
movsx eax, [rbp+var_74]
sub eax, 1
cvtsi2ss xmm0, eax
mulss xmm0, [rbp+var_34]
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 4
mov [rbp+var_10], rcx
movss dword ptr [rax], xmm0
mov rax, [rbp+var_70]
add rax, 1
mov [rbp+var_70], rax
jmp short loc_783A4
loc_78414:
jmp short $+2
loc_78416:
mov rax, [rbp+var_68]
add rax, 1
mov [rbp+var_68], rax
jmp loc_78391
loc_78427:
jmp short $+2
loc_78429:
mov rax, [rbp+var_60]
add rax, 10h
mov [rbp+var_60], rax
jmp loc_7837E
loc_7843A:
mov [rbp+var_80], 0
loc_78442:
cmp [rbp+var_80], 4
jnb loc_784F3
mov [rbp+var_88], 0
loc_78458:
cmp [rbp+var_88], 4
jnb short loc_784E0
mov rax, [rbp+var_8]
imul rcx, [rbp+var_30], 36h ; '6'
add rax, rcx
mov rcx, [rbp+var_88]
movzx eax, byte ptr [rax+rcx+30h]
mov rcx, [rbp+var_80]
movzx ecx, byte ptr [rbp+rcx+var_26]
imul eax, ecx
mov [rbp+var_89], al
movzx eax, [rbp+var_89]
movzx eax, ax
imul eax, 3
sar eax, 8
mov [rbp+var_8C], ax
movsx eax, [rbp+var_8C]
sub eax, 1
cvtsi2ss xmm0, eax
mulss xmm0, [rbp+var_34]
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 4
mov [rbp+var_10], rcx
movss dword ptr [rax], xmm0
mov rax, [rbp+var_88]
add rax, 1
mov [rbp+var_88], rax
jmp loc_78458
loc_784E0:
jmp short $+2
loc_784E2:
mov rax, [rbp+var_80]
add rax, 1
mov [rbp+var_80], rax
jmp loc_78442
loc_784F3:
jmp short $+2
loc_784F5:
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_30], rax
jmp loc_7828A
loc_78506:
add rsp, 90h
pop rbp
retn
| long long dequantize_row_tq1_0(long long a1, float *a2, long long a3)
{
long long result; // rax
float v4; // xmm0_4
float *v5; // rax
float v6; // xmm0_4
float *v7; // rax
float v8; // xmm0_4
float *v9; // rax
unsigned long long mm; // [rsp+8h] [rbp-88h]
unsigned long long kk; // [rsp+10h] [rbp-80h]
unsigned long long jj; // [rsp+20h] [rbp-70h]
unsigned long long ii; // [rsp+28h] [rbp-68h]
unsigned long long n; // [rsp+30h] [rbp-60h]
unsigned long long m; // [rsp+40h] [rbp-50h]
unsigned long long k; // [rsp+48h] [rbp-48h]
unsigned long long j; // [rsp+50h] [rbp-40h]
float v18; // [rsp+5Ch] [rbp-34h]
long long i; // [rsp+60h] [rbp-30h]
int v20; // [rsp+6Ah] [rbp-26h]
__int16 v21; // [rsp+6Eh] [rbp-22h]
long long v22; // [rsp+70h] [rbp-20h]
long long v23; // [rsp+78h] [rbp-18h]
float *v24; // [rsp+80h] [rbp-10h]
long long v25; // [rsp+88h] [rbp-8h]
v25 = a1;
v24 = a2;
v23 = a3;
if ( a3 % 256 )
__assert_fail(
"k % QK_K == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c",
2138LL,
"void dequantize_row_tq1_0(const block_tq1_0 *restrict, float *restrict, int64_t)");
v22 = v23 / 256;
v20 = 453575425;
v21 = -3247;
for ( i = 0LL; ; ++i )
{
result = i;
if ( i >= v22 )
break;
v18 = ggml_lookup_fp16_to_fp32_0(*(_WORD *)(54 * i + v25 + 52));
for ( j = 0LL; j < 0x20; j += 32LL )
{
for ( k = 0LL; k < 5; ++k )
{
for ( m = 0LL; m < 0x20; ++m )
{
v4 = (float)((__int16)((3 * (unsigned __int8)(*((_BYTE *)&v20 + k) * *(_BYTE *)(54 * i + v25 + m + j))) >> 8)
- 1)
* v18;
v5 = v24++;
*v5 = v4;
}
}
}
for ( n = 32LL; n < 0x30; n += 16LL )
{
for ( ii = 0LL; ii < 5; ++ii )
{
for ( jj = 0LL; jj < 0x10; ++jj )
{
v6 = (float)((__int16)((3 * (unsigned __int8)(*((_BYTE *)&v20 + ii) * *(_BYTE *)(54 * i + v25 + jj + n))) >> 8)
- 1)
* v18;
v7 = v24++;
*v7 = v6;
}
}
}
for ( kk = 0LL; kk < 4; ++kk )
{
for ( mm = 0LL; mm < 4; ++mm )
{
v8 = (float)((__int16)((3 * (unsigned __int8)(*((_BYTE *)&v20 + kk) * *(_BYTE *)(54 * i + v25 + mm + 48))) >> 8)
- 1)
* v18;
v9 = v24++;
*v9 = v8;
}
}
}
return result;
}
| dequantize_row_tq1_0:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,0x100
CQO
IDIV RCX
CMP RDX,0x0
JNZ 0x0017823d
JMP 0x0017825c
LAB_0017823d:
LEA RDI,[0x1c1144]
LEA RSI,[0x1c0d5c]
MOV EDX,0x85a
LEA RCX,[0x1c1518]
CALL 0x00144810
LAB_0017825c:
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,0x100
CQO
IDIV RCX
MOV qword ptr [RBP + -0x20],RAX
MOV EAX,dword ptr [0x001b646c]
MOV dword ptr [RBP + -0x26],EAX
MOV AX,word ptr [0x001b6470]
MOV word ptr [RBP + -0x22],AX
MOV qword ptr [RBP + -0x30],0x0
LAB_0017828a:
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x20]
JGE 0x00178506
MOV RAX,qword ptr [RBP + -0x8]
IMUL RCX,qword ptr [RBP + -0x30],0x36
ADD RAX,RCX
MOVZX EDI,word ptr [RAX + 0x34]
CALL 0x0016e6e0
MOVSS dword ptr [RBP + -0x34],XMM0
MOV qword ptr [RBP + -0x40],0x0
LAB_001782ba:
CMP qword ptr [RBP + -0x40],0x20
JNC 0x00178376
MOV qword ptr [RBP + -0x48],0x0
LAB_001782cd:
CMP qword ptr [RBP + -0x48],0x5
JNC 0x00178363
MOV qword ptr [RBP + -0x50],0x0
LAB_001782e0:
CMP qword ptr [RBP + -0x50],0x20
JNC 0x00178350
MOV RAX,qword ptr [RBP + -0x8]
IMUL RCX,qword ptr [RBP + -0x30],0x36
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x40]
ADD RCX,qword ptr [RBP + -0x50]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV RCX,qword ptr [RBP + -0x48]
MOVZX ECX,byte ptr [RBP + RCX*0x1 + -0x26]
IMUL EAX,ECX
MOV byte ptr [RBP + -0x51],AL
MOVZX EAX,byte ptr [RBP + -0x51]
MOVZX EAX,AX
IMUL EAX,EAX,0x3
SAR EAX,0x8
MOV word ptr [RBP + -0x54],AX
MOVSX EAX,word ptr [RBP + -0x54]
SUB EAX,0x1
CVTSI2SS XMM0,EAX
MULSS XMM0,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RBP + -0x10],RCX
MOVSS dword ptr [RAX],XMM0
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x1
MOV qword ptr [RBP + -0x50],RAX
JMP 0x001782e0
LAB_00178350:
JMP 0x00178352
LAB_00178352:
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,0x1
MOV qword ptr [RBP + -0x48],RAX
JMP 0x001782cd
LAB_00178363:
JMP 0x00178365
LAB_00178365:
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x20
MOV qword ptr [RBP + -0x40],RAX
JMP 0x001782ba
LAB_00178376:
MOV qword ptr [RBP + -0x60],0x20
LAB_0017837e:
CMP qword ptr [RBP + -0x60],0x30
JNC 0x0017843a
MOV qword ptr [RBP + -0x68],0x0
LAB_00178391:
CMP qword ptr [RBP + -0x68],0x5
JNC 0x00178427
MOV qword ptr [RBP + -0x70],0x0
LAB_001783a4:
CMP qword ptr [RBP + -0x70],0x10
JNC 0x00178414
MOV RAX,qword ptr [RBP + -0x8]
IMUL RCX,qword ptr [RBP + -0x30],0x36
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x60]
ADD RCX,qword ptr [RBP + -0x70]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV RCX,qword ptr [RBP + -0x68]
MOVZX ECX,byte ptr [RBP + RCX*0x1 + -0x26]
IMUL EAX,ECX
MOV byte ptr [RBP + -0x71],AL
MOVZX EAX,byte ptr [RBP + -0x71]
MOVZX EAX,AX
IMUL EAX,EAX,0x3
SAR EAX,0x8
MOV word ptr [RBP + -0x74],AX
MOVSX EAX,word ptr [RBP + -0x74]
SUB EAX,0x1
CVTSI2SS XMM0,EAX
MULSS XMM0,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RBP + -0x10],RCX
MOVSS dword ptr [RAX],XMM0
MOV RAX,qword ptr [RBP + -0x70]
ADD RAX,0x1
MOV qword ptr [RBP + -0x70],RAX
JMP 0x001783a4
LAB_00178414:
JMP 0x00178416
LAB_00178416:
MOV RAX,qword ptr [RBP + -0x68]
ADD RAX,0x1
MOV qword ptr [RBP + -0x68],RAX
JMP 0x00178391
LAB_00178427:
JMP 0x00178429
LAB_00178429:
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x10
MOV qword ptr [RBP + -0x60],RAX
JMP 0x0017837e
LAB_0017843a:
MOV qword ptr [RBP + -0x80],0x0
LAB_00178442:
CMP qword ptr [RBP + -0x80],0x4
JNC 0x001784f3
MOV qword ptr [RBP + -0x88],0x0
LAB_00178458:
CMP qword ptr [RBP + -0x88],0x4
JNC 0x001784e0
MOV RAX,qword ptr [RBP + -0x8]
IMUL RCX,qword ptr [RBP + -0x30],0x36
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x88]
MOVZX EAX,byte ptr [RAX + RCX*0x1 + 0x30]
MOV RCX,qword ptr [RBP + -0x80]
MOVZX ECX,byte ptr [RBP + RCX*0x1 + -0x26]
IMUL EAX,ECX
MOV byte ptr [RBP + -0x89],AL
MOVZX EAX,byte ptr [RBP + -0x89]
MOVZX EAX,AX
IMUL EAX,EAX,0x3
SAR EAX,0x8
MOV word ptr [RBP + -0x8c],AX
MOVSX EAX,word ptr [RBP + -0x8c]
SUB EAX,0x1
CVTSI2SS XMM0,EAX
MULSS XMM0,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RBP + -0x10],RCX
MOVSS dword ptr [RAX],XMM0
MOV RAX,qword ptr [RBP + -0x88]
ADD RAX,0x1
MOV qword ptr [RBP + -0x88],RAX
JMP 0x00178458
LAB_001784e0:
JMP 0x001784e2
LAB_001784e2:
MOV RAX,qword ptr [RBP + -0x80]
ADD RAX,0x1
MOV qword ptr [RBP + -0x80],RAX
JMP 0x00178442
LAB_001784f3:
JMP 0x001784f5
LAB_001784f5:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0017828a
LAB_00178506:
ADD RSP,0x90
POP RBP
RET
|
void dequantize_row_tq1_0(long param_1,float *param_2,long param_3)
{
float fVar1;
ulong local_90;
ulong local_88;
ulong local_78;
ulong local_70;
ulong local_68;
ulong local_58;
ulong local_50;
ulong local_48;
long local_38;
int4 local_2e;
int2 local_2a;
long local_28;
long local_20;
float *local_18;
long local_10;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
if (param_3 % 0x100 == 0) {
local_28 = param_3 / 0x100;
local_2e = DAT_001b646c;
local_2a = DAT_001b6470;
for (local_38 = 0; local_38 < local_28; local_38 = local_38 + 1) {
fVar1 = (float)ggml_lookup_fp16_to_fp32(*(int2 *)(local_10 + local_38 * 0x36 + 0x34));
for (local_48 = 0; local_48 < 0x20; local_48 = local_48 + 0x20) {
for (local_50 = 0; local_50 < 5; local_50 = local_50 + 1) {
for (local_58 = 0; local_58 < 0x20; local_58 = local_58 + 1) {
*local_18 = (float)((short)((uint)(byte)(*(char *)(local_10 + local_38 * 0x36 +
local_48 + local_58) *
*(char *)((long)&local_2e + local_50)) * 3 >> 8)
+ -1) * fVar1;
local_18 = local_18 + 1;
}
}
}
for (local_68 = 0x20; local_68 < 0x30; local_68 = local_68 + 0x10) {
for (local_70 = 0; local_70 < 5; local_70 = local_70 + 1) {
for (local_78 = 0; local_78 < 0x10; local_78 = local_78 + 1) {
*local_18 = (float)((short)((uint)(byte)(*(char *)(local_10 + local_38 * 0x36 +
local_68 + local_78) *
*(char *)((long)&local_2e + local_70)) * 3 >> 8)
+ -1) * fVar1;
local_18 = local_18 + 1;
}
}
}
for (local_88 = 0; local_88 < 4; local_88 = local_88 + 1) {
for (local_90 = 0; local_90 < 4; local_90 = local_90 + 1) {
*local_18 = (float)((short)((uint)(byte)(*(char *)(local_10 + local_38 * 0x36 + 0x30 +
local_90) *
*(char *)((long)&local_2e + local_88)) * 3 >> 8) +
-1) * fVar1;
local_18 = local_18 + 1;
}
}
}
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("k % QK_K == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c"
,0x85a,
"void dequantize_row_tq1_0(const block_tq1_0 *restrict, float *restrict, int64_t)");
}
| |
44,851 | free_root | eloqsql/mysys/my_alloc.c | void free_root(MEM_ROOT *root, myf MyFlags)
{
reg1 USED_MEM *next,*old;
DBUG_ENTER("free_root");
DBUG_PRINT("enter",("root: %p flags: %lu", root, MyFlags));
#if !(defined(HAVE_valgrind) && defined(EXTRA_DEBUG))
/*
There is no point in using mark_blocks_free when using valgrind as
it will not reclaim any memory
*/
if (MyFlags & MY_MARK_BLOCKS_FREE)
{
mark_blocks_free(root);
DBUG_VOID_RETURN;
}
#endif
if (!(MyFlags & MY_KEEP_PREALLOC))
root->pre_alloc=0;
for (next=root->used; next ;)
{
old=next; next= next->next ;
if (old != root->pre_alloc)
my_free(old);
}
for (next=root->free ; next ;)
{
old=next; next= next->next;
if (old != root->pre_alloc)
my_free(old);
}
root->used=root->free=0;
if (root->pre_alloc)
{
root->free=root->pre_alloc;
root->free->left=root->pre_alloc->size-ALIGN_SIZE(sizeof(USED_MEM));
TRASH_MEM(root->pre_alloc);
root->free->next=0;
}
root->block_num= 4;
root->first_block_usage= 0;
DBUG_VOID_RETURN;
} | O0 | c | free_root:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x33fd2
movq -0x10(%rbp), %rax
andq $0x2, %rax
cmpq $0x0, %rax
je 0x33fee
movq -0x8(%rbp), %rdi
callq 0x34110
jmp 0x340fd
movq -0x10(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x34008
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x34047
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x34045
movq -0x20(%rbp), %rdi
callq 0x2f830
jmp 0x34014
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x34085
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x34083
movq -0x20(%rbp), %rdi
callq 0x2f830
jmp 0x34052
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x340e5
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rcx
subq $0x18, %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x340d3
jmp 0x340d5
jmp 0x340d7
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x4, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x2c(%rax)
jmp 0x340fd
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| free_root:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
jmp short $+2
loc_33FD2:
mov rax, [rbp+var_10]
and rax, 2
cmp rax, 0
jz short loc_33FEE
mov rdi, [rbp+var_8]
call mark_blocks_free
jmp loc_340FD
loc_33FEE:
mov rax, [rbp+var_10]
and rax, 1
cmp rax, 0
jnz short loc_34008
mov rax, [rbp+var_8]
mov qword ptr [rax+10h], 0
loc_34008:
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov [rbp+var_18], rax
loc_34014:
cmp [rbp+var_18], 0
jz short loc_34047
mov rax, [rbp+var_18]
mov [rbp+var_20], rax
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_18], rax
mov rax, [rbp+var_20]
mov rcx, [rbp+var_8]
cmp rax, [rcx+10h]
jz short loc_34045
mov rdi, [rbp+var_20]
call my_free
loc_34045:
jmp short loc_34014
loc_34047:
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_18], rax
loc_34052:
cmp [rbp+var_18], 0
jz short loc_34085
mov rax, [rbp+var_18]
mov [rbp+var_20], rax
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_18], rax
mov rax, [rbp+var_20]
mov rcx, [rbp+var_8]
cmp rax, [rcx+10h]
jz short loc_34083
mov rdi, [rbp+var_20]
call my_free
loc_34083:
jmp short loc_34052
loc_34085:
mov rax, [rbp+var_8]
mov qword ptr [rax], 0
mov rax, [rbp+var_8]
mov qword ptr [rax+8], 0
mov rax, [rbp+var_8]
cmp qword ptr [rax+10h], 0
jz short loc_340E5
mov rax, [rbp+var_8]
mov rcx, [rax+10h]
mov rax, [rbp+var_8]
mov [rax], rcx
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov rcx, [rax+10h]
sub rcx, 18h
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rax+8], rcx
jmp short $+2
loc_340D3:
jmp short $+2
loc_340D5:
jmp short $+2
loc_340D7:
mov rax, [rbp+var_8]
mov rax, [rax]
mov qword ptr [rax], 0
loc_340E5:
mov rax, [rbp+var_8]
mov dword ptr [rax+28h], 4
mov rax, [rbp+var_8]
mov dword ptr [rax+2Ch], 0
jmp short $+2
loc_340FD:
add rsp, 20h
pop rbp
retn
| long long free_root(long long a1, char a2)
{
long long result; // rax
long long v3; // [rsp+0h] [rbp-20h]
long long v4; // [rsp+0h] [rbp-20h]
_QWORD *v5; // [rsp+8h] [rbp-18h]
_QWORD *v6; // [rsp+8h] [rbp-18h]
if ( (a2 & 2) != 0 )
return mark_blocks_free(a1);
if ( (a2 & 1) == 0 )
*(_QWORD *)(a1 + 16) = 0LL;
v5 = *(_QWORD **)(a1 + 8);
while ( v5 )
{
v3 = (long long)v5;
v5 = (_QWORD *)*v5;
if ( v3 != *(_QWORD *)(a1 + 16) )
my_free(v3);
}
v6 = *(_QWORD **)a1;
while ( v6 )
{
v4 = (long long)v6;
v6 = (_QWORD *)*v6;
if ( v4 != *(_QWORD *)(a1 + 16) )
my_free(v4);
}
*(_QWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 8) = 0LL;
if ( *(_QWORD *)(a1 + 16) )
{
*(_QWORD *)a1 = *(_QWORD *)(a1 + 16);
*(_QWORD *)(*(_QWORD *)a1 + 8LL) = *(_QWORD *)(*(_QWORD *)(a1 + 16) + 16LL) - 24LL;
**(_QWORD **)a1 = 0LL;
}
*(_DWORD *)(a1 + 40) = 4;
result = a1;
*(_DWORD *)(a1 + 44) = 0;
return result;
}
| free_root:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
JMP 0x00133fd2
LAB_00133fd2:
MOV RAX,qword ptr [RBP + -0x10]
AND RAX,0x2
CMP RAX,0x0
JZ 0x00133fee
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00134110
JMP 0x001340fd
LAB_00133fee:
MOV RAX,qword ptr [RBP + -0x10]
AND RAX,0x1
CMP RAX,0x0
JNZ 0x00134008
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x10],0x0
LAB_00134008:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x18],RAX
LAB_00134014:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00134047
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RCX + 0x10]
JZ 0x00134045
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x0012f830
LAB_00134045:
JMP 0x00134014
LAB_00134047:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
LAB_00134052:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00134085
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RCX + 0x10]
JZ 0x00134083
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x0012f830
LAB_00134083:
JMP 0x00134052
LAB_00134085:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x8],0x0
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x10],0x0
JZ 0x001340e5
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RAX + 0x10]
SUB RCX,0x18
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x001340d3
LAB_001340d3:
JMP 0x001340d5
LAB_001340d5:
JMP 0x001340d7
LAB_001340d7:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX],0x0
LAB_001340e5:
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x28],0x4
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x2c],0x0
JMP 0x001340fd
LAB_001340fd:
ADD RSP,0x20
POP RBP
RET
|
void free_root(long *param_1,ulong param_2)
{
int8 *puVar1;
int8 *local_20;
if ((param_2 & 2) == 0) {
if ((param_2 & 1) == 0) {
param_1[2] = 0;
}
puVar1 = (int8 *)param_1[1];
while (local_20 = puVar1, local_20 != (int8 *)0x0) {
puVar1 = (int8 *)*local_20;
if (local_20 != (int8 *)param_1[2]) {
my_free(local_20);
}
}
puVar1 = (int8 *)*param_1;
while (local_20 = puVar1, local_20 != (int8 *)0x0) {
puVar1 = (int8 *)*local_20;
if (local_20 != (int8 *)param_1[2]) {
my_free(local_20);
}
}
*param_1 = 0;
param_1[1] = 0;
if (param_1[2] != 0) {
*param_1 = param_1[2];
*(long *)(*param_1 + 8) = *(long *)(param_1[2] + 0x10) + -0x18;
*(int8 *)*param_1 = 0;
}
*(int4 *)(param_1 + 5) = 4;
*(int4 *)((long)param_1 + 0x2c) = 0;
}
else {
mark_blocks_free(param_1);
}
return;
}
| |
44,852 | nlohmann::json_abi_v3_11_3::detail::serializer<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>>::serializer(std::shared_ptr<nlohmann::json_abi_v3_11_3::detail::output_adapter_protocol<char>>, char, nlohmann::json_abi_v3_11_3::detail::error_handler_t) | monkey531[P]llama/common/./json.hpp | serializer(output_adapter_t<char> s, const char ichar,
error_handler_t error_handler_ = error_handler_t::strict)
: o(std::move(s))
, loc(std::localeconv())
, thousands_sep(loc->thousands_sep == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->thousands_sep)))
, decimal_point(loc->decimal_point == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->decimal_point)))
, indent_char(ichar)
, indent_string(512, indent_char)
, error_handler(error_handler_)
{} | O2 | cpp | nlohmann::json_abi_v3_11_3::detail::serializer<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>>::serializer(std::shared_ptr<nlohmann::json_abi_v3_11_3::detail::output_adapter_protocol<char>>, char, nlohmann::json_abi_v3_11_3::detail::error_handler_t):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movq %rdi, %r14
andq $0x0, 0x8(%rdi)
movups (%rsi), %xmm0
andq $0x0, 0x8(%rsi)
movups %xmm0, (%rdi)
andq $0x0, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
callq 0x20ce0
movq %rax, 0x50(%r14)
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x5c95d
movb (%rcx), %cl
jmp 0x5c95f
xorl %ecx, %ecx
movb %cl, 0x58(%r14)
movq (%rax), %rax
testq %rax, %rax
je 0x5c96f
movb (%rax), %al
jmp 0x5c971
xorl %eax, %eax
leaq 0x8(%r14), %r15
movb %al, 0x59(%r14)
leaq 0x5a(%r14), %rdi
movl $0x200, %edx # imm = 0x200
xorl %esi, %esi
callq 0x20400
movb %bpl, 0x25a(%r14)
leaq 0x260(%r14), %rdi
leaq 0x270(%r14), %rax
movq %rax, 0x260(%r14)
movsbl %bpl, %edx
movl $0x200, %esi # imm = 0x200
callq 0x207b0
movl %ebx, 0x280(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x2eeb2
movq %rbx, %rdi
callq 0x20b90
| _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEC2ESt10shared_ptrINS1_23output_adapter_protocolIcEEEcNS1_15error_handler_tE:
push rbp
push r15
push r14
push rbx
push rax
mov ebx, ecx
mov ebp, edx
mov r14, rdi
and qword ptr [rdi+8], 0
movups xmm0, xmmword ptr [rsi]
and qword ptr [rsi+8], 0
movups xmmword ptr [rdi], xmm0
and qword ptr [rsi], 0
xorps xmm0, xmm0
movups xmmword ptr [rdi+40h], xmm0
movups xmmword ptr [rdi+30h], xmm0
movups xmmword ptr [rdi+20h], xmm0
movups xmmword ptr [rdi+10h], xmm0
call _localeconv
mov [r14+50h], rax
mov rcx, [rax+8]
test rcx, rcx
jz short loc_5C95D
mov cl, [rcx]
jmp short loc_5C95F
loc_5C95D:
xor ecx, ecx
loc_5C95F:
mov [r14+58h], cl
mov rax, [rax]
test rax, rax
jz short loc_5C96F
mov al, [rax]
jmp short loc_5C971
loc_5C96F:
xor eax, eax
loc_5C971:
lea r15, [r14+8]
mov [r14+59h], al
lea rdi, [r14+5Ah]
mov edx, 200h
xor esi, esi
call _memset
mov [r14+25Ah], bpl
lea rdi, [r14+260h]
lea rax, [r14+270h]
mov [r14+260h], rax
movsx edx, bpl
mov esi, 200h
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
mov [r14+280h], ebx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, r15
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, rbx
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::serializer<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>>::serializer(
long long a1,
__int128 *a2,
char a3,
int a4)
{
__int128 v6; // xmm0
long long v7; // rax
char *v8; // rcx
char v9; // cl
char *v10; // rax
char v11; // al
long long result; // rax
*(_QWORD *)(a1 + 8) = 0LL;
v6 = *a2;
*((_QWORD *)a2 + 1) = 0LL;
*(_OWORD *)a1 = v6;
*(_QWORD *)a2 = 0LL;
*(_OWORD *)(a1 + 64) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 16) = 0LL;
v7 = localeconv(a1);
*(_QWORD *)(a1 + 80) = v7;
v8 = *(char **)(v7 + 8);
if ( v8 )
v9 = *v8;
else
v9 = 0;
*(_BYTE *)(a1 + 88) = v9;
v10 = *(char **)v7;
if ( v10 )
v11 = *v10;
else
v11 = 0;
*(_BYTE *)(a1 + 89) = v11;
memset(a1 + 90, 0LL, 512LL);
*(_BYTE *)(a1 + 602) = a3;
*(_QWORD *)(a1 + 608) = a1 + 624;
result = std::string::_M_construct(a1 + 608, 512LL, (unsigned int)a3);
*(_DWORD *)(a1 + 640) = a4;
return result;
}
| serializer:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EBX,ECX
MOV EBP,EDX
MOV R14,RDI
AND qword ptr [RDI + 0x8],0x0
MOVUPS XMM0,xmmword ptr [RSI]
AND qword ptr [RSI + 0x8],0x0
MOVUPS xmmword ptr [RDI],XMM0
AND qword ptr [RSI],0x0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x40],XMM0
MOVUPS xmmword ptr [RDI + 0x30],XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
CALL 0x00120ce0
MOV qword ptr [R14 + 0x50],RAX
MOV RCX,qword ptr [RAX + 0x8]
TEST RCX,RCX
JZ 0x0015c95d
MOV CL,byte ptr [RCX]
JMP 0x0015c95f
LAB_0015c95d:
XOR ECX,ECX
LAB_0015c95f:
MOV byte ptr [R14 + 0x58],CL
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x0015c96f
MOV AL,byte ptr [RAX]
JMP 0x0015c971
LAB_0015c96f:
XOR EAX,EAX
LAB_0015c971:
LEA R15,[R14 + 0x8]
MOV byte ptr [R14 + 0x59],AL
LEA RDI,[R14 + 0x5a]
MOV EDX,0x200
XOR ESI,ESI
CALL 0x00120400
MOV byte ptr [R14 + 0x25a],BPL
LEA RDI,[R14 + 0x260]
LEA RAX,[R14 + 0x270]
MOV qword ptr [R14 + 0x260],RAX
LAB_0015c9a5:
MOVSX EDX,BPL
MOV ESI,0x200
CALL 0x001207b0
LAB_0015c9b3:
MOV dword ptr [R14 + 0x280],EBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::detail::serializer<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>
>::serializer(std::shared_ptr<nlohmann::json_abi_v3_11_3::detail::output_adapter_protocol<char>
>, char, nlohmann::json_abi_v3_11_3::detail::error_handler_t) */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
serializer<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>>
::serializer(serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this,int8 *param_2,
serializer<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_3,int4 param_4)
{
int8 uVar1;
lconv *plVar2;
serializer<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>>
sVar3;
*(int8 *)(this + 8) = 0;
uVar1 = param_2[1];
param_2[1] = 0;
*(int8 *)this = *param_2;
*(int8 *)(this + 8) = uVar1;
*param_2 = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
plVar2 = localeconv();
*(lconv **)(this + 0x50) = plVar2;
if ((serializer<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>>
*)plVar2->thousands_sep ==
(serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)0x0) {
sVar3 = (serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
)0x0;
}
else {
sVar3 = *(serializer<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>>
*)plVar2->thousands_sep;
}
this[0x58] = sVar3;
if ((serializer<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>>
*)plVar2->decimal_point ==
(serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)0x0) {
sVar3 = (serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
)0x0;
}
else {
sVar3 = *(serializer<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>>
*)plVar2->decimal_point;
}
this[0x59] = sVar3;
memset(this + 0x5a,0,0x200);
this[0x25a] = param_3;
*(serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
**)(this + 0x260) = this + 0x270;
/* try { // try from 0015c9a5 to 0015c9b2 has its CatchHandler @ 0015c9c5 */
std::__cxx11::string::_M_construct((ulong)(this + 0x260),'\0');
*(int4 *)(this + 0x280) = param_4;
return;
}
| |
44,853 | common_arg::get_value_from_env(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | monkey531[P]llama/common/arg.cpp | bool common_arg::get_value_from_env(std::string & output) {
if (env == nullptr) return false;
char * value = std::getenv(env);
if (value) {
output = value;
return true;
}
return false;
} | O0 | cpp | common_arg::get_value_from_env(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&):
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x88(%rax)
jne 0xa2d78
movb $0x0, 0x27(%rsp)
jmp 0xa2db0
movq (%rsp), %rax
movq 0x88(%rax), %rdi
callq 0x5eda0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xa2dab
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x5e6f0
movb $0x1, 0x27(%rsp)
jmp 0xa2db0
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
| _ZN10common_arg18get_value_from_envERNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov [rsp+28h+var_18], rsi
mov rax, [rsp+28h+var_10]
mov [rsp+28h+var_28], rax
cmp qword ptr [rax+88h], 0
jnz short loc_A2D78
mov [rsp+28h+var_1], 0
jmp short loc_A2DB0
loc_A2D78:
mov rax, [rsp+28h+var_28]
mov rdi, [rax+88h]
call _getenv
mov [rsp+28h+var_20], rax
cmp [rsp+28h+var_20], 0
jz short loc_A2DAB
mov rsi, [rsp+28h+var_20]
mov rdi, [rsp+28h+var_18]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc; std::string::operator=(char const*)
mov [rsp+28h+var_1], 1
jmp short loc_A2DB0
loc_A2DAB:
mov [rsp+28h+var_1], 0
loc_A2DB0:
mov al, [rsp+28h+var_1]
and al, 1
add rsp, 28h
retn
| char common_arg::get_value_from_env(long long a1, long long a2)
{
long long v3; // [rsp+8h] [rbp-20h]
if ( !*(_QWORD *)(a1 + 136) )
return 0;
v3 = getenv(*(_QWORD *)(a1 + 136));
if ( !v3 )
return 0;
std::string::operator=(a2, v3);
return 1;
}
| get_value_from_env:
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
MOV qword ptr [RSP + 0x10],RSI
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP],RAX
CMP qword ptr [RAX + 0x88],0x0
JNZ 0x001a2d78
MOV byte ptr [RSP + 0x27],0x0
JMP 0x001a2db0
LAB_001a2d78:
MOV RAX,qword ptr [RSP]
MOV RDI,qword ptr [RAX + 0x88]
CALL 0x0015eda0
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x8],0x0
JZ 0x001a2dab
MOV RSI,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x0015e6f0
MOV byte ptr [RSP + 0x27],0x1
JMP 0x001a2db0
LAB_001a2dab:
MOV byte ptr [RSP + 0x27],0x0
LAB_001a2db0:
MOV AL,byte ptr [RSP + 0x27]
AND AL,0x1
ADD RSP,0x28
RET
|
/* common_arg::get_value_from_env(std::__cxx11::string&) */
int1 __thiscall common_arg::get_value_from_env(common_arg *this,string *param_1)
{
char *pcVar1;
int1 local_1;
if (*(long *)(this + 0x88) == 0) {
local_1 = 0;
}
else {
pcVar1 = getenv(*(char **)(this + 0x88));
if (pcVar1 == (char *)0x0) {
local_1 = 0;
}
else {
std::__cxx11::string::operator=(param_1,pcVar1);
local_1 = 1;
}
}
return local_1;
}
| |
44,854 | common_arg::get_value_from_env(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | monkey531[P]llama/common/arg.cpp | bool common_arg::get_value_from_env(std::string & output) {
if (env == nullptr) return false;
char * value = std::getenv(env);
if (value) {
output = value;
return true;
}
return false;
} | O2 | cpp | common_arg::get_value_from_env(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&):
movq 0x88(%rdi), %rdi
testq %rdi, %rdi
je 0x38d95
pushq %rbx
movq %rsi, %rbx
callq 0x24ae0
testq %rax, %rax
je 0x38d98
movq %rbx, %rdi
movq %rax, %rsi
callq 0x25170
movb $0x1, %al
jmp 0x38d9a
xorl %eax, %eax
retq
xorl %eax, %eax
popq %rbx
retq
| _ZN10common_arg18get_value_from_envERNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
mov rdi, [rdi+88h]
test rdi, rdi
jz short loc_38D95
push rbx
mov rbx, rsi
call _getenv
test rax, rax
jz short loc_38D98
mov rdi, rbx
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6assignEPKc; std::string::assign(char const*)
mov al, 1
jmp short loc_38D9A
loc_38D95:
xor eax, eax
retn
loc_38D98:
xor eax, eax
loc_38D9A:
pop rbx
retn
| char common_arg::get_value_from_env(long long a1, long long a2)
{
long long v2; // rax
if ( !*(_QWORD *)(a1 + 136) )
return 0;
v2 = getenv();
if ( !v2 )
return 0;
std::string::assign(a2, v2);
return 1;
}
| get_value_from_env:
MOV RDI,qword ptr [RDI + 0x88]
TEST RDI,RDI
JZ 0x00138d95
PUSH RBX
MOV RBX,RSI
CALL 0x00124ae0
TEST RAX,RAX
JZ 0x00138d98
MOV RDI,RBX
MOV RSI,RAX
CALL 0x00125170
MOV AL,0x1
JMP 0x00138d9a
LAB_00138d95:
XOR EAX,EAX
RET
LAB_00138d98:
XOR EAX,EAX
LAB_00138d9a:
POP RBX
RET
|
/* common_arg::get_value_from_env(std::__cxx11::string&) */
bool __thiscall common_arg::get_value_from_env(common_arg *this,string *param_1)
{
char *pcVar1;
if (*(char **)(this + 0x88) == (char *)0x0) {
return false;
}
pcVar1 = getenv(*(char **)(this + 0x88));
if (pcVar1 != (char *)0x0) {
std::__cxx11::string::assign((char *)param_1);
}
return pcVar1 != (char *)0x0;
}
| |
44,855 | common_arg::get_value_from_env(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | monkey531[P]llama/common/arg.cpp | bool common_arg::get_value_from_env(std::string & output) {
if (env == nullptr) return false;
char * value = std::getenv(env);
if (value) {
output = value;
return true;
}
return false;
} | O3 | cpp | common_arg::get_value_from_env(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&):
movq 0x88(%rdi), %rdi
testq %rdi, %rdi
je 0x35854
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
callq 0x1bac0
testq %rax, %rax
je 0x35857
movq %rax, %r14
movq 0x8(%rbx), %r15
movq %rax, %rdi
callq 0x1b3f0
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x1bdc0
movb $0x1, %al
jmp 0x35859
xorl %eax, %eax
retq
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
| _ZN10common_arg18get_value_from_envERNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
mov rdi, [rdi+88h]
test rdi, rdi
jz short loc_35854
push r15
push r14
push rbx
mov rbx, rsi
call _getenv
test rax, rax
jz short loc_35857
mov r14, rax
mov r15, [rbx+8]
mov rdi, rax
call _strlen
mov rdi, rbx
xor esi, esi
mov rdx, r15
mov rcx, r14
mov r8, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
mov al, 1
jmp short loc_35859
loc_35854:
xor eax, eax
retn
loc_35857:
xor eax, eax
loc_35859:
pop rbx
pop r14
pop r15
retn
| char common_arg::get_value_from_env(long long a1, long long a2)
{
long long v2; // rax
long long v3; // r14
long long v4; // r15
long long v5; // rax
if ( !*(_QWORD *)(a1 + 136) )
return 0;
v2 = getenv();
if ( !v2 )
return 0;
v3 = v2;
v4 = *(_QWORD *)(a2 + 8);
v5 = strlen(v2);
std::string::_M_replace(a2, 0LL, v4, v3, v5);
return 1;
}
| get_value_from_env:
MOV RDI,qword ptr [RDI + 0x88]
TEST RDI,RDI
JZ 0x00135854
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RSI
CALL 0x0011bac0
TEST RAX,RAX
JZ 0x00135857
MOV R14,RAX
MOV R15,qword ptr [RBX + 0x8]
MOV RDI,RAX
CALL 0x0011b3f0
MOV RDI,RBX
XOR ESI,ESI
MOV RDX,R15
MOV RCX,R14
MOV R8,RAX
CALL 0x0011bdc0
MOV AL,0x1
JMP 0x00135859
LAB_00135854:
XOR EAX,EAX
RET
LAB_00135857:
XOR EAX,EAX
LAB_00135859:
POP RBX
POP R14
POP R15
RET
|
/* common_arg::get_value_from_env(std::__cxx11::string&) */
bool __thiscall common_arg::get_value_from_env(common_arg *this,string *param_1)
{
char *pcVar1;
char *__s;
if (*(char **)(this + 0x88) == (char *)0x0) {
return false;
}
__s = getenv(*(char **)(this + 0x88));
if (__s != (char *)0x0) {
pcVar1 = *(char **)(param_1 + 8);
strlen(__s);
std::__cxx11::string::_M_replace((ulong)param_1,0,pcVar1,(ulong)__s);
}
return __s != (char *)0x0;
}
| |
44,856 | common_init()::$_0::__invoke(ggml_log_level, char const*, void*) | monkey531[P]llama/common/common.cpp | void common_init() {
llama_log_set([](ggml_log_level level, const char * text, void * /*user_data*/) {
if (LOG_DEFAULT_LLAMA <= common_log_verbosity_thold) {
common_log_add(common_log_main(), level, "%s", text);
}
}, NULL);
#ifdef NDEBUG
const char * build_type = "";
#else
const char * build_type = " (debug)";
#endif
LOG_INF("build: %d (%s) with %s for %s%s\n", LLAMA_BUILD_NUMBER, LLAMA_COMMIT, LLAMA_COMPILER, LLAMA_BUILD_TARGET, build_type);
} | O2 | cpp | common_init()::$_0::__invoke(ggml_log_level, char const*, void*):
leaq 0x8e041(%rip), %rax # 0xdb260
cmpl $0x0, (%rax)
js 0x4d24d
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
callq 0x76516
leaq 0x48966(%rip), %rdx # 0x95b9e
movq %rax, %rdi
movl %ebp, %esi
movq %rbx, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x765ae
retq
| _ZZ11common_initvEN3$_08__invokeE14ggml_log_levelPKcPv:
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js short locret_4D24D
push rbp
push rbx
push rax
mov rbx, rsi
mov ebp, edi
call _Z15common_log_mainv; common_log_main(void)
lea rdx, aS+1; "%s"
mov rdi, rax
mov esi, ebp
mov rcx, rbx
xor eax, eax
add rsp, 8
pop rbx
pop rbp
jmp _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
locret_4D24D:
retn
| void * common_init(void)::$_0::__invoke(int a1, int a2)
{
void *result; // rax
int v3; // eax
int v4; // r8d
int v5; // r9d
result = &common_log_verbosity_thold;
if ( common_log_verbosity_thold >= 0 )
{
v3 = common_log_main();
return (void *)common_log_add(v3, a1, (unsigned int)"%s", a2, v4, v5);
}
return result;
}
| __invoke:
LEA RAX,[0x1db260]
CMP dword ptr [RAX],0x0
JS 0x0014d24d
PUSH RBP
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV EBP,EDI
CALL 0x00176516
LEA RDX,[0x195b9e]
MOV RDI,RAX
MOV ESI,EBP
MOV RCX,RBX
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x001765ae
LAB_0014d24d:
RET
|
/* __invoke(ggml_log_level, char const*, void*) */
void common_init()::$_0::__invoke(int4 param_1,int8 param_2)
{
int8 uVar1;
if (-1 < common_log_verbosity_thold) {
uVar1 = common_log_main();
common_log_add(uVar1,param_1,&DAT_00195b9e,param_2);
return;
}
return;
}
| |
44,857 | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::append_exponent(char*, int) | monkey531[P]llama/common/json.hpp | inline char* append_exponent(char* buf, int e)
{
JSON_ASSERT(e > -1000);
JSON_ASSERT(e < 1000);
if (e < 0)
{
e = -e;
*buf++ = '-';
}
else
{
*buf++ = '+';
}
auto k = static_cast<std::uint32_t>(e);
if (k < 10)
{
// Always print at least two digits in the exponent.
// This is for compatibility with printf("%g").
*buf++ = '0';
*buf++ = static_cast<char>('0' + k);
}
else if (k < 100)
{
*buf++ = static_cast<char>('0' + k / 10);
k %= 10;
*buf++ = static_cast<char>('0' + k);
}
else
{
*buf++ = static_cast<char>('0' + k / 100);
k %= 100;
*buf++ = static_cast<char>('0' + k / 10);
k %= 10;
*buf++ = static_cast<char>('0' + k);
}
return buf;
} | O2 | cpp | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::append_exponent(char*, int):
pushq %rax
cmpl $0xfffffc18, %esi # imm = 0xFFFFFC18
jle 0x87a04
cmpl $0x3e8, %esi # imm = 0x3E8
jge 0x87a20
movl %esi, %ecx
shrl $0x1f, %ecx
addb %cl, %cl
addb $0x2b, %cl
movl %esi, %eax
negl %eax
cmovsl %esi, %eax
movb %cl, (%rdi)
cmpl $0x9, %eax
ja 0x879b2
leaq 0x2(%rdi), %rdx
movb $0x30, 0x1(%rdi)
jmp 0x879cd
cmpl $0x63, %eax
ja 0x879d1
movzbl %al, %eax
movb $0xa, %cl
divb %cl
movl %eax, %ecx
movzbl %ah, %eax
orb $0x30, %cl
leaq 0x2(%rdi), %rdx
movb %cl, 0x1(%rdi)
pushq $0x3
jmp 0x879f7
movw $0x64, %cx
xorl %edx, %edx
divw %cx
addb $0x30, %al
movb %al, 0x1(%rdi)
movzbl %dl, %eax
movb $0xa, %cl
divb %cl
movl %eax, %ecx
movzbl %ah, %eax
orb $0x30, %cl
leaq 0x3(%rdi), %rdx
movb %cl, 0x2(%rdi)
pushq $0x4
popq %rcx
orb $0x30, %al
addq %rcx, %rdi
movb %al, (%rdx)
movq %rdi, %rax
popq %rcx
retq
leaq 0x271d1(%rip), %rdi # 0xaebdc
leaq 0x27214(%rip), %rdx # 0xaec26
leaq 0x2cb9e(%rip), %rcx # 0xb45b7
movl $0x45ae, %esi # imm = 0x45AE
jmp 0x87a3a
leaq 0x271b5(%rip), %rdi # 0xaebdc
leaq 0x271f8(%rip), %rdx # 0xaec26
leaq 0x2cb8c(%rip), %rcx # 0xb45c1
movl $0x45af, %esi # imm = 0x45AF
xorl %eax, %eax
callq 0x23e40
nop
| _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl15append_exponentEPci:
push rax
cmp esi, 0FFFFFC18h
jle loc_87A04
cmp esi, 3E8h
jge loc_87A20
mov ecx, esi
shr ecx, 1Fh
add cl, cl
add cl, 2Bh ; '+'
mov eax, esi
neg eax
cmovs eax, esi
mov [rdi], cl
cmp eax, 9
ja short loc_879B2
lea rdx, [rdi+2]
mov byte ptr [rdi+1], 30h ; '0'
jmp short loc_879CD
loc_879B2:
cmp eax, 63h ; 'c'
ja short loc_879D1
movzx eax, al
mov cl, 0Ah
div cl
mov ecx, eax
movzx eax, ah
or cl, 30h
lea rdx, [rdi+2]
mov [rdi+1], cl
loc_879CD:
push 3
jmp short loc_879F7
loc_879D1:
mov cx, 64h ; 'd'
xor edx, edx
div cx
add al, 30h ; '0'
mov [rdi+1], al
movzx eax, dl
mov cl, 0Ah
div cl
mov ecx, eax
movzx eax, ah
or cl, 30h
lea rdx, [rdi+3]
mov [rdi+2], cl
push 4
loc_879F7:
pop rcx
or al, 30h
add rdi, rcx
mov [rdx], al
mov rax, rdi
pop rcx
retn
loc_87A04:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aE1000; "e > -1000"
mov esi, 45AEh
jmp short loc_87A3A
loc_87A20:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aE1000_0; "e < 1000"
mov esi, 45AFh
loc_87A3A:
xor eax, eax
call _ggml_abort
nop
| long long nlohmann::json_abi_v3_11_3::detail::dtoa_impl::append_exponent(
nlohmann::json_abi_v3_11_3::detail::dtoa_impl *this,
char *a2)
{
unsigned int v2; // eax
_BYTE *v3; // rdx
char v4; // cl
char v5; // cl
long long v7; // [rsp-10h] [rbp-10h]
if ( (int)a2 <= -1000 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17838LL,
"GGML_ASSERT(%s) failed",
"e > -1000");
}
else
{
if ( (int)a2 < 1000 )
{
v2 = -(int)a2;
if ( (int)a2 > 0 )
v2 = (unsigned int)a2;
*(_BYTE *)this = 2 * ((int)a2 < 0) + 43;
if ( v2 > 9 )
{
if ( v2 > 0x63 )
{
*((_BYTE *)this + 1) = (unsigned __int16)v2 / 0x64u + 48;
v5 = (unsigned __int16)v2 % 0x64u / 0xA;
LOBYTE(v2) = (unsigned __int16)v2 % 0x64u % 0xA;
v3 = (char *)this + 3;
*((_BYTE *)this + 2) = v5 | 0x30;
v7 = 4LL;
goto LABEL_11;
}
v4 = (unsigned __int8)v2 / 0xAu;
LOBYTE(v2) = (unsigned __int8)v2 % 0xAu;
v3 = (char *)this + 2;
*((_BYTE *)this + 1) = v4 | 0x30;
}
else
{
v3 = (char *)this + 2;
*((_BYTE *)this + 1) = 48;
}
v7 = 3LL;
LABEL_11:
*v3 = v2 | 0x30;
return (long long)this + v7;
}
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17839LL,
"GGML_ASSERT(%s) failed",
"e < 1000");
}
return nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)3>::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>>("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp");
}
| append_exponent:
PUSH RAX
CMP ESI,0xfffffc18
JLE 0x00187a04
CMP ESI,0x3e8
JGE 0x00187a20
MOV ECX,ESI
SHR ECX,0x1f
ADD CL,CL
ADD CL,0x2b
MOV EAX,ESI
NEG EAX
CMOVS EAX,ESI
MOV byte ptr [RDI],CL
CMP EAX,0x9
JA 0x001879b2
LEA RDX,[RDI + 0x2]
MOV byte ptr [RDI + 0x1],0x30
JMP 0x001879cd
LAB_001879b2:
CMP EAX,0x63
JA 0x001879d1
MOVZX EAX,AL
MOV CL,0xa
DIV CL
MOV ECX,EAX
MOVZX EAX,AH
OR CL,0x30
LEA RDX,[RDI + 0x2]
MOV byte ptr [RDI + 0x1],CL
LAB_001879cd:
PUSH 0x3
JMP 0x001879f7
LAB_001879d1:
MOV CX,0x64
XOR EDX,EDX
DIV CX
ADD AL,0x30
MOV byte ptr [RDI + 0x1],AL
MOVZX EAX,DL
MOV CL,0xa
DIV CL
MOV ECX,EAX
MOVZX EAX,AH
OR CL,0x30
LEA RDX,[RDI + 0x3]
MOV byte ptr [RDI + 0x2],CL
PUSH 0x4
LAB_001879f7:
POP RCX
OR AL,0x30
ADD RDI,RCX
MOV byte ptr [RDX],AL
MOV RAX,RDI
POP RCX
RET
LAB_00187a04:
LEA RDI,[0x1aebdc]
LEA RDX,[0x1aec26]
LEA RCX,[0x1b45b7]
MOV ESI,0x45ae
JMP 0x00187a3a
LAB_00187a20:
LEA RDI,[0x1aebdc]
LEA RDX,[0x1aec26]
LEA RCX,[0x1b45c1]
MOV ESI,0x45af
LAB_00187a3a:
XOR EAX,EAX
CALL 0x00123e40
|
/* nlohmann::json_abi_v3_11_3::detail::dtoa_impl::append_exponent(char*, int) */
char * nlohmann::json_abi_v3_11_3::detail::dtoa_impl::append_exponent(char *param_1,int param_2)
{
byte bVar2;
uint uVar1;
char *pcVar3;
ushort uVar4;
byte *pbVar5;
int8 uVar6;
long lStack_10;
if (param_2 < -999) {
pcVar3 = "e > -1000";
uVar6 = 0x45ae;
LAB_00187a3a:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",uVar6,
"GGML_ASSERT(%s) failed",pcVar3);
}
if (999 < param_2) {
pcVar3 = "e < 1000";
uVar6 = 0x45af;
goto LAB_00187a3a;
}
uVar1 = -param_2;
if (0 < param_2) {
uVar1 = param_2;
}
*param_1 = (char)(param_2 >> 0x1f) * -2 + '+';
if (uVar1 < 10) {
param_1[1] = '0';
}
else {
if (99 < uVar1) {
uVar4 = (ushort)((uVar1 & 0xffff) % 100);
param_1[1] = (char)((uVar1 & 0xffff) / 100) + '0';
bVar2 = (byte)(uVar4 % 10);
pbVar5 = (byte *)(param_1 + 3);
param_1[2] = (byte)(uVar4 / 10) | 0x30;
lStack_10 = 4;
goto LAB_001879f7;
}
uVar4 = (ushort)uVar1 & 0xff;
uVar1 = (uint)(byte)(uVar4 % 10);
param_1[1] = (byte)(uVar4 / 10) | 0x30;
}
pbVar5 = (byte *)(param_1 + 2);
bVar2 = (byte)uVar1;
lStack_10 = 3;
LAB_001879f7:
*pbVar5 = bVar2 | 0x30;
return param_1 + lStack_10;
}
| |
44,858 | apply_shift | eloqsql/strings/ctype-uca.c | static my_bool
apply_shift(MY_CHARSET_LOADER *loader,
MY_COLL_RULES *rules, MY_COLL_RULE *r, int level,
uint16 *to, size_t nweights)
{
/* Apply level difference. */
if (nweights)
{
to[nweights - 1]+= r->diff[level];
if (r->before_level == 1) /* Apply "&[before primary]" */
{
if (nweights >= 2)
{
to[nweights - 2]--; /* Reset before */
if (rules->shift_after_method == my_shift_method_expand)
{
/*
Special case. Don't let characters shifted after X
and before next(X) intermix to each other.
For example:
"[shift-after-method expand] &0 < a &[before primary]1 < A".
I.e. we reorder 'a' after '0', and then 'A' before '1'.
'a' must be sorted before 'A'.
Note, there are no real collations in CLDR which shift
after and before two neighbourgh characters. We need this
just in case. Reserving 4096 (0x1000) weights for such
cases is perfectly enough.
*/
to[nweights - 1]+= 0x1000; /* W3-TODO: const may vary on levels 2,3*/
}
}
else
{
my_snprintf(loader->error, sizeof(loader->error),
"Can't reset before "
"a primary ignorable character U+%04lX", r->base[0]);
return TRUE;
}
}
}
else
{
/* Shift to an ignorable character, e.g.: & \u0000 < \u0001 */
DBUG_ASSERT(to[0] == 0);
to[0]= r->diff[level];
}
return FALSE;
} | O0 | c | apply_shift:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x855da
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl 0x80(%rax,%rcx,4), %esi
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
subq $0x1, %rcx
movzwl (%rax,%rcx,2), %edx
addl %esi, %edx
movw %dx, (%rax,%rcx,2)
movq -0x20(%rbp), %rax
cmpq $0x1, 0x90(%rax)
jne 0x855d8
cmpq $0x2, -0x38(%rbp)
jb 0x855b2
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
subq $0x2, %rcx
movw (%rax,%rcx,2), %dx
addw $-0x1, %dx
movw %dx, (%rax,%rcx,2)
movq -0x18(%rbp), %rax
cmpl $0x1, 0x30(%rax)
jne 0x855b0
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
subq $0x1, %rcx
movzwl (%rax,%rcx,2), %edx
addl $0x1000, %edx # imm = 0x1000
movw %dx, (%rax,%rcx,2)
jmp 0x855d6
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movl $0x80, %esi
leaq 0x2c7c3(%rip), %rdx # 0xb1d8c
movb $0x0, %al
callq 0xab160
movb $0x1, -0x1(%rbp)
jmp 0x855fb
jmp 0x855d8
jmp 0x855f7
jmp 0x855dc
jmp 0x855de
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl 0x80(%rax,%rcx,4), %eax
movw %ax, %cx
movq -0x30(%rbp), %rax
movw %cx, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| apply_shift:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov [rbp+var_30], r8
mov [rbp+var_38], r9
cmp [rbp+var_38], 0
jz loc_855DA
mov rax, [rbp+var_20]
movsxd rcx, [rbp+var_24]
mov esi, [rax+rcx*4+80h]
mov rax, [rbp+var_30]
mov rcx, [rbp+var_38]
sub rcx, 1
movzx edx, word ptr [rax+rcx*2]
add edx, esi
mov [rax+rcx*2], dx
mov rax, [rbp+var_20]
cmp qword ptr [rax+90h], 1
jnz short loc_855D8
cmp [rbp+var_38], 2
jb short loc_855B2
mov rax, [rbp+var_30]
mov rcx, [rbp+var_38]
sub rcx, 2
mov dx, [rax+rcx*2]
add dx, 0FFFFh
mov [rax+rcx*2], dx
mov rax, [rbp+var_18]
cmp dword ptr [rax+30h], 1
jnz short loc_855B0
mov rax, [rbp+var_30]
mov rcx, [rbp+var_38]
sub rcx, 1
movzx edx, word ptr [rax+rcx*2]
add edx, 1000h
mov [rax+rcx*2], dx
loc_855B0:
jmp short loc_855D6
loc_855B2:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_20]
mov rcx, [rax]
mov esi, 80h
lea rdx, aCanTResetBefor; "Can't reset before a primary ignorable "...
mov al, 0
call my_snprintf
mov [rbp+var_1], 1
jmp short loc_855FB
loc_855D6:
jmp short $+2
loc_855D8:
jmp short loc_855F7
loc_855DA:
jmp short $+2
loc_855DC:
jmp short $+2
loc_855DE:
mov rax, [rbp+var_20]
movsxd rcx, [rbp+var_24]
mov eax, [rax+rcx*4+80h]
mov cx, ax
mov rax, [rbp+var_30]
mov [rax], cx
loc_855F7:
mov [rbp+var_1], 0
loc_855FB:
mov al, [rbp+var_1]
add rsp, 40h
pop rbp
retn
| char apply_shift(int a1, long long a2, _QWORD *a3, int a4, _WORD *a5, unsigned long long a6)
{
if ( !a6 )
{
*a5 = *((_DWORD *)a3 + a4 + 32);
return 0;
}
a5[a6 - 1] += *((_DWORD *)a3 + a4 + 32);
if ( a3[18] != 1LL )
return 0;
if ( a6 >= 2 )
{
--a5[a6 - 2];
if ( *(_DWORD *)(a2 + 48) == 1 )
a5[a6 - 1] += 4096;
return 0;
}
my_snprintf(a1, 128, (unsigned int)"Can't reset before a primary ignorable character U+%04lX", *a3, (_DWORD)a5, a6);
return 1;
}
| apply_shift:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
CMP qword ptr [RBP + -0x38],0x0
JZ 0x001855da
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,dword ptr [RBP + -0x24]
MOV ESI,dword ptr [RAX + RCX*0x4 + 0x80]
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x38]
SUB RCX,0x1
MOVZX EDX,word ptr [RAX + RCX*0x2]
ADD EDX,ESI
MOV word ptr [RAX + RCX*0x2],DX
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX + 0x90],0x1
JNZ 0x001855d8
CMP qword ptr [RBP + -0x38],0x2
JC 0x001855b2
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x38]
SUB RCX,0x2
MOV DX,word ptr [RAX + RCX*0x2]
ADD DX,-0x1
MOV word ptr [RAX + RCX*0x2],DX
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX + 0x30],0x1
JNZ 0x001855b0
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x38]
SUB RCX,0x1
MOVZX EDX,word ptr [RAX + RCX*0x2]
ADD EDX,0x1000
MOV word ptr [RAX + RCX*0x2],DX
LAB_001855b0:
JMP 0x001855d6
LAB_001855b2:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX]
MOV ESI,0x80
LEA RDX,[0x1b1d8c]
MOV AL,0x0
CALL 0x001ab160
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001855fb
LAB_001855d6:
JMP 0x001855d8
LAB_001855d8:
JMP 0x001855f7
LAB_001855da:
JMP 0x001855dc
LAB_001855dc:
JMP 0x001855de
LAB_001855de:
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,dword ptr [RBP + -0x24]
MOV EAX,dword ptr [RAX + RCX*0x4 + 0x80]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x30]
MOV word ptr [RAX],CX
LAB_001855f7:
MOV byte ptr [RBP + -0x1],0x0
LAB_001855fb:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x40
POP RBP
RET
|
int1
apply_shift(int8 param_1,long param_2,int8 *param_3,int param_4,int2 *param_5,
ulong param_6)
{
if (param_6 == 0) {
*param_5 = (short)*(int4 *)((long)param_3 + (long)param_4 * 4 + 0x80);
}
else {
param_5[param_6 - 1] =
param_5[param_6 - 1] + (short)*(int4 *)((long)param_3 + (long)param_4 * 4 + 0x80);
if (param_3[0x12] == 1) {
if (param_6 < 2) {
my_snprintf(param_1,0x80,"Can\'t reset before a primary ignorable character U+%04lX",
*param_3);
return 1;
}
param_5[param_6 - 2] = param_5[param_6 - 2] + -1;
if (*(int *)(param_2 + 0x30) == 1) {
param_5[param_6 - 1] = param_5[param_6 - 1] + 0x1000;
}
}
}
return 0;
}
| |
44,859 | nglog::tools::InitializeLoggingUtilities(char const*) | ng-log[P]ng-log/src/utilities.cc | bool IsLoggingInitialized() {
return g_program_invocation_short_name != nullptr;
} | O1 | cpp | nglog::tools::InitializeLoggingUtilities(char const*):
pushq %rbx
subq $0x60, %rsp
cmpq $0x0, 0x1e7f9(%rip) # 0x3fa20
jne 0x21259
movq %rdi, %rbx
movl $0x2f, %esi
callq 0x75d0
leaq 0x1(%rax), %rcx
testq %rax, %rax
cmoveq %rbx, %rcx
movq %rcx, 0x1e7d8(%rip) # 0x3fa20
leaq 0x6c(%rip), %rdi # 0x212bb
addq $0x60, %rsp
popq %rbx
jmp 0xaea3
leaq 0x2c3c(%rip), %rsi # 0x23e9c
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x12b, %edx # imm = 0x12B
callq 0xdda4
movq %rbx, %rdi
callq 0xa516
movq %rax, %rbx
leaq 0x2c63(%rip), %rsi # 0x23ee5
movl $0x26, %edx
movq %rax, %rdi
callq 0x7610
leaq 0x2c76(%rip), %rsi # 0x23f0c
movl $0x25, %edx
movq %rbx, %rdi
callq 0x7610
movq %rsp, %rdi
callq 0xdde8
movq %rsp, %rdi
callq 0xdde8
movq %rax, %rdi
callq 0x924d
| _ZN5nglog5tools26InitializeLoggingUtilitiesEPKc:
push rbx
sub rsp, 60h
cmp cs:_ZN5nglogL31g_program_invocation_short_nameE, 0; nglog::g_program_invocation_short_name
jnz short loc_21259
mov rbx, rdi
mov esi, (offset qword_28+7); void (*)(void)
call _strrchr
lea rcx, [rax+1]
test rax, rax
cmovz rcx, rbx
mov cs:_ZN5nglogL31g_program_invocation_short_nameE, rcx; nglog::g_program_invocation_short_name
lea rdi, _ZN5nglogL21DumpStackTraceAndExitEv; this
add rsp, 60h
pop rbx
jmp _ZN5nglog22InstallFailureFunctionEPFvvE; nglog::InstallFailureFunction(void (*)(void))
loc_21259:
lea rsi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
mov rbx, rsp
mov rdi, rbx; this
mov edx, 12Bh; int
call _ZN5nglog15LogMessageFatalC2EPKci; nglog::LogMessageFatal::LogMessageFatal(char const*,int)
mov rdi, rbx; this
call _ZN5nglog10LogMessage6streamEv; nglog::LogMessage::stream(void)
mov rbx, rax
lea rsi, aCheckFailedIsl; "Check failed: !IsLoggingInitialized() "
mov edx, 26h ; '&'
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, aYouCalledIniti; "You called InitializeLogging() twice!"
mov edx, 25h ; '%'
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
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
| long long ( * nglog::tools::InitializeLoggingUtilities(nglog::tools *this, const char *a2))(_QWORD)
{
long long v2; // rax
nglog::tools *v3; // rcx
long long v5; // rbx
_BYTE v6[104]; // [rsp+0h] [rbp-68h] BYREF
if ( nglog::g_program_invocation_short_name )
{
nglog::LogMessageFatal::LogMessageFatal(
(nglog::LogMessageFatal *)v6,
(nglog::tools *)"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/utilities.cc",
299);
v5 = nglog::LogMessage::stream((nglog::LogMessage *)v6);
std::__ostream_insert<char,std::char_traits<char>>(v5, "Check failed: !IsLoggingInitialized() ", 38LL);
std::__ostream_insert<char,std::char_traits<char>>(v5, "You called InitializeLogging() twice!", 37LL);
nglog::LogMessageFatal::~LogMessageFatal((nglog::LogMessageFatal *)v6);
}
v2 = strrchr(this, (char *)&qword_28 + 7);
v3 = (nglog::tools *)(v2 + 1);
if ( !v2 )
v3 = this;
nglog::g_program_invocation_short_name = (long long)v3;
return nglog::InstallFailureFunction((nglog *)nglog::DumpStackTraceAndExit, (void (*)(void))((char *)&qword_28 + 7));
}
| InitializeLoggingUtilities:
PUSH RBX
SUB RSP,0x60
CMP qword ptr [0x0013fa20],0x0
JNZ 0x00121259
MOV RBX,RDI
MOV ESI,0x2f
CALL 0x001075d0
LEA RCX,[RAX + 0x1]
TEST RAX,RAX
CMOVZ RCX,RBX
MOV qword ptr [0x0013fa20],RCX
LEA RDI,[0x1212bb]
ADD RSP,0x60
POP RBX
JMP 0x0010aea3
LAB_00121259:
LEA RSI,[0x123e9c]
MOV RBX,RSP
MOV RDI,RBX
MOV EDX,0x12b
CALL 0x0010dda4
LAB_00121270:
MOV RDI,RBX
CALL 0x0010a516
MOV RBX,RAX
LEA RSI,[0x123ee5]
MOV EDX,0x26
MOV RDI,RAX
CALL 0x00107610
LEA RSI,[0x123f0c]
MOV EDX,0x25
MOV RDI,RBX
CALL 0x00107610
LAB_001212a3:
MOV RDI,RSP
CALL 0x0010dde8
LAB_001212ab:
MOV RDI,RSP
CALL 0x0010dde8
LAB_001212b3:
MOV RDI,RAX
CALL 0x0010924d
|
/* nglog::tools::InitializeLoggingUtilities(char const*) */
void nglog::tools::InitializeLoggingUtilities(char *param_1)
{
char *pcVar1;
ostream *poVar2;
int8 uVar3;
LogMessageFatal aLStack_68 [96];
if (g_program_invocation_short_name == (char *)0x0) {
pcVar1 = strrchr(param_1,0x2f);
g_program_invocation_short_name = pcVar1 + 1;
if (pcVar1 == (char *)0x0) {
g_program_invocation_short_name = param_1;
}
InstallFailureFunction(DumpStackTraceAndExit);
return;
}
LogMessageFatal::LogMessageFatal
(aLStack_68,"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/utilities.cc",
299);
/* try { // try from 00121270 to 001212a2 has its CatchHandler @ 001212ab */
poVar2 = (ostream *)LogMessage::stream((LogMessage *)aLStack_68);
std::__ostream_insert<char,std::char_traits<char>>
(poVar2,"Check failed: !IsLoggingInitialized() ",0x26);
std::__ostream_insert<char,std::char_traits<char>>
(poVar2,"You called InitializeLogging() twice!",0x25);
LogMessageFatal::~LogMessageFatal(aLStack_68);
/* catch(type#1 @ 00000000) { ... } // from try @ 00121270 with catch @ 001212ab
try { // try from 001212ab to 001212b2 has its CatchHandler @ 001212b3 */
uVar3 = LogMessageFatal::~LogMessageFatal(aLStack_68);
/* catch(type#1 @ 00000000) { ... } // from try @ 001212ab with catch @ 001212b3
*/
/* WARNING: Subroutine does not return */
__clang_call_terminate(uVar3);
}
| |
44,860 | nglog::tools::InitializeLoggingUtilities(char const*) | ng-log[P]ng-log/src/utilities.cc | bool IsLoggingInitialized() {
return g_program_invocation_short_name != nullptr;
} | O3 | cpp | nglog::tools::InitializeLoggingUtilities(char const*):
pushq %rbx
subq $0x60, %rsp
cmpq $0x0, 0x1ea1c(%rip) # 0x3fa20
je 0x2101b
movq $0x0, 0x1ea0f(%rip) # 0x3fa20
addq $0x60, %rsp
popq %rbx
jmp 0x7500
leaq 0x2e56(%rip), %rsi # 0x23e78
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x134, %edx # imm = 0x134
callq 0xdc12
movq %rbx, %rdi
callq 0xa38a
movq %rax, %rbx
leaq 0x2eca(%rip), %rsi # 0x23f0e
movl $0x25, %edx
movq %rax, %rdi
callq 0x7610
leaq 0x2edc(%rip), %rsi # 0x23f34
movl $0x47, %edx
movq %rbx, %rdi
callq 0x7610
movq %rsp, %rdi
callq 0xdc56
movq %rsp, %rdi
callq 0xdc56
movq %rax, %rdi
callq 0x911d
| _ZN5nglog5tools24ShutdownLoggingUtilitiesEv:
push rbx
sub rsp, 60h
cmp cs:_ZN5nglogL31g_program_invocation_short_nameE, 0; nglog::g_program_invocation_short_name
jz short loc_2101B
mov cs:_ZN5nglogL31g_program_invocation_short_nameE, 0; nglog::g_program_invocation_short_name
add rsp, 60h
pop rbx
jmp _closelog
loc_2101B:
lea rsi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
mov rbx, rsp
mov rdi, rbx; this
mov edx, 134h; int
call _ZN5nglog15LogMessageFatalC2EPKci; nglog::LogMessageFatal::LogMessageFatal(char const*,int)
mov rdi, rbx; this
call _ZN5nglog10LogMessage6streamEv; nglog::LogMessage::stream(void)
mov rbx, rax
lea rsi, aCheckFailedIsl_0; "Check failed: IsLoggingInitialized() "
mov edx, 25h ; '%'
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, aYouCalledShutd; "You called ShutdownLogging() without ca"...
mov edx, 47h ; 'G'
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
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
| long long nglog::tools::ShutdownLoggingUtilities(nglog::tools *this)
{
long long v2; // rbx
_BYTE v3[104]; // [rsp+0h] [rbp-68h] BYREF
if ( !nglog::g_program_invocation_short_name )
{
nglog::LogMessageFatal::LogMessageFatal(
(nglog::LogMessageFatal *)v3,
(nglog::tools *)"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/utilities.cc",
308);
v2 = nglog::LogMessage::stream((nglog::LogMessage *)v3);
std::__ostream_insert<char,std::char_traits<char>>(v2, "Check failed: IsLoggingInitialized() ", 37LL);
std::__ostream_insert<char,std::char_traits<char>>(
v2,
"You called ShutdownLogging() without calling InitializeLogging() first!",
71LL);
nglog::LogMessageFatal::~LogMessageFatal((nglog::LogMessageFatal *)v3);
}
nglog::g_program_invocation_short_name = 0LL;
return closelog(this);
}
| ShutdownLoggingUtilities:
PUSH RBX
SUB RSP,0x60
CMP qword ptr [0x0013fa20],0x0
JZ 0x0012101b
MOV qword ptr [0x0013fa20],0x0
ADD RSP,0x60
POP RBX
JMP 0x00107500
LAB_0012101b:
LEA RSI,[0x123e78]
MOV RBX,RSP
MOV RDI,RBX
MOV EDX,0x134
CALL 0x0010dc12
LAB_00121032:
MOV RDI,RBX
CALL 0x0010a38a
MOV RBX,RAX
LEA RSI,[0x123f0e]
MOV EDX,0x25
MOV RDI,RAX
CALL 0x00107610
LEA RSI,[0x123f34]
MOV EDX,0x47
MOV RDI,RBX
CALL 0x00107610
LAB_00121065:
MOV RDI,RSP
CALL 0x0010dc56
LAB_0012106d:
MOV RDI,RSP
CALL 0x0010dc56
LAB_00121075:
MOV RDI,RAX
CALL 0x0010911d
|
/* nglog::tools::ShutdownLoggingUtilities() */
void nglog::tools::ShutdownLoggingUtilities(void)
{
ostream *poVar1;
int8 uVar2;
LogMessageFatal aLStack_68 [96];
if (g_program_invocation_short_name != 0) {
g_program_invocation_short_name = 0;
closelog();
return;
}
LogMessageFatal::LogMessageFatal
(aLStack_68,"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/utilities.cc",
0x134);
/* try { // try from 00121032 to 00121064 has its CatchHandler @ 0012106d */
poVar1 = (ostream *)LogMessage::stream((LogMessage *)aLStack_68);
std::__ostream_insert<char,std::char_traits<char>>
(poVar1,"Check failed: IsLoggingInitialized() ",0x25);
std::__ostream_insert<char,std::char_traits<char>>
(poVar1,"You called ShutdownLogging() without calling InitializeLogging() first!",0x47);
LogMessageFatal::~LogMessageFatal(aLStack_68);
/* catch(type#1 @ 00000000) { ... } // from try @ 00121032 with catch @ 0012106d
try { // try from 0012106d to 00121074 has its CatchHandler @ 00121075 */
uVar2 = LogMessageFatal::~LogMessageFatal(aLStack_68);
/* catch(type#1 @ 00000000) { ... } // from try @ 0012106d with catch @ 00121075
*/
/* WARNING: Subroutine does not return */
__clang_call_terminate(uVar2);
}
| |
44,861 | my_setstacksize | eloqsql/mysys/my_pthread.c | size_t my_setstacksize(pthread_attr_t *attr, size_t stacksize)
{
size_t guard_size __attribute__((unused))= 0;
#if defined(__ia64__) || defined(__ia64)
/*
On IA64, half of the requested stack size is used for "normal stack"
and half for "register stack". The space measured by check_stack_overrun
is the "normal stack", so double the request to make sure we have the
caller-expected amount of normal stack.
NOTE: there is no guarantee that the register stack can't grow faster
than normal stack, so it's very unclear that we won't dump core due to
stack overrun despite check_stack_overrun's efforts. Experimentation
shows that in the execution_constants test, the register stack grows
less than half as fast as normal stack, but perhaps other scenarios are
less forgiving. If it turns out that more space is needed for the
register stack, that could be forced (rather inefficiently) by using a
multiplier higher than 2 here.
*/
stacksize *= 2;
#endif
/*
On many machines, the "guard space" is subtracted from the requested
stack size, and that space is quite large on some platforms. So add
it to our request, if we can find out what it is.
*/
#ifdef HAVE_PTHREAD_ATTR_GETGUARDSIZE
if (pthread_attr_getguardsize(attr, &guard_size))
guard_size = 0; /* if can't find it out, treat as 0 */
#endif /* HAVE_PTHREAD_ATTR_GETGUARDSIZE */
pthread_attr_setstacksize(attr, stacksize + guard_size);
/* Retrieve actual stack size if possible */
#ifdef HAVE_PTHREAD_ATTR_GETSTACKSIZE
{
size_t real_stack_size= 0;
/* We must ignore real_stack_size = 0 as Solaris 2.9 can return 0 here */
if (pthread_attr_getstacksize(attr, &real_stack_size) == 0 &&
real_stack_size > guard_size)
{
real_stack_size -= guard_size;
if (real_stack_size < stacksize)
stacksize= real_stack_size;
}
}
#endif /* HAVE_PTHREAD_ATTR_GETSTACKSIZE */
#if defined(__ia64__) || defined(__ia64)
stacksize /= 2;
#endif
return stacksize;
} | O3 | c | my_setstacksize:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x18(%rbp), %rsi
movq $0x0, (%rsi)
callq 0x24080
testl %eax, %eax
je 0x263a9
movq $0x0, -0x18(%rbp)
xorl %esi, %esi
jmp 0x263ad
movq -0x18(%rbp), %rsi
addq %rbx, %rsi
movq %r14, %rdi
callq 0x24410
leaq -0x20(%rbp), %rsi
movq $0x0, (%rsi)
movq %r14, %rdi
callq 0x24280
testl %eax, %eax
jne 0x263e0
movq -0x20(%rbp), %rax
subq -0x18(%rbp), %rax
jbe 0x263e0
cmpq %rbx, %rax
cmovbq %rax, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| my_setstacksize:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 10h
mov rbx, rsi
mov r14, rdi
lea rsi, [rbp+var_18]
mov qword ptr [rsi], 0
call _pthread_attr_getguardsize
test eax, eax
jz short loc_263A9
mov [rbp+var_18], 0
xor esi, esi
jmp short loc_263AD
loc_263A9:
mov rsi, [rbp+var_18]
loc_263AD:
add rsi, rbx
mov rdi, r14
call _pthread_attr_setstacksize
lea rsi, [rbp+var_20]
mov qword ptr [rsi], 0
mov rdi, r14
call _pthread_attr_getstacksize
test eax, eax
jnz short loc_263E0
mov rax, [rbp+var_20]
sub rax, [rbp+var_18]
jbe short loc_263E0
cmp rax, rbx
cmovb rbx, rax
loc_263E0:
mov rax, rbx
add rsp, 10h
pop rbx
pop r14
pop rbp
retn
| unsigned long long my_setstacksize(long long a1, unsigned long long a2)
{
long long v3; // rsi
unsigned long long v5; // [rsp+0h] [rbp-20h] BYREF
_QWORD v6[3]; // [rsp+8h] [rbp-18h] BYREF
v6[0] = 0LL;
if ( (unsigned int)pthread_attr_getguardsize(a1, v6) )
{
v6[0] = 0LL;
v3 = 0LL;
}
else
{
v3 = v6[0];
}
pthread_attr_setstacksize(a1, a2 + v3);
v5 = 0LL;
if ( !(unsigned int)pthread_attr_getstacksize(a1, &v5) && v5 > v6[0] && v5 - v6[0] < a2 )
return v5 - v6[0];
return a2;
}
| my_setstacksize:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV RBX,RSI
MOV R14,RDI
LEA RSI,[RBP + -0x18]
MOV qword ptr [RSI],0x0
CALL 0x00124080
TEST EAX,EAX
JZ 0x001263a9
MOV qword ptr [RBP + -0x18],0x0
XOR ESI,ESI
JMP 0x001263ad
LAB_001263a9:
MOV RSI,qword ptr [RBP + -0x18]
LAB_001263ad:
ADD RSI,RBX
MOV RDI,R14
CALL 0x00124410
LEA RSI,[RBP + -0x20]
MOV qword ptr [RSI],0x0
MOV RDI,R14
CALL 0x00124280
TEST EAX,EAX
JNZ 0x001263e0
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,qword ptr [RBP + -0x18]
JBE 0x001263e0
CMP RAX,RBX
CMOVC RBX,RAX
LAB_001263e0:
MOV RAX,RBX
ADD RSP,0x10
POP RBX
POP R14
POP RBP
RET
|
ulong my_setstacksize(pthread_attr_t *param_1,ulong param_2)
{
int iVar1;
ulong uVar2;
size_t local_28;
size_t local_20;
local_20 = 0;
iVar1 = pthread_attr_getguardsize(param_1,&local_20);
if (iVar1 != 0) {
local_20 = 0;
}
pthread_attr_setstacksize(param_1,local_20 + param_2);
local_28 = 0;
iVar1 = pthread_attr_getstacksize(param_1,&local_28);
if (((iVar1 == 0) && (uVar2 = local_28 - local_20, local_20 <= local_28 && uVar2 != 0)) &&
(uVar2 < param_2)) {
param_2 = uVar2;
}
return param_2;
}
| |
44,862 | strxmov | eloqsql/strings/strxmov.c | char *strxmov(char *dst,const char *src, ...)
{
va_list pvar;
va_start(pvar,src);
while (src != NullS) {
while ((*dst++ = *src++)) ;
dst--;
src = va_arg(pvar, char *);
}
va_end(pvar);
*dst = 0; /* there might have been no sources! */
return dst;
} | O3 | c | strxmov:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %eax, %r10d
movq %rdi, %rax
leaq -0xd0(%rbp), %rdi
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %r10b, %r10b
je 0xd71b4
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
leaq 0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movabsq $0x3000000010, %rcx # imm = 0x3000000010
movq %rcx, -0x20(%rbp)
testq %rsi, %rsi
je 0xd7222
movq -0x10(%rbp), %rcx
movl -0x20(%rbp), %edx
movq -0x18(%rbp), %rdi
movq %rdi, %r8
movb (%rsi), %r9b
movb %r9b, (%rax)
testb %r9b, %r9b
jne 0xd721a
cmpl $0x28, %edx
ja 0xd7202
movq %r8, %r9
movl %edx, %r8d
addq %rcx, %r8
addl $0x8, %edx
movl %edx, -0x20(%rbp)
jmp 0xd720d
leaq 0x8(%r8), %rdi
movq %rdi, -0x18(%rbp)
movq %rdi, %r9
movq (%r8), %rsi
movq %r9, %r8
testq %rsi, %rsi
jne 0xd71e1
jmp 0xd7222
incq %rax
incq %rsi
jmp 0xd71de
movb $0x0, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nop
| strxmov:
push rbp
mov rbp, rsp
sub rsp, 50h
mov r10d, eax
mov rax, rdi
lea rdi, [rbp+var_D0]
mov [rdi+10h], rdx
mov [rdi+18h], rcx
mov [rdi+20h], r8
mov [rdi+28h], r9
test r10b, r10b
jz short loc_D71B4
movaps [rbp+var_A0], xmm0
movaps [rbp+var_90], xmm1
movaps [rbp+var_80], xmm2
movaps [rbp+var_70], xmm3
movaps [rbp+var_60], xmm4
movaps [rbp+var_50], xmm5
movaps [rbp+var_40], xmm6
movaps [rbp+var_30], xmm7
loc_D71B4:
mov [rbp+var_10], rdi
lea rcx, [rbp+arg_0]
mov [rbp+var_18], rcx
mov rcx, 3000000010h
mov [rbp+var_20], rcx
test rsi, rsi
jz short loc_D7222
mov rcx, [rbp+var_10]
mov edx, dword ptr [rbp+var_20]
mov rdi, [rbp+var_18]
loc_D71DE:
mov r8, rdi
loc_D71E1:
mov r9b, [rsi]
mov [rax], r9b
test r9b, r9b
jnz short loc_D721A
cmp edx, 28h ; '('
ja short loc_D7202
mov r9, r8
mov r8d, edx
add r8, rcx
add edx, 8
mov dword ptr [rbp+var_20], edx
jmp short loc_D720D
loc_D7202:
lea rdi, [r8+8]
mov [rbp+var_18], rdi
mov r9, rdi
loc_D720D:
mov rsi, [r8]
mov r8, r9
test rsi, rsi
jnz short loc_D71E1
jmp short loc_D7222
loc_D721A:
inc rax
inc rsi
jmp short loc_D71DE
loc_D7222:
mov byte ptr [rax], 0
add rsp, 50h
pop rbp
retn
| char *strxmov(char *a1, char *a2, ...)
{
char *result; // rax
char *reg_save_area; // rcx
unsigned int gp_offset; // edx
char *overflow_arg_area; // rdi
char *v6; // r8
char v7; // r9
char *v8; // r9
va_list va; // [rsp+B0h] [rbp-20h] BYREF
result = a1;
va_start(va, a2);
if ( a2 )
{
reg_save_area = (char *)va[0].reg_save_area;
gp_offset = va[0].gp_offset;
overflow_arg_area = (char *)va[0].overflow_arg_area;
while ( 1 )
{
v6 = overflow_arg_area;
while ( 1 )
{
v7 = *a2;
*result = *a2;
if ( v7 )
break;
if ( gp_offset > 0x28 )
{
overflow_arg_area = v6 + 8;
va[0].overflow_arg_area = v6 + 8;
v8 = v6 + 8;
}
else
{
v8 = v6;
v6 = ®_save_area[gp_offset];
gp_offset += 8;
va[0].gp_offset = gp_offset;
}
a2 = *(char **)v6;
v6 = v8;
if ( !a2 )
goto LABEL_11;
}
++result;
++a2;
}
}
LABEL_11:
*result = 0;
return result;
}
| strxmov:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV R10D,EAX
MOV RAX,RDI
LEA RDI,[RBP + -0xd0]
MOV qword ptr [RDI + 0x10],RDX
MOV qword ptr [RDI + 0x18],RCX
MOV qword ptr [RDI + 0x20],R8
MOV qword ptr [RDI + 0x28],R9
TEST R10B,R10B
JZ 0x001d71b4
MOVAPS xmmword ptr [RBP + -0xa0],XMM0
MOVAPS xmmword ptr [RBP + -0x90],XMM1
MOVAPS xmmword ptr [RBP + -0x80],XMM2
MOVAPS xmmword ptr [RBP + -0x70],XMM3
MOVAPS xmmword ptr [RBP + -0x60],XMM4
MOVAPS xmmword ptr [RBP + -0x50],XMM5
MOVAPS xmmword ptr [RBP + -0x40],XMM6
MOVAPS xmmword ptr [RBP + -0x30],XMM7
LAB_001d71b4:
MOV qword ptr [RBP + -0x10],RDI
LEA RCX,[RBP + 0x10]
MOV qword ptr [RBP + -0x18],RCX
MOV RCX,0x3000000010
MOV qword ptr [RBP + -0x20],RCX
TEST RSI,RSI
JZ 0x001d7222
MOV RCX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x20]
MOV RDI,qword ptr [RBP + -0x18]
LAB_001d71de:
MOV R8,RDI
LAB_001d71e1:
MOV R9B,byte ptr [RSI]
MOV byte ptr [RAX],R9B
TEST R9B,R9B
JNZ 0x001d721a
CMP EDX,0x28
JA 0x001d7202
MOV R9,R8
MOV R8D,EDX
ADD R8,RCX
ADD EDX,0x8
MOV dword ptr [RBP + -0x20],EDX
JMP 0x001d720d
LAB_001d7202:
LEA RDI,[R8 + 0x8]
MOV qword ptr [RBP + -0x18],RDI
MOV R9,RDI
LAB_001d720d:
MOV RSI,qword ptr [R8]
MOV R8,R9
TEST RSI,RSI
JNZ 0x001d71e1
JMP 0x001d7222
LAB_001d721a:
INC RAX
INC RSI
JMP 0x001d71de
LAB_001d7222:
MOV byte ptr [RAX],0x0
ADD RSP,0x50
POP RBP
RET
|
void strxmov(char *param_1,char *param_2)
{
char cVar1;
int8 *puVar2;
int8 *puVar3;
ulong uVar4;
int8 *puVar5;
int8 local_d8 [22];
uint local_28;
puVar2 = (int8 *)&stack0x00000008;
if (param_2 != (char *)0x0) {
local_28 = 0x10;
puVar3 = puVar2;
do {
for (; cVar1 = *param_2, *param_1 = cVar1, cVar1 != '\0'; param_2 = param_2 + 1) {
param_1 = param_1 + 1;
puVar3 = puVar2;
}
if (local_28 < 0x29) {
uVar4 = (ulong)local_28;
local_28 = local_28 + 8;
puVar5 = (int8 *)((long)local_d8 + uVar4);
}
else {
puVar2 = puVar3 + 1;
puVar5 = puVar3;
puVar3 = puVar2;
}
param_2 = (char *)*puVar5;
} while (param_2 != (char *)0x0);
}
*param_1 = '\0';
return;
}
| |
44,863 | QUICK_RANGE_SELECT::get_next() | eloqsql/sql/opt_range.cc | int QUICK_RANGE_SELECT::get_next()
{
range_id_t dummy;
int result;
DBUG_ENTER("QUICK_RANGE_SELECT::get_next");
if (!in_ror_merged_scan)
DBUG_RETURN(file->multi_range_read_next(&dummy));
MY_BITMAP * const save_read_set= head->read_set;
MY_BITMAP * const save_write_set= head->write_set;
/*
We don't need to signal the bitmap change as the bitmap is always the
same for this head->file
*/
head->column_bitmaps_set_no_signal(&column_bitmap, &column_bitmap);
result= file->multi_range_read_next(&dummy);
head->column_bitmaps_set_no_signal(save_read_set, save_write_set);
DBUG_RETURN(result);
} | O0 | cpp | QUICK_RANGE_SELECT::get_next():
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
testb $0x1, 0x60(%rax)
jne 0xa50da6
jmp 0xa50d8c
movq -0x38(%rbp), %rax
movq 0x58(%rax), %rdi
movq (%rdi), %rax
leaq -0x18(%rbp), %rsi
callq *0x1d0(%rax)
movl %eax, -0x4(%rbp)
jmp 0xa50e11
movq -0x38(%rbp), %rdx
movq 0x18(%rdx), %rax
movq 0x1f0(%rax), %rax
movq %rax, -0x28(%rbp)
movq 0x18(%rdx), %rax
movq 0x1f8(%rax), %rax
movq %rax, -0x30(%rbp)
movq 0x18(%rdx), %rdi
movq %rdx, %rsi
addq $0x68, %rsi
addq $0x68, %rdx
callq 0x55a2b0
movq -0x38(%rbp), %rax
movq 0x58(%rax), %rdi
movq (%rdi), %rax
leaq -0x18(%rbp), %rsi
callq *0x1d0(%rax)
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, -0x1c(%rbp)
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x55a2b0
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _ZN18QUICK_RANGE_SELECT8get_nextEv:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov [rbp+var_38], rax
test byte ptr [rax+60h], 1
jnz short loc_A50DA6
jmp short $+2
loc_A50D8C:
mov rax, [rbp+var_38]
mov rdi, [rax+58h]
mov rax, [rdi]
lea rsi, [rbp+var_18]
call qword ptr [rax+1D0h]
mov [rbp+var_4], eax
jmp short loc_A50E11
loc_A50DA6:
mov rdx, [rbp+var_38]
mov rax, [rdx+18h]
mov rax, [rax+1F0h]
mov [rbp+var_28], rax
mov rax, [rdx+18h]
mov rax, [rax+1F8h]
mov [rbp+var_30], rax
mov rdi, [rdx+18h]
mov rsi, rdx
add rsi, 68h ; 'h'
add rdx, 68h ; 'h'
call _ZN5TABLE28column_bitmaps_set_no_signalEP9st_bitmapS1_; TABLE::column_bitmaps_set_no_signal(st_bitmap *,st_bitmap *)
mov rax, [rbp+var_38]
mov rdi, [rax+58h]
mov rax, [rdi]
lea rsi, [rbp+var_18]
call qword ptr [rax+1D0h]
mov ecx, eax
mov rax, [rbp+var_38]
mov [rbp+var_1C], ecx
mov rdi, [rax+18h]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_30]
call _ZN5TABLE28column_bitmaps_set_no_signalEP9st_bitmapS1_; TABLE::column_bitmaps_set_no_signal(st_bitmap *,st_bitmap *)
mov eax, [rbp+var_1C]
mov [rbp+var_4], eax
loc_A50E11:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
| long long QUICK_RANGE_SELECT::get_next(QUICK_RANGE_SELECT *this)
{
long long v2; // [rsp+10h] [rbp-30h]
long long v3; // [rsp+18h] [rbp-28h]
unsigned int v4; // [rsp+24h] [rbp-1Ch]
_BYTE v5[8]; // [rsp+28h] [rbp-18h] BYREF
QUICK_RANGE_SELECT *v6; // [rsp+30h] [rbp-10h]
v6 = this;
if ( (*((_BYTE *)this + 96) & 1) != 0 )
{
v3 = *(_QWORD *)(*((_QWORD *)this + 3) + 496LL);
v2 = *(_QWORD *)(*((_QWORD *)this + 3) + 504LL);
TABLE::column_bitmaps_set_no_signal(*((_QWORD *)this + 3), (long long)this + 104, (long long)this + 104);
v4 = (*(long long ( **)(_QWORD, _BYTE *))(**((_QWORD **)this + 11) + 464LL))(*((_QWORD *)this + 11), v5);
TABLE::column_bitmaps_set_no_signal(*((_QWORD *)this + 3), v3, v2);
return v4;
}
else
{
return (unsigned int)(*(long long ( **)(_QWORD, _BYTE *))(**((_QWORD **)this + 11) + 464LL))(
*((_QWORD *)this + 11),
v5);
}
}
| ~Create_func_sha2:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RDI
CALL 0x00a4d7d0
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x8
CALL 0x00533290
ADD RSP,0x10
POP RBP
RET
|
/* Create_func_sha2::~Create_func_sha2() */
void __thiscall Create_func_sha2::~Create_func_sha2(Create_func_sha2 *this)
{
~Create_func_sha2(this);
::operator_delete(this,8);
return;
}
| |
44,864 | common_log::add(ggml_log_level, char const*, __va_list_tag*) | monkey531[P]llama/common/log.cpp | void add(enum ggml_log_level level, const char * fmt, va_list args) {
std::lock_guard<std::mutex> lock(mtx);
if (!running) {
// discard messages while the worker thread is paused
return;
}
auto & entry = entries[tail];
{
// cannot use args twice, so make a copy in case we need to expand the buffer
va_list args_copy;
va_copy(args_copy, args);
#if 1
const size_t n = vsnprintf(entry.msg.data(), entry.msg.size(), fmt, args);
if (n >= entry.msg.size()) {
entry.msg.resize(n + 1);
vsnprintf(entry.msg.data(), entry.msg.size(), fmt, args_copy);
}
#else
// hack for bolding arguments
std::stringstream ss;
for (int i = 0; fmt[i] != 0; i++) {
if (fmt[i] == '%') {
ss << LOG_COL_BOLD;
while (fmt[i] != ' ' && fmt[i] != ')' && fmt[i] != ']' && fmt[i] != 0) ss << fmt[i++];
ss << LOG_COL_DEFAULT;
if (fmt[i] == 0) break;
}
ss << fmt[i];
}
const size_t n = vsnprintf(entry.msg.data(), entry.msg.size(), ss.str().c_str(), args);
if (n >= entry.msg.size()) {
entry.msg.resize(n + 1);
vsnprintf(entry.msg.data(), entry.msg.size(), ss.str().c_str(), args_copy);
}
#endif
va_end(args_copy);
}
entry.level = level;
entry.prefix = prefix;
entry.timestamp = 0;
if (timestamps) {
entry.timestamp = t_us() - t_start;
}
entry.is_end = false;
tail = (tail + 1) % entries.size();
if (tail == head) {
// expand the buffer
std::vector<common_log_entry> new_entries(2*entries.size());
size_t new_tail = 0;
do {
new_entries[new_tail] = std::move(entries[head]);
head = (head + 1) % entries.size();
new_tail = (new_tail + 1);
} while (head != tail);
head = 0;
tail = new_tail;
for (size_t i = tail; i < new_entries.size(); i++) {
new_entries[i].msg.resize(256);
}
entries = std::move(new_entries);
}
cv.notify_one();
} | O2 | cpp | common_log::add(ggml_log_level, char const*, __va_list_tag*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r15
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0x98b2e
cmpb $0x1, 0x6a(%rbx)
jne 0x985a1
movl %ebp, 0xc(%rsp)
movq 0x78(%rbx), %r13
imulq $0x30, 0x98(%rbx), %rbp
movq %r13, %r12
addq %rbp, %r12
movq 0x10(%r15), %rax
movq %rax, 0x20(%rsp)
movups (%r15), %xmm0
movaps %xmm0, 0x10(%rsp)
movq 0x10(%r13,%rbp), %rdi
movq 0x18(%r13,%rbp), %rsi
subq %rdi, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x242b0
movslq %eax, %rsi
movq 0x18(%r13,%rbp), %rax
subq 0x10(%r13,%rbp), %rax
cmpq %rsi, %rax
ja 0x98457
leaq 0x10(,%rbp), %rdi
addq %r13, %rdi
incq %rsi
callq 0x5db5e
movq 0x10(%r12), %rdi
movq 0x18(%r12), %rsi
subq %rdi, %rsi
leaq 0x10(%rsp), %rcx
movq %r14, %rdx
callq 0x242b0
movl 0xc(%rsp), %eax
movl %eax, (%r12)
movb 0x68(%rbx), %al
movb %al, 0x4(%r12)
andq $0x0, 0x8(%r12)
cmpb $0x1, 0x69(%rbx)
jne 0x98481
callq 0x98266
subq 0x70(%rbx), %rax
movq %rax, 0x8(%r12)
movb $0x0, 0x28(%r12)
movq 0x80(%rbx), %rax
movq 0x98(%rbx), %rcx
incq %rcx
subq 0x78(%rbx), %rax
pushq $0x30
popq %r15
cqto
idivq %r15
movq %rax, %rsi
movq %rcx, %rax
xorl %edx, %edx
divq %rsi
movq %rdx, 0x98(%rbx)
cmpq 0x90(%rbx), %rdx
jne 0x98598
addq %rsi, %rsi
leaq 0x10(%rsp), %rdi
leaq 0xb(%rsp), %rdx
callq 0x9901e
leaq 0x78(%rbx), %r14
movq 0x78(%rbx), %rdi
movq 0x90(%rbx), %rdx
pushq $0x10
popq %r12
xorl %r13d, %r13d
imulq $0x30, %rdx, %rsi
addq %rdi, %rsi
movq 0x10(%rsp), %rax
leaq (%rax,%r12), %rdi
addq $-0x10, %rdi
callq 0x99070
movq 0x90(%rbx), %rcx
incq %rcx
movq 0x78(%rbx), %rdi
movq 0x80(%rbx), %rax
subq %rdi, %rax
cqto
idivq %r15
movq %rax, %rsi
movq %rcx, %rax
xorl %edx, %edx
divq %rsi
movq %rdx, 0x90(%rbx)
incq %r13
addq $0x30, %r12
cmpq 0x98(%rbx), %rdx
jne 0x984ec
andq $0x0, 0x90(%rbx)
movq %r13, 0x98(%rbx)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
subq %rdi, %rax
cqto
idivq %r15
cmpq %rax, %r13
jae 0x98580
addq %r12, %rdi
movl $0x100, %esi # imm = 0x100
callq 0x5db5e
incq %r13
addq $0x30, %r12
jmp 0x98553
leaq 0x10(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x9914e
movq %r15, %rdi
callq 0x9883a
leaq 0x30(%rbx), %rdi
callq 0x23480
movq %rbx, %rdi
callq 0x236d0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x985ba
movq %rax, %r14
jmp 0x985cc
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x9883a
movq %rbx, %rdi
callq 0x236d0
movq %r14, %rdi
callq 0x24030
| _ZN10common_log3addE14ggml_log_levelPKcP13__va_list_tag:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r15, rcx
mov r14, rdx
mov ebp, esi
mov rbx, rdi
call _ZNSt5mutex4lockEv; std::mutex::lock(void)
cmp byte ptr [rbx+6Ah], 1
jnz loc_985A1
mov [rsp+58h+var_4C], ebp
mov r13, [rbx+78h]
imul rbp, [rbx+98h], 30h ; '0'
mov r12, r13
add r12, rbp
mov rax, [r15+10h]
mov [rsp+58h+var_38], rax
movups xmm0, xmmword ptr [r15]
movaps [rsp+58h+var_48], xmm0
mov rdi, [r13+rbp+10h]
mov rsi, [r13+rbp+18h]
sub rsi, rdi
mov rdx, r14
mov rcx, r15
call vsnprintf
movsxd rsi, eax
mov rax, [r13+rbp+18h]
sub rax, [r13+rbp+10h]
cmp rax, rsi
ja short loc_98457
lea rdi, ds:10h[rbp]
add rdi, r13
inc rsi
call _ZNSt6vectorIcSaIcEE6resizeEm; std::vector<char>::resize(ulong)
mov rdi, [r12+10h]
mov rsi, [r12+18h]
sub rsi, rdi
lea rcx, [rsp+58h+var_48]
mov rdx, r14
call vsnprintf
loc_98457:
mov eax, [rsp+58h+var_4C]
mov [r12], eax
mov al, [rbx+68h]
mov [r12+4], al
and qword ptr [r12+8], 0
cmp byte ptr [rbx+69h], 1
jnz short loc_98481
call _ZL4t_usv; t_us(void)
sub rax, [rbx+70h]
mov [r12+8], rax
loc_98481:
mov byte ptr [r12+28h], 0
mov rax, [rbx+80h]
mov rcx, [rbx+98h]
inc rcx
sub rax, [rbx+78h]
push 30h ; '0'
pop r15
cqo
idiv r15
mov rsi, rax
mov rax, rcx
xor edx, edx
div rsi
mov [rbx+98h], rdx
cmp rdx, [rbx+90h]
jnz loc_98598
add rsi, rsi
lea rdi, [rsp+58h+var_48]
lea rdx, [rsp+58h+var_4D]
call _ZNSt6vectorI16common_log_entrySaIS0_EEC2EmRKS1_; std::vector<common_log_entry>::vector(ulong,std::allocator<common_log_entry> const&)
lea r14, [rbx+78h]
mov rdi, [rbx+78h]
mov rdx, [rbx+90h]
push 10h
pop r12
xor r13d, r13d
loc_984EC:
imul rsi, rdx, 30h ; '0'
add rsi, rdi
mov rax, qword ptr [rsp+58h+var_48]
lea rdi, [rax+r12]
add rdi, 0FFFFFFFFFFFFFFF0h
call _ZN16common_log_entryaSEOS_; common_log_entry::operator=(common_log_entry&&)
mov rcx, [rbx+90h]
inc rcx
mov rdi, [rbx+78h]
mov rax, [rbx+80h]
sub rax, rdi
cqo
idiv r15
mov rsi, rax
mov rax, rcx
xor edx, edx
div rsi
mov [rbx+90h], rdx
inc r13
add r12, 30h ; '0'
cmp rdx, [rbx+98h]
jnz short loc_984EC
and qword ptr [rbx+90h], 0
mov [rbx+98h], r13
loc_98553:
mov rdi, qword ptr [rsp+58h+var_48]
mov rax, qword ptr [rsp+58h+var_48+8]
sub rax, rdi
cqo
idiv r15
cmp r13, rax
jnb short loc_98580
add rdi, r12
mov esi, 100h
call _ZNSt6vectorIcSaIcEE6resizeEm; std::vector<char>::resize(ulong)
inc r13
add r12, 30h ; '0'
jmp short loc_98553
loc_98580:
lea r15, [rsp+58h+var_48]
mov rdi, r14
mov rsi, r15
call _ZNSt6vectorI16common_log_entrySaIS0_EE14_M_move_assignEOS2_St17integral_constantIbLb1EE; std::vector<common_log_entry>::_M_move_assign(std::vector<common_log_entry>&&,std::integral_constant<bool,true>)
mov rdi, r15
call _ZNSt6vectorI16common_log_entrySaIS0_EED2Ev; std::vector<common_log_entry>::~vector()
loc_98598:
lea rdi, [rbx+30h]; this
call __ZNSt18condition_variable10notify_oneEv; std::condition_variable::notify_one(void)
loc_985A1:
mov rdi, rbx
call _pthread_mutex_unlock
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short $+2
loc_985BA:
mov r14, rax
jmp short loc_985CC
mov r14, rax
lea rdi, [rsp+arg_8]
call _ZNSt6vectorI16common_log_entrySaIS0_EED2Ev; std::vector<common_log_entry>::~vector()
loc_985CC:
mov rdi, rbx
call _pthread_mutex_unlock
mov rdi, r14
call __Unwind_Resume
| long long common_log::add(long long a1, int a2, long long a3, __int128 *a4)
{
long long v7; // r13
long long v8; // rbp
long long v9; // r12
std::chrono::_V2::system_clock *v10; // rdi
unsigned long long v11; // rsi
unsigned long long v12; // rsi
unsigned long long v13; // rdx
long long v14; // rdi
unsigned long long v15; // rdx
long long v16; // r12
unsigned long long v17; // r13
char v19; // [rsp+Bh] [rbp-4Dh] BYREF
int v20; // [rsp+Ch] [rbp-4Ch]
__int128 v21; // [rsp+10h] [rbp-48h] BYREF
long long v22; // [rsp+20h] [rbp-38h]
std::mutex::lock((std::mutex *)a1);
if ( *(_BYTE *)(a1 + 106) == 1 )
{
v20 = a2;
v7 = *(_QWORD *)(a1 + 120);
v8 = 48LL * *(_QWORD *)(a1 + 152);
v9 = v8 + v7;
v22 = *((_QWORD *)a4 + 2);
v21 = *a4;
v10 = *(std::chrono::_V2::system_clock **)(v7 + v8 + 16);
v11 = (int)vsnprintf(v10, *(_QWORD *)(v7 + v8 + 24) - (_QWORD)v10, a3, a4);
if ( *(_QWORD *)(v7 + v8 + 24) - *(_QWORD *)(v7 + v8 + 16) <= v11 )
{
std::vector<char>::resize((_QWORD *)(v7 + v8 + 16), v11 + 1);
v10 = *(std::chrono::_V2::system_clock **)(v9 + 16);
vsnprintf(v10, *(_QWORD *)(v9 + 24) - (_QWORD)v10, a3, &v21);
}
*(_DWORD *)v9 = v20;
*(_BYTE *)(v9 + 4) = *(_BYTE *)(a1 + 104);
*(_QWORD *)(v9 + 8) = 0LL;
if ( *(_BYTE *)(a1 + 105) == 1 )
*(_QWORD *)(v9 + 8) = t_us(v10) - *(_QWORD *)(a1 + 112);
*(_BYTE *)(v9 + 40) = 0;
v12 = (*(_QWORD *)(a1 + 128) - *(_QWORD *)(a1 + 120)) / 48LL;
v13 = (*(_QWORD *)(a1 + 152) + 1LL) % v12;
*(_QWORD *)(a1 + 152) = v13;
if ( v13 == *(_QWORD *)(a1 + 144) )
{
std::vector<common_log_entry>::vector(&v21, 2 * v12, &v19);
v14 = *(_QWORD *)(a1 + 120);
v15 = *(_QWORD *)(a1 + 144);
v16 = 16LL;
v17 = 0LL;
do
{
common_log_entry::operator=(v21 + v16 - 16, v14 + 48 * v15);
v14 = *(_QWORD *)(a1 + 120);
v15 = (*(_QWORD *)(a1 + 144) + 1LL) % (unsigned long long)((*(_QWORD *)(a1 + 128) - v14) / 48);
*(_QWORD *)(a1 + 144) = v15;
++v17;
v16 += 48LL;
}
while ( v15 != *(_QWORD *)(a1 + 152) );
*(_QWORD *)(a1 + 144) = 0LL;
*(_QWORD *)(a1 + 152) = v17;
while ( v17 < (*((_QWORD *)&v21 + 1) - (_QWORD)v21) / 48LL )
{
std::vector<char>::resize((_QWORD *)(v16 + v21), 0x100uLL);
++v17;
v16 += 48LL;
}
std::vector<common_log_entry>::_M_move_assign(a1 + 120, &v21, (*((_QWORD *)&v21 + 1) - (_QWORD)v21) % 48LL);
std::vector<common_log_entry>::~vector(&v21);
}
std::condition_variable::notify_one((std::condition_variable *)(a1 + 48));
}
return pthread_mutex_unlock(a1);
}
| add:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R15,RCX
MOV R14,RDX
MOV EBP,ESI
MOV RBX,RDI
CALL 0x00198b2e
CMP byte ptr [RBX + 0x6a],0x1
JNZ 0x001985a1
MOV dword ptr [RSP + 0xc],EBP
MOV R13,qword ptr [RBX + 0x78]
IMUL RBP,qword ptr [RBX + 0x98],0x30
MOV R12,R13
ADD R12,RBP
MOV RAX,qword ptr [R15 + 0x10]
MOV qword ptr [RSP + 0x20],RAX
MOVUPS XMM0,xmmword ptr [R15]
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOV RDI,qword ptr [R13 + RBP*0x1 + 0x10]
MOV RSI,qword ptr [R13 + RBP*0x1 + 0x18]
SUB RSI,RDI
MOV RDX,R14
MOV RCX,R15
CALL 0x001242b0
MOVSXD RSI,EAX
MOV RAX,qword ptr [R13 + RBP*0x1 + 0x18]
SUB RAX,qword ptr [R13 + RBP*0x1 + 0x10]
CMP RAX,RSI
JA 0x00198457
LEA RDI,[0x10 + RBP*0x1]
ADD RDI,R13
INC RSI
LAB_00198438:
CALL 0x0015db5e
MOV RDI,qword ptr [R12 + 0x10]
MOV RSI,qword ptr [R12 + 0x18]
SUB RSI,RDI
LEA RCX,[RSP + 0x10]
MOV RDX,R14
CALL 0x001242b0
LAB_00198457:
MOV EAX,dword ptr [RSP + 0xc]
MOV dword ptr [R12],EAX
MOV AL,byte ptr [RBX + 0x68]
MOV byte ptr [R12 + 0x4],AL
AND qword ptr [R12 + 0x8],0x0
CMP byte ptr [RBX + 0x69],0x1
JNZ 0x00198481
CALL 0x00198266
SUB RAX,qword ptr [RBX + 0x70]
MOV qword ptr [R12 + 0x8],RAX
LAB_00198481:
MOV byte ptr [R12 + 0x28],0x0
MOV RAX,qword ptr [RBX + 0x80]
MOV RCX,qword ptr [RBX + 0x98]
INC RCX
SUB RAX,qword ptr [RBX + 0x78]
PUSH 0x30
POP R15
CQO
IDIV R15
MOV RSI,RAX
MOV RAX,RCX
XOR EDX,EDX
DIV RSI
MOV qword ptr [RBX + 0x98],RDX
CMP RDX,qword ptr [RBX + 0x90]
JNZ 0x00198598
ADD RSI,RSI
LAB_001984c7:
LEA RDI,[RSP + 0x10]
LEA RDX,[RSP + 0xb]
CALL 0x0019901e
LEA R14,[RBX + 0x78]
MOV RDI,qword ptr [RBX + 0x78]
MOV RDX,qword ptr [RBX + 0x90]
PUSH 0x10
POP R12
XOR R13D,R13D
LAB_001984ec:
IMUL RSI,RDX,0x30
ADD RSI,RDI
MOV RAX,qword ptr [RSP + 0x10]
LEA RDI,[RAX + R12*0x1]
ADD RDI,-0x10
CALL 0x00199070
MOV RCX,qword ptr [RBX + 0x90]
INC RCX
MOV RDI,qword ptr [RBX + 0x78]
MOV RAX,qword ptr [RBX + 0x80]
SUB RAX,RDI
CQO
IDIV R15
MOV RSI,RAX
MOV RAX,RCX
XOR EDX,EDX
DIV RSI
MOV qword ptr [RBX + 0x90],RDX
INC R13
ADD R12,0x30
CMP RDX,qword ptr [RBX + 0x98]
JNZ 0x001984ec
AND qword ptr [RBX + 0x90],0x0
MOV qword ptr [RBX + 0x98],R13
LAB_00198553:
MOV RDI,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x18]
SUB RAX,RDI
CQO
IDIV R15
CMP R13,RAX
JNC 0x00198580
ADD RDI,R12
LAB_0019856d:
MOV ESI,0x100
CALL 0x0015db5e
LAB_00198577:
INC R13
ADD R12,0x30
JMP 0x00198553
LAB_00198580:
LEA R15,[RSP + 0x10]
MOV RDI,R14
MOV RSI,R15
CALL 0x0019914e
MOV RDI,R15
CALL 0x0019883a
LAB_00198598:
LEA RDI,[RBX + 0x30]
CALL 0x00123480
LAB_001985a1:
MOV RDI,RBX
CALL 0x001236d0
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* common_log::add(ggml_log_level, char const*, __va_list_tag*) */
void __thiscall common_log::add(common_log *this,int4 param_2,char *param_3,long *param_4)
{
char *__s;
int iVar1;
long lVar2;
ulong uVar3;
ulong uVar4;
long lVar5;
int4 *puVar6;
allocator local_4d;
int4 local_4c;
long local_48;
long lStack_40;
long local_38;
std::mutex::lock((mutex *)this);
if (this[0x6a] == (common_log)0x1) {
lVar2 = *(long *)(this + 0x78);
lVar5 = *(long *)(this + 0x98) * 0x30;
puVar6 = (int4 *)(lVar2 + lVar5);
local_38 = param_4[2];
local_48 = *param_4;
lStack_40 = param_4[1];
__s = *(char **)(lVar2 + 0x10 + lVar5);
local_4c = param_2;
iVar1 = vsnprintf(__s,*(long *)(lVar2 + 0x18 + lVar5) - (long)__s,param_3,param_4);
if ((ulong)(*(long *)(lVar2 + 0x18 + lVar5) - *(long *)(lVar2 + 0x10 + lVar5)) <=
(ulong)(long)iVar1) {
/* try { // try from 00198438 to 0019843c has its CatchHandler @ 001985ba */
std::vector<char,std::allocator<char>>::resize
((vector<char,std::allocator<char>> *)(lVar5 + 0x10 + lVar2),(long)iVar1 + 1);
vsnprintf(*(char **)(puVar6 + 4),*(long *)(puVar6 + 6) - (long)*(char **)(puVar6 + 4),param_3,
&local_48);
}
*puVar6 = local_4c;
*(common_log *)(puVar6 + 1) = this[0x68];
*(int8 *)(puVar6 + 2) = 0;
if (this[0x69] == (common_log)0x1) {
lVar2 = t_us();
*(long *)(puVar6 + 2) = lVar2 - *(long *)(this + 0x70);
}
*(int1 *)(puVar6 + 10) = 0;
uVar3 = (*(long *)(this + 0x80) - *(long *)(this + 0x78)) / 0x30;
uVar4 = (*(long *)(this + 0x98) + 1U) % uVar3;
*(ulong *)(this + 0x98) = uVar4;
if (uVar4 == *(ulong *)(this + 0x90)) {
/* try { // try from 001984c7 to 001984d5 has its CatchHandler @ 001985b8 */
std::vector<common_log_entry,std::allocator<common_log_entry>>::vector
((vector<common_log_entry,std::allocator<common_log_entry>> *)&local_48,uVar3 * 2,
&local_4d);
lVar2 = *(long *)(this + 0x78);
uVar3 = *(ulong *)(this + 0x90);
lVar5 = 0x10;
uVar4 = 0;
do {
common_log_entry::operator=
((common_log_entry *)(local_48 + lVar5 + -0x10),
(common_log_entry *)(uVar3 * 0x30 + lVar2));
lVar2 = *(long *)(this + 0x78);
uVar3 = (*(long *)(this + 0x90) + 1U) % (ulong)((*(long *)(this + 0x80) - lVar2) / 0x30);
*(ulong *)(this + 0x90) = uVar3;
uVar4 = uVar4 + 1;
lVar5 = lVar5 + 0x30;
} while (uVar3 != *(ulong *)(this + 0x98));
*(int8 *)(this + 0x90) = 0;
*(ulong *)(this + 0x98) = uVar4;
while( true ) {
if ((ulong)((lStack_40 - local_48) / 0x30) <= uVar4) break;
/* try { // try from 0019856d to 00198576 has its CatchHandler @ 001985bf */
std::vector<char,std::allocator<char>>::resize
((vector<char,std::allocator<char>> *)(local_48 + lVar5),0x100);
uVar4 = uVar4 + 1;
lVar5 = lVar5 + 0x30;
}
std::vector<common_log_entry,std::allocator<common_log_entry>>::_M_move_assign
(this + 0x78,(vector<common_log_entry,std::allocator<common_log_entry>> *)&local_48,
(lStack_40 - local_48) % 0x30);
std::vector<common_log_entry,std::allocator<common_log_entry>>::~vector
((vector<common_log_entry,std::allocator<common_log_entry>> *)&local_48);
}
std::condition_variable::notify_one();
}
pthread_mutex_unlock((pthread_mutex_t *)this);
return;
}
| |
44,865 | msgpack23::Packer<true>::pack_type(long const&) | msgpack23/include/msgpack23/msgpack23.h | void pack_type(std::int64_t const &value) {
if (
value > std::numeric_limits<std::int32_t>::min()
and value < std::numeric_limits<std::int32_t>::max()
) {
pack_type(static_cast<std::int32_t>(value));
} else {
emplace_combined(FormatConstants::int64, value);
}
} | O0 | c | msgpack23::Packer<true>::pack_type(long const&):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x399e0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
cmpq %rcx, %rax
jle 0x396ed
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
callq 0x399f0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x396ed
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl %eax, -0x14(%rbp)
leaq -0x14(%rbp), %rsi
callq 0x39a00
jmp 0x39702
movq -0x28(%rbp), %rdi
movb $-0x2d, -0x15(%rbp)
movq -0x10(%rbp), %rdx
leaq -0x15(%rbp), %rsi
callq 0x39a90
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ZN9msgpack236PackerILb1EE9pack_typeERKl:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_20], rax
call _ZNSt14numeric_limitsIiE3minEv; std::numeric_limits<int>::min(void)
mov ecx, eax
mov rax, [rbp+var_20]
movsxd rcx, ecx
cmp rax, rcx
jle short loc_396ED
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_30], rax
call _ZNSt14numeric_limitsIiE3maxEv; std::numeric_limits<int>::max(void)
mov ecx, eax
mov rax, [rbp+var_30]
movsxd rcx, ecx
cmp rax, rcx
jge short loc_396ED
mov rdi, [rbp+var_28]
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_14], eax
lea rsi, [rbp+var_14]
call _ZN9msgpack236PackerILb1EE9pack_typeERKi; msgpack23::Packer<true>::pack_type(int const&)
jmp short loc_39702
loc_396ED:
mov rdi, [rbp+var_28]
mov [rbp+var_15], 0D3h
mov rdx, [rbp+var_10]
lea rsi, [rbp+var_15]
call _ZN9msgpack236PackerILb1EE16emplace_combinedITkSt8integrallEEvRKNS_15FormatConstantsERKT_
loc_39702:
add rsp, 30h
pop rbp
retn
| long long msgpack23::Packer<true>::pack_type(long long a1, long long *a2)
{
long long v3; // [rsp+0h] [rbp-30h]
long long v4; // [rsp+10h] [rbp-20h]
char v5; // [rsp+1Bh] [rbp-15h] BYREF
int v6; // [rsp+1Ch] [rbp-14h] BYREF
long long *v7; // [rsp+20h] [rbp-10h]
long long v8; // [rsp+28h] [rbp-8h]
v8 = a1;
v7 = a2;
v4 = *a2;
if ( v4 <= (int)std::numeric_limits<int>::min() || (v3 = *v7, v3 >= (int)std::numeric_limits<int>::max()) )
{
v5 = -45;
return ZN9msgpack236PackerILb1EE16emplace_combinedITkSt8integrallEEvRKNS_15FormatConstantsERKT_(a1, &v5, v7);
}
else
{
v6 = *v7;
return msgpack23::Packer<true>::pack_type(a1, &v6);
}
}
| pack_type:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
CALL 0x001399e0
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,ECX
CMP RAX,RCX
JLE 0x001396ed
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x30],RAX
CALL 0x001399f0
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOVSXD RCX,ECX
CMP RAX,RCX
JGE 0x001396ed
MOV RDI,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV dword ptr [RBP + -0x14],EAX
LEA RSI,[RBP + -0x14]
CALL 0x00139a00
JMP 0x00139702
LAB_001396ed:
MOV RDI,qword ptr [RBP + -0x28]
MOV byte ptr [RBP + -0x15],0xd3
MOV RDX,qword ptr [RBP + -0x10]
LEA RSI,[RBP + -0x15]
CALL 0x00139a90
LAB_00139702:
ADD RSP,0x30
POP RBP
RET
|
/* msgpack23::Packer<true>::pack_type(long const&) */
void __thiscall msgpack23::Packer<true>::pack_type(Packer<true> *this,long *param_1)
{
long lVar1;
int iVar2;
int1 local_1d;
int local_1c;
long *local_18;
Packer<true> *local_10;
lVar1 = *param_1;
local_18 = param_1;
local_10 = this;
iVar2 = std::numeric_limits<int>::min();
if ((iVar2 < lVar1) && (lVar1 = *local_18, iVar2 = std::numeric_limits<int>::max(), lVar1 < iVar2)
) {
local_1c = (int)*local_18;
pack_type(this,&local_1c);
return;
}
local_1d = 0xd3;
_ZN9msgpack236PackerILb1EE16emplace_combinedITkSt8integrallEEvRKNS_15FormatConstantsERKT_
(this,&local_1d,local_18);
return;
}
| |
44,866 | key_cache_read | eloqsql/mysys/mf_keycache.c | uchar *key_cache_read(KEY_CACHE *keycache,
File file, my_off_t filepos, int level,
uchar *buff, uint length,
uint block_length, int return_buffer)
{
if (keycache->can_be_used)
return keycache->interface_funcs->read(keycache->keycache_cb,
file, filepos, level,
buff, length,
block_length, return_buffer);
/* We can't use mutex here as the key cache may not be initialized */
if (my_pread(file, (uchar*) buff, length, filepos, MYF(MY_NABP)))
return (uchar *) 0;
return buff;
} | O0 | c | key_cache_read:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x49(%rax)
je 0xe4b3d
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %r8
movl -0x34(%rbp), %r9d
movl 0x10(%rbp), %r11d
movl 0x18(%rbp), %r10d
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
callq *%rax
movq %rax, -0x8(%rbp)
jmp 0xe4b70
movl -0x14(%rbp), %edi
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %eax
movl %eax, %edx
movq -0x20(%rbp), %rcx
movl $0x4, %r8d
callq 0xf4630
cmpq $0x0, %rax
je 0xe4b68
movq $0x0, -0x8(%rbp)
jmp 0xe4b70
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| key_cache_read:
push rbp
mov rbp, rsp
sub rsp, 50h
mov eax, [rbp+arg_8]
mov eax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov [rbp+var_30], r8
mov [rbp+var_34], r9d
mov rax, [rbp+var_10]
cmp byte ptr [rax+49h], 0
jz short loc_E4B3D
mov rax, [rbp+var_10]
mov rax, [rax+10h]
mov rax, [rax+18h]
mov rcx, [rbp+var_10]
mov rdi, [rcx+8]
mov esi, [rbp+var_14]
mov rdx, [rbp+var_20]
mov ecx, [rbp+var_24]
mov r8, [rbp+var_30]
mov r9d, [rbp+var_34]
mov r11d, [rbp+arg_0]
mov r10d, [rbp+arg_8]
mov [rsp+50h+var_50], r11d
mov [rsp+50h+var_48], r10d
call rax
mov [rbp+var_8], rax
jmp short loc_E4B70
loc_E4B3D:
mov edi, [rbp+var_14]
mov rsi, [rbp+var_30]
mov eax, [rbp+var_34]
mov edx, eax
mov rcx, [rbp+var_20]
mov r8d, 4
call my_pread
cmp rax, 0
jz short loc_E4B68
mov [rbp+var_8], 0
jmp short loc_E4B70
loc_E4B68:
mov rax, [rbp+var_30]
mov [rbp+var_8], rax
loc_E4B70:
mov rax, [rbp+var_8]
add rsp, 50h
pop rbp
retn
| long long key_cache_read(
long long a1,
unsigned int a2,
long long a3,
unsigned int a4,
long long a5,
unsigned int a6,
int a7,
int a8)
{
if ( *(_BYTE *)(a1 + 73) )
return (*(long long ( **)(_QWORD, _QWORD, long long, _QWORD, long long, _QWORD, int, int))(*(_QWORD *)(a1 + 16)
+ 24LL))(
*(_QWORD *)(a1 + 8),
a2,
a3,
a4,
a5,
a6,
a7,
a8);
if ( my_pread(a2, a5, a6, a3, 4LL) )
return 0LL;
return a5;
}
| key_cache_read:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV EAX,dword ptr [RBP + 0x18]
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV qword ptr [RBP + -0x30],R8
MOV dword ptr [RBP + -0x34],R9D
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX + 0x49],0x0
JZ 0x001e4b3d
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RCX + 0x8]
MOV ESI,dword ptr [RBP + -0x14]
MOV RDX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x24]
MOV R8,qword ptr [RBP + -0x30]
MOV R9D,dword ptr [RBP + -0x34]
MOV R11D,dword ptr [RBP + 0x10]
MOV R10D,dword ptr [RBP + 0x18]
MOV dword ptr [RSP],R11D
MOV dword ptr [RSP + 0x8],R10D
CALL RAX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001e4b70
LAB_001e4b3d:
MOV EDI,dword ptr [RBP + -0x14]
MOV RSI,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RBP + -0x34]
MOV EDX,EAX
MOV RCX,qword ptr [RBP + -0x20]
MOV R8D,0x4
CALL 0x001f4630
CMP RAX,0x0
JZ 0x001e4b68
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001e4b70
LAB_001e4b68:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x8],RAX
LAB_001e4b70:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x50
POP RBP
RET
|
int8
key_cache_read(long param_1,int4 param_2,int8 param_3,int4 param_4,
int8 param_5,int4 param_6,int4 param_7,int4 param_8)
{
long lVar1;
int8 local_10;
if (*(char *)(param_1 + 0x49) == '\0') {
lVar1 = my_pread(param_2,param_5,param_6,param_3,4);
local_10 = param_5;
if (lVar1 != 0) {
local_10 = 0;
}
}
else {
local_10 = (**(code **)(*(long *)(param_1 + 0x10) + 0x18))
(*(int8 *)(param_1 + 8),param_2,param_3,param_4,param_5,param_6,
param_7,param_8);
}
return local_10;
}
| |
44,867 | PFS_user_allocator::free_array(PFS_user_array*) | eloqsql/storage/perfschema/pfs_buffer_container.cc | void PFS_user_allocator::free_array(PFS_user_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_user,
size, sizeof(PFS_user), array->m_ptr);
array->m_ptr= NULL;
PFS_FREE_ARRAY(& builtin_memory_user_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_user_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_user_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_user_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_user_memory,
memory_sizing, sizeof(PFS_memory_stat),
array->m_instr_class_memory_array);
array->m_instr_class_memory_array= NULL;
} | O0 | cpp | PFS_user_allocator::free_array(PFS_user_array*):
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
leaq 0x3dd2d9(%rip), %rcx # 0x40ce20
movl (%rcx), %ecx
imulq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
leaq 0x3dca74(%rip), %rcx # 0x40c5d0
imulq (%rcx), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
leaq 0x3dca71(%rip), %rcx # 0x40c5e0
imulq (%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
leaq 0x3dca8e(%rip), %rcx # 0x40c610
imulq (%rcx), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
leaq 0x3dca6b(%rip), %rcx # 0x40c600
imulq (%rcx), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
leaq 0x3d91d0(%rip), %rdi # 0x408d80
movl $0x9c0, %edx # imm = 0x9C0
callq 0x29be0
movq -0x10(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rcx
leaq 0x3d92e7(%rip), %rdi # 0x408ec0
movl $0x20, %edx
callq 0x29be0
movq -0x10(%rbp), %rax
movq $0x0, 0x60(%rax)
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rcx
leaq 0x3d93fe(%rip), %rdi # 0x409000
movl $0x20, %edx
callq 0x29be0
movq -0x10(%rbp), %rax
movq $0x0, 0x68(%rax)
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rcx
leaq 0x3d9515(%rip), %rdi # 0x409140
movl $0xb8, %edx
callq 0x29be0
movq -0x10(%rbp), %rax
movq $0x0, 0x70(%rax)
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rcx
leaq 0x3d962c(%rip), %rdi # 0x409280
movl $0x58, %edx
callq 0x29be0
movq -0x10(%rbp), %rax
movq $0x0, 0x78(%rax)
movq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rcx
leaq 0x3d9740(%rip), %rdi # 0x4093c0
movl $0x48, %edx
callq 0x29be0
movq -0x10(%rbp), %rax
movq $0x0, 0x80(%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
| _ZN18PFS_user_allocator10free_arrayEP14PFS_user_array:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov rax, [rax+50h]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
lea rcx, wait_class_max
mov ecx, [rcx]
imul rax, rcx
mov [rbp+var_20], rax
mov rax, [rbp+var_18]
lea rcx, stage_class_max
imul rax, [rcx]
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
lea rcx, statement_class_max
imul rax, [rcx]
mov [rbp+var_30], rax
mov rax, [rbp+var_18]
lea rcx, transaction_class_max
imul rax, [rcx]
mov [rbp+var_38], rax
mov rax, [rbp+var_18]
lea rcx, memory_class_max
imul rax, [rcx]
mov [rbp+var_40], rax
mov rsi, [rbp+var_18]
mov rax, [rbp+var_10]
mov rcx, [rax+48h]
lea rdi, builtin_memory_user
mov edx, 9C0h
call _Z14pfs_free_arrayP24PFS_builtin_memory_classmmPv; pfs_free_array(PFS_builtin_memory_class *,ulong,ulong,void *)
mov rax, [rbp+var_10]
mov qword ptr [rax+48h], 0
mov rsi, [rbp+var_20]
mov rax, [rbp+var_10]
mov rcx, [rax+60h]
lea rdi, builtin_memory_user_waits
mov edx, 20h ; ' '
call _Z14pfs_free_arrayP24PFS_builtin_memory_classmmPv; pfs_free_array(PFS_builtin_memory_class *,ulong,ulong,void *)
mov rax, [rbp+var_10]
mov qword ptr [rax+60h], 0
mov rsi, [rbp+var_28]
mov rax, [rbp+var_10]
mov rcx, [rax+68h]
lea rdi, builtin_memory_user_stages
mov edx, 20h ; ' '
call _Z14pfs_free_arrayP24PFS_builtin_memory_classmmPv; pfs_free_array(PFS_builtin_memory_class *,ulong,ulong,void *)
mov rax, [rbp+var_10]
mov qword ptr [rax+68h], 0
mov rsi, [rbp+var_30]
mov rax, [rbp+var_10]
mov rcx, [rax+70h]
lea rdi, builtin_memory_user_statements
mov edx, 0B8h
call _Z14pfs_free_arrayP24PFS_builtin_memory_classmmPv; pfs_free_array(PFS_builtin_memory_class *,ulong,ulong,void *)
mov rax, [rbp+var_10]
mov qword ptr [rax+70h], 0
mov rsi, [rbp+var_38]
mov rax, [rbp+var_10]
mov rcx, [rax+78h]
lea rdi, builtin_memory_user_transactions
mov edx, 58h ; 'X'
call _Z14pfs_free_arrayP24PFS_builtin_memory_classmmPv; pfs_free_array(PFS_builtin_memory_class *,ulong,ulong,void *)
mov rax, [rbp+var_10]
mov qword ptr [rax+78h], 0
mov rsi, [rbp+var_40]
mov rax, [rbp+var_10]
mov rcx, [rax+80h]
lea rdi, builtin_memory_user_memory
mov edx, 48h ; 'H'
call _Z14pfs_free_arrayP24PFS_builtin_memory_classmmPv; pfs_free_array(PFS_builtin_memory_class *,ulong,ulong,void *)
mov rax, [rbp+var_10]
mov qword ptr [rax+80h], 0
add rsp, 40h
pop rbp
retn
| PFS_user_array * PFS_user_allocator::free_array(PFS_user_allocator *this, PFS_user_array *a2)
{
PFS_user_array *result; // rax
long long v3; // [rsp+0h] [rbp-40h]
long long v4; // [rsp+8h] [rbp-38h]
long long v5; // [rsp+10h] [rbp-30h]
long long v6; // [rsp+18h] [rbp-28h]
long long v7; // [rsp+20h] [rbp-20h]
long long v8; // [rsp+28h] [rbp-18h]
v8 = *((_QWORD *)a2 + 10);
v7 = (unsigned int)wait_class_max * v8;
v6 = stage_class_max * v8;
v5 = statement_class_max * v8;
v4 = transaction_class_max * v8;
v3 = memory_class_max * v8;
pfs_free_array((PFS_builtin_memory_class *)&builtin_memory_user, v8, 2496LL, *((void **)a2 + 9));
*((_QWORD *)a2 + 9) = 0LL;
pfs_free_array((PFS_builtin_memory_class *)&builtin_memory_user_waits, v7, 32LL, *((void **)a2 + 12));
*((_QWORD *)a2 + 12) = 0LL;
pfs_free_array((PFS_builtin_memory_class *)&builtin_memory_user_stages, v6, 32LL, *((void **)a2 + 13));
*((_QWORD *)a2 + 13) = 0LL;
pfs_free_array((PFS_builtin_memory_class *)&builtin_memory_user_statements, v5, 184LL, *((void **)a2 + 14));
*((_QWORD *)a2 + 14) = 0LL;
pfs_free_array((PFS_builtin_memory_class *)&builtin_memory_user_transactions, v4, 88LL, *((void **)a2 + 15));
*((_QWORD *)a2 + 15) = 0LL;
pfs_free_array((PFS_builtin_memory_class *)&builtin_memory_user_memory, v3, 72LL, *((void **)a2 + 16));
result = a2;
*((_QWORD *)a2 + 16) = 0LL;
return result;
}
| free_array:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x50]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[0x50ce20]
MOV ECX,dword ptr [RCX]
IMUL RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[0x50c5d0]
IMUL RAX,qword ptr [RCX]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[0x50c5e0]
IMUL RAX,qword ptr [RCX]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[0x50c610]
IMUL RAX,qword ptr [RCX]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[0x50c600]
IMUL RAX,qword ptr [RCX]
MOV qword ptr [RBP + -0x40],RAX
MOV RSI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x48]
LEA RDI,[0x508d80]
MOV EDX,0x9c0
CALL 0x00129be0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x48],0x0
MOV RSI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x60]
LEA RDI,[0x508ec0]
MOV EDX,0x20
CALL 0x00129be0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x60],0x0
MOV RSI,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x68]
LEA RDI,[0x509000]
MOV EDX,0x20
CALL 0x00129be0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x68],0x0
MOV RSI,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x70]
LEA RDI,[0x509140]
MOV EDX,0xb8
CALL 0x00129be0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x70],0x0
MOV RSI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x78]
LEA RDI,[0x509280]
MOV EDX,0x58
CALL 0x00129be0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x78],0x0
MOV RSI,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x80]
LEA RDI,[0x5093c0]
MOV EDX,0x48
CALL 0x00129be0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x80],0x0
ADD RSP,0x40
POP RBP
RET
|
/* PFS_user_allocator::free_array(PFS_user_array*) */
void __thiscall PFS_user_allocator::free_array(PFS_user_allocator *this,PFS_user_array *param_1)
{
ulong uVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
ulong uVar5;
ulong uVar6;
uVar1 = *(ulong *)(param_1 + 0x50);
uVar6 = (ulong)wait_class_max;
uVar2 = uVar1 * stage_class_max;
uVar3 = uVar1 * statement_class_max;
uVar4 = uVar1 * transaction_class_max;
uVar5 = uVar1 * memory_class_max;
pfs_free_array((PFS_builtin_memory_class *)builtin_memory_user,uVar1,0x9c0,
*(void **)(param_1 + 0x48));
*(int8 *)(param_1 + 0x48) = 0;
pfs_free_array((PFS_builtin_memory_class *)builtin_memory_user_waits,uVar1 * uVar6,0x20,
*(void **)(param_1 + 0x60));
*(int8 *)(param_1 + 0x60) = 0;
pfs_free_array((PFS_builtin_memory_class *)builtin_memory_user_stages,uVar2,0x20,
*(void **)(param_1 + 0x68));
*(int8 *)(param_1 + 0x68) = 0;
pfs_free_array((PFS_builtin_memory_class *)builtin_memory_user_statements,uVar3,0xb8,
*(void **)(param_1 + 0x70));
*(int8 *)(param_1 + 0x70) = 0;
pfs_free_array((PFS_builtin_memory_class *)builtin_memory_user_transactions,uVar4,0x58,
*(void **)(param_1 + 0x78));
*(int8 *)(param_1 + 0x78) = 0;
pfs_free_array((PFS_builtin_memory_class *)builtin_memory_user_memory,uVar5,0x48,
*(void **)(param_1 + 0x80));
*(int8 *)(param_1 + 0x80) = 0;
return;
}
| |
44,868 | my_append_fix_badly_formed_tail | eloqsql/strings/ctype-mb.c | static size_t
my_append_fix_badly_formed_tail(CHARSET_INFO *cs,
char *to, char *to_end,
const char *from, const char *from_end,
size_t nchars,
MY_STRCOPY_STATUS *status)
{
char *to0= to;
for ( ; nchars; nchars--)
{
int chlen;
if ((chlen= my_ci_charlen(cs, (const uchar*) from,
(const uchar *) from_end)) > 0)
{
/* Found a valid character */ /* chlen == 1..MBMAXLEN */
DBUG_ASSERT(chlen <= (int) cs->mbmaxlen);
if (to + chlen > to_end)
goto end; /* Does not fit to "to" */
memcpy(to, from, (size_t) chlen);
from+= chlen;
to+= chlen;
continue;
}
if (chlen == MY_CS_ILSEQ) /* chlen == 0 */
{
DBUG_ASSERT(from < from_end); /* Shouldn't get MY_CS_ILSEQ if empty */
goto bad;
}
/* Got an incomplete character */ /* chlen == MY_CS_TOOSMALLXXX */
DBUG_ASSERT(chlen >= MY_CS_TOOSMALL6);
DBUG_ASSERT(chlen <= MY_CS_TOOSMALL);
if (from >= from_end)
break; /* End of the source string */
bad:
/* Bad byte sequence, or incomplete character found */
if (!status->m_well_formed_error_pos)
status->m_well_formed_error_pos= from;
if ((chlen= my_ci_wc_mb(cs, '?', (uchar*) to, (uchar *) to_end)) <= 0)
break; /* Question mark does not fit into the destination */
to+= chlen;
from++;
}
end:
status->m_source_end_pos= from;
return to - to0;
} | O0 | c | my_append_fix_badly_formed_tail:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x46ca5
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x462b0
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
jle 0x46c12
jmp 0x46bc2
jmp 0x46bc4
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
addq %rcx, %rax
cmpq -0x18(%rbp), %rax
jbe 0x46bda
jmp 0x46ca7
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movslq -0x3c(%rbp), %rdx
callq 0x24200
movl -0x3c(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x3c(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x46c94
cmpl $0x0, -0x3c(%rbp)
jne 0x46c1e
jmp 0x46c1a
jmp 0x46c1c
jmp 0x46c34
jmp 0x46c20
jmp 0x46c22
jmp 0x46c24
jmp 0x46c26
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x46c32
jmp 0x46ca5
jmp 0x46c34
movq 0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x46c4b
movq -0x20(%rbp), %rcx
movq 0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x3f, %esi
callq *%rax
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
jg 0x46c77
jmp 0x46ca5
movl -0x3c(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x46b9c
jmp 0x46ca7
movq -0x20(%rbp), %rcx
movq 0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
subq %rcx, %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_append_fix_badly_formed_tail:
push rbp
mov rbp, rsp
sub rsp, 40h
mov rax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_10]
mov [rbp+var_38], rax
loc_46B9C:
cmp [rbp+var_30], 0
jz loc_46CA5
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
call my_ci_charlen_2
mov [rbp+var_3C], eax
cmp eax, 0
jle short loc_46C12
jmp short $+2
loc_46BC2:
jmp short $+2
loc_46BC4:
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_3C]
add rax, rcx
cmp rax, [rbp+var_18]
jbe short loc_46BDA
jmp loc_46CA7
loc_46BDA:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
movsxd rdx, [rbp+var_3C]
call _memcpy
mov ecx, [rbp+var_3C]
mov rax, [rbp+var_20]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_20], rax
mov ecx, [rbp+var_3C]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
jmp loc_46C94
loc_46C12:
cmp [rbp+var_3C], 0
jnz short loc_46C1E
jmp short $+2
loc_46C1A:
jmp short $+2
loc_46C1C:
jmp short loc_46C34
loc_46C1E:
jmp short $+2
loc_46C20:
jmp short $+2
loc_46C22:
jmp short $+2
loc_46C24:
jmp short $+2
loc_46C26:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jb short loc_46C32
jmp short loc_46CA5
loc_46C32:
jmp short $+2
loc_46C34:
mov rax, [rbp+arg_0]
cmp qword ptr [rax+8], 0
jnz short loc_46C4B
mov rcx, [rbp+var_20]
mov rax, [rbp+arg_0]
mov [rax+8], rcx
loc_46C4B:
mov rax, [rbp+var_8]
mov rax, [rax+0B8h]
mov rax, [rax+30h]
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_18]
mov esi, 3Fh ; '?'
call rax
mov [rbp+var_3C], eax
cmp eax, 0
jg short loc_46C77
jmp short loc_46CA5
loc_46C77:
mov ecx, [rbp+var_3C]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
loc_46C94:
mov rax, [rbp+var_30]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_30], rax
jmp loc_46B9C
loc_46CA5:
jmp short $+2
loc_46CA7:
mov rcx, [rbp+var_20]
mov rax, [rbp+arg_0]
mov [rax], rcx
mov rax, [rbp+var_10]
mov rcx, [rbp+var_38]
sub rax, rcx
add rsp, 40h
pop rbp
retn
| long long my_append_fix_badly_formed_tail(
long long a1,
long long a2,
unsigned long long a3,
unsigned long long a4,
unsigned long long a5,
long long a6,
unsigned long long *a7)
{
int v8; // [rsp+4h] [rbp-3Ch]
int v9; // [rsp+4h] [rbp-3Ch]
long long v14; // [rsp+30h] [rbp-10h]
v14 = a2;
while ( a6 )
{
v8 = my_ci_charlen_2(a1, a4, a5);
if ( v8 <= 0 )
{
if ( v8 && a4 >= a5 )
break;
if ( !a7[1] )
a7[1] = a4;
v9 = (*(long long ( **)(long long, long long, long long, unsigned long long))(*(_QWORD *)(a1 + 184) + 48LL))(
a1,
63LL,
v14,
a3);
if ( v9 <= 0 )
break;
v14 += v9;
++a4;
}
else
{
if ( v8 + v14 > a3 )
break;
memcpy(v14, a4, v8);
a4 += v8;
v14 += v8;
}
--a6;
}
*a7 = a4;
return v14 - a2;
}
| my_append_fix_badly_formed_tail:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x38],RAX
LAB_00146b9c:
CMP qword ptr [RBP + -0x30],0x0
JZ 0x00146ca5
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
CALL 0x001462b0
MOV dword ptr [RBP + -0x3c],EAX
CMP EAX,0x0
JLE 0x00146c12
JMP 0x00146bc2
LAB_00146bc2:
JMP 0x00146bc4
LAB_00146bc4:
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x3c]
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x18]
JBE 0x00146bda
JMP 0x00146ca7
LAB_00146bda:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
MOVSXD RDX,dword ptr [RBP + -0x3c]
CALL 0x00124200
MOV ECX,dword ptr [RBP + -0x3c]
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV ECX,dword ptr [RBP + -0x3c]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00146c94
LAB_00146c12:
CMP dword ptr [RBP + -0x3c],0x0
JNZ 0x00146c1e
JMP 0x00146c1a
LAB_00146c1a:
JMP 0x00146c1c
LAB_00146c1c:
JMP 0x00146c34
LAB_00146c1e:
JMP 0x00146c20
LAB_00146c20:
JMP 0x00146c22
LAB_00146c22:
JMP 0x00146c24
LAB_00146c24:
JMP 0x00146c26
LAB_00146c26:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x00146c32
JMP 0x00146ca5
LAB_00146c32:
JMP 0x00146c34
LAB_00146c34:
MOV RAX,qword ptr [RBP + 0x10]
CMP qword ptr [RAX + 0x8],0x0
JNZ 0x00146c4b
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
LAB_00146c4b:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x30]
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x18]
MOV ESI,0x3f
CALL RAX
MOV dword ptr [RBP + -0x3c],EAX
CMP EAX,0x0
JG 0x00146c77
JMP 0x00146ca5
LAB_00146c77:
MOV ECX,dword ptr [RBP + -0x3c]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
LAB_00146c94:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x30],RAX
JMP 0x00146b9c
LAB_00146ca5:
JMP 0x00146ca7
LAB_00146ca7:
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x38]
SUB RAX,RCX
ADD RSP,0x40
POP RBP
RET
|
long my_append_fix_badly_formed_tail
(long param_1,void *param_2,ulong param_3,void *param_4,void *param_5,long param_6,
int8 *param_7)
{
int iVar1;
long local_38;
void *local_28;
void *local_18;
local_28 = param_4;
local_18 = param_2;
for (local_38 = param_6; local_38 != 0; local_38 = local_38 + -1) {
iVar1 = my_ci_charlen(param_1,local_28,param_5);
if (iVar1 < 1) {
if ((iVar1 != 0) && (param_5 <= local_28)) break;
if (param_7[1] == 0) {
param_7[1] = local_28;
}
iVar1 = (**(code **)(*(long *)(param_1 + 0xb8) + 0x30))(param_1,0x3f,local_18,param_3);
if (iVar1 < 1) break;
local_28 = (void *)((long)local_28 + 1);
}
else {
if (param_3 < (ulong)((long)local_18 + (long)iVar1)) break;
memcpy(local_18,local_28,(long)iVar1);
local_28 = (void *)((long)local_28 + (long)iVar1);
}
local_18 = (void *)((long)local_18 + (long)iVar1);
}
*param_7 = local_28;
return (long)local_18 - (long)param_2;
}
| |
44,869 | my_strnxfrm_tis620_nopad | eloqsql/strings/ctype-tis620.c | static size_t
my_strnxfrm_tis620_nopad(CHARSET_INFO *cs,
uchar *dst, size_t dstlen, uint nweights,
const uchar *src, size_t srclen, uint flags)
{
size_t len, dstlen0= dstlen;
len= MY_MIN(dstlen, srclen);
memcpy(dst, src, len);
len= thai2sortable(dst, len);
set_if_smaller(dstlen, nweights);
set_if_smaller(len, dstlen);
len= my_strxfrm_pad_desc_and_reverse_nopad(cs, dst, dst + len, dst + dstlen,
(uint)(dstlen - len), flags, 0);
if ((flags & MY_STRXFRM_PAD_TO_MAXLEN) && len < dstlen0)
{
size_t fill_length= dstlen0 - len;
memset(dst + len, 0x00, fill_length);
len= dstlen0;
}
return len;
} | O0 | c | my_strnxfrm_tis620_nopad:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0xfcaee
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0xfcaf6
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x3a0b0
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xfc890
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
cmpq %rcx, %rax
jbe 0xfcb33
movl -0x1c(%rbp), %eax
movq %rax, -0x18(%rbp)
jmp 0xfcb35
jmp 0xfcb37
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0xfcb49
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0xfcb4b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rcx
addq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
subq -0x38(%rbp), %rax
movl %eax, %r8d
movl 0x10(%rbp), %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0xf7010
movq %rax, -0x38(%rbp)
movl 0x10(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xfcbc2
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0xfcbc2
movq -0x40(%rbp), %rax
subq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rdx
xorl %esi, %esi
callq 0x3a2e0
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| my_strnxfrm_tis620_nopad:
push rbp
mov rbp, rsp
sub rsp, 60h
mov eax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rax, [rbp+var_18]
cmp rax, [rbp+var_30]
jnb short loc_FCAEE
mov rax, [rbp+var_18]
mov [rbp+var_50], rax
jmp short loc_FCAF6
loc_FCAEE:
mov rax, [rbp+var_30]
mov [rbp+var_50], rax
loc_FCAF6:
mov rax, [rbp+var_50]
mov [rbp+var_38], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_38]
call _memcpy
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_38]
call thai2sortable
mov [rbp+var_38], rax
mov rax, [rbp+var_18]
mov ecx, [rbp+var_1C]
cmp rax, rcx
jbe short loc_FCB33
mov eax, [rbp+var_1C]
mov [rbp+var_18], rax
loc_FCB33:
jmp short $+2
loc_FCB35:
jmp short $+2
loc_FCB37:
mov rax, [rbp+var_38]
cmp rax, [rbp+var_18]
jbe short loc_FCB49
mov rax, [rbp+var_18]
mov [rbp+var_38], rax
loc_FCB49:
jmp short $+2
loc_FCB4B:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_10]
add rdx, [rbp+var_38]
mov rcx, [rbp+var_10]
add rcx, [rbp+var_18]
mov rax, [rbp+var_18]
sub rax, [rbp+var_38]
mov r8d, eax
mov r9d, [rbp+arg_0]
xor eax, eax
mov [rsp+60h+var_60], 0
call my_strxfrm_pad_desc_and_reverse_nopad
mov [rbp+var_38], rax
mov eax, [rbp+arg_0]
and eax, 80h
cmp eax, 0
jz short loc_FCBC2
mov rax, [rbp+var_38]
cmp rax, [rbp+var_40]
jnb short loc_FCBC2
mov rax, [rbp+var_40]
sub rax, [rbp+var_38]
mov [rbp+var_48], rax
mov rdi, [rbp+var_10]
add rdi, [rbp+var_38]
mov rdx, [rbp+var_48]
xor esi, esi
call _memset
mov rax, [rbp+var_40]
mov [rbp+var_38], rax
loc_FCBC2:
mov rax, [rbp+var_38]
add rsp, 60h
pop rbp
retn
| unsigned long long my_strnxfrm_tis620_nopad(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
unsigned int a4,
long long a5,
unsigned long long a6,
unsigned int a7)
{
long long v8; // [rsp+10h] [rbp-50h]
unsigned long long v10; // [rsp+28h] [rbp-38h]
unsigned long long v11; // [rsp+28h] [rbp-38h]
unsigned long long v13; // [rsp+48h] [rbp-18h]
v13 = a3;
if ( a3 >= a6 )
v8 = a6;
else
v8 = a3;
memcpy(a2, a5, v8);
v10 = thai2sortable(a2, v8);
if ( v13 > a4 )
v13 = a4;
if ( v10 > v13 )
v10 = v13;
v11 = my_strxfrm_pad_desc_and_reverse_nopad(
a1,
(long long)a2,
(unsigned long long)&a2[v10],
(unsigned long long)&a2[v13],
(int)v13 - (int)v10,
a7,
0);
if ( (a7 & 0x80) != 0 && v11 < a3 )
{
memset(&a2[v11], 0LL, a3 - v11);
return a3;
}
return v11;
}
| my_strnxfrm_tis620_nopad:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x001fcaee
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x001fcaf6
LAB_001fcaee:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x50],RAX
LAB_001fcaf6:
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x38]
CALL 0x0013a0b0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x001fc890
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x1c]
CMP RAX,RCX
JBE 0x001fcb33
MOV EAX,dword ptr [RBP + -0x1c]
MOV qword ptr [RBP + -0x18],RAX
LAB_001fcb33:
JMP 0x001fcb35
LAB_001fcb35:
JMP 0x001fcb37
LAB_001fcb37:
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x18]
JBE 0x001fcb49
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x38],RAX
LAB_001fcb49:
JMP 0x001fcb4b
LAB_001fcb4b:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x10]
ADD RDX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr [RBP + -0x38]
MOV R8D,EAX
MOV R9D,dword ptr [RBP + 0x10]
XOR EAX,EAX
MOV dword ptr [RSP],0x0
CALL 0x001f7010
MOV qword ptr [RBP + -0x38],RAX
MOV EAX,dword ptr [RBP + 0x10]
AND EAX,0x80
CMP EAX,0x0
JZ 0x001fcbc2
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x001fcbc2
MOV RAX,qword ptr [RBP + -0x40]
SUB RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x48],RAX
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x48]
XOR ESI,ESI
CALL 0x0013a2e0
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x38],RAX
LAB_001fcbc2:
MOV RAX,qword ptr [RBP + -0x38]
ADD RSP,0x60
POP RBP
RET
|
ulong my_strnxfrm_tis620_nopad
(int8 param_1,void *param_2,ulong param_3,uint param_4,void *param_5,
ulong param_6,uint param_7)
{
size_t local_58;
ulong local_40;
ulong local_20;
local_58 = param_6;
if (param_3 < param_6) {
local_58 = param_3;
}
memcpy(param_2,param_5,local_58);
local_40 = thai2sortable(param_2,local_58);
local_20 = param_3;
if (param_4 < param_3) {
local_20 = (ulong)param_4;
}
if (local_20 < local_40) {
local_40 = local_20;
}
local_40 = my_strxfrm_pad_desc_and_reverse_nopad
(param_1,param_2,(long)param_2 + local_40,(long)param_2 + local_20,
(int)local_20 - (int)local_40,param_7,0);
if (((param_7 & 0x80) != 0) && (local_40 < param_3)) {
memset((void *)((long)param_2 + local_40),0,param_3 - local_40);
local_40 = param_3;
}
return local_40;
}
| |
44,870 | my_strnxfrm_tis620_nopad | eloqsql/strings/ctype-tis620.c | static size_t
my_strnxfrm_tis620_nopad(CHARSET_INFO *cs,
uchar *dst, size_t dstlen, uint nweights,
const uchar *src, size_t srclen, uint flags)
{
size_t len, dstlen0= dstlen;
len= MY_MIN(dstlen, srclen);
memcpy(dst, src, len);
len= thai2sortable(dst, len);
set_if_smaller(dstlen, nweights);
set_if_smaller(len, dstlen);
len= my_strxfrm_pad_desc_and_reverse_nopad(cs, dst, dst + len, dst + dstlen,
(uint)(dstlen - len), flags, 0);
if ((flags & MY_STRXFRM_PAD_TO_MAXLEN) && len < dstlen0)
{
size_t fill_length= dstlen0 - len;
memset(dst + len, 0x00, fill_length);
len= dstlen0;
}
return len;
} | O3 | c | my_strnxfrm_tis620_nopad:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r12
movl %ecx, %r15d
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r13
cmpq %r9, %rdx
cmovbq %rdx, %r12
movq %rsi, %rdi
movq %r8, %rsi
movq %r12, %rdx
callq 0x390a0
movq %r14, %rdi
movq %r12, %rsi
callq 0xbdd17
movl %r15d, %r8d
cmpq %rbx, %r8
cmovaeq %rbx, %r8
cmpq %r8, %r12
cmovaeq %r8, %r12
leaq (%r14,%r12), %rdx
leaq (%r14,%r8), %rcx
subl %r12d, %r8d
movl $0x0, (%rsp)
movq %r13, %rdi
movq %r14, %rsi
movl 0x10(%rbp), %r15d
movl %r15d, %r9d
callq 0xbabaa
testb %r15b, %r15b
jns 0xbdeaf
movq %rbx, %rdx
subq %rax, %rdx
jbe 0xbdeaf
addq %rax, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x392e0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| my_strnxfrm_tis620_nopad:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r12, r9
mov r15d, ecx
mov rbx, rdx
mov r14, rsi
mov r13, rdi
cmp rdx, r9
cmovb r12, rdx
mov rdi, rsi
mov rsi, r8
mov rdx, r12
call _memcpy
mov rdi, r14
mov rsi, r12
call thai2sortable
mov r8d, r15d
cmp r8, rbx
cmovnb r8, rbx
cmp r12, r8
cmovnb r12, r8
lea rdx, [r14+r12]
lea rcx, [r14+r8]
sub r8d, r12d
mov [rsp+30h+var_30], 0
mov rdi, r13
mov rsi, r14
mov r15d, [rbp+arg_0]
mov r9d, r15d
call my_strxfrm_pad_desc_and_reverse_nopad
test r15b, r15b
jns short loc_BDEAF
mov rdx, rbx
sub rdx, rax
jbe short loc_BDEAF
add r14, rax
mov rdi, r14
xor esi, esi
call _memset
mov rax, rbx
loc_BDEAF:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| unsigned long long my_strnxfrm_tis620_nopad(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
unsigned int a4,
long long a5,
unsigned long long a6,
unsigned int a7)
{
unsigned long long v7; // r12
unsigned long long v10; // r8
unsigned long long result; // rax
v7 = a6;
if ( a3 < a6 )
v7 = a3;
memcpy(a2, a5, v7);
thai2sortable(a2, v7);
v10 = a4;
if ( a4 >= a3 )
v10 = a3;
if ( v7 >= v10 )
v7 = v10;
result = my_strxfrm_pad_desc_and_reverse_nopad(
a1,
(long long)a2,
(unsigned long long)&a2[v7],
(unsigned long long)&a2[v10],
(int)v10 - (int)v7,
a7,
0);
if ( (a7 & 0x80u) != 0 && a3 > result )
{
memset(&a2[result], 0LL, a3 - result);
return a3;
}
return result;
}
| my_strnxfrm_tis620_nopad:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R12,R9
MOV R15D,ECX
MOV RBX,RDX
MOV R14,RSI
MOV R13,RDI
CMP RDX,R9
CMOVC R12,RDX
MOV RDI,RSI
MOV RSI,R8
MOV RDX,R12
CALL 0x001390a0
MOV RDI,R14
MOV RSI,R12
CALL 0x001bdd17
MOV R8D,R15D
CMP R8,RBX
CMOVNC R8,RBX
CMP R12,R8
CMOVNC R12,R8
LEA RDX,[R14 + R12*0x1]
LEA RCX,[R14 + R8*0x1]
SUB R8D,R12D
MOV dword ptr [RSP],0x0
MOV RDI,R13
MOV RSI,R14
MOV R15D,dword ptr [RBP + 0x10]
MOV R9D,R15D
CALL 0x001babaa
TEST R15B,R15B
JNS 0x001bdeaf
MOV RDX,RBX
SUB RDX,RAX
JBE 0x001bdeaf
ADD R14,RAX
MOV RDI,R14
XOR ESI,ESI
CALL 0x001392e0
MOV RAX,RBX
LAB_001bdeaf:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong my_strnxfrm_tis620_nopad
(int8 param_1,void *param_2,ulong param_3,uint param_4,void *param_5,
ulong param_6,int4 param_7)
{
int8 in_RAX;
ulong uVar1;
uint uVar2;
uVar2 = (uint)((ulong)in_RAX >> 0x20);
if (param_3 < param_6) {
param_6 = param_3;
}
memcpy(param_2,param_5,param_6);
thai2sortable(param_2,param_6);
uVar1 = (ulong)param_4;
if (param_3 <= param_4) {
uVar1 = param_3;
}
if (uVar1 <= param_6) {
param_6 = uVar1;
}
uVar1 = my_strxfrm_pad_desc_and_reverse_nopad
(param_1,param_2,(long)param_2 + param_6,(long)param_2 + uVar1,
(int)uVar1 - (int)param_6,param_7,(ulong)uVar2 << 0x20);
if (((char)param_7 < '\0') && (uVar1 <= param_3 && param_3 - uVar1 != 0)) {
memset((void *)((long)param_2 + uVar1),0,param_3 - uVar1);
uVar1 = param_3;
}
return uVar1;
}
| |
44,871 | test_conc155 | eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c | static int test_conc155(MYSQL *mysql)
{
MYSQL_STMT *stmt;
MYSQL_BIND bind;
char buffer[50];
int rc;
rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
check_mysql_rc(rc, mysql);
rc= mysql_query(mysql, "CREATE TABLE t1 (a TEXT)");
check_mysql_rc(rc, mysql);
rc= mysql_query(mysql, "INSERT INTO t1 VALUES ('zero terminated string')");
check_mysql_rc(rc, mysql);
stmt= mysql_stmt_init(mysql);
rc= mysql_stmt_prepare(stmt, SL("SELECT a FROM t1"));
check_stmt_rc(rc, stmt);
rc= mysql_stmt_execute(stmt);
check_stmt_rc(rc, stmt);
memset(buffer, 'X', 50);
memset(&bind, 0, sizeof(MYSQL_BIND));
bind.buffer= buffer;
bind.buffer_length= 50;
bind.buffer_type= MYSQL_TYPE_STRING;
rc= mysql_stmt_bind_result(stmt, &bind);
check_stmt_rc(rc, stmt);
rc= mysql_stmt_fetch(stmt);
check_stmt_rc(rc, stmt);
if (strlen(buffer) != strlen("zero terminated string"))
{
diag("Wrong buffer length");
return FAIL;
}
mysql_stmt_close(stmt);
rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
check_mysql_rc(rc, mysql);
return OK;
} | O0 | c | test_conc155:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x50(%rbp)
movq -0x50(%rbp), %rdi
leaq 0x4aa1f(%rip), %rsi # 0x66636
callq 0x38a70
movl %eax, -0xcc(%rbp)
cmpl $0x0, -0xcc(%rbp)
je 0x1bc86
movl -0xcc(%rbp), %eax
movl %eax, -0xdc(%rbp)
movq -0x50(%rbp), %rdi
callq 0x3c3f0
movq %rax, -0xd8(%rbp)
movq -0x50(%rbp), %rdi
callq 0x3c3c0
movl -0xdc(%rbp), %esi
movq -0xd8(%rbp), %rdx
movl %eax, %ecx
leaq 0x49a6f(%rip), %rdi # 0x656d5
leaq 0x4a400(%rip), %r8 # 0x6606d
movl $0xffb, %r9d # imm = 0xFFB
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x44(%rbp)
jmp 0x1bfc8
jmp 0x1bc88
movq -0x50(%rbp), %rdi
leaq 0x4b922(%rip), %rsi # 0x675b5
callq 0x38a70
movl %eax, -0xcc(%rbp)
cmpl $0x0, -0xcc(%rbp)
je 0x1bd02
movl -0xcc(%rbp), %eax
movl %eax, -0xec(%rbp)
movq -0x50(%rbp), %rdi
callq 0x3c3f0
movq %rax, -0xe8(%rbp)
movq -0x50(%rbp), %rdi
callq 0x3c3c0
movl -0xec(%rbp), %esi
movq -0xe8(%rbp), %rdx
movl %eax, %ecx
leaq 0x499f3(%rip), %rdi # 0x656d5
leaq 0x4a384(%rip), %r8 # 0x6606d
movl $0xffd, %r9d # imm = 0xFFD
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x44(%rbp)
jmp 0x1bfc8
jmp 0x1bd04
movq -0x50(%rbp), %rdi
leaq 0x4b8bf(%rip), %rsi # 0x675ce
callq 0x38a70
movl %eax, -0xcc(%rbp)
cmpl $0x0, -0xcc(%rbp)
je 0x1bd7e
movl -0xcc(%rbp), %eax
movl %eax, -0xfc(%rbp)
movq -0x50(%rbp), %rdi
callq 0x3c3f0
movq %rax, -0xf8(%rbp)
movq -0x50(%rbp), %rdi
callq 0x3c3c0
movl -0xfc(%rbp), %esi
movq -0xf8(%rbp), %rdx
movl %eax, %ecx
leaq 0x49977(%rip), %rdi # 0x656d5
leaq 0x4a308(%rip), %r8 # 0x6606d
movl $0xfff, %r9d # imm = 0xFFF
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x44(%rbp)
jmp 0x1bfc8
jmp 0x1bd80
movq -0x50(%rbp), %rdi
callq 0x44950
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
leaq 0x4a78d(%rip), %rsi # 0x66525
movl $0x10, %edx
callq 0x45070
movl %eax, -0xcc(%rbp)
cmpl $0x0, -0xcc(%rbp)
je 0x1bde3
movq -0x58(%rbp), %rdi
callq 0x43fd0
movq %rax, %rsi
leaq 0x497cc(%rip), %rdi # 0x65590
leaq 0x4a2a2(%rip), %rdx # 0x6606d
movl $0x1003, %ecx # imm = 0x1003
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x44(%rbp)
jmp 0x1bfc8
jmp 0x1bde5
movq -0x58(%rbp), %rdi
callq 0x46580
movl %eax, -0xcc(%rbp)
cmpl $0x0, -0xcc(%rbp)
je 0x1be2f
movq -0x58(%rbp), %rdi
callq 0x43fd0
movq %rax, %rsi
leaq 0x49780(%rip), %rdi # 0x65590
leaq 0x4a256(%rip), %rdx # 0x6606d
movl $0x1006, %ecx # imm = 0x1006
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x44(%rbp)
jmp 0x1bfc8
jmp 0x1be31
leaq -0x40(%rbp), %rdi
movl $0x58, %esi
movl $0x32, %edx
callq 0x14260
leaq -0xc8(%rbp), %rdi
xorl %esi, %esi
movl $0x70, %edx
callq 0x14260
leaq -0x40(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq $0x32, -0x88(%rbp)
movl $0xfe, -0x68(%rbp)
movq -0x58(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x43940
movsbl %al, %eax
movl %eax, -0xcc(%rbp)
cmpl $0x0, -0xcc(%rbp)
je 0x1bec8
movq -0x58(%rbp), %rdi
callq 0x43fd0
movq %rax, %rsi
leaq 0x496e7(%rip), %rdi # 0x65590
leaq 0x4a1bd(%rip), %rdx # 0x6606d
movl $0x1010, %ecx # imm = 0x1010
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x44(%rbp)
jmp 0x1bfc8
jmp 0x1beca
movq -0x58(%rbp), %rdi
callq 0x44020
movl %eax, -0xcc(%rbp)
cmpl $0x0, -0xcc(%rbp)
je 0x1bf14
movq -0x58(%rbp), %rdi
callq 0x43fd0
movq %rax, %rsi
leaq 0x4969b(%rip), %rdi # 0x65590
leaq 0x4a171(%rip), %rdx # 0x6606d
movl $0x1013, %ecx # imm = 0x1013
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x44(%rbp)
jmp 0x1bfc8
jmp 0x1bf16
leaq -0x40(%rbp), %rdi
callq 0x141a0
cmpq $0x16, %rax
je 0x1bf3f
leaq 0x4b6d3(%rip), %rdi # 0x675ff
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x44(%rbp)
jmp 0x1bfc8
movq -0x58(%rbp), %rdi
callq 0x43eb0
movq -0x50(%rbp), %rdi
leaq 0x4a6e3(%rip), %rsi # 0x66636
callq 0x38a70
movl %eax, -0xcc(%rbp)
cmpl $0x0, -0xcc(%rbp)
je 0x1bfbf
movl -0xcc(%rbp), %eax
movl %eax, -0x10c(%rbp)
movq -0x50(%rbp), %rdi
callq 0x3c3f0
movq %rax, -0x108(%rbp)
movq -0x50(%rbp), %rdi
callq 0x3c3c0
movl -0x10c(%rbp), %esi
movq -0x108(%rbp), %rdx
movl %eax, %ecx
leaq 0x49733(%rip), %rdi # 0x656d5
leaq 0x4a0c4(%rip), %r8 # 0x6606d
movl $0x101d, %r9d # imm = 0x101D
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x44(%rbp)
jmp 0x1bfc8
jmp 0x1bfc1
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x110(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x1bff2
movl -0x110(%rbp), %eax
addq $0x110, %rsp # imm = 0x110
popq %rbp
retq
callq 0x144c0
nopw (%rax,%rax)
| test_conc155:
push rbp
mov rbp, rsp
sub rsp, 110h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_50], rdi
mov rdi, [rbp+var_50]
lea rsi, aDropTableIfExi_0; "DROP TABLE IF EXISTS t1"
call mysql_query
mov [rbp+var_CC], eax
cmp [rbp+var_CC], 0
jz short loc_1BC86
mov eax, [rbp+var_CC]
mov [rbp+var_DC], eax
mov rdi, [rbp+var_50]
call mysql_error
mov [rbp+var_D8], rax
mov rdi, [rbp+var_50]
call mysql_errno
mov esi, [rbp+var_DC]
mov rdx, [rbp+var_D8]
mov ecx, eax
lea rdi, aErrorDSDInSLin; "Error (%d): %s (%d) in %s line %d"
lea r8, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov r9d, 0FFBh
mov al, 0
call diag
mov [rbp+var_44], 1
jmp loc_1BFC8
loc_1BC86:
jmp short $+2
loc_1BC88:
mov rdi, [rbp+var_50]
lea rsi, aCreateTableT1A_4; "CREATE TABLE t1 (a TEXT)"
call mysql_query
mov [rbp+var_CC], eax
cmp [rbp+var_CC], 0
jz short loc_1BD02
mov eax, [rbp+var_CC]
mov [rbp+var_EC], eax
mov rdi, [rbp+var_50]
call mysql_error
mov [rbp+var_E8], rax
mov rdi, [rbp+var_50]
call mysql_errno
mov esi, [rbp+var_EC]
mov rdx, [rbp+var_E8]
mov ecx, eax
lea rdi, aErrorDSDInSLin; "Error (%d): %s (%d) in %s line %d"
lea r8, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov r9d, 0FFDh
mov al, 0
call diag
mov [rbp+var_44], 1
jmp loc_1BFC8
loc_1BD02:
jmp short $+2
loc_1BD04:
mov rdi, [rbp+var_50]
lea rsi, aInsertIntoT1Va_6; "INSERT INTO t1 VALUES ('zero terminated"...
call mysql_query
mov [rbp+var_CC], eax
cmp [rbp+var_CC], 0
jz short loc_1BD7E
mov eax, [rbp+var_CC]
mov [rbp+var_FC], eax
mov rdi, [rbp+var_50]
call mysql_error
mov [rbp+var_F8], rax
mov rdi, [rbp+var_50]
call mysql_errno
mov esi, [rbp+var_FC]
mov rdx, [rbp+var_F8]
mov ecx, eax
lea rdi, aErrorDSDInSLin; "Error (%d): %s (%d) in %s line %d"
lea r8, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov r9d, 0FFFh
mov al, 0
call diag
mov [rbp+var_44], 1
jmp loc_1BFC8
loc_1BD7E:
jmp short $+2
loc_1BD80:
mov rdi, [rbp+var_50]
call mysql_stmt_init
mov [rbp+var_58], rax
mov rdi, [rbp+var_58]
lea rsi, aSelectAFromT1; "SELECT a FROM t1"
mov edx, 10h
call mysql_stmt_prepare
mov [rbp+var_CC], eax
cmp [rbp+var_CC], 0
jz short loc_1BDE3
mov rdi, [rbp+var_58]
call mysql_stmt_error
mov rsi, rax
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 1003h
mov al, 0
call diag
mov [rbp+var_44], 1
jmp loc_1BFC8
loc_1BDE3:
jmp short $+2
loc_1BDE5:
mov rdi, [rbp+var_58]
call mysql_stmt_execute
mov [rbp+var_CC], eax
cmp [rbp+var_CC], 0
jz short loc_1BE2F
mov rdi, [rbp+var_58]
call mysql_stmt_error
mov rsi, rax
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 1006h
mov al, 0
call diag
mov [rbp+var_44], 1
jmp loc_1BFC8
loc_1BE2F:
jmp short $+2
loc_1BE31:
lea rdi, [rbp+var_40]
mov esi, 58h ; 'X'
mov edx, 32h ; '2'
call _memset
lea rdi, [rbp+var_C8]
xor esi, esi
mov edx, 70h ; 'p'
call _memset
lea rax, [rbp+var_40]
mov [rbp+var_B8], rax
mov [rbp+var_88], 32h ; '2'
mov [rbp+var_68], 0FEh
mov rdi, [rbp+var_58]
lea rsi, [rbp+var_C8]
call mysql_stmt_bind_result
movsx eax, al
mov [rbp+var_CC], eax
cmp [rbp+var_CC], 0
jz short loc_1BEC8
mov rdi, [rbp+var_58]
call mysql_stmt_error
mov rsi, rax
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 1010h
mov al, 0
call diag
mov [rbp+var_44], 1
jmp loc_1BFC8
loc_1BEC8:
jmp short $+2
loc_1BECA:
mov rdi, [rbp+var_58]
call mysql_stmt_fetch
mov [rbp+var_CC], eax
cmp [rbp+var_CC], 0
jz short loc_1BF14
mov rdi, [rbp+var_58]
call mysql_stmt_error
mov rsi, rax
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 1013h
mov al, 0
call diag
mov [rbp+var_44], 1
jmp loc_1BFC8
loc_1BF14:
jmp short $+2
loc_1BF16:
lea rdi, [rbp+var_40]
call _strlen
cmp rax, 16h
jz short loc_1BF3F
lea rdi, aWrongBufferLen; "Wrong buffer length"
mov al, 0
call diag
mov [rbp+var_44], 1
jmp loc_1BFC8
loc_1BF3F:
mov rdi, [rbp+var_58]
call mysql_stmt_close
mov rdi, [rbp+var_50]
lea rsi, aDropTableIfExi_0; "DROP TABLE IF EXISTS t1"
call mysql_query
mov [rbp+var_CC], eax
cmp [rbp+var_CC], 0
jz short loc_1BFBF
mov eax, [rbp+var_CC]
mov [rbp+var_10C], eax
mov rdi, [rbp+var_50]
call mysql_error
mov [rbp+var_108], rax
mov rdi, [rbp+var_50]
call mysql_errno
mov esi, [rbp+var_10C]
mov rdx, [rbp+var_108]
mov ecx, eax
lea rdi, aErrorDSDInSLin; "Error (%d): %s (%d) in %s line %d"
lea r8, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov r9d, 101Dh
mov al, 0
call diag
mov [rbp+var_44], 1
jmp short loc_1BFC8
loc_1BFBF:
jmp short $+2
loc_1BFC1:
mov [rbp+var_44], 0
loc_1BFC8:
mov eax, [rbp+var_44]
mov [rbp+var_110], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_1BFF2
mov eax, [rbp+var_110]
add rsp, 110h
pop rbp
retn
loc_1BFF2:
call ___stack_chk_fail
| long long test_conc155(long long a1)
{
int v1; // eax
int v2; // eax
int v3; // eax
int v4; // eax
int v5; // r8d
int v6; // r9d
int v7; // eax
int v8; // r8d
int v9; // r9d
int v10; // eax
int v11; // r8d
int v12; // r9d
int v13; // eax
int v14; // r8d
int v15; // r9d
int v16; // edx
int v17; // ecx
int v18; // r8d
int v19; // r9d
int v20; // eax
int v22; // [rsp+8h] [rbp-108h]
int v23; // [rsp+18h] [rbp-F8h]
int v24; // [rsp+28h] [rbp-E8h]
int v25; // [rsp+38h] [rbp-D8h]
int v26; // [rsp+44h] [rbp-CCh]
int v27; // [rsp+44h] [rbp-CCh]
int v28; // [rsp+44h] [rbp-CCh]
int v29; // [rsp+44h] [rbp-CCh]
_BYTE v30[16]; // [rsp+48h] [rbp-C8h] BYREF
_BYTE *v31; // [rsp+58h] [rbp-B8h]
long long v32; // [rsp+88h] [rbp-88h]
int v33; // [rsp+A8h] [rbp-68h]
long long v34; // [rsp+B8h] [rbp-58h]
long long v35; // [rsp+C0h] [rbp-50h]
_BYTE v37[56]; // [rsp+D0h] [rbp-40h] BYREF
unsigned long long v38; // [rsp+108h] [rbp-8h]
v38 = __readfsqword(0x28u);
v35 = a1;
v26 = mysql_query(a1, "DROP TABLE IF EXISTS t1");
if ( v26 )
{
v25 = mysql_error(v35);
v1 = mysql_errno(v35);
diag(
(unsigned int)"Error (%d): %s (%d) in %s line %d",
v26,
v25,
v1,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
4091);
return 1;
}
else
{
v27 = mysql_query(v35, "CREATE TABLE t1 (a TEXT)");
if ( v27 )
{
v24 = mysql_error(v35);
v2 = mysql_errno(v35);
diag(
(unsigned int)"Error (%d): %s (%d) in %s line %d",
v27,
v24,
v2,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
4093);
return 1;
}
else
{
v28 = mysql_query(v35, "INSERT INTO t1 VALUES ('zero terminated string')");
if ( v28 )
{
v23 = mysql_error(v35);
v3 = mysql_errno(v35);
diag(
(unsigned int)"Error (%d): %s (%d) in %s line %d",
v28,
v23,
v3,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
4095);
return 1;
}
else
{
v34 = mysql_stmt_init(v35);
if ( (unsigned int)mysql_stmt_prepare(v34, "SELECT a FROM t1", 16LL) )
{
v4 = mysql_stmt_error(v34);
diag(
(unsigned int)"Error: %s (%s: %d)",
v4,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
4099,
v5,
v6);
return 1;
}
else if ( (unsigned int)mysql_stmt_execute(v34) )
{
v7 = mysql_stmt_error(v34);
diag(
(unsigned int)"Error: %s (%s: %d)",
v7,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
4102,
v8,
v9);
return 1;
}
else
{
memset(v37, 88LL, 50LL);
memset(v30, 0LL, 112LL);
v31 = v37;
v32 = 50LL;
v33 = 254;
if ( (unsigned __int8)mysql_stmt_bind_result(v34, v30) )
{
v10 = mysql_stmt_error(v34);
diag(
(unsigned int)"Error: %s (%s: %d)",
v10,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
4112,
v11,
v12);
return 1;
}
else if ( (unsigned int)mysql_stmt_fetch(v34) )
{
v13 = mysql_stmt_error(v34);
diag(
(unsigned int)"Error: %s (%s: %d)",
v13,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
4115,
v14,
v15);
return 1;
}
else if ( strlen(v37) == 22 )
{
mysql_stmt_close(v34);
v29 = mysql_query(v35, "DROP TABLE IF EXISTS t1");
if ( v29 )
{
v22 = mysql_error(v35);
v20 = mysql_errno(v35);
diag(
(unsigned int)"Error (%d): %s (%d) in %s line %d",
v29,
v22,
v20,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
4125);
return 1;
}
else
{
return 0;
}
}
else
{
diag((unsigned int)"Wrong buffer length", (unsigned int)v30, v16, v17, v18, v19);
return 1;
}
}
}
}
}
}
| test_conc155:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x110
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x50],RDI
MOV RDI,qword ptr [RBP + -0x50]
LEA RSI,[0x166636]
CALL 0x00138a70
MOV dword ptr [RBP + -0xcc],EAX
CMP dword ptr [RBP + -0xcc],0x0
JZ 0x0011bc86
MOV EAX,dword ptr [RBP + -0xcc]
MOV dword ptr [RBP + -0xdc],EAX
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x0013c3f0
MOV qword ptr [RBP + -0xd8],RAX
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x0013c3c0
MOV ESI,dword ptr [RBP + -0xdc]
MOV RDX,qword ptr [RBP + -0xd8]
MOV ECX,EAX
LEA RDI,[0x1656d5]
LEA R8,[0x16606d]
MOV R9D,0xffb
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x44],0x1
JMP 0x0011bfc8
LAB_0011bc86:
JMP 0x0011bc88
LAB_0011bc88:
MOV RDI,qword ptr [RBP + -0x50]
LEA RSI,[0x1675b5]
CALL 0x00138a70
MOV dword ptr [RBP + -0xcc],EAX
CMP dword ptr [RBP + -0xcc],0x0
JZ 0x0011bd02
MOV EAX,dword ptr [RBP + -0xcc]
MOV dword ptr [RBP + -0xec],EAX
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x0013c3f0
MOV qword ptr [RBP + -0xe8],RAX
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x0013c3c0
MOV ESI,dword ptr [RBP + -0xec]
MOV RDX,qword ptr [RBP + -0xe8]
MOV ECX,EAX
LEA RDI,[0x1656d5]
LEA R8,[0x16606d]
MOV R9D,0xffd
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x44],0x1
JMP 0x0011bfc8
LAB_0011bd02:
JMP 0x0011bd04
LAB_0011bd04:
MOV RDI,qword ptr [RBP + -0x50]
LEA RSI,[0x1675ce]
CALL 0x00138a70
MOV dword ptr [RBP + -0xcc],EAX
CMP dword ptr [RBP + -0xcc],0x0
JZ 0x0011bd7e
MOV EAX,dword ptr [RBP + -0xcc]
MOV dword ptr [RBP + -0xfc],EAX
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x0013c3f0
MOV qword ptr [RBP + -0xf8],RAX
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x0013c3c0
MOV ESI,dword ptr [RBP + -0xfc]
MOV RDX,qword ptr [RBP + -0xf8]
MOV ECX,EAX
LEA RDI,[0x1656d5]
LEA R8,[0x16606d]
MOV R9D,0xfff
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x44],0x1
JMP 0x0011bfc8
LAB_0011bd7e:
JMP 0x0011bd80
LAB_0011bd80:
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x00144950
MOV qword ptr [RBP + -0x58],RAX
MOV RDI,qword ptr [RBP + -0x58]
LEA RSI,[0x166525]
MOV EDX,0x10
CALL 0x00145070
MOV dword ptr [RBP + -0xcc],EAX
CMP dword ptr [RBP + -0xcc],0x0
JZ 0x0011bde3
MOV RDI,qword ptr [RBP + -0x58]
CALL 0x00143fd0
MOV RSI,RAX
LEA RDI,[0x165590]
LEA RDX,[0x16606d]
MOV ECX,0x1003
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x44],0x1
JMP 0x0011bfc8
LAB_0011bde3:
JMP 0x0011bde5
LAB_0011bde5:
MOV RDI,qword ptr [RBP + -0x58]
CALL 0x00146580
MOV dword ptr [RBP + -0xcc],EAX
CMP dword ptr [RBP + -0xcc],0x0
JZ 0x0011be2f
MOV RDI,qword ptr [RBP + -0x58]
CALL 0x00143fd0
MOV RSI,RAX
LEA RDI,[0x165590]
LEA RDX,[0x16606d]
MOV ECX,0x1006
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x44],0x1
JMP 0x0011bfc8
LAB_0011be2f:
JMP 0x0011be31
LAB_0011be31:
LEA RDI,[RBP + -0x40]
MOV ESI,0x58
MOV EDX,0x32
CALL 0x00114260
LEA RDI,[RBP + -0xc8]
XOR ESI,ESI
MOV EDX,0x70
CALL 0x00114260
LEA RAX,[RBP + -0x40]
MOV qword ptr [RBP + -0xb8],RAX
MOV qword ptr [RBP + -0x88],0x32
MOV dword ptr [RBP + -0x68],0xfe
MOV RDI,qword ptr [RBP + -0x58]
LEA RSI,[RBP + -0xc8]
CALL 0x00143940
MOVSX EAX,AL
MOV dword ptr [RBP + -0xcc],EAX
CMP dword ptr [RBP + -0xcc],0x0
JZ 0x0011bec8
MOV RDI,qword ptr [RBP + -0x58]
CALL 0x00143fd0
MOV RSI,RAX
LEA RDI,[0x165590]
LEA RDX,[0x16606d]
MOV ECX,0x1010
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x44],0x1
JMP 0x0011bfc8
LAB_0011bec8:
JMP 0x0011beca
LAB_0011beca:
MOV RDI,qword ptr [RBP + -0x58]
CALL 0x00144020
MOV dword ptr [RBP + -0xcc],EAX
CMP dword ptr [RBP + -0xcc],0x0
JZ 0x0011bf14
MOV RDI,qword ptr [RBP + -0x58]
CALL 0x00143fd0
MOV RSI,RAX
LEA RDI,[0x165590]
LEA RDX,[0x16606d]
MOV ECX,0x1013
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x44],0x1
JMP 0x0011bfc8
LAB_0011bf14:
JMP 0x0011bf16
LAB_0011bf16:
LEA RDI,[RBP + -0x40]
CALL 0x001141a0
CMP RAX,0x16
JZ 0x0011bf3f
LEA RDI,[0x1675ff]
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x44],0x1
JMP 0x0011bfc8
LAB_0011bf3f:
MOV RDI,qword ptr [RBP + -0x58]
CALL 0x00143eb0
MOV RDI,qword ptr [RBP + -0x50]
LEA RSI,[0x166636]
CALL 0x00138a70
MOV dword ptr [RBP + -0xcc],EAX
CMP dword ptr [RBP + -0xcc],0x0
JZ 0x0011bfbf
MOV EAX,dword ptr [RBP + -0xcc]
MOV dword ptr [RBP + -0x10c],EAX
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x0013c3f0
MOV qword ptr [RBP + -0x108],RAX
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x0013c3c0
MOV ESI,dword ptr [RBP + -0x10c]
MOV RDX,qword ptr [RBP + -0x108]
MOV ECX,EAX
LEA RDI,[0x1656d5]
LEA R8,[0x16606d]
MOV R9D,0x101d
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x44],0x1
JMP 0x0011bfc8
LAB_0011bfbf:
JMP 0x0011bfc1
LAB_0011bfc1:
MOV dword ptr [RBP + -0x44],0x0
LAB_0011bfc8:
MOV EAX,dword ptr [RBP + -0x44]
MOV dword ptr [RBP + -0x110],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0011bff2
MOV EAX,dword ptr [RBP + -0x110]
ADD RSP,0x110
POP RBP
RET
LAB_0011bff2:
CALL 0x001144c0
|
int4 test_conc155(int8 param_1)
{
char cVar1;
int iVar2;
int4 uVar3;
int8 uVar4;
size_t sVar5;
long in_FS_OFFSET;
int1 local_d0 [16];
char *local_c0;
int8 local_90;
int4 local_70;
int8 local_60;
int8 local_58;
int4 local_4c;
char local_48 [56];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_58 = param_1;
iVar2 = mysql_query(param_1,"DROP TABLE IF EXISTS t1");
if (iVar2 == 0) {
iVar2 = mysql_query(local_58,"CREATE TABLE t1 (a TEXT)");
if (iVar2 == 0) {
iVar2 = mysql_query(local_58,"INSERT INTO t1 VALUES (\'zero terminated string\')");
if (iVar2 == 0) {
local_60 = mysql_stmt_init(local_58);
iVar2 = mysql_stmt_prepare(local_60,"SELECT a FROM t1",0x10);
if (iVar2 == 0) {
iVar2 = mysql_stmt_execute(local_60);
if (iVar2 == 0) {
memset(local_48,0x58,0x32);
memset(local_d0,0,0x70);
local_c0 = local_48;
local_90 = 0x32;
local_70 = 0xfe;
cVar1 = mysql_stmt_bind_result(local_60,local_d0);
if (cVar1 == '\0') {
iVar2 = mysql_stmt_fetch(local_60);
if (iVar2 == 0) {
sVar5 = strlen(local_48);
if (sVar5 == 0x16) {
mysql_stmt_close(local_60);
iVar2 = mysql_query(local_58,"DROP TABLE IF EXISTS t1");
if (iVar2 == 0) {
local_4c = 0;
}
else {
uVar4 = mysql_error(local_58);
uVar3 = mysql_errno(local_58);
diag("Error (%d): %s (%d) in %s line %d",iVar2,uVar4,uVar3,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c"
,0x101d);
local_4c = 1;
}
}
else {
diag("Wrong buffer length");
local_4c = 1;
}
}
else {
uVar4 = mysql_stmt_error(local_60);
diag("Error: %s (%s: %d)",uVar4,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c"
,0x1013);
local_4c = 1;
}
}
else {
uVar4 = mysql_stmt_error(local_60);
diag("Error: %s (%s: %d)",uVar4,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c"
,0x1010);
local_4c = 1;
}
}
else {
uVar4 = mysql_stmt_error(local_60);
diag("Error: %s (%s: %d)",uVar4,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c"
,0x1006);
local_4c = 1;
}
}
else {
uVar4 = mysql_stmt_error(local_60);
diag("Error: %s (%s: %d)",uVar4,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
0x1003);
local_4c = 1;
}
}
else {
uVar4 = mysql_error(local_58);
uVar3 = mysql_errno(local_58);
diag("Error (%d): %s (%d) in %s line %d",iVar2,uVar4,uVar3,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
0xfff);
local_4c = 1;
}
}
else {
uVar4 = mysql_error(local_58);
uVar3 = mysql_errno(local_58);
diag("Error (%d): %s (%d) in %s line %d",iVar2,uVar4,uVar3,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",0xffd
);
local_4c = 1;
}
}
else {
uVar4 = mysql_error(local_58);
uVar3 = mysql_errno(local_58);
diag("Error (%d): %s (%d) in %s line %d",iVar2,uVar4,uVar3,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",0xffb);
local_4c = 1;
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_4c;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
44,872 | minja::ArgumentsExpression::evaluate(std::shared_ptr<minja::Context> const&) const | monkey531[P]llama/common/./minja.hpp | ArgumentsValue evaluate(const std::shared_ptr<Context> & context) const {
ArgumentsValue vargs;
for (const auto& arg : this->args) {
if (auto un_expr = std::dynamic_pointer_cast<UnaryOpExpr>(arg)) {
if (un_expr->op == UnaryOpExpr::Op::Expansion) {
auto array = un_expr->expr->evaluate(context);
if (!array.is_array()) {
throw std::runtime_error("Expansion operator only supported on arrays");
}
array.for_each([&](Value & value) {
vargs.args.push_back(value);
});
continue;
} else if (un_expr->op == UnaryOpExpr::Op::ExpansionDict) {
auto dict = un_expr->expr->evaluate(context);
if (!dict.is_object()) {
throw std::runtime_error("ExpansionDict operator only supported on objects");
}
dict.for_each([&](const Value & key) {
vargs.kwargs.push_back({key.get<std::string>(), dict.at(key)});
});
continue;
}
}
vargs.args.push_back(arg->evaluate(context));
}
for (const auto& [name, value] : this->kwargs) {
vargs.kwargs.push_back({name, value->evaluate(context)});
}
return vargs;
} | O0 | cpp | minja::ArgumentsExpression::evaluate(std::shared_ptr<minja::Context> const&) const:
subq $0x2f8, %rsp # imm = 0x2F8
movq %rdi, 0x40(%rsp)
movq %rdi, %rax
movq %rax, 0x48(%rsp)
movq %rdi, 0x2f0(%rsp)
movq %rsi, 0x2e8(%rsp)
movq %rdx, 0x2e0(%rsp)
movq 0x2e8(%rsp), %rax
movq %rax, 0x50(%rsp)
movb $0x0, 0x2df(%rsp)
callq 0xda590
movq 0x50(%rsp), %rax
movq %rax, 0x2d0(%rsp)
movq 0x2d0(%rsp), %rdi
callq 0xcd800
movq %rax, 0x2c8(%rsp)
movq 0x2d0(%rsp), %rdi
callq 0xcd830
movq %rax, 0x2c0(%rsp)
leaq 0x2c8(%rsp), %rdi
leaq 0x2c0(%rsp), %rsi
callq 0xcd860
testb $0x1, %al
jne 0xd848b
jmp 0xd88b5
leaq 0x2c8(%rsp), %rdi
callq 0xcd8a0
movq %rax, 0x2b8(%rsp)
movq 0x2b8(%rsp), %rsi
leaq 0x2a8(%rsp), %rdi
callq 0xda5c0
leaq 0x2a8(%rsp), %rdi
callq 0xda660
testb $0x1, %al
jne 0xd84cb
jmp 0xd87d9
leaq 0x2a8(%rsp), %rdi
callq 0xda680
cmpl $0x3, 0x30(%rax)
jne 0xd8657
leaq 0x2a8(%rsp), %rdi
callq 0xda680
movq %rax, %rdi
addq $0x20, %rdi
callq 0x9f2f0
movq %rax, %rsi
movq 0x2e0(%rsp), %rdx
leaq 0x258(%rsp), %rdi
callq 0x9f300
jmp 0xd8515
leaq 0x258(%rsp), %rdi
callq 0xa4990
testb $0x1, %al
jne 0xd85bf
movl $0x10, %edi
callq 0x50540
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x38(%rsp)
leaq 0xf948f(%rip), %rsi # 0x1d19d5
callq 0x50340
jmp 0xd854d
movq 0x38(%rsp), %rdi
movq 0x17ba57(%rip), %rsi # 0x253fb0
movq 0x17ba18(%rip), %rdx # 0x253f78
callq 0x508f0
jmp 0xd8a71
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x250(%rsp)
movl %eax, 0x24c(%rsp)
jmp 0xd8864
movq 0x38(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x250(%rsp)
movl %eax, 0x24c(%rsp)
callq 0x50c40
jmp 0xd8645
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x250(%rsp)
movl %eax, 0x24c(%rsp)
jmp 0xd8645
movq 0x40(%rsp), %rax
movq %rax, 0x220(%rsp)
leaq 0x228(%rsp), %rdi
movq %rdi, 0x30(%rsp)
leaq 0x220(%rsp), %rsi
callq 0xdab90
movq 0x30(%rsp), %rsi
leaq 0x258(%rsp), %rdi
callq 0xda690
jmp 0xd85fa
leaq 0x228(%rsp), %rdi
callq 0xdac20
movl $0x3, 0x21c(%rsp)
leaq 0x258(%rsp), %rdi
callq 0x9f7a0
jmp 0xd87e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x250(%rsp)
movl %eax, 0x24c(%rsp)
leaq 0x228(%rsp), %rdi
callq 0xdac20
leaq 0x258(%rsp), %rdi
callq 0x9f7a0
jmp 0xd8864
leaq 0x2a8(%rsp), %rdi
callq 0xda680
cmpl $0x4, 0x30(%rax)
jne 0xd87d5
leaq 0x2a8(%rsp), %rdi
callq 0xda680
movq %rax, %rdi
addq $0x20, %rdi
callq 0x9f2f0
movq %rax, %rsi
movq 0x2e0(%rsp), %rdx
leaq 0x1c8(%rsp), %rdi
callq 0x9f300
jmp 0xd86a1
leaq 0x1c8(%rsp), %rdi
callq 0xa5180
testb $0x1, %al
jne 0xd872e
movl $0x10, %edi
callq 0x50540
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x28(%rsp)
leaq 0xf9333(%rip), %rsi # 0x1d1a01
callq 0x50340
jmp 0xd86d5
movq 0x28(%rsp), %rdi
movq 0x17b8cf(%rip), %rsi # 0x253fb0
movq 0x17b890(%rip), %rdx # 0x253f78
callq 0x508f0
jmp 0xd8a71
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x250(%rsp)
movl %eax, 0x24c(%rsp)
callq 0x50c40
jmp 0xd87c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x250(%rsp)
movl %eax, 0x24c(%rsp)
jmp 0xd87c3
movq 0x40(%rsp), %rax
movq %rax, 0x198(%rsp)
leaq 0x1c8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, 0x1a0(%rsp)
leaq 0x1a8(%rsp), %rdi
movq %rdi, 0x20(%rsp)
leaq 0x198(%rsp), %rsi
callq 0xdac30
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xda690
jmp 0xd877b
leaq 0x1a8(%rsp), %rdi
callq 0xdac20
movl $0x3, 0x21c(%rsp)
leaq 0x1c8(%rsp), %rdi
callq 0x9f7a0
jmp 0xd87e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x250(%rsp)
movl %eax, 0x24c(%rsp)
leaq 0x1a8(%rsp), %rdi
callq 0xdac20
leaq 0x1c8(%rsp), %rdi
callq 0x9f7a0
jmp 0xd8864
jmp 0xd87d7
jmp 0xd87d9
movl $0x0, 0x21c(%rsp)
leaq 0x2a8(%rsp), %rdi
callq 0x9de00
movl 0x21c(%rsp), %eax
testl %eax, %eax
je 0xd8800
jmp 0xd87fe
jmp 0xd8852
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x2b8(%rsp), %rdi
callq 0x9f2f0
movq %rax, %rsi
movq 0x2e0(%rsp), %rdx
leaq 0x148(%rsp), %rdi
callq 0x9f300
jmp 0xd8831
movq 0x10(%rsp), %rdi
leaq 0x148(%rsp), %rsi
callq 0xc7180
jmp 0xd8845
leaq 0x148(%rsp), %rdi
callq 0x9f7a0
leaq 0x2c8(%rsp), %rdi
callq 0xcd9e0
jmp 0xd846d
leaq 0x2a8(%rsp), %rdi
callq 0x9de00
jmp 0xd8a5a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x250(%rsp)
movl %eax, 0x24c(%rsp)
jmp 0xd8a5a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x250(%rsp)
movl %eax, 0x24c(%rsp)
leaq 0x148(%rsp), %rdi
callq 0x9f7a0
jmp 0xd8a5a
movq 0x50(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x140(%rsp)
movq 0x140(%rsp), %rdi
callq 0xdacc0
movq %rax, 0x138(%rsp)
movq 0x140(%rsp), %rdi
callq 0xdacf0
movq %rax, 0x130(%rsp)
leaq 0x138(%rsp), %rdi
leaq 0x130(%rsp), %rsi
callq 0xdad20
testb $0x1, %al
jne 0xd890e
jmp 0xd8a26
leaq 0x138(%rsp), %rdi
callq 0xdad60
movq %rax, 0x128(%rsp)
movq 0x128(%rsp), %rdi
callq 0xdad70
movq %rax, 0x120(%rsp)
movq 0x128(%rsp), %rdi
callq 0xdad80
movq %rax, %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x118(%rsp)
addq $0x18, %rax
movq %rax, (%rsp)
movq 0x120(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x118(%rsp), %rdi
callq 0x9f2f0
movq %rax, %rsi
movq 0x2e0(%rsp), %rdx
leaq 0x58(%rsp), %rdi
callq 0x9f300
jmp 0xd898e
movq 0x8(%rsp), %rsi
leaq 0xa8(%rsp), %rdi
leaq 0x58(%rsp), %rdx
callq 0xdadc0
jmp 0xd89a7
movq (%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0xdad90
jmp 0xd89ba
leaq 0xa8(%rsp), %rdi
callq 0xdae00
leaq 0x58(%rsp), %rdi
callq 0x9f7a0
leaq 0x138(%rsp), %rdi
callq 0xdae30
jmp 0xd88f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x250(%rsp)
movl %eax, 0x24c(%rsp)
jmp 0xd8a1a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x250(%rsp)
movl %eax, 0x24c(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0xdae00
leaq 0x58(%rsp), %rdi
callq 0x9f7a0
jmp 0xd8a5a
movb $0x1, 0x2df(%rsp)
movl $0x1, 0x21c(%rsp)
testb $0x1, 0x2df(%rsp)
jne 0xd8a4d
movq 0x40(%rsp), %rdi
callq 0xda560
movq 0x48(%rsp), %rax
addq $0x2f8, %rsp # imm = 0x2F8
retq
movq 0x40(%rsp), %rdi
callq 0xda560
movq 0x250(%rsp), %rdi
callq 0x50940
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| _ZNK5minja19ArgumentsExpression8evaluateERKSt10shared_ptrINS_7ContextEE:
sub rsp, 2F8h
mov [rsp+2F8h+var_2B8], rdi
mov rax, rdi
mov [rsp+2F8h+var_2B0], rax
mov [rsp+2F8h+var_8], rdi
mov [rsp+2F8h+var_10], rsi
mov [rsp+2F8h+var_18], rdx
mov rax, [rsp+2F8h+var_10]
mov [rsp+2F8h+var_2A8], rax
mov [rsp+2F8h+var_19], 0
call _ZN5minja14ArgumentsValueC2Ev; minja::ArgumentsValue::ArgumentsValue(void)
mov rax, [rsp+2F8h+var_2A8]
mov [rsp+2F8h+var_28], rax
mov rdi, [rsp+2F8h+var_28]
call _ZNKSt6vectorISt10shared_ptrIN5minja10ExpressionEESaIS3_EE5beginEv; std::vector<std::shared_ptr<minja::Expression>>::begin(void)
mov [rsp+2F8h+var_30], rax
mov rdi, [rsp+2F8h+var_28]
call _ZNKSt6vectorISt10shared_ptrIN5minja10ExpressionEESaIS3_EE3endEv; std::vector<std::shared_ptr<minja::Expression>>::end(void)
mov [rsp+2F8h+var_38], rax
loc_D846D:
lea rdi, [rsp+2F8h+var_30]
lea rsi, [rsp+2F8h+var_38]
call _ZN9__gnu_cxxneIPKSt10shared_ptrIN5minja10ExpressionEESt6vectorIS4_SaIS4_EEEEbRKNS_17__normal_iteratorIT_T0_EESF_; __gnu_cxx::operator!=<std::shared_ptr<minja::Expression> const*,std::vector<std::shared_ptr<minja::Expression>>>(__gnu_cxx::__normal_iterator<std::shared_ptr<minja::Expression> const*,std::vector<std::shared_ptr<minja::Expression>>> const&,__gnu_cxx::__normal_iterator<std::shared_ptr<minja::Expression> const*,std::vector<std::shared_ptr<minja::Expression>>> const&)
test al, 1
jnz short loc_D848B
jmp loc_D88B5
loc_D848B:
lea rdi, [rsp+2F8h+var_30]
call _ZNK9__gnu_cxx17__normal_iteratorIPKSt10shared_ptrIN5minja10ExpressionEESt6vectorIS4_SaIS4_EEEdeEv; __gnu_cxx::__normal_iterator<std::shared_ptr<minja::Expression> const*,std::vector<std::shared_ptr<minja::Expression>>>::operator*(void)
mov [rsp+2F8h+var_40], rax
mov rsi, [rsp+2F8h+var_40]
lea rdi, [rsp+2F8h+var_50]
call _ZSt20dynamic_pointer_castIN5minja11UnaryOpExprENS0_10ExpressionEESt10shared_ptrIT_ERKS3_IT0_E; std::dynamic_pointer_cast<minja::UnaryOpExpr,minja::Expression>(std::shared_ptr const&<minja::Expression>)
lea rdi, [rsp+2F8h+var_50]
call _ZNKSt12__shared_ptrIN5minja11UnaryOpExprELN9__gnu_cxx12_Lock_policyE2EEcvbEv; std::__shared_ptr<minja::UnaryOpExpr,(__gnu_cxx::_Lock_policy)2>::operator bool(void)
test al, 1
jnz short loc_D84CB
jmp loc_D87D9
loc_D84CB:
lea rdi, [rsp+2F8h+var_50]
call _ZNKSt19__shared_ptr_accessIN5minja11UnaryOpExprELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<minja::UnaryOpExpr,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
cmp dword ptr [rax+30h], 3
jnz loc_D8657
lea rdi, [rsp+2F8h+var_50]
call _ZNKSt19__shared_ptr_accessIN5minja11UnaryOpExprELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<minja::UnaryOpExpr,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rdi, rax
add rdi, 20h ; ' '
call _ZNKSt19__shared_ptr_accessIN5minja10ExpressionELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<minja::Expression,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rsi, rax
mov rdx, [rsp+2F8h+var_18]
lea rdi, [rsp+2F8h+var_A0]
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
jmp short $+2
loc_D8515:
lea rdi, [rsp+2F8h+var_A0]; this
call _ZNK5minja5Value8is_arrayEv; minja::Value::is_array(void)
test al, 1
jnz loc_D85BF
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+2F8h+var_2C0], rax
lea rsi, aExpansionOpera_0; "Expansion operator only supported on ar"...
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_D854D:
mov rdi, [rsp+2F8h+var_2C0]; void *
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp loc_D8A71
mov rcx, rax
mov eax, edx
mov [rsp+arg_248], rcx
mov [rsp+arg_244], eax
jmp loc_D8864
mov rdi, [rsp+arg_30]; void *
mov rcx, rax
mov eax, edx
mov [rsp+arg_248], rcx
mov [rsp+arg_244], eax
call ___cxa_free_exception
jmp loc_D8645
mov rcx, rax
mov eax, edx
mov [rsp+arg_248], rcx
mov [rsp+arg_244], eax
jmp loc_D8645
loc_D85BF:
mov rax, [rsp+2F8h+var_2B8]
mov [rsp+2F8h+var_D8], rax
lea rdi, [rsp+2F8h+var_D0]
mov [rsp+2F8h+var_2C8], rdi
lea rsi, [rsp+2F8h+var_D8]
call _ZNSt8functionIFvRN5minja5ValueEEEC2IZNKS0_19ArgumentsExpression8evaluateERKSt10shared_ptrINS0_7ContextEEEUlS2_E_vEEOT_; std::function<void ()(minja::Value &)>::function<minja::ArgumentsExpression::evaluate(std::shared_ptr<minja::Context> const&)::{lambda(minja::Value &)#1},void>(minja::ArgumentsExpression::evaluate(std::shared_ptr<minja::Context> const&)::{lambda(minja::Value &)#1} &&)
mov rsi, [rsp+2F8h+var_2C8]
lea rdi, [rsp+2F8h+var_A0]
call _ZNK5minja5Value8for_eachERKSt8functionIFvRS0_EE; minja::Value::for_each(std::function<void ()(minja::Value&)> const&)
jmp short $+2
loc_D85FA:
lea rdi, [rsp+2F8h+var_D0]
call _ZNSt8functionIFvRN5minja5ValueEEED2Ev; std::function<void ()(minja::Value &)>::~function()
mov [rsp+2F8h+var_DC], 3
lea rdi, [rsp+2F8h+var_A0]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
jmp loc_D87E4
mov rcx, rax
mov eax, edx
mov [rsp+arg_248], rcx
mov [rsp+arg_244], eax
lea rdi, [rsp+arg_220]
call _ZNSt8functionIFvRN5minja5ValueEEED2Ev; std::function<void ()(minja::Value &)>::~function()
loc_D8645:
lea rdi, [rsp+arg_250]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
jmp loc_D8864
loc_D8657:
lea rdi, [rsp+2F8h+var_50]
call _ZNKSt19__shared_ptr_accessIN5minja11UnaryOpExprELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<minja::UnaryOpExpr,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
cmp dword ptr [rax+30h], 4
jnz loc_D87D5
lea rdi, [rsp+2F8h+var_50]
call _ZNKSt19__shared_ptr_accessIN5minja11UnaryOpExprELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<minja::UnaryOpExpr,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rdi, rax
add rdi, 20h ; ' '
call _ZNKSt19__shared_ptr_accessIN5minja10ExpressionELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<minja::Expression,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rsi, rax
mov rdx, [rsp+2F8h+var_18]
lea rdi, [rsp+2F8h+var_130]
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
jmp short $+2
loc_D86A1:
lea rdi, [rsp+2F8h+var_130]; this
call _ZNK5minja5Value9is_objectEv; minja::Value::is_object(void)
test al, 1
jnz short loc_D872E
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+2F8h+var_2D0], rax
lea rsi, aExpansiondictO; "ExpansionDict operator only supported o"...
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_D86D5:
mov rdi, [rsp+2F8h+var_2D0]; void *
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp loc_D8A71
mov rdi, [rsp+arg_20]; void *
mov rcx, rax
mov eax, edx
mov [rsp+arg_248], rcx
mov [rsp+arg_244], eax
call ___cxa_free_exception
jmp loc_D87C3
mov rcx, rax
mov eax, edx
mov [rsp+arg_248], rcx
mov [rsp+arg_244], eax
jmp loc_D87C3
loc_D872E:
mov rax, [rsp+2F8h+var_2B8]
mov [rsp+2F8h+var_160], rax
lea rax, [rsp+2F8h+var_130]
mov [rsp+2F8h+var_2E0], rax
mov [rsp+2F8h+var_158], rax
lea rdi, [rsp+2F8h+var_150]
mov [rsp+2F8h+var_2D8], rdi
lea rsi, [rsp+2F8h+var_160]
call _ZNSt8functionIFvRN5minja5ValueEEEC2IZNKS0_19ArgumentsExpression8evaluateERKSt10shared_ptrINS0_7ContextEEEUlRKS1_E_vEEOT_; std::function<void ()(minja::Value &)>::function<minja::ArgumentsExpression::evaluate(std::shared_ptr<minja::Context> const&)::{lambda(minja::Value const&)#1},void>(minja::ArgumentsExpression::evaluate(std::shared_ptr<minja::Context> const&)::{lambda(minja::Value const&)#1} &&)
mov rdi, [rsp+2F8h+var_2E0]
mov rsi, [rsp+2F8h+var_2D8]
call _ZNK5minja5Value8for_eachERKSt8functionIFvRS0_EE; minja::Value::for_each(std::function<void ()(minja::Value&)> const&)
jmp short $+2
loc_D877B:
lea rdi, [rsp+2F8h+var_150]
call _ZNSt8functionIFvRN5minja5ValueEEED2Ev; std::function<void ()(minja::Value &)>::~function()
mov [rsp+2F8h+var_DC], 3
lea rdi, [rsp+2F8h+var_130]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
jmp short loc_D87E4
mov rcx, rax
mov eax, edx
mov [rsp+arg_248], rcx
mov [rsp+arg_244], eax
lea rdi, [rsp+arg_1A0]
call _ZNSt8functionIFvRN5minja5ValueEEED2Ev; std::function<void ()(minja::Value &)>::~function()
loc_D87C3:
lea rdi, [rsp+arg_1C0]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
jmp loc_D8864
loc_D87D5:
jmp short $+2
loc_D87D7:
jmp short $+2
loc_D87D9:
mov [rsp+2F8h+var_DC], 0
loc_D87E4:
lea rdi, [rsp+2F8h+var_50]
call _ZNSt10shared_ptrIN5minja11UnaryOpExprEED2Ev; std::shared_ptr<minja::UnaryOpExpr>::~shared_ptr()
mov eax, [rsp+2F8h+var_DC]
test eax, eax
jz short loc_D8800
jmp short $+2
loc_D87FE:
jmp short loc_D8852
loc_D8800:
mov rax, [rsp+2F8h+var_2B8]
mov [rsp+2F8h+var_2E8], rax
mov rdi, [rsp+2F8h+var_40]
call _ZNKSt19__shared_ptr_accessIN5minja10ExpressionELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<minja::Expression,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rsi, rax
mov rdx, [rsp+2F8h+var_18]
lea rdi, [rsp+2F8h+var_1B0]
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
jmp short $+2
loc_D8831:
mov rdi, [rsp+2F8h+var_2E8]
lea rsi, [rsp+2F8h+var_1B0]
call _ZNSt6vectorIN5minja5ValueESaIS1_EE9push_backEOS1_; std::vector<minja::Value>::push_back(minja::Value&&)
jmp short $+2
loc_D8845:
lea rdi, [rsp+2F8h+var_1B0]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_D8852:
lea rdi, [rsp+2F8h+var_30]
call _ZN9__gnu_cxx17__normal_iteratorIPKSt10shared_ptrIN5minja10ExpressionEESt6vectorIS4_SaIS4_EEEppEv; __gnu_cxx::__normal_iterator<std::shared_ptr<minja::Expression> const*,std::vector<std::shared_ptr<minja::Expression>>>::operator++(void)
jmp loc_D846D
loc_D8864:
lea rdi, [rsp+arg_2A0]
call _ZNSt10shared_ptrIN5minja11UnaryOpExprEED2Ev; std::shared_ptr<minja::UnaryOpExpr>::~shared_ptr()
jmp loc_D8A5A
mov rcx, rax
mov eax, edx
mov [rsp+arg_248], rcx
mov [rsp+arg_244], eax
jmp loc_D8A5A
mov rcx, rax
mov eax, edx
mov [rsp+arg_248], rcx
mov [rsp+arg_244], eax
lea rdi, [rsp+arg_140]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
jmp loc_D8A5A
loc_D88B5:
mov rax, [rsp+2F8h+var_2A8]
add rax, 18h
mov [rsp+2F8h+var_1B8], rax
mov rdi, [rsp+2F8h+var_1B8]
call _ZNKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt10shared_ptrIN5minja10ExpressionEEESaISB_EE5beginEv; std::vector<std::pair<std::string,std::shared_ptr<minja::Expression>>>::begin(void)
mov [rsp+2F8h+var_1C0], rax
mov rdi, [rsp+2F8h+var_1B8]
call _ZNKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt10shared_ptrIN5minja10ExpressionEEESaISB_EE3endEv; std::vector<std::pair<std::string,std::shared_ptr<minja::Expression>>>::end(void)
mov [rsp+2F8h+var_1C8], rax
loc_D88F0:
lea rdi, [rsp+2F8h+var_1C0]
lea rsi, [rsp+2F8h+var_1C8]
call _ZN9__gnu_cxxneIPKSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt10shared_ptrIN5minja10ExpressionEEESt6vectorISC_SaISC_EEEEbRKNS_17__normal_iteratorIT_T0_EESN_; __gnu_cxx::operator!=<std::pair<std::string,std::shared_ptr<minja::Expression>> const*,std::vector<std::pair<std::string,std::shared_ptr<minja::Expression>>>>(__gnu_cxx::__normal_iterator<std::pair<std::string,std::shared_ptr<minja::Expression>> const*,std::vector<std::pair<std::string,std::shared_ptr<minja::Expression>>>> const&,__gnu_cxx::__normal_iterator<std::pair<std::string,std::shared_ptr<minja::Expression>> const*,std::vector<std::pair<std::string,std::shared_ptr<minja::Expression>>>> const&)
test al, 1
jnz short loc_D890E
jmp loc_D8A26
loc_D890E:
lea rdi, [rsp+2F8h+var_1C0]
call _ZNK9__gnu_cxx17__normal_iteratorIPKSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt10shared_ptrIN5minja10ExpressionEEESt6vectorISC_SaISC_EEEdeEv; __gnu_cxx::__normal_iterator<std::pair<std::string,std::shared_ptr<minja::Expression>> const*,std::vector<std::pair<std::string,std::shared_ptr<minja::Expression>>>>::operator*(void)
mov [rsp+2F8h+var_1D0], rax
mov rdi, [rsp+2F8h+var_1D0]
call _ZSt3getILm0ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt10shared_ptrIN5minja10ExpressionEEERKNSt13tuple_elementIXT_ESt4pairIT0_T1_EE4typeERKSE_; std::get<0ul,std::string,std::shared_ptr<minja::Expression>>(std::pair<std::string,std::shared_ptr<minja::Expression>> const&)
mov [rsp+2F8h+var_1D8], rax
mov rdi, [rsp+2F8h+var_1D0]
call _ZSt3getILm1ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt10shared_ptrIN5minja10ExpressionEEERKNSt13tuple_elementIXT_ESt4pairIT0_T1_EE4typeERKSE_; std::get<1ul,std::string,std::shared_ptr<minja::Expression>>(std::pair<std::string,std::shared_ptr<minja::Expression>> const&)
mov rcx, rax
mov rax, [rsp+2F8h+var_2B8]
mov [rsp+2F8h+var_1E0], rcx
add rax, 18h
mov [rsp+2F8h+var_2F8], rax
mov rax, [rsp+2F8h+var_1D8]
mov [rsp+2F8h+var_2F0], rax
mov rdi, [rsp+2F8h+var_1E0]
call _ZNKSt19__shared_ptr_accessIN5minja10ExpressionELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<minja::Expression,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rsi, rax
mov rdx, [rsp+2F8h+var_18]
lea rdi, [rsp+2F8h+var_2A0]
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
jmp short $+2
loc_D898E:
mov rsi, [rsp+2F8h+var_2F0]
lea rdi, [rsp+2F8h+var_250]
lea rdx, [rsp+2F8h+var_2A0]
call _ZNSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN5minja5ValueEEC2IS7_TnNSt9enable_ifIXclsr5_PCCPE13_CopyMovePairILb1ES5_T_EEEbE4typeELb1EEERKS5_OSB_
jmp short $+2
loc_D89A7:
mov rdi, [rsp+2F8h+var_2F8]
lea rsi, [rsp+2F8h+var_250]
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN5minja5ValueEESaIS9_EE9push_backEOS9_; std::vector<std::pair<std::string,minja::Value>>::push_back(std::pair<std::string,minja::Value>&&)
jmp short $+2
loc_D89BA:
lea rdi, [rsp+2F8h+var_250]
call _ZNSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN5minja5ValueEED2Ev; std::pair<std::string,minja::Value>::~pair()
lea rdi, [rsp+2F8h+var_2A0]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
lea rdi, [rsp+2F8h+var_1C0]
call _ZN9__gnu_cxx17__normal_iteratorIPKSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt10shared_ptrIN5minja10ExpressionEEESt6vectorISC_SaISC_EEEppEv; __gnu_cxx::__normal_iterator<std::pair<std::string,std::shared_ptr<minja::Expression>> const*,std::vector<std::pair<std::string,std::shared_ptr<minja::Expression>>>>::operator++(void)
jmp loc_D88F0
mov rcx, rax
mov eax, edx
mov [rsp+arg_248], rcx
mov [rsp+arg_244], eax
jmp short loc_D8A1A
mov rcx, rax
mov eax, edx
mov [rsp+arg_248], rcx
mov [rsp+arg_244], eax
lea rdi, [rsp+arg_A0]
call _ZNSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN5minja5ValueEED2Ev; std::pair<std::string,minja::Value>::~pair()
loc_D8A1A:
lea rdi, [rsp+arg_50]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
jmp short loc_D8A5A
loc_D8A26:
mov [rsp+2F8h+var_19], 1
mov [rsp+2F8h+var_DC], 1
test [rsp+2F8h+var_19], 1
jnz short loc_D8A4D
mov rdi, [rsp+2F8h+var_2B8]; this
call _ZN5minja14ArgumentsValueD2Ev; minja::ArgumentsValue::~ArgumentsValue()
loc_D8A4D:
mov rax, [rsp+2F8h+var_2B0]
add rsp, 2F8h
retn
loc_D8A5A:
mov rdi, [rsp+arg_38]; this
call _ZN5minja14ArgumentsValueD2Ev; minja::ArgumentsValue::~ArgumentsValue()
mov rdi, [rsp+arg_248]
call __Unwind_Resume
loc_D8A71:
nop word ptr [rax+rax+00000000h]
nop dword ptr [rax+rax+00h]
| minja::ArgumentsValue * minja::ArgumentsExpression::evaluate(
minja::ArgumentsValue *a1,
long long a2,
long long a3)
{
long long v3; // rax
void (***v4)(void); // rax
long long v5; // rax
void (***v6)(void); // rax
void (***v7)(void); // rax
void (***v8)(void); // rax
long long v10; // [rsp+8h] [rbp-2F0h]
std::runtime_error *v11; // [rsp+28h] [rbp-2D0h]
std::runtime_error *exception; // [rsp+38h] [rbp-2C0h]
_BYTE v13[80]; // [rsp+58h] [rbp-2A0h] BYREF
_BYTE v14[112]; // [rsp+A8h] [rbp-250h] BYREF
long long v15; // [rsp+118h] [rbp-1E0h]
long long v16; // [rsp+120h] [rbp-1D8h]
long long v17; // [rsp+128h] [rbp-1D0h]
long long v18; // [rsp+130h] [rbp-1C8h] BYREF
_QWORD v19[2]; // [rsp+138h] [rbp-1C0h] BYREF
_BYTE v20[80]; // [rsp+148h] [rbp-1B0h] BYREF
_QWORD v21[2]; // [rsp+198h] [rbp-160h] BYREF
_BYTE v22[32]; // [rsp+1A8h] [rbp-150h] BYREF
_BYTE v23[84]; // [rsp+1C8h] [rbp-130h] BYREF
int v24; // [rsp+21Ch] [rbp-DCh]
minja::ArgumentsValue *v25; // [rsp+220h] [rbp-D8h] BYREF
_BYTE v26[48]; // [rsp+228h] [rbp-D0h] BYREF
_BYTE v27[80]; // [rsp+258h] [rbp-A0h] BYREF
_BYTE v28[16]; // [rsp+2A8h] [rbp-50h] BYREF
long long v29; // [rsp+2B8h] [rbp-40h]
long long v30; // [rsp+2C0h] [rbp-38h] BYREF
_QWORD v31[2]; // [rsp+2C8h] [rbp-30h] BYREF
char v32; // [rsp+2DFh] [rbp-19h]
long long v33; // [rsp+2E0h] [rbp-18h]
long long v34; // [rsp+2E8h] [rbp-10h]
minja::ArgumentsValue *v35; // [rsp+2F0h] [rbp-8h]
v35 = a1;
v34 = a2;
v33 = a3;
v32 = 0;
minja::ArgumentsValue::ArgumentsValue(a1);
v31[1] = a2;
v31[0] = std::vector<std::shared_ptr<minja::Expression>>::begin(a2);
v30 = std::vector<std::shared_ptr<minja::Expression>>::end(a2);
while ( __gnu_cxx::operator!=<std::shared_ptr<minja::Expression> const*,std::vector<std::shared_ptr<minja::Expression>>>(
(long long)v31,
(long long)&v30) )
{
v29 = __gnu_cxx::__normal_iterator<std::shared_ptr<minja::Expression> const*,std::vector<std::shared_ptr<minja::Expression>>>::operator*((long long)v31);
std::dynamic_pointer_cast<minja::UnaryOpExpr,minja::Expression>(v28, v29);
if ( (std::__shared_ptr<minja::UnaryOpExpr,(__gnu_cxx::_Lock_policy)2>::operator bool(v28) & 1) == 0 )
goto LABEL_12;
if ( *(_DWORD *)(std::__shared_ptr_access<minja::UnaryOpExpr,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(v28)
+ 48) == 3 )
{
v3 = std::__shared_ptr_access<minja::UnaryOpExpr,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(v28);
v4 = (void (***)(void))std::__shared_ptr_access<minja::Expression,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(v3 + 32);
minja::Expression::evaluate((long long)v27, v4);
if ( !minja::Value::is_array((minja::Value *)v27) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Expansion operator only supported on arrays");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v25 = a1;
std::function<void ()(minja::Value &)>::function<minja::ArgumentsExpression::evaluate(std::shared_ptr<minja::Context> const&)::{lambda(minja::Value &)#1},void>(
v26,
&v25);
minja::Value::for_each(v27, v26);
std::function<void ()(minja::Value &)>::~function(v26);
v24 = 3;
minja::Value::~Value((minja::Value *)v27);
}
else
{
if ( *(_DWORD *)(std::__shared_ptr_access<minja::UnaryOpExpr,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(v28)
+ 48) != 4 )
{
LABEL_12:
v24 = 0;
goto LABEL_13;
}
v5 = std::__shared_ptr_access<minja::UnaryOpExpr,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(v28);
v6 = (void (***)(void))std::__shared_ptr_access<minja::Expression,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(v5 + 32);
minja::Expression::evaluate((long long)v23, v6);
if ( !minja::Value::is_object((minja::Value *)v23) )
{
v11 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v11, "ExpansionDict operator only supported on objects");
__cxa_throw(
v11,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v21[0] = a1;
v21[1] = v23;
std::function<void ()(minja::Value &)>::function<minja::ArgumentsExpression::evaluate(std::shared_ptr<minja::Context> const&)::{lambda(minja::Value const&)#1},void>(
v22,
v21);
minja::Value::for_each(v23, v22);
std::function<void ()(minja::Value &)>::~function(v22);
v24 = 3;
minja::Value::~Value((minja::Value *)v23);
}
LABEL_13:
std::shared_ptr<minja::UnaryOpExpr>::~shared_ptr((long long)v28);
if ( !v24 )
{
v7 = (void (***)(void))std::__shared_ptr_access<minja::Expression,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(v29);
minja::Expression::evaluate((long long)v20, v7);
std::vector<minja::Value>::push_back((long long)a1, (long long)v20);
minja::Value::~Value((minja::Value *)v20);
}
__gnu_cxx::__normal_iterator<std::shared_ptr<minja::Expression> const*,std::vector<std::shared_ptr<minja::Expression>>>::operator++(v31);
}
v19[1] = a2 + 24;
v19[0] = std::vector<std::pair<std::string,std::shared_ptr<minja::Expression>>>::begin(a2 + 24);
v18 = std::vector<std::pair<std::string,std::shared_ptr<minja::Expression>>>::end(a2 + 24);
while ( (__gnu_cxx::operator!=<std::pair<std::string,std::shared_ptr<minja::Expression>> const*,std::vector<std::pair<std::string,std::shared_ptr<minja::Expression>>>>(
v19,
&v18) & 1) != 0 )
{
v17 = __gnu_cxx::__normal_iterator<std::pair<std::string,std::shared_ptr<minja::Expression>> const*,std::vector<std::pair<std::string,std::shared_ptr<minja::Expression>>>>::operator*(v19);
v16 = std::get<0ul,std::string,std::shared_ptr<minja::Expression>>(v17);
v15 = std::get<1ul,std::string,std::shared_ptr<minja::Expression>>(v17);
v10 = v16;
v8 = (void (***)(void))std::__shared_ptr_access<minja::Expression,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(v15);
minja::Expression::evaluate((long long)v13, v8);
ZNSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN5minja5ValueEEC2IS7_TnNSt9enable_ifIXclsr5_PCCPE13_CopyMovePairILb1ES5_T_EEEbE4typeELb1EEERKS5_OSB_(
v14,
v10,
v13);
std::vector<std::pair<std::string,minja::Value>>::push_back((char *)a1 + 24, v14);
std::pair<std::string,minja::Value>::~pair(v14);
minja::Value::~Value((minja::Value *)v13);
__gnu_cxx::__normal_iterator<std::pair<std::string,std::shared_ptr<minja::Expression>> const*,std::vector<std::pair<std::string,std::shared_ptr<minja::Expression>>>>::operator++(v19);
}
return a1;
}
| evaluate:
SUB RSP,0x2f8
MOV qword ptr [RSP + 0x40],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x48],RAX
MOV qword ptr [RSP + 0x2f0],RDI
MOV qword ptr [RSP + 0x2e8],RSI
MOV qword ptr [RSP + 0x2e0],RDX
MOV RAX,qword ptr [RSP + 0x2e8]
MOV qword ptr [RSP + 0x50],RAX
MOV byte ptr [RSP + 0x2df],0x0
CALL 0x001da590
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x2d0],RAX
MOV RDI,qword ptr [RSP + 0x2d0]
CALL 0x001cd800
MOV qword ptr [RSP + 0x2c8],RAX
MOV RDI,qword ptr [RSP + 0x2d0]
CALL 0x001cd830
MOV qword ptr [RSP + 0x2c0],RAX
LAB_001d846d:
LEA RDI,[RSP + 0x2c8]
LEA RSI,[RSP + 0x2c0]
CALL 0x001cd860
TEST AL,0x1
JNZ 0x001d848b
JMP 0x001d88b5
LAB_001d848b:
LEA RDI,[RSP + 0x2c8]
CALL 0x001cd8a0
MOV qword ptr [RSP + 0x2b8],RAX
MOV RSI,qword ptr [RSP + 0x2b8]
LEA RDI,[RSP + 0x2a8]
CALL 0x001da5c0
LEA RDI,[RSP + 0x2a8]
CALL 0x001da660
TEST AL,0x1
JNZ 0x001d84cb
JMP 0x001d87d9
LAB_001d84cb:
LEA RDI,[RSP + 0x2a8]
CALL 0x001da680
CMP dword ptr [RAX + 0x30],0x3
JNZ 0x001d8657
LEA RDI,[RSP + 0x2a8]
CALL 0x001da680
MOV RDI,RAX
ADD RDI,0x20
CALL 0x0019f2f0
MOV RSI,RAX
MOV RDX,qword ptr [RSP + 0x2e0]
LAB_001d8506:
LEA RDI,[RSP + 0x258]
CALL 0x0019f300
LAB_001d8513:
JMP 0x001d8515
LAB_001d8515:
LEA RDI,[RSP + 0x258]
CALL 0x001a4990
TEST AL,0x1
JNZ 0x001d85bf
MOV EDI,0x10
CALL 0x00150540
MOV RDI,RAX
MOV RAX,RDI
MOV qword ptr [RSP + 0x38],RAX
LAB_001d853f:
LEA RSI,[0x2d19d5]
CALL 0x00150340
JMP 0x001d854d
LAB_001d854d:
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [0x00353fb0]
MOV RDX,qword ptr [0x00353f78]
CALL 0x001508f0
LAB_001d85bf:
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x220],RAX
LEA RDI,[RSP + 0x228]
MOV qword ptr [RSP + 0x30],RDI
LEA RSI,[RSP + 0x220]
CALL 0x001dab90
MOV RSI,qword ptr [RSP + 0x30]
LAB_001d85eb:
LEA RDI,[RSP + 0x258]
CALL 0x001da690
JMP 0x001d85fa
LAB_001d85fa:
LEA RDI,[RSP + 0x228]
CALL 0x001dac20
MOV dword ptr [RSP + 0x21c],0x3
LEA RDI,[RSP + 0x258]
CALL 0x0019f7a0
JMP 0x001d87e4
LAB_001d8657:
LEA RDI,[RSP + 0x2a8]
CALL 0x001da680
CMP dword ptr [RAX + 0x30],0x4
JNZ 0x001d87d5
LEA RDI,[RSP + 0x2a8]
CALL 0x001da680
MOV RDI,RAX
ADD RDI,0x20
CALL 0x0019f2f0
MOV RSI,RAX
MOV RDX,qword ptr [RSP + 0x2e0]
LAB_001d8692:
LEA RDI,[RSP + 0x1c8]
CALL 0x0019f300
LAB_001d869f:
JMP 0x001d86a1
LAB_001d86a1:
LEA RDI,[RSP + 0x1c8]
CALL 0x001a5180
TEST AL,0x1
JNZ 0x001d872e
MOV EDI,0x10
CALL 0x00150540
MOV RDI,RAX
MOV RAX,RDI
MOV qword ptr [RSP + 0x28],RAX
LAB_001d86c7:
LEA RSI,[0x2d1a01]
CALL 0x00150340
JMP 0x001d86d5
LAB_001d86d5:
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [0x00353fb0]
MOV RDX,qword ptr [0x00353f78]
CALL 0x001508f0
LAB_001d872e:
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x198],RAX
LEA RAX,[RSP + 0x1c8]
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x1a0],RAX
LEA RDI,[RSP + 0x1a8]
MOV qword ptr [RSP + 0x20],RDI
LEA RSI,[RSP + 0x198]
CALL 0x001dac30
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x20]
LAB_001d8774:
CALL 0x001da690
JMP 0x001d877b
LAB_001d877b:
LEA RDI,[RSP + 0x1a8]
CALL 0x001dac20
MOV dword ptr [RSP + 0x21c],0x3
LEA RDI,[RSP + 0x1c8]
CALL 0x0019f7a0
JMP 0x001d87e4
LAB_001d87d5:
JMP 0x001d87d7
LAB_001d87d7:
JMP 0x001d87d9
LAB_001d87d9:
MOV dword ptr [RSP + 0x21c],0x0
LAB_001d87e4:
LEA RDI,[RSP + 0x2a8]
CALL 0x0019de00
MOV EAX,dword ptr [RSP + 0x21c]
TEST EAX,EAX
JZ 0x001d8800
JMP 0x001d87fe
LAB_001d87fe:
JMP 0x001d8852
LAB_001d8800:
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RSP + 0x2b8]
CALL 0x0019f2f0
MOV RSI,RAX
MOV RDX,qword ptr [RSP + 0x2e0]
LAB_001d8822:
LEA RDI,[RSP + 0x148]
CALL 0x0019f300
JMP 0x001d8831
LAB_001d8831:
MOV RDI,qword ptr [RSP + 0x10]
LEA RSI,[RSP + 0x148]
CALL 0x001c7180
JMP 0x001d8845
LAB_001d8845:
LEA RDI,[RSP + 0x148]
CALL 0x0019f7a0
LAB_001d8852:
LEA RDI,[RSP + 0x2c8]
CALL 0x001cd9e0
JMP 0x001d846d
LAB_001d88b5:
MOV RAX,qword ptr [RSP + 0x50]
ADD RAX,0x18
MOV qword ptr [RSP + 0x140],RAX
MOV RDI,qword ptr [RSP + 0x140]
CALL 0x001dacc0
MOV qword ptr [RSP + 0x138],RAX
MOV RDI,qword ptr [RSP + 0x140]
CALL 0x001dacf0
MOV qword ptr [RSP + 0x130],RAX
LAB_001d88f0:
LEA RDI,[RSP + 0x138]
LEA RSI,[RSP + 0x130]
CALL 0x001dad20
TEST AL,0x1
JNZ 0x001d890e
JMP 0x001d8a26
LAB_001d890e:
LEA RDI,[RSP + 0x138]
CALL 0x001dad60
MOV qword ptr [RSP + 0x128],RAX
MOV RDI,qword ptr [RSP + 0x128]
CALL 0x001dad70
MOV qword ptr [RSP + 0x120],RAX
MOV RDI,qword ptr [RSP + 0x128]
CALL 0x001dad80
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x118],RCX
ADD RAX,0x18
MOV qword ptr [RSP],RAX
MOV RAX,qword ptr [RSP + 0x120]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x118]
CALL 0x0019f2f0
MOV RSI,RAX
MOV RDX,qword ptr [RSP + 0x2e0]
LAB_001d8982:
LEA RDI,[RSP + 0x58]
CALL 0x0019f300
JMP 0x001d898e
LAB_001d898e:
MOV RSI,qword ptr [RSP + 0x8]
LEA RDI,[RSP + 0xa8]
LEA RDX,[RSP + 0x58]
CALL 0x001dadc0
JMP 0x001d89a7
LAB_001d89a7:
MOV RDI,qword ptr [RSP]
LEA RSI,[RSP + 0xa8]
CALL 0x001dad90
LAB_001d89b8:
JMP 0x001d89ba
LAB_001d89ba:
LEA RDI,[RSP + 0xa8]
CALL 0x001dae00
LEA RDI,[RSP + 0x58]
CALL 0x0019f7a0
LEA RDI,[RSP + 0x138]
CALL 0x001dae30
JMP 0x001d88f0
LAB_001d8a26:
MOV byte ptr [RSP + 0x2df],0x1
MOV dword ptr [RSP + 0x21c],0x1
TEST byte ptr [RSP + 0x2df],0x1
JNZ 0x001d8a4d
MOV RDI,qword ptr [RSP + 0x40]
CALL 0x001da560
LAB_001d8a4d:
MOV RAX,qword ptr [RSP + 0x48]
ADD RSP,0x2f8
RET
|
/* WARNING: Removing unreachable block (ram,0x001d8a43) */
/* minja::ArgumentsExpression::evaluate(std::shared_ptr<minja::Context> const&) const */
shared_ptr * minja::ArgumentsExpression::evaluate(shared_ptr *param_1)
{
type *ptVar1;
bool bVar2;
long lVar3;
ulong uVar4;
runtime_error *prVar5;
vector<std::shared_ptr<minja::Expression>,std::allocator<std::shared_ptr<minja::Expression>>>
*in_RSI;
shared_ptr local_2a0 [80];
pair local_250 [112];
type *local_1e0;
type *local_1d8;
pair *local_1d0;
int8 local_1c8;
int8 local_1c0;
vector<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>,std::allocator<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>>>
*local_1b8;
shared_ptr local_1b0 [80];
shared_ptr *local_160;
Value *local_158;
function<void(minja::Value&)> local_150 [32];
shared_ptr local_130 [84];
int local_dc;
shared_ptr *local_d8;
function<void(minja::Value&)> local_d0 [48];
shared_ptr local_a0 [80];
shared_ptr local_50 [16];
__shared_ptr_access<minja::Expression,(__gnu_cxx::_Lock_policy)2,false,false> *local_40;
int8 local_38;
int8 local_30;
vector<std::shared_ptr<minja::Expression>,std::allocator<std::shared_ptr<minja::Expression>>>
*local_28;
int1 local_19;
shared_ptr *local_8;
local_19 = 0;
local_8 = param_1;
ArgumentsValue::ArgumentsValue((ArgumentsValue *)param_1);
local_28 = in_RSI;
local_30 = std::
vector<std::shared_ptr<minja::Expression>,std::allocator<std::shared_ptr<minja::Expression>>>
::begin(in_RSI);
local_38 = std::
vector<std::shared_ptr<minja::Expression>,std::allocator<std::shared_ptr<minja::Expression>>>
::end(local_28);
do {
bVar2 = __gnu_cxx::operator!=((__normal_iterator *)&local_30,(__normal_iterator *)&local_38);
if (!bVar2) {
local_1b8 = (vector<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>,std::allocator<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>>>
*)(in_RSI + 0x18);
local_1c0 = std::
vector<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>,std::allocator<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>>>
::begin(local_1b8);
local_1c8 = std::
vector<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>,std::allocator<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>>>
::end(local_1b8);
while (bVar2 = __gnu_cxx::operator!=
((__normal_iterator *)&local_1c0,(__normal_iterator *)&local_1c8),
bVar2) {
local_1d0 = (pair *)__gnu_cxx::
__normal_iterator<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>const*,std::vector<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>,std::allocator<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>>>>
::operator*((__normal_iterator<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>const*,std::vector<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>,std::allocator<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>>>>
*)&local_1c0);
local_1d8 = std::get<0ul,std::__cxx11::string,std::shared_ptr<minja::Expression>>(local_1d0)
;
local_1e0 = std::get<1ul,std::__cxx11::string,std::shared_ptr<minja::Expression>>(local_1d0)
;
ptVar1 = local_1d8;
std::__shared_ptr_access<minja::Expression,(__gnu_cxx::_Lock_policy)2,false,false>::
operator->((__shared_ptr_access<minja::Expression,(__gnu_cxx::_Lock_policy)2,false,false> *)
local_1e0);
/* try { // try from 001d8982 to 001d898b has its CatchHandler @ 001d8876 */
Expression::evaluate(local_2a0);
/* try { // try from 001d898e to 001d89a4 has its CatchHandler @ 001d89e3 */
_ZNSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN5minja5ValueEEC2IS7_TnNSt9enable_ifIXclsr5_PCCPE13_CopyMovePairILb1ES5_T_EEEbE4typeELb1EEERKS5_OSB_
(local_250,ptVar1,local_2a0);
/* try { // try from 001d89a7 to 001d89b7 has its CatchHandler @ 001d89f9 */
std::
vector<std::pair<std::__cxx11::string,minja::Value>,std::allocator<std::pair<std::__cxx11::string,minja::Value>>>
::push_back((vector<std::pair<std::__cxx11::string,minja::Value>,std::allocator<std::pair<std::__cxx11::string,minja::Value>>>
*)(param_1 + 0x18),local_250);
std::pair<std::__cxx11::string,minja::Value>::~pair
((pair<std::__cxx11::string,minja::Value> *)local_250);
Value::~Value((Value *)local_2a0);
__gnu_cxx::
__normal_iterator<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>const*,std::vector<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>,std::allocator<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>>>>
::operator++((__normal_iterator<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>const*,std::vector<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>,std::allocator<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>>>>
*)&local_1c0);
}
return param_1;
}
local_40 = (__shared_ptr_access<minja::Expression,(__gnu_cxx::_Lock_policy)2,false,false> *)
__gnu_cxx::
__normal_iterator<std::shared_ptr<minja::Expression>const*,std::vector<std::shared_ptr<minja::Expression>,std::allocator<std::shared_ptr<minja::Expression>>>>
::operator*((__normal_iterator<std::shared_ptr<minja::Expression>const*,std::vector<std::shared_ptr<minja::Expression>,std::allocator<std::shared_ptr<minja::Expression>>>>
*)&local_30);
std::dynamic_pointer_cast<minja::UnaryOpExpr,minja::Expression>(local_50);
bVar2 = std::__shared_ptr::operator_cast_to_bool((__shared_ptr *)local_50);
if (bVar2) {
lVar3 = std::__shared_ptr_access<minja::UnaryOpExpr,(__gnu_cxx::_Lock_policy)2,false,false>::
operator->((__shared_ptr_access<minja::UnaryOpExpr,(__gnu_cxx::_Lock_policy)2,false,false>
*)local_50);
if (*(int *)(lVar3 + 0x30) == 3) {
lVar3 = std::__shared_ptr_access<minja::UnaryOpExpr,(__gnu_cxx::_Lock_policy)2,false,false>
::operator->((__shared_ptr_access<minja::UnaryOpExpr,(__gnu_cxx::_Lock_policy)2,false,false>
*)local_50);
std::__shared_ptr_access<minja::Expression,(__gnu_cxx::_Lock_policy)2,false,false>::
operator->((__shared_ptr_access<minja::Expression,(__gnu_cxx::_Lock_policy)2,false,false> *)
(lVar3 + 0x20));
/* try { // try from 001d8506 to 001d8512 has its CatchHandler @ 001d856a */
Expression::evaluate(local_a0);
uVar4 = Value::is_array((Value *)local_a0);
if ((uVar4 & 1) == 0) {
prVar5 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001d853f to 001d854a has its CatchHandler @ 001d8583 */
std::runtime_error::runtime_error(prVar5,"Expansion operator only supported on arrays");
/* try { // try from 001d854d to 001d8564 has its CatchHandler @ 001d85a6 */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar5,PTR_typeinfo_00353fb0,PTR__runtime_error_00353f78);
}
local_d8 = param_1;
std::function<void(minja::Value&)>::
function<minja::ArgumentsExpression::evaluate(std::shared_ptr<minja::Context>const&)const::_lambda(minja::Value&)_1_,void>
(local_d0,(_lambda_minja__Value___1_ *)&local_d8);
/* try { // try from 001d85eb to 001d85f7 has its CatchHandler @ 001d8624 */
Value::for_each((Value *)local_a0,(function *)local_d0);
std::function<void(minja::Value&)>::~function(local_d0);
local_dc = 3;
Value::~Value((Value *)local_a0);
}
else {
lVar3 = std::__shared_ptr_access<minja::UnaryOpExpr,(__gnu_cxx::_Lock_policy)2,false,false>
::operator->((__shared_ptr_access<minja::UnaryOpExpr,(__gnu_cxx::_Lock_policy)2,false,false>
*)local_50);
if (*(int *)(lVar3 + 0x30) != 4) goto LAB_001d87d9;
lVar3 = std::__shared_ptr_access<minja::UnaryOpExpr,(__gnu_cxx::_Lock_policy)2,false,false>
::operator->((__shared_ptr_access<minja::UnaryOpExpr,(__gnu_cxx::_Lock_policy)2,false,false>
*)local_50);
std::__shared_ptr_access<minja::Expression,(__gnu_cxx::_Lock_policy)2,false,false>::
operator->((__shared_ptr_access<minja::Expression,(__gnu_cxx::_Lock_policy)2,false,false> *)
(lVar3 + 0x20));
/* try { // try from 001d8692 to 001d869e has its CatchHandler @ 001d856a */
Expression::evaluate(local_130);
uVar4 = Value::is_object((Value *)local_130);
if ((uVar4 & 1) == 0) {
prVar5 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001d86c7 to 001d86d2 has its CatchHandler @ 001d86f2 */
std::runtime_error::runtime_error
(prVar5,"ExpansionDict operator only supported on objects");
/* try { // try from 001d86d5 to 001d86ec has its CatchHandler @ 001d8715 */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar5,PTR_typeinfo_00353fb0,PTR__runtime_error_00353f78);
}
local_160 = param_1;
local_158 = (Value *)local_130;
std::function<void(minja::Value&)>::
function<minja::ArgumentsExpression::evaluate(std::shared_ptr<minja::Context>const&)const::_lambda(minja::Value_const&)_1_,void>
(local_150,(_lambda_minja__Value_const___1_ *)&local_160);
/* try { // try from 001d8774 to 001d8778 has its CatchHandler @ 001d87a2 */
Value::for_each((Value *)local_130,(function *)local_150);
std::function<void(minja::Value&)>::~function(local_150);
local_dc = 3;
Value::~Value((Value *)local_130);
}
}
else {
LAB_001d87d9:
local_dc = 0;
}
std::shared_ptr<minja::UnaryOpExpr>::~shared_ptr((shared_ptr<minja::UnaryOpExpr> *)local_50);
if (local_dc == 0) {
std::__shared_ptr_access<minja::Expression,(__gnu_cxx::_Lock_policy)2,false,false>::operator->
(local_40);
/* try { // try from 001d8822 to 001d882e has its CatchHandler @ 001d8876 */
Expression::evaluate(local_1b0);
/* try { // try from 001d8831 to 001d8842 has its CatchHandler @ 001d888f */
std::vector<minja::Value,std::allocator<minja::Value>>::push_back
((vector<minja::Value,std::allocator<minja::Value>> *)param_1,(Value *)local_1b0);
Value::~Value((Value *)local_1b0);
}
__gnu_cxx::
__normal_iterator<std::shared_ptr<minja::Expression>const*,std::vector<std::shared_ptr<minja::Expression>,std::allocator<std::shared_ptr<minja::Expression>>>>
::operator++((__normal_iterator<std::shared_ptr<minja::Expression>const*,std::vector<std::shared_ptr<minja::Expression>,std::allocator<std::shared_ptr<minja::Expression>>>>
*)&local_30);
} while( true );
}
| |
44,873 | my_strntol_8bit | eloqsql/strings/ctype-simple.c | long my_strntol_8bit(CHARSET_INFO *cs,
const char *nptr, size_t l, int base,
char **endptr, int *err)
{
int negative;
register uint32 cutoff;
register uint cutlim;
register uint32 i;
register const char *s;
register uchar c;
const char *save, *e;
int overflow;
*err= 0; /* Initialize error indicator */
s = nptr;
e = nptr+l;
for ( ; s<e && my_isspace(cs, *s) ; s++);
if (s == e)
{
goto noconv;
}
/* Check for a sign. */
if (*s == '-')
{
negative = 1;
++s;
}
else if (*s == '+')
{
negative = 0;
++s;
}
else
negative = 0;
save = s;
cutoff = ((uint32)~0L) / (uint32) base;
cutlim = (uint) (((uint32)~0L) % (uint32) base);
overflow = 0;
i = 0;
for (c = *s; s != e; c = *++s)
{
if (c>='0' && c<='9')
c -= '0';
else if (c>='A' && c<='Z')
c = c - 'A' + 10;
else if (c>='a' && c<='z')
c = c - 'a' + 10;
else
break;
if (c >= base)
break;
if (i > cutoff || (i == cutoff && c > cutlim))
overflow = 1;
else
{
i *= (uint32) base;
i += c;
}
}
if (s == save)
goto noconv;
if (endptr != NULL)
*endptr = (char *) s;
if (negative)
{
if (i > (uint32) INT_MIN32)
overflow = 1;
}
else if (i > INT_MAX32)
overflow = 1;
if (overflow)
{
err[0]= ERANGE;
return negative ? INT_MIN32 : INT_MAX32;
}
return (negative ? -((long) i) : (long) i);
noconv:
err[0]= EDOM;
if (endptr != NULL)
*endptr = (char *) nptr;
return 0L;
} | O0 | c | my_strntol_8bit:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x50(%rbp), %rcx
xorl %eax, %eax
cmpq -0x68(%rbp), %rcx
movb %al, -0x6d(%rbp)
jae 0x49ab8
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x50(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl 0x1(%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x6d(%rbp)
movb -0x6d(%rbp), %al
testb $0x1, %al
jne 0x49ac1
jmp 0x49ad1
jmp 0x49ac3
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x49a89
movq -0x50(%rbp), %rax
cmpq -0x68(%rbp), %rax
jne 0x49ae0
jmp 0x49cd5
movq -0x50(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x49b01
movl $0x1, -0x3c(%rbp)
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x49b2b
movq -0x50(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x49b22
movl $0x0, -0x3c(%rbp)
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x49b29
movl $0x0, -0x3c(%rbp)
jmp 0x49b2b
movq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
xorl %edx, %edx
divl -0x24(%rbp)
movl %eax, -0x40(%rbp)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
xorl %edx, %edx
divl -0x24(%rbp)
movl %edx, -0x44(%rbp)
movl $0x0, -0x6c(%rbp)
movl $0x0, -0x48(%rbp)
movq -0x50(%rbp), %rax
movb (%rax), %al
movb %al, -0x51(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x68(%rbp), %rax
je 0x49c35
movzbl -0x51(%rbp), %eax
cmpl $0x30, %eax
jl 0x49b90
movzbl -0x51(%rbp), %eax
cmpl $0x39, %eax
jg 0x49b90
movzbl -0x51(%rbp), %eax
subl $0x30, %eax
movb %al, -0x51(%rbp)
jmp 0x49bd8
movzbl -0x51(%rbp), %eax
cmpl $0x41, %eax
jl 0x49bb1
movzbl -0x51(%rbp), %eax
cmpl $0x5a, %eax
jg 0x49bb1
movzbl -0x51(%rbp), %eax
subl $0x41, %eax
addl $0xa, %eax
movb %al, -0x51(%rbp)
jmp 0x49bd6
movzbl -0x51(%rbp), %eax
cmpl $0x61, %eax
jl 0x49bd2
movzbl -0x51(%rbp), %eax
cmpl $0x7a, %eax
jg 0x49bd2
movzbl -0x51(%rbp), %eax
subl $0x61, %eax
addl $0xa, %eax
movb %al, -0x51(%rbp)
jmp 0x49bd4
jmp 0x49c35
jmp 0x49bd6
jmp 0x49bd8
movzbl -0x51(%rbp), %eax
cmpl -0x24(%rbp), %eax
jl 0x49be3
jmp 0x49c35
movl -0x48(%rbp), %eax
cmpl -0x40(%rbp), %eax
ja 0x49bfc
movl -0x48(%rbp), %eax
cmpl -0x40(%rbp), %eax
jne 0x49c05
movzbl -0x51(%rbp), %eax
cmpl -0x44(%rbp), %eax
jbe 0x49c05
movl $0x1, -0x6c(%rbp)
jmp 0x49c19
movl -0x24(%rbp), %eax
imull -0x48(%rbp), %eax
movl %eax, -0x48(%rbp)
movzbl -0x51(%rbp), %eax
addl -0x48(%rbp), %eax
movl %eax, -0x48(%rbp)
jmp 0x49c1b
movq -0x50(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x50(%rbp)
movb 0x1(%rax), %al
movb %al, -0x51(%rbp)
jmp 0x49b64
movq -0x50(%rbp), %rax
cmpq -0x60(%rbp), %rax
jne 0x49c44
jmp 0x49cd5
cmpq $0x0, -0x30(%rbp)
je 0x49c56
movq -0x50(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
cmpl $0x0, -0x3c(%rbp)
je 0x49c6e
cmpl $0x80000000, -0x48(%rbp) # imm = 0x80000000
jbe 0x49c6c
movl $0x1, -0x6c(%rbp)
jmp 0x49c82
movl -0x48(%rbp), %eax
cmpq $0x7fffffff, %rax # imm = 0x7FFFFFFF
jle 0x49c80
movl $0x1, -0x6c(%rbp)
jmp 0x49c82
cmpl $0x0, -0x6c(%rbp)
je 0x49cae
movq -0x38(%rbp), %rax
movl $0x22, (%rax)
movl -0x3c(%rbp), %edx
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
movq $-0x80000000, %rcx # imm = 0x80000000
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x49cf9
cmpl $0x0, -0x3c(%rbp)
je 0x49cc4
movl -0x48(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
subq %rcx, %rax
movq %rax, -0x78(%rbp)
jmp 0x49ccb
movl -0x48(%rbp), %eax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x49cf9
movq -0x38(%rbp), %rax
movl $0x21, (%rax)
cmpq $0x0, -0x30(%rbp)
je 0x49cf1
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| my_strntol_8bit:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov [rbp+var_30], r8
mov [rbp+var_38], r9
mov rax, [rbp+var_38]
mov dword ptr [rax], 0
mov rax, [rbp+var_18]
mov [rbp+var_50], rax
mov rax, [rbp+var_18]
add rax, [rbp+var_20]
mov [rbp+var_68], rax
loc_49A89:
mov rcx, [rbp+var_50]
xor eax, eax
cmp rcx, [rbp+var_68]
mov [rbp+var_6D], al
jnb short loc_49AB8
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rcx, [rbp+var_50]
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx+1]
and eax, 8
cmp eax, 0
setnz al
mov [rbp+var_6D], al
loc_49AB8:
mov al, [rbp+var_6D]
test al, 1
jnz short loc_49AC1
jmp short loc_49AD1
loc_49AC1:
jmp short $+2
loc_49AC3:
mov rax, [rbp+var_50]
add rax, 1
mov [rbp+var_50], rax
jmp short loc_49A89
loc_49AD1:
mov rax, [rbp+var_50]
cmp rax, [rbp+var_68]
jnz short loc_49AE0
jmp loc_49CD5
loc_49AE0:
mov rax, [rbp+var_50]
movsx eax, byte ptr [rax]
cmp eax, 2Dh ; '-'
jnz short loc_49B01
mov [rbp+var_3C], 1
mov rax, [rbp+var_50]
add rax, 1
mov [rbp+var_50], rax
jmp short loc_49B2B
loc_49B01:
mov rax, [rbp+var_50]
movsx eax, byte ptr [rax]
cmp eax, 2Bh ; '+'
jnz short loc_49B22
mov [rbp+var_3C], 0
mov rax, [rbp+var_50]
add rax, 1
mov [rbp+var_50], rax
jmp short loc_49B29
loc_49B22:
mov [rbp+var_3C], 0
loc_49B29:
jmp short $+2
loc_49B2B:
mov rax, [rbp+var_50]
mov [rbp+var_60], rax
mov eax, 0FFFFFFFFh
xor edx, edx
div [rbp+var_24]
mov [rbp+var_40], eax
mov eax, 0FFFFFFFFh
xor edx, edx
div [rbp+var_24]
mov [rbp+var_44], edx
mov [rbp+var_6C], 0
mov [rbp+var_48], 0
mov rax, [rbp+var_50]
mov al, [rax]
mov [rbp+var_51], al
loc_49B64:
mov rax, [rbp+var_50]
cmp rax, [rbp+var_68]
jz loc_49C35
movzx eax, [rbp+var_51]
cmp eax, 30h ; '0'
jl short loc_49B90
movzx eax, [rbp+var_51]
cmp eax, 39h ; '9'
jg short loc_49B90
movzx eax, [rbp+var_51]
sub eax, 30h ; '0'
mov [rbp+var_51], al
jmp short loc_49BD8
loc_49B90:
movzx eax, [rbp+var_51]
cmp eax, 41h ; 'A'
jl short loc_49BB1
movzx eax, [rbp+var_51]
cmp eax, 5Ah ; 'Z'
jg short loc_49BB1
movzx eax, [rbp+var_51]
sub eax, 41h ; 'A'
add eax, 0Ah
mov [rbp+var_51], al
jmp short loc_49BD6
loc_49BB1:
movzx eax, [rbp+var_51]
cmp eax, 61h ; 'a'
jl short loc_49BD2
movzx eax, [rbp+var_51]
cmp eax, 7Ah ; 'z'
jg short loc_49BD2
movzx eax, [rbp+var_51]
sub eax, 61h ; 'a'
add eax, 0Ah
mov [rbp+var_51], al
jmp short loc_49BD4
loc_49BD2:
jmp short loc_49C35
loc_49BD4:
jmp short $+2
loc_49BD6:
jmp short $+2
loc_49BD8:
movzx eax, [rbp+var_51]
cmp eax, [rbp+var_24]
jl short loc_49BE3
jmp short loc_49C35
loc_49BE3:
mov eax, [rbp+var_48]
cmp eax, [rbp+var_40]
ja short loc_49BFC
mov eax, [rbp+var_48]
cmp eax, [rbp+var_40]
jnz short loc_49C05
movzx eax, [rbp+var_51]
cmp eax, [rbp+var_44]
jbe short loc_49C05
loc_49BFC:
mov [rbp+var_6C], 1
jmp short loc_49C19
loc_49C05:
mov eax, [rbp+var_24]
imul eax, [rbp+var_48]
mov [rbp+var_48], eax
movzx eax, [rbp+var_51]
add eax, [rbp+var_48]
mov [rbp+var_48], eax
loc_49C19:
jmp short $+2
loc_49C1B:
mov rax, [rbp+var_50]
mov rcx, rax
add rcx, 1
mov [rbp+var_50], rcx
mov al, [rax+1]
mov [rbp+var_51], al
jmp loc_49B64
loc_49C35:
mov rax, [rbp+var_50]
cmp rax, [rbp+var_60]
jnz short loc_49C44
jmp loc_49CD5
loc_49C44:
cmp [rbp+var_30], 0
jz short loc_49C56
mov rcx, [rbp+var_50]
mov rax, [rbp+var_30]
mov [rax], rcx
loc_49C56:
cmp [rbp+var_3C], 0
jz short loc_49C6E
cmp [rbp+var_48], 80000000h
jbe short loc_49C6C
mov [rbp+var_6C], 1
loc_49C6C:
jmp short loc_49C82
loc_49C6E:
mov eax, [rbp+var_48]
cmp rax, 7FFFFFFFh
jle short loc_49C80
mov [rbp+var_6C], 1
loc_49C80:
jmp short $+2
loc_49C82:
cmp [rbp+var_6C], 0
jz short loc_49CAE
mov rax, [rbp+var_38]
mov dword ptr [rax], 22h ; '"'
mov edx, [rbp+var_3C]
mov eax, 7FFFFFFFh
mov rcx, 0FFFFFFFF80000000h
cmp edx, 0
cmovnz rax, rcx
mov [rbp+var_8], rax
jmp short loc_49CF9
loc_49CAE:
cmp [rbp+var_3C], 0
jz short loc_49CC4
mov eax, [rbp+var_48]
mov ecx, eax
xor eax, eax
sub rax, rcx
mov [rbp+var_78], rax
jmp short loc_49CCB
loc_49CC4:
mov eax, [rbp+var_48]
mov [rbp+var_78], rax
loc_49CCB:
mov rax, [rbp+var_78]
mov [rbp+var_8], rax
jmp short loc_49CF9
loc_49CD5:
mov rax, [rbp+var_38]
mov dword ptr [rax], 21h ; '!'
cmp [rbp+var_30], 0
jz short loc_49CF1
mov rcx, [rbp+var_18]
mov rax, [rbp+var_30]
mov [rax], rcx
loc_49CF1:
mov [rbp+var_8], 0
loc_49CF9:
mov rax, [rbp+var_8]
pop rbp
retn
| long long my_strntol_8bit(long long a1, _BYTE *a2, long long a3, int a4, _QWORD *a5, _DWORD *a6)
{
_BYTE *v6; // rax
long long v7; // rax
bool v10; // [rsp+Bh] [rbp-6Dh]
int v11; // [rsp+Ch] [rbp-6Ch]
_BYTE *v12; // [rsp+10h] [rbp-68h]
_BYTE *v13; // [rsp+18h] [rbp-60h]
unsigned __int8 v14; // [rsp+27h] [rbp-51h]
unsigned __int8 v15; // [rsp+27h] [rbp-51h]
_BYTE *v16; // [rsp+28h] [rbp-50h]
unsigned int v17; // [rsp+30h] [rbp-48h]
unsigned long long v18; // [rsp+34h] [rbp-44h]
int v19; // [rsp+3Ch] [rbp-3Ch]
*a6 = 0;
v16 = a2;
v12 = &a2[a3];
while ( 1 )
{
v10 = 0;
if ( v16 < v12 )
v10 = (*(_BYTE *)(*(_QWORD *)(a1 + 64) + (unsigned __int8)*v16 + 1LL) & 8) != 0;
if ( !v10 )
break;
++v16;
}
if ( v16 == v12 )
goto LABEL_45;
if ( *v16 == 45 )
{
v19 = 1;
++v16;
}
else
{
v19 = 0;
if ( *v16 == 43 )
++v16;
}
v13 = v16;
v11 = 0;
v17 = 0;
v14 = *v16;
while ( v16 != v12 )
{
if ( v14 < 0x30u || v14 > 0x39u )
{
if ( v14 < 0x41u || v14 > 0x5Au )
{
if ( v14 < 0x61u || v14 > 0x7Au )
break;
v15 = v14 - 97 + 10;
}
else
{
v15 = v14 - 65 + 10;
}
}
else
{
v15 = v14 - 48;
}
if ( v15 >= a4 )
break;
LODWORD(v18) = 0xFFFFFFFF % a4;
HIDWORD(v18) = 0xFFFFFFFF / a4;
if ( __PAIR64__(v17, v15) <= v18 )
v17 = v17 * a4 + v15;
else
v11 = 1;
v6 = v16++;
v14 = v6[1];
}
if ( v16 == v13 )
{
LABEL_45:
*a6 = 33;
if ( a5 )
*a5 = a2;
return 0LL;
}
else
{
if ( a5 )
*a5 = v16;
if ( v19 )
{
if ( v17 > 0x80000000 )
v11 = 1;
}
else if ( v17 > 0x7FFFFFFFuLL )
{
v11 = 1;
}
if ( v11 )
{
*a6 = 34;
v7 = 0x7FFFFFFFLL;
if ( v19 )
return 0xFFFFFFFF80000000LL;
return v7;
}
else if ( v19 )
{
return -(long long)v17;
}
else
{
return v17;
}
}
}
| my_strntol_8bit:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x68],RAX
LAB_00149a89:
MOV RCX,qword ptr [RBP + -0x50]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x68]
MOV byte ptr [RBP + -0x6d],AL
JNC 0x00149ab8
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x50]
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1 + 0x1]
AND EAX,0x8
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x6d],AL
LAB_00149ab8:
MOV AL,byte ptr [RBP + -0x6d]
TEST AL,0x1
JNZ 0x00149ac1
JMP 0x00149ad1
LAB_00149ac1:
JMP 0x00149ac3
LAB_00149ac3:
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x1
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00149a89
LAB_00149ad1:
MOV RAX,qword ptr [RBP + -0x50]
CMP RAX,qword ptr [RBP + -0x68]
JNZ 0x00149ae0
JMP 0x00149cd5
LAB_00149ae0:
MOV RAX,qword ptr [RBP + -0x50]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2d
JNZ 0x00149b01
MOV dword ptr [RBP + -0x3c],0x1
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x1
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00149b2b
LAB_00149b01:
MOV RAX,qword ptr [RBP + -0x50]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2b
JNZ 0x00149b22
MOV dword ptr [RBP + -0x3c],0x0
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x1
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00149b29
LAB_00149b22:
MOV dword ptr [RBP + -0x3c],0x0
LAB_00149b29:
JMP 0x00149b2b
LAB_00149b2b:
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x60],RAX
MOV EAX,0xffffffff
XOR EDX,EDX
DIV dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x40],EAX
MOV EAX,0xffffffff
XOR EDX,EDX
DIV dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x44],EDX
MOV dword ptr [RBP + -0x6c],0x0
MOV dword ptr [RBP + -0x48],0x0
MOV RAX,qword ptr [RBP + -0x50]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x51],AL
LAB_00149b64:
MOV RAX,qword ptr [RBP + -0x50]
CMP RAX,qword ptr [RBP + -0x68]
JZ 0x00149c35
MOVZX EAX,byte ptr [RBP + -0x51]
CMP EAX,0x30
JL 0x00149b90
MOVZX EAX,byte ptr [RBP + -0x51]
CMP EAX,0x39
JG 0x00149b90
MOVZX EAX,byte ptr [RBP + -0x51]
SUB EAX,0x30
MOV byte ptr [RBP + -0x51],AL
JMP 0x00149bd8
LAB_00149b90:
MOVZX EAX,byte ptr [RBP + -0x51]
CMP EAX,0x41
JL 0x00149bb1
MOVZX EAX,byte ptr [RBP + -0x51]
CMP EAX,0x5a
JG 0x00149bb1
MOVZX EAX,byte ptr [RBP + -0x51]
SUB EAX,0x41
ADD EAX,0xa
MOV byte ptr [RBP + -0x51],AL
JMP 0x00149bd6
LAB_00149bb1:
MOVZX EAX,byte ptr [RBP + -0x51]
CMP EAX,0x61
JL 0x00149bd2
MOVZX EAX,byte ptr [RBP + -0x51]
CMP EAX,0x7a
JG 0x00149bd2
MOVZX EAX,byte ptr [RBP + -0x51]
SUB EAX,0x61
ADD EAX,0xa
MOV byte ptr [RBP + -0x51],AL
JMP 0x00149bd4
LAB_00149bd2:
JMP 0x00149c35
LAB_00149bd4:
JMP 0x00149bd6
LAB_00149bd6:
JMP 0x00149bd8
LAB_00149bd8:
MOVZX EAX,byte ptr [RBP + -0x51]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x00149be3
JMP 0x00149c35
LAB_00149be3:
MOV EAX,dword ptr [RBP + -0x48]
CMP EAX,dword ptr [RBP + -0x40]
JA 0x00149bfc
MOV EAX,dword ptr [RBP + -0x48]
CMP EAX,dword ptr [RBP + -0x40]
JNZ 0x00149c05
MOVZX EAX,byte ptr [RBP + -0x51]
CMP EAX,dword ptr [RBP + -0x44]
JBE 0x00149c05
LAB_00149bfc:
MOV dword ptr [RBP + -0x6c],0x1
JMP 0x00149c19
LAB_00149c05:
MOV EAX,dword ptr [RBP + -0x24]
IMUL EAX,dword ptr [RBP + -0x48]
MOV dword ptr [RBP + -0x48],EAX
MOVZX EAX,byte ptr [RBP + -0x51]
ADD EAX,dword ptr [RBP + -0x48]
MOV dword ptr [RBP + -0x48],EAX
LAB_00149c19:
JMP 0x00149c1b
LAB_00149c1b:
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x50],RCX
MOV AL,byte ptr [RAX + 0x1]
MOV byte ptr [RBP + -0x51],AL
JMP 0x00149b64
LAB_00149c35:
MOV RAX,qword ptr [RBP + -0x50]
CMP RAX,qword ptr [RBP + -0x60]
JNZ 0x00149c44
JMP 0x00149cd5
LAB_00149c44:
CMP qword ptr [RBP + -0x30],0x0
JZ 0x00149c56
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
LAB_00149c56:
CMP dword ptr [RBP + -0x3c],0x0
JZ 0x00149c6e
CMP dword ptr [RBP + -0x48],0x80000000
JBE 0x00149c6c
MOV dword ptr [RBP + -0x6c],0x1
LAB_00149c6c:
JMP 0x00149c82
LAB_00149c6e:
MOV EAX,dword ptr [RBP + -0x48]
CMP RAX,0x7fffffff
JLE 0x00149c80
MOV dword ptr [RBP + -0x6c],0x1
LAB_00149c80:
JMP 0x00149c82
LAB_00149c82:
CMP dword ptr [RBP + -0x6c],0x0
JZ 0x00149cae
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x22
MOV EDX,dword ptr [RBP + -0x3c]
MOV EAX,0x7fffffff
MOV RCX,-0x80000000
CMP EDX,0x0
CMOVNZ RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00149cf9
LAB_00149cae:
CMP dword ptr [RBP + -0x3c],0x0
JZ 0x00149cc4
MOV EAX,dword ptr [RBP + -0x48]
MOV ECX,EAX
XOR EAX,EAX
SUB RAX,RCX
MOV qword ptr [RBP + -0x78],RAX
JMP 0x00149ccb
LAB_00149cc4:
MOV EAX,dword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x78],RAX
LAB_00149ccb:
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00149cf9
LAB_00149cd5:
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x21
CMP qword ptr [RBP + -0x30],0x0
JZ 0x00149cf1
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
LAB_00149cf1:
MOV qword ptr [RBP + -0x8],0x0
LAB_00149cf9:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
ulong my_strntol_8bit(long param_1,byte *param_2,long param_3,uint param_4,int8 *param_5,
int4 *param_6)
{
bool bVar1;
byte *pbVar2;
uint uVar3;
byte *pbVar4;
bool bVar5;
ulong local_80;
byte local_59;
byte *local_58;
uint local_50;
*param_6 = 0;
pbVar4 = param_2 + param_3;
local_58 = param_2;
while( true ) {
bVar5 = false;
if (local_58 < pbVar4) {
bVar5 = (*(byte *)(*(long *)(param_1 + 0x40) + 1 + (ulong)*local_58) & 8) != 0;
}
if (!bVar5) break;
local_58 = local_58 + 1;
}
if (local_58 != pbVar4) {
if (*local_58 == 0x2d) {
bVar5 = true;
local_58 = local_58 + 1;
}
else {
if (*local_58 == 0x2b) {
local_58 = local_58 + 1;
}
bVar5 = false;
}
pbVar2 = local_58;
uVar3 = (uint)(0xffffffff / (ulong)param_4);
bVar1 = false;
local_50 = 0;
local_59 = *local_58;
for (; local_58 != pbVar4; local_58 = local_58 + 1) {
if ((local_59 < 0x30) || (0x39 < local_59)) {
if ((local_59 < 0x41) || (0x5a < local_59)) {
if ((local_59 < 0x61) || (0x7a < local_59)) break;
local_59 = local_59 + 0xa9;
}
else {
local_59 = local_59 - 0x37;
}
}
else {
local_59 = local_59 - 0x30;
}
if ((int)param_4 <= (int)(uint)local_59) break;
if ((uVar3 < local_50) ||
((local_50 == uVar3 && ((uint)(0xffffffff % (ulong)param_4) < (uint)local_59)))) {
bVar1 = true;
}
else {
local_50 = (uint)local_59 + param_4 * local_50;
}
local_59 = local_58[1];
}
if (local_58 != pbVar2) {
if (param_5 != (int8 *)0x0) {
*param_5 = local_58;
}
if (bVar5) {
if (0x80000000 < local_50) {
bVar1 = true;
}
}
else if (0x7fffffff < local_50) {
bVar1 = true;
}
if (bVar1) {
*param_6 = 0x22;
if (!bVar5) {
return 0x7fffffff;
}
return 0xffffffff80000000;
}
if (bVar5) {
local_80 = -(ulong)local_50;
}
else {
local_80 = (ulong)local_50;
}
return local_80;
}
}
*param_6 = 0x21;
if (param_5 != (int8 *)0x0) {
*param_5 = param_2;
}
return 0;
}
| |
44,874 | translog_get_current_group_size | eloqsql/storage/maria/ma_loghandler.c | static translog_size_t translog_get_current_group_size()
{
/* buffer rest in full pages */
translog_size_t buffer_rest= translog_get_current_buffer_rest();
DBUG_ENTER("translog_get_current_group_size");
DBUG_PRINT("info", ("buffer_rest in pages: %u", buffer_rest));
buffer_rest*= log_descriptor.page_capacity_chunk_2;
/* in case of only half of buffer free we can write this and next buffer */
if (buffer_rest < log_descriptor.half_buffer_capacity_chunk_2)
{
DBUG_PRINT("info", ("buffer_rest: %lu -> add %lu",
(ulong) buffer_rest,
(ulong) log_descriptor.buffer_capacity_chunk_2));
buffer_rest+= log_descriptor.buffer_capacity_chunk_2;
}
DBUG_PRINT("info", ("buffer_rest: %lu", (ulong) buffer_rest));
DBUG_RETURN(buffer_rest);
} | O0 | c | translog_get_current_group_size:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x5cbf0
movl %eax, -0x4(%rbp)
jmp 0x5cbb2
movzwl 0x41dacd(%rip), %eax # 0x47a686
imull -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x41dab7(%rip), %eax # 0x47a680
jae 0x5cbdb
jmp 0x5cbcd
jmp 0x5cbcf
movl 0x41daa7(%rip), %eax # 0x47a67c
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5cbdd
jmp 0x5cbdf
jmp 0x5cbe1
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
| translog_get_current_group_size:
push rbp
mov rbp, rsp
sub rsp, 10h
call translog_get_current_buffer_rest
mov [rbp+var_4], eax
jmp short $+2
loc_5CBB2:
movzx eax, cs:word_47A686
imul eax, [rbp+var_4]
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
cmp eax, cs:dword_47A680
jnb short loc_5CBDB
jmp short $+2
loc_5CBCD:
jmp short $+2
loc_5CBCF:
mov eax, cs:dword_47A67C
add eax, [rbp+var_4]
mov [rbp+var_4], eax
loc_5CBDB:
jmp short $+2
loc_5CBDD:
jmp short $+2
loc_5CBDF:
jmp short $+2
loc_5CBE1:
mov eax, [rbp+var_4]
mov [rbp+var_8], eax
mov eax, [rbp+var_8]
add rsp, 10h
pop rbp
retn
| long long translog_get_current_group_size()
{
unsigned int v1; // [rsp+Ch] [rbp-4h]
v1 = translog_get_current_buffer_rest() * (unsigned __int16)word_47A686;
if ( v1 < dword_47A680 )
v1 += dword_47A67C;
return v1;
}
| translog_get_current_group_size:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
CALL 0x0015cbf0
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0015cbb2
LAB_0015cbb2:
MOVZX EAX,word ptr [0x0057a686]
IMUL EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [0x0057a680]
JNC 0x0015cbdb
JMP 0x0015cbcd
LAB_0015cbcd:
JMP 0x0015cbcf
LAB_0015cbcf:
MOV EAX,dword ptr [0x0057a67c]
ADD EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x4],EAX
LAB_0015cbdb:
JMP 0x0015cbdd
LAB_0015cbdd:
JMP 0x0015cbdf
LAB_0015cbdf:
JMP 0x0015cbe1
LAB_0015cbe1:
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x8],EAX
MOV EAX,dword ptr [RBP + -0x8]
ADD RSP,0x10
POP RBP
RET
|
uint translog_get_current_group_size(void)
{
int iVar1;
int4 local_c;
iVar1 = translog_get_current_buffer_rest();
local_c = (uint)DAT_0057a686 * iVar1;
if (local_c < DAT_0057a680) {
local_c = DAT_0057a67c + local_c;
}
return local_c;
}
| |
44,875 | fmt::v10::appender fmt::v10::detail::write<char, fmt::v10::appender, float, 0>(fmt::v10::appender, float) | AlayaLite/build_O0/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h | FMT_CONSTEXPR20 auto write(OutputIt out, T value) -> OutputIt {
if (is_constant_evaluated()) return write(out, value, format_specs<Char>());
if (const_check(!is_supported_floating_point(value))) return out;
auto fspecs = float_specs();
if (detail::signbit(value)) {
fspecs.sign = sign::minus;
value = -value;
}
constexpr auto specs = format_specs<Char>();
using floaty = conditional_t<std::is_same<T, long double>::value, double, T>;
using floaty_uint = typename dragonbox::float_info<floaty>::carrier_uint;
floaty_uint mask = exponent_mask<floaty>();
if ((bit_cast<floaty_uint>(value) & mask) == mask)
return write_nonfinite(out, std::isnan(value), specs, fspecs);
auto dec = dragonbox::to_decimal(static_cast<floaty>(value));
return write_float(out, dec, specs, fspecs, {});
} | O0 | c | fmt::v10::appender fmt::v10::detail::write<char, fmt::v10::appender, float, 0>(fmt::v10::appender, float):
subq $0x78, %rsp
movq %rdi, 0x58(%rsp)
movss %xmm0, 0x54(%rsp)
movss 0x54(%rsp), %xmm0
callq 0x9a9f0
xorb $-0x1, %al
andb $0x1, %al
movb %al, 0x73(%rsp)
testb $0x1, 0x73(%rsp)
je 0x9a8a8
movq 0x58(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x9a9e3
leaq 0x4c(%rsp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x163a0
movss 0x54(%rsp), %xmm0
movss %xmm0, 0x74(%rsp)
movss 0x74(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x9ac30
testb $0x1, %al
jne 0x9a8da
jmp 0x9a905
movl 0x50(%rsp), %eax
andl $0xffff00ff, %eax # imm = 0xFFFF00FF
orl $0x100, %eax # imm = 0x100
movl %eax, 0x50(%rsp)
movss 0x54(%rsp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, 0x54(%rsp)
movq 0x803a4(%rip), %rax # 0x11acb0
movq %rax, 0x3c(%rsp)
movq 0x803a0(%rip), %rax # 0x11acb8
movq %rax, 0x44(%rsp)
callq 0x92850
movl %eax, 0x38(%rsp)
leaq 0x54(%rsp), %rdi
callq 0x92830
andl 0x38(%rsp), %eax
cmpl 0x38(%rsp), %eax
jne 0x9a989
movq 0x58(%rsp), %rax
movq %rax, 0x30(%rsp)
movss 0x54(%rsp), %xmm0
callq 0x9aba0
movq 0x3c(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movq 0x44(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rcx
movzbl %al, %esi
andl $0x1, %esi
leaq 0x4c(%rsp), %r8
callq 0x9aa00
movq %rax, 0x60(%rsp)
jmp 0x9a9e3
movss 0x54(%rsp), %xmm0
callq 0x91fd0
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x4c(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rsp, %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq $0x0, (%rax)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rcx
movq (%rsp), %r8
leaq 0x18(%rsp), %rsi
leaq 0x3c(%rsp), %rdx
callq 0x9abc0
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x78, %rsp
retq
nopl (%rax)
| _ZN3fmt3v106detail5writeIcNS0_8appenderEfTnNSt9enable_ifIXsr13is_fast_floatIT1_EE5valueEiE4typeELi0EEET0_S8_S5_:
sub rsp, 78h
mov [rsp+78h+var_20], rdi
movss [rsp+78h+var_24], xmm0
movss xmm0, [rsp+78h+var_24]
call _ZN3fmt3v106detail27is_supported_floating_pointIfEEbT_; fmt::v10::detail::is_supported_floating_point<float>(float)
xor al, 0FFh
and al, 1
mov [rsp+78h+var_5], al
test [rsp+78h+var_5], 1
jz short loc_9A8A8
mov rax, [rsp+78h+var_20]
mov [rsp+78h+var_18], rax
jmp loc_9A9E3
loc_9A8A8:
lea rdi, [rsp+78h+var_2C]
xor esi, esi
mov edx, 8
call _memset
movss xmm0, [rsp+78h+var_24]
movss [rsp+78h+var_4], xmm0
movss xmm0, [rsp+78h+var_4]
cvtss2sd xmm0, xmm0; double
call _ZSt7signbitd; std::signbit(double)
test al, 1
jnz short loc_9A8DA
jmp short loc_9A905
loc_9A8DA:
mov eax, dword ptr [rsp+78h+var_2C+4]
and eax, 0FFFF00FFh
or eax, 100h
mov dword ptr [rsp+78h+var_2C+4], eax
movss xmm0, [rsp+78h+var_24]
movd eax, xmm0
xor eax, 80000000h
movd xmm0, eax
movss [rsp+78h+var_24], xmm0
loc_9A905:
mov rax, cs:qword_11ACB0
mov [rsp+78h+var_3C], rax
mov rax, cs:qword_11ACB8
mov [rsp+78h+var_34], rax
call _ZN3fmt3v106detail13exponent_maskIfEENS1_9dragonbox10float_infoIT_vE12carrier_uintEv; fmt::v10::detail::exponent_mask<float>(void)
mov [rsp+78h+var_40], eax
lea rdi, [rsp+78h+var_24]
call _ZN3fmt3v106detail8bit_castIjfTnNSt9enable_ifIXeqstT_stT0_EiE4typeELi0EEES4_RKS5_
and eax, [rsp+78h+var_40]
cmp eax, [rsp+78h+var_40]
jnz short loc_9A989
mov rax, [rsp+78h+var_20]
mov [rsp+78h+var_48], rax
movss xmm0, [rsp+78h+var_24]; float
call _ZSt5isnanf; std::isnan(float)
mov rcx, [rsp+78h+var_3C]
mov [rsp+78h+var_58], rcx
mov rcx, [rsp+78h+var_34]
mov [rsp+78h+var_50], rcx
mov rdi, [rsp+78h+var_48]
mov rdx, [rsp+78h+var_58]
mov rcx, [rsp+78h+var_50]
movzx esi, al
and esi, 1
lea r8, [rsp+78h+var_2C]
call _ZN3fmt3v106detail15write_nonfiniteIcNS0_8appenderEEET0_S4_bNS0_12format_specsIT_EERKNS1_11float_specsE; fmt::v10::detail::write_nonfinite<char,fmt::v10::appender>(fmt::v10::appender,bool,fmt::v10::format_specs<char>,fmt::v10::detail::float_specs const&)
mov [rsp+78h+var_18], rax
jmp short loc_9A9E3
loc_9A989:
movss xmm0, [rsp+78h+var_24]
call _ZN3fmt3v106detail9dragonbox10to_decimalIfEENS2_10decimal_fpIT_EES5_; fmt::v10::detail::dragonbox::to_decimal<float>(float)
mov [rsp+78h+var_60], rax
mov rax, [rsp+78h+var_20]
mov [rsp+78h+var_68], rax
mov rax, [rsp+78h+var_2C]
mov [rsp+78h+var_70], rax
mov rax, rsp
mov [rsp+78h+var_10], rax
mov rax, [rsp+78h+var_10]
mov qword ptr [rax], 0
mov rdi, [rsp+78h+var_68]
mov rcx, [rsp+78h+var_70]
mov r8, [rsp+78h+var_78]
lea rsi, [rsp+78h+var_60]
lea rdx, [rsp+78h+var_3C]
call _ZN3fmt3v106detail11write_floatINS0_8appenderENS1_9dragonbox10decimal_fpIfEEcEET_S7_RKT0_RKNS0_12format_specsIT1_EENS1_11float_specsENS1_10locale_refE; fmt::v10::detail::write_float<fmt::v10::appender,fmt::v10::detail::dragonbox::decimal_fp<float>,char>(fmt::v10::appender,fmt::v10::detail::dragonbox::decimal_fp<float> const&,fmt::v10::format_specs<char> const&,fmt::v10::detail::float_specs,fmt::v10::detail::locale_ref)
mov [rsp+78h+var_18], rax
loc_9A9E3:
mov rax, [rsp+78h+var_18]
add rsp, 78h
retn
| long long ZN3fmt3v106detail5writeIcNS0_8appenderEfTnNSt9enable_ifIXsr13is_fast_floatIT1_EE5valueEiE4typeELi0EEET0_S8_S5_(
long long a1,
float a2)
{
char is_supported_floating; // al
char v3; // al
long long v4; // r9
long long v6; // [rsp+0h] [rbp-78h] BYREF
_QWORD v7[3]; // [rsp+18h] [rbp-60h] BYREF
long long v8; // [rsp+30h] [rbp-48h]
int v9; // [rsp+38h] [rbp-40h]
unsigned long long v10; // [rsp+3Ch] [rbp-3Ch] BYREF
long long v11; // [rsp+44h] [rbp-34h]
long long v12; // [rsp+4Ch] [rbp-2Ch] BYREF
float v13; // [rsp+54h] [rbp-24h] BYREF
long long v14; // [rsp+58h] [rbp-20h]
long long *v16; // [rsp+68h] [rbp-10h]
bool v17; // [rsp+73h] [rbp-5h]
unsigned int v18; // [rsp+74h] [rbp-4h]
v14 = a1;
v13 = a2;
is_supported_floating = fmt::v10::detail::is_supported_floating_point<float>(a2);
v17 = (is_supported_floating & 1) == 0;
if ( (is_supported_floating & 1) == 0 )
return v14;
memset(&v12, 0LL, sizeof(v12));
v18 = LODWORD(v13);
if ( (std::signbit(v13) & 1) != 0 )
{
HIDWORD(v12) = HIDWORD(v12) & 0xFFFF00FF | 0x100;
LODWORD(v13) = _mm_cvtsi128_si32((__m128i)LODWORD(v13)) ^ 0x80000000;
}
v10 = 0xFFFFFFFF00000000LL;
v11 = 0x100000020000000LL;
v9 = fmt::v10::detail::exponent_mask<float>((long long)&v12);
if ( (v9 & (unsigned int)ZN3fmt3v106detail8bit_castIjfTnNSt9enable_ifIXeqstT_stT0_EiE4typeELi0EEES4_RKS5_((unsigned int *)&v13)) == v9 )
{
v8 = v14;
v3 = std::isnan(v13);
v7[1] = v10;
v7[2] = v11;
return fmt::v10::detail::write_nonfinite<char,fmt::v10::appender>(v8, v3 & 1, v10, v11, &v12);
}
else
{
v7[0] = fmt::v10::detail::dragonbox::to_decimal<float>(v13, (long long)&v13, 0);
v16 = &v6;
return ((long long ( *)(long long, _QWORD *, unsigned long long *, long long, _QWORD, long long, _QWORD, long long, long long))fmt::v10::detail::write_float<fmt::v10::appender,fmt::v10::detail::dragonbox::decimal_fp<float>,char>)(
v14,
v7,
&v10,
v12,
0LL,
v4,
0LL,
v12,
v14);
}
}
| _ZN3fmt3v106detail5writeIcNS0_8appenderEfTnNSt9enable_ifIXsr13is_fast_floatIT1_EE5valueEiE4typeELi0EEET0_S8_S5_:
SUB RSP,0x78
MOV qword ptr [RSP + 0x58],RDI
MOVSS dword ptr [RSP + 0x54],XMM0
MOVSS XMM0,dword ptr [RSP + 0x54]
CALL 0x0019a9f0
XOR AL,0xff
AND AL,0x1
MOV byte ptr [RSP + 0x73],AL
TEST byte ptr [RSP + 0x73],0x1
JZ 0x0019a8a8
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x60],RAX
JMP 0x0019a9e3
LAB_0019a8a8:
LEA RDI,[RSP + 0x4c]
XOR ESI,ESI
MOV EDX,0x8
CALL 0x001163a0
MOVSS XMM0,dword ptr [RSP + 0x54]
MOVSS dword ptr [RSP + 0x74],XMM0
MOVSS XMM0,dword ptr [RSP + 0x74]
CVTSS2SD XMM0,XMM0
CALL 0x0019ac30
TEST AL,0x1
JNZ 0x0019a8da
JMP 0x0019a905
LAB_0019a8da:
MOV EAX,dword ptr [RSP + 0x50]
AND EAX,0xffff00ff
OR EAX,0x100
MOV dword ptr [RSP + 0x50],EAX
MOVSS XMM0,dword ptr [RSP + 0x54]
MOVD EAX,XMM0
XOR EAX,0x80000000
MOVD XMM0,EAX
MOVSS dword ptr [RSP + 0x54],XMM0
LAB_0019a905:
MOV RAX,qword ptr [0x0021acb0]
MOV qword ptr [RSP + 0x3c],RAX
MOV RAX,qword ptr [0x0021acb8]
MOV qword ptr [RSP + 0x44],RAX
CALL 0x00192850
MOV dword ptr [RSP + 0x38],EAX
LEA RDI,[RSP + 0x54]
CALL 0x00192830
AND EAX,dword ptr [RSP + 0x38]
CMP EAX,dword ptr [RSP + 0x38]
JNZ 0x0019a989
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x30],RAX
MOVSS XMM0,dword ptr [RSP + 0x54]
CALL 0x0019aba0
MOV RCX,qword ptr [RSP + 0x3c]
MOV qword ptr [RSP + 0x20],RCX
MOV RCX,qword ptr [RSP + 0x44]
MOV qword ptr [RSP + 0x28],RCX
MOV RDI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x28]
MOVZX ESI,AL
AND ESI,0x1
LEA R8,[RSP + 0x4c]
CALL 0x0019aa00
MOV qword ptr [RSP + 0x60],RAX
JMP 0x0019a9e3
LAB_0019a989:
MOVSS XMM0,dword ptr [RSP + 0x54]
CALL 0x00191fd0
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x4c]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,RSP
MOV qword ptr [RSP + 0x68],RAX
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RAX],0x0
MOV RDI,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x8]
MOV R8,qword ptr [RSP]
LEA RSI,[RSP + 0x18]
LEA RDX,[RSP + 0x3c]
CALL 0x0019abc0
MOV qword ptr [RSP + 0x60],RAX
LAB_0019a9e3:
MOV RAX,qword ptr [RSP + 0x60]
ADD RSP,0x78
RET
|
detail * _ZN3fmt3v106detail5writeIcNS0_8appenderEfTnNSt9enable_ifIXsr13is_fast_floatIT1_EE5valueEiE4typeELi0EEET0_S8_S5_
(float param_1,detail *param_2)
{
bool bVar1;
byte bVar2;
uint uVar3;
ulong uVar4;
int1 local_78 [8];
int8 local_70;
detail *local_68;
int8 local_60;
int8 local_58;
int8 local_50;
detail *local_48;
uint local_40;
int8 local_3c;
int8 local_34;
int4 local_2c;
uint uStack_28;
float local_24;
detail *local_20;
detail *local_18;
int1 *local_10;
byte local_5;
float local_4;
local_24 = param_1;
local_20 = param_2;
bVar1 = fmt::v10::detail::is_supported_floating_point<float>(param_1);
local_5 = (bVar1 ^ 0xffU) & 1;
if (local_5 == 0) {
memset(&local_2c,0,8);
local_4 = local_24;
uVar4 = std::signbit((double)local_24);
if ((uVar4 & 1) != 0) {
uStack_28 = uStack_28 & 0xffff00ff | 0x100;
local_24 = -local_24;
}
local_3c = DAT_0021acb0;
local_34 = DAT_0021acb8;
local_40 = fmt::v10::detail::exponent_mask<float>();
uVar3 = _ZN3fmt3v106detail8bit_castIjfTnNSt9enable_ifIXeqstT_stT0_EiE4typeELi0EEES4_RKS5_
(&local_24);
if ((uVar3 & local_40) == local_40) {
local_48 = local_20;
bVar2 = std::isnan(local_24);
local_58 = local_3c;
local_50 = local_34;
local_18 = (detail *)
fmt::v10::detail::write_nonfinite<char,fmt::v10::appender>
(local_48,bVar2 & 1,local_3c,local_34,&local_2c);
}
else {
local_60 = fmt::v10::detail::dragonbox::to_decimal<float>(local_24);
local_68 = local_20;
local_70 = CONCAT44(uStack_28,local_2c);
local_10 = local_78;
local_18 = (detail *)
fmt::v10::detail::
write_float<fmt::v10::appender,fmt::v10::detail::dragonbox::decimal_fp<float>,char>
(local_20,&local_60,&local_3c,local_70,0);
}
}
else {
local_18 = local_20;
}
return local_18;
}
| |
44,876 | finish_resize_simple_key_cache | eloqsql/mysys/mf_keycache.c | static
void finish_resize_simple_key_cache(SIMPLE_KEY_CACHE_CB *keycache)
{
DBUG_ENTER("finish_resize_simple_key_cache");
mysql_mutex_assert_owner(&keycache->cache_lock);
/*
Mark the resize finished. This allows other threads to start a
resize or to request new cache blocks.
*/
keycache->in_resize= 0;
/* Signal waiting threads. */
release_whole_queue(&keycache->resize_queue);
keycache_pthread_mutex_unlock(&keycache->cache_lock);
DBUG_VOID_RETURN;
} | O3 | c | finish_resize_simple_key_cache:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x0, 0x1(%rdi)
addq $0x108, %rdi # imm = 0x108
callq 0x98585
movq 0x100(%rbx), %rdi
testq %rdi, %rdi
jne 0x99a68
addq $0xc0, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x291e0
leaq 0x2ec5a1(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x99a53
| finish_resize_simple_key_cache:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
mov byte ptr [rdi+1], 0
add rdi, 108h
call release_whole_queue
mov rdi, [rbx+100h]
test rdi, rdi
jnz short loc_99A68
loc_99A53:
add rbx, 0C0h
mov rdi, rbx
add rsp, 8
pop rbx
pop rbp
jmp _pthread_mutex_unlock
loc_99A68:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_99A53
| long long finish_resize_simple_key_cache(long long a1)
{
long long v2; // rdi
*(_BYTE *)(a1 + 1) = 0;
release_whole_queue((long long *)(a1 + 264));
v2 = *(_QWORD *)(a1 + 256);
if ( v2 )
((void ( *)(long long))PSI_server[44])(v2);
return pthread_mutex_unlock(a1 + 192);
}
| finish_resize_simple_key_cache:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV byte ptr [RDI + 0x1],0x0
ADD RDI,0x108
CALL 0x00198585
MOV RDI,qword ptr [RBX + 0x100]
TEST RDI,RDI
JNZ 0x00199a68
LAB_00199a53:
ADD RBX,0xc0
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x001291e0
LAB_00199a68:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00199a53
|
void finish_resize_simple_key_cache(long param_1)
{
*(int1 *)(param_1 + 1) = 0;
release_whole_queue(param_1 + 0x108);
if (*(long *)(param_1 + 0x100) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0xc0));
return;
}
| |
44,877 | minja::FilterTemplateToken::FilterTemplateToken(minja::Location const&, minja::SpaceHandling, minja::SpaceHandling, std::shared_ptr<minja::Expression>&&) | monkey531[P]llama/common/minja.hpp | TemplateToken(Type type, const Location & location, SpaceHandling pre, SpaceHandling post) : type(type), location(location), pre_space(pre), post_space(post) {} | O1 | cpp | minja::FilterTemplateToken::FilterTemplateToken(minja::Location const&, minja::SpaceHandling, minja::SpaceHandling, std::shared_ptr<minja::Expression>&&):
leaq 0x840ef(%rip), %rax # 0xe41c8
addq $0x10, %rax
movq %rax, (%rdi)
movl $0xf, 0x8(%rdi)
movq (%rsi), %rax
movq %rax, 0x10(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x18(%rdi)
testq %rax, %rax
je 0x60111
movq 0x85e96(%rip), %r9 # 0xe5f98
cmpb $0x0, (%r9)
je 0x6010d
incl 0x8(%rax)
jmp 0x60111
lock
incl 0x8(%rax)
movq 0x10(%rsi), %rax
movq %rax, 0x20(%rdi)
movl %edx, 0x28(%rdi)
movl %ecx, 0x2c(%rdi)
leaq 0x84d42(%rip), %rax # 0xe4e68
addq $0x10, %rax
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x38(%rdi)
movups (%r8), %xmm0
movq %rax, 0x8(%r8)
movups %xmm0, 0x30(%rdi)
movq %rax, (%r8)
retq
nop
| _ZN5minja19FilterTemplateTokenC2ERKNS_8LocationENS_13SpaceHandlingES4_OSt10shared_ptrINS_10ExpressionEE:
lea rax, _ZTVN5minja13TemplateTokenE; `vtable for'minja::TemplateToken
add rax, 10h
mov [rdi], rax
mov dword ptr [rdi+8], 0Fh
mov rax, [rsi]
mov [rdi+10h], rax
mov rax, [rsi+8]
mov [rdi+18h], rax
test rax, rax
jz short loc_60111
mov r9, cs:__libc_single_threaded_ptr
cmp byte ptr [r9], 0
jz short loc_6010D
inc dword ptr [rax+8]
jmp short loc_60111
loc_6010D:
lock inc dword ptr [rax+8]
loc_60111:
mov rax, [rsi+10h]
mov [rdi+20h], rax
mov [rdi+28h], edx
mov [rdi+2Ch], ecx
lea rax, _ZTVN5minja19FilterTemplateTokenE; `vtable for'minja::FilterTemplateToken
add rax, 10h
mov [rdi], rax
xor eax, eax
mov [rdi+38h], rax
movups xmm0, xmmword ptr [r8]
mov [r8+8], rax
movups xmmword ptr [rdi+30h], xmm0
mov [r8], rax
retn
| long long minja::FilterTemplateToken::FilterTemplateToken(
long long a1,
_QWORD *a2,
int a3,
int a4,
__int128 *a5)
{
long long v5; // rax
long long result; // rax
__int128 v7; // xmm0
*(_QWORD *)a1 = &`vtable for'minja::TemplateToken + 2;
*(_DWORD *)(a1 + 8) = 15;
*(_QWORD *)(a1 + 16) = *a2;
v5 = a2[1];
*(_QWORD *)(a1 + 24) = v5;
if ( v5 )
{
if ( _libc_single_threaded )
++*(_DWORD *)(v5 + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(v5 + 8));
}
*(_QWORD *)(a1 + 32) = a2[2];
*(_DWORD *)(a1 + 40) = a3;
*(_DWORD *)(a1 + 44) = a4;
*(_QWORD *)a1 = &`vtable for'minja::FilterTemplateToken + 2;
result = 0LL;
*(_QWORD *)(a1 + 56) = 0LL;
v7 = *a5;
*((_QWORD *)a5 + 1) = 0LL;
*(_OWORD *)(a1 + 48) = v7;
*(_QWORD *)a5 = 0LL;
return result;
}
| FilterTemplateToken:
LEA RAX,[0x1e41c8]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV dword ptr [RDI + 0x8],0xf
MOV RAX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],RAX
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x18],RAX
TEST RAX,RAX
JZ 0x00160111
MOV R9,qword ptr [0x001e5f98]
CMP byte ptr [R9],0x0
JZ 0x0016010d
INC dword ptr [RAX + 0x8]
JMP 0x00160111
LAB_0016010d:
INC.LOCK dword ptr [RAX + 0x8]
LAB_00160111:
MOV RAX,qword ptr [RSI + 0x10]
MOV qword ptr [RDI + 0x20],RAX
MOV dword ptr [RDI + 0x28],EDX
MOV dword ptr [RDI + 0x2c],ECX
LEA RAX,[0x1e4e68]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x38],RAX
MOVUPS XMM0,xmmword ptr [R8]
MOV qword ptr [R8 + 0x8],RAX
MOVUPS xmmword ptr [RDI + 0x30],XMM0
MOV qword ptr [R8],RAX
RET
|
/* minja::FilterTemplateToken::FilterTemplateToken(minja::Location const&, minja::SpaceHandling,
minja::SpaceHandling, std::shared_ptr<minja::Expression>&&) */
void __thiscall
minja::FilterTemplateToken::FilterTemplateToken
(FilterTemplateToken *this,int8 *param_1,int4 param_3,int4 param_4,
int8 *param_5)
{
long lVar1;
int8 uVar2;
*(int ***)this = &PTR__TemplateToken_001e41d8;
*(int4 *)(this + 8) = 0xf;
*(int8 *)(this + 0x10) = *param_1;
lVar1 = param_1[1];
*(long *)(this + 0x18) = lVar1;
if (lVar1 != 0) {
if (*PTR___libc_single_threaded_001e5f98 == '\0') {
LOCK();
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
UNLOCK();
}
else {
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
}
}
*(int8 *)(this + 0x20) = param_1[2];
*(int4 *)(this + 0x28) = param_3;
*(int4 *)(this + 0x2c) = param_4;
*(int ***)this = &PTR__FilterTemplateToken_001e4e78;
*(int8 *)(this + 0x38) = 0;
uVar2 = param_5[1];
param_5[1] = 0;
*(int8 *)(this + 0x30) = *param_5;
*(int8 *)(this + 0x38) = uVar2;
*param_5 = 0;
return;
}
| |
44,878 | 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;
} | O3 | c | ma_ll2str:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, %rax
movq %fs:0x28, %rcx
movq %rcx, -0x8(%rbp)
testl %edx, %edx
js 0x356f6
leal -0x25(%rdx), %ecx
cmpl $-0x23, %ecx
jb 0x356fe
jmp 0x35715
leal 0x1(%rdx), %ecx
cmpl $-0x23, %ecx
jae 0x35705
xorl %esi, %esi
jmp 0x35787
testq %rax, %rax
jns 0x35713
movb $0x2d, (%rsi)
incq %rsi
negq %rax
negl %edx
testq %rax, %rax
je 0x3577f
leaq -0x10(%rbp), %rcx
movb $0x0, (%rcx)
movl %edx, %edi
jns 0x35740
leaq 0x6794(%rip), %r8 # 0x3bec0
xorl %edx, %edx
divq %rdi
movb (%rdx,%r8), %dl
movb %dl, -0x1(%rcx)
decq %rcx
testq %rax, %rax
js 0x3572c
incq %rcx
leaq 0x6776(%rip), %r8 # 0x3bec0
cqto
idivq %rdi
movzbl %dl, %edx
movb (%rdx,%r8), %r9b
movb %r9b, -0x2(%rcx)
decq %rcx
testq %rax, %rax
jne 0x3574a
movb %r9b, (%rsi)
cmpl $0x24, %edx
je 0x35787
xorl %eax, %eax
movb (%rcx,%rax), %dl
movb %dl, 0x1(%rsi,%rax)
incq %rax
testb %dl, %dl
jne 0x3576c
addq %rax, %rsi
jmp 0x35787
movw $0x30, (%rsi)
incq %rsi
movq %fs:0x28, %rax
cmpq -0x8(%rbp), %rax
jne 0x3579f
movq %rsi, %rax
addq $0x50, %rsp
popq %rbp
retq
callq 0x13500
| ma_ll2str:
push rbp
mov rbp, rsp
sub rsp, 50h
mov rax, rdi
mov rcx, fs:28h
mov [rbp+var_8], rcx
test edx, edx
js short loc_356F6
lea ecx, [rdx-25h]
cmp ecx, 0FFFFFFDDh
jb short loc_356FE
jmp short loc_35715
loc_356F6:
lea ecx, [rdx+1]
cmp ecx, 0FFFFFFDDh
jnb short loc_35705
loc_356FE:
xor esi, esi
jmp loc_35787
loc_35705:
test rax, rax
jns short loc_35713
mov byte ptr [rsi], 2Dh ; '-'
inc rsi
neg rax
loc_35713:
neg edx
loc_35715:
test rax, rax
jz short loc_3577F
lea rcx, [rbp+var_10]
mov byte ptr [rcx], 0
mov edi, edx
jns short loc_35740
lea r8, _dig_vec; "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
loc_3572C:
xor edx, edx
div rdi
mov dl, [rdx+r8]
mov [rcx-1], dl
dec rcx
test rax, rax
js short loc_3572C
loc_35740:
inc rcx
lea r8, _dig_vec; "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
loc_3574A:
cqo
idiv rdi
movzx edx, dl
mov r9b, [rdx+r8]
mov [rcx-2], r9b
dec rcx
test rax, rax
jnz short loc_3574A
mov [rsi], r9b
cmp edx, 24h ; '$'
jz short loc_35787
xor eax, eax
loc_3576C:
mov dl, [rcx+rax]
mov [rsi+rax+1], dl
inc rax
test dl, dl
jnz short loc_3576C
add rsi, rax
jmp short loc_35787
loc_3577F:
mov word ptr [rsi], 30h ; '0'
inc rsi
loc_35787:
mov rax, fs:28h
cmp rax, [rbp+var_8]
jnz short loc_3579F
mov rax, rsi
add rsp, 50h
pop rbp
retn
loc_3579F:
call ___stack_chk_fail
| char * ma_ll2str(long long a1, char *a2, unsigned int a3)
{
long long v3; // rax
char *v4; // rcx
long long i; // rdi
unsigned long long v6; // rtt
_BYTE *v7; // rcx
long long v8; // rt2
int v9; // edx
char v10; // r9
long long v11; // rax
char v12; // dl
char v14; // [rsp+40h] [rbp-10h] BYREF
unsigned long long v15; // [rsp+48h] [rbp-8h]
v3 = a1;
v15 = __readfsqword(0x28u);
if ( (a3 & 0x80000000) != 0 )
{
if ( a3 + 1 >= 0xFFFFFFDD )
{
if ( a1 < 0 )
{
*a2++ = 45;
v3 = -a1;
}
a3 = -a3;
goto LABEL_9;
}
return 0LL;
}
if ( a3 - 37 < 0xFFFFFFDD )
return 0LL;
LABEL_9:
if ( v3 )
{
v4 = &v14;
v14 = 0;
for ( i = a3; v3 < 0; --v4 )
{
v6 = v3;
v3 /= (unsigned long long)a3;
*(v4 - 1) = dig_vec[v6 % a3];
}
v7 = v4 + 1;
do
{
v8 = v3 % i;
v3 /= i;
v9 = (unsigned __int8)v8;
v10 = dig_vec[(unsigned __int8)v8];
*(v7 - 2) = v10;
--v7;
}
while ( v3 );
*a2 = v10;
if ( v9 != 36 )
{
v11 = 0LL;
do
{
v12 = v7[v11];
a2[++v11] = v12;
}
while ( v12 );
a2 += v11;
}
}
else
{
*(_WORD *)a2++ = 48;
}
return a2;
}
| ma_ll2str:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV RAX,RDI
MOV RCX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RCX
TEST EDX,EDX
JS 0x001356f6
LEA ECX,[RDX + -0x25]
CMP ECX,-0x23
JC 0x001356fe
JMP 0x00135715
LAB_001356f6:
LEA ECX,[RDX + 0x1]
CMP ECX,-0x23
JNC 0x00135705
LAB_001356fe:
XOR ESI,ESI
JMP 0x00135787
LAB_00135705:
TEST RAX,RAX
JNS 0x00135713
MOV byte ptr [RSI],0x2d
INC RSI
NEG RAX
LAB_00135713:
NEG EDX
LAB_00135715:
TEST RAX,RAX
JZ 0x0013577f
LEA RCX,[RBP + -0x10]
MOV byte ptr [RCX],0x0
MOV EDI,EDX
JNS 0x00135740
LEA R8,[0x13bec0]
LAB_0013572c:
XOR EDX,EDX
DIV RDI
MOV DL,byte ptr [RDX + R8*0x1]
MOV byte ptr [RCX + -0x1],DL
DEC RCX
TEST RAX,RAX
JS 0x0013572c
LAB_00135740:
INC RCX
LEA R8,[0x13bec0]
LAB_0013574a:
CQO
IDIV RDI
MOVZX EDX,DL
MOV R9B,byte ptr [RDX + R8*0x1]
MOV byte ptr [RCX + -0x2],R9B
DEC RCX
TEST RAX,RAX
JNZ 0x0013574a
MOV byte ptr [RSI],R9B
CMP EDX,0x24
JZ 0x00135787
XOR EAX,EAX
LAB_0013576c:
MOV DL,byte ptr [RCX + RAX*0x1]
MOV byte ptr [RSI + RAX*0x1 + 0x1],DL
INC RAX
TEST DL,DL
JNZ 0x0013576c
ADD RSI,RAX
JMP 0x00135787
LAB_0013577f:
MOV word ptr [RSI],0x30
INC RSI
LAB_00135787:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x8]
JNZ 0x0013579f
MOV RAX,RSI
ADD RSP,0x50
POP RBP
RET
LAB_0013579f:
CALL 0x00113500
|
char * ma_ll2str(ulong param_1,char *param_2,uint param_3)
{
char cVar1;
ulong uVar2;
long lVar3;
char *pcVar4;
ulong uVar5;
ulong uVar6;
long in_FS_OFFSET;
char local_19 [9];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if ((int)param_3 < 0) {
if (param_3 + 1 < 0xffffffdd) goto LAB_001356fe;
if ((long)param_1 < 0) {
*param_2 = '-';
param_2 = param_2 + 1;
param_1 = -param_1;
}
param_3 = -param_3;
}
else if (param_3 - 0x25 < 0xffffffdd) {
LAB_001356fe:
param_2 = (char *)0x0;
goto LAB_00135787;
}
if (param_1 == 0) {
param_2[0] = '0';
param_2[1] = '\0';
param_2 = param_2 + 1;
}
else {
pcVar4 = local_19 + 1;
local_19[1] = 0;
uVar6 = (ulong)param_3;
for (; (long)param_1 < 0; param_1 = param_1 / uVar6) {
pcVar4[-1] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[param_1 % uVar6];
pcVar4 = pcVar4 + -1;
}
pcVar4 = pcVar4 + 1;
do {
uVar2 = (long)param_1 / (long)uVar6;
uVar5 = (long)param_1 % (long)uVar6 & 0xff;
cVar1 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[uVar5];
pcVar4[-2] = cVar1;
pcVar4 = pcVar4 + -1;
param_1 = uVar2;
} while (uVar2 != 0);
*param_2 = cVar1;
if ((int)uVar5 != 0x24) {
lVar3 = 0;
do {
cVar1 = pcVar4[lVar3];
param_2[lVar3 + 1] = cVar1;
lVar3 = lVar3 + 1;
} while (cVar1 != '\0');
param_2 = param_2 + lVar3;
}
}
LAB_00135787:
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return param_2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
44,879 | ma_crypt_read | eloqsql/storage/maria/ma_crypt.c | uchar*
ma_crypt_read(MARIA_SHARE* share, uchar *buff)
{
uchar type= buff[0];
uchar iv_length= buff[1];
/* currently only supported type */
if (type != CRYPT_SCHEME_1 ||
iv_length != sizeof(((MARIA_CRYPT_DATA*)1)->scheme.iv) + 4)
{
my_printf_error(HA_ERR_UNSUPPORTED,
"Unsupported crypt scheme! type: %d iv_length: %d\n",
MYF(ME_FATAL|ME_ERROR_LOG),
type, iv_length);
return 0;
}
if (share->crypt_data == NULL)
{
/* opening a table */
MARIA_CRYPT_DATA *crypt_data=
(MARIA_CRYPT_DATA*)my_malloc(PSI_INSTRUMENT_ME, sizeof(MARIA_CRYPT_DATA), MYF(MY_ZEROFILL));
crypt_data->scheme.type= type;
mysql_mutex_init(key_CRYPT_DATA_lock, &crypt_data->lock,
MY_MUTEX_INIT_FAST);
crypt_data->scheme.locker= crypt_data_scheme_locker;
crypt_data->scheme.key_id= get_encryption_key_id(share);
crypt_data->space= uint4korr(buff + 2);
memcpy(crypt_data->scheme.iv, buff + 6, sizeof(crypt_data->scheme.iv));
share->crypt_data= crypt_data;
}
share->crypt_page_header_space= CRYPT_SCHEME_1_KEY_VERSION_SIZE;
return buff + 2 + iv_length;
} | O0 | c | ma_crypt_read:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x1a(%rbp)
movzbl -0x19(%rbp), %eax
cmpl $0x1, %eax
jne 0x5e1b6
movzbl -0x1a(%rbp), %eax
cmpq $0x14, %rax
je 0x5e1e4
movzbl -0x19(%rbp), %ecx
movzbl -0x1a(%rbp), %r8d
movl $0x8a, %edi
leaq 0xf34e8(%rip), %rsi # 0x1516b3
movl $0x1040, %edx # imm = 0x1040
movb $0x0, %al
callq 0xef670
movq $0x0, -0x8(%rbp)
jmp 0x5e2a9
movq -0x10(%rbp), %rax
cmpq $0x0, 0xc20(%rax)
jne 0x5e285
xorl %edi, %edi
movl $0xb0, %esi
movl $0x20, %edx
callq 0xf3210
movq %rax, -0x28(%rbp)
movzbl -0x19(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x54(%rax)
movl 0xc1b1f0(%rip), %edi # 0xc7940c
movq -0x28(%rbp), %rsi
addq $0x68, %rsi
leaq 0xc24405(%rip), %rdx # 0xc82630
callq 0x5ddc0
movq -0x28(%rbp), %rax
leaq -0x4cb(%rip), %rcx # 0x5dd70
movq %rcx, 0x58(%rax)
movq -0x10(%rbp), %rdi
callq 0x5de30
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x50(%rax)
movq -0x18(%rbp), %rax
movl 0x2(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x60(%rax)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x6(%rcx), %rdx
movq %rdx, (%rax)
movq 0xe(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xc20(%rax)
movq -0x10(%rbp), %rax
movl $0x4, 0xc18(%rax)
movq -0x18(%rbp), %rax
addq $0x2, %rax
movzbl -0x1a(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ma_crypt_read:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_18]
mov al, [rax]
mov [rbp+var_19], al
mov rax, [rbp+var_18]
mov al, [rax+1]
mov [rbp+var_1A], al
movzx eax, [rbp+var_19]
cmp eax, 1
jnz short loc_5E1B6
movzx eax, [rbp+var_1A]
cmp rax, 14h
jz short loc_5E1E4
loc_5E1B6:
movzx ecx, [rbp+var_19]
movzx r8d, [rbp+var_1A]
mov edi, 8Ah
lea rsi, aUnsupportedCry; "Unsupported crypt scheme! type: %d iv_l"...
mov edx, 1040h
mov al, 0
call my_printf_error
mov [rbp+var_8], 0
jmp loc_5E2A9
loc_5E1E4:
mov rax, [rbp+var_10]
cmp qword ptr [rax+0C20h], 0
jnz loc_5E285
xor edi, edi
mov esi, 0B0h
mov edx, 20h ; ' '
call my_malloc
mov [rbp+var_28], rax
movzx ecx, [rbp+var_19]
mov rax, [rbp+var_28]
mov [rax+54h], ecx
mov edi, cs:key_CRYPT_DATA_lock
mov rsi, [rbp+var_28]
add rsi, 68h ; 'h'
lea rdx, my_fast_mutexattr
call inline_mysql_mutex_init_4
mov rax, [rbp+var_28]
lea rcx, crypt_data_scheme_locker
mov [rax+58h], rcx
mov rdi, [rbp+var_10]
call get_encryption_key_id
mov ecx, eax
mov rax, [rbp+var_28]
mov [rax+50h], ecx
mov rax, [rbp+var_18]
mov ecx, [rax+2]
mov rax, [rbp+var_28]
mov [rax+60h], ecx
mov rax, [rbp+var_28]
mov rcx, [rbp+var_18]
mov rdx, [rcx+6]
mov [rax], rdx
mov rcx, [rcx+0Eh]
mov [rax+8], rcx
mov rcx, [rbp+var_28]
mov rax, [rbp+var_10]
mov [rax+0C20h], rcx
loc_5E285:
mov rax, [rbp+var_10]
mov dword ptr [rax+0C18h], 4
mov rax, [rbp+var_18]
add rax, 2
movzx ecx, [rbp+var_1A]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_8], rax
loc_5E2A9:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
| long long ma_crypt_read(long long a1, char *a2, long long a3, long long a4, long long a5, int a6)
{
long long v7; // [rsp+8h] [rbp-28h]
unsigned __int8 v8; // [rsp+16h] [rbp-1Ah]
unsigned __int8 v9; // [rsp+17h] [rbp-19h]
v9 = *a2;
v8 = a2[1];
if ( *a2 == 1 && v8 == 20LL )
{
if ( !*(_QWORD *)(a1 + 3104) )
{
v7 = my_malloc(0LL, 176LL, 32LL);
*(_DWORD *)(v7 + 84) = v9;
inline_mysql_mutex_init_4(key_CRYPT_DATA_lock, (_QWORD *)(v7 + 104), (long long)&my_fast_mutexattr);
*(_QWORD *)(v7 + 88) = crypt_data_scheme_locker;
*(_DWORD *)(v7 + 80) = get_encryption_key_id(a1);
*(_DWORD *)(v7 + 96) = *(_DWORD *)(a2 + 2);
*(_QWORD *)v7 = *(_QWORD *)(a2 + 6);
*(_QWORD *)(v7 + 8) = *(_QWORD *)(a2 + 14);
*(_QWORD *)(a1 + 3104) = v7;
}
*(_DWORD *)(a1 + 3096) = 4;
return (long long)&a2[v8 + 2];
}
else
{
my_printf_error(138, (unsigned int)"Unsupported crypt scheme! type: %d iv_length: %d\n", 4160, v9, v8, a6);
return 0LL;
}
}
| ma_crypt_read:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x18]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x19],AL
MOV RAX,qword ptr [RBP + -0x18]
MOV AL,byte ptr [RAX + 0x1]
MOV byte ptr [RBP + -0x1a],AL
MOVZX EAX,byte ptr [RBP + -0x19]
CMP EAX,0x1
JNZ 0x0015e1b6
MOVZX EAX,byte ptr [RBP + -0x1a]
CMP RAX,0x14
JZ 0x0015e1e4
LAB_0015e1b6:
MOVZX ECX,byte ptr [RBP + -0x19]
MOVZX R8D,byte ptr [RBP + -0x1a]
MOV EDI,0x8a
LEA RSI,[0x2516b3]
MOV EDX,0x1040
MOV AL,0x0
CALL 0x001ef670
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0015e2a9
LAB_0015e1e4:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0xc20],0x0
JNZ 0x0015e285
XOR EDI,EDI
MOV ESI,0xb0
MOV EDX,0x20
CALL 0x001f3210
MOV qword ptr [RBP + -0x28],RAX
MOVZX ECX,byte ptr [RBP + -0x19]
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0x54],ECX
MOV EDI,dword ptr [0x00d7940c]
MOV RSI,qword ptr [RBP + -0x28]
ADD RSI,0x68
LEA RDX,[0xd82630]
CALL 0x0015ddc0
MOV RAX,qword ptr [RBP + -0x28]
LEA RCX,[0x15dd70]
MOV qword ptr [RAX + 0x58],RCX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0015de30
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0x50],ECX
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RAX + 0x2]
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0x60],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RCX + 0x6]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0xe]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xc20],RCX
LAB_0015e285:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xc18],0x4
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x2
MOVZX ECX,byte ptr [RBP + -0x1a]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
LAB_0015e2a9:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
char * ma_crypt_read(long param_1,char *param_2)
{
int4 uVar1;
int8 *puVar2;
char *local_10;
if ((*param_2 == '\x01') && (param_2[1] == '\x14')) {
if (*(long *)(param_1 + 0xc20) == 0) {
puVar2 = (int8 *)my_malloc(0,0xb0,0x20);
*(int4 *)((long)puVar2 + 0x54) = 1;
inline_mysql_mutex_init(key_CRYPT_DATA_lock,puVar2 + 0xd,&my_fast_mutexattr);
puVar2[0xb] = crypt_data_scheme_locker;
uVar1 = get_encryption_key_id(param_1);
*(int4 *)(puVar2 + 10) = uVar1;
*(int4 *)(puVar2 + 0xc) = *(int4 *)(param_2 + 2);
*puVar2 = *(int8 *)(param_2 + 6);
puVar2[1] = *(int8 *)(param_2 + 0xe);
*(int8 **)(param_1 + 0xc20) = puVar2;
}
*(int4 *)(param_1 + 0xc18) = 4;
local_10 = param_2 + 0x16;
}
else {
my_printf_error(0x8a,"Unsupported crypt scheme! type: %d iv_length: %d\n",0x1040,*param_2,
param_2[1]);
local_10 = (char *)0x0;
}
return local_10;
}
| |
44,880 | fmt::v10::vformat[abi:cxx11](fmt::v10::basic_string_view<char>, fmt::v10::basic_format_args<fmt::v10::basic_format_context<fmt::v10::appender, char>>) | aimrt_mujoco_sim/_deps/fmt-src/include/fmt/format-inl.h | FMT_FUNC auto vformat(string_view fmt, format_args args) -> std::string {
// Don't optimize the "{}" case to keep the binary size small and because it
// can be better optimized in fmt::format anyway.
auto buffer = memory_buffer();
detail::vformat_to(buffer, fmt, args);
return to_string(buffer);
} | O3 | c | fmt::v10::vformat[abi:cxx11](fmt::v10::basic_string_view<char>, fmt::v10::basic_format_args<fmt::v10::basic_format_context<fmt::v10::appender, char>>):
pushq %r14
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq $0x0, -0x10(%r14)
leaq 0x1fb217(%rip), %rax # 0x296c00
movq %rax, -0x20(%r14)
movq %r14, -0x18(%r14)
movq $0x1f4, -0x8(%r14) # imm = 0x1F4
movq %rsp, %rdi
xorl %r9d, %r9d
callq 0x89ac9
movq 0x8(%rsp), %rsi
leaq 0x10(%rbx), %rax
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x80c40
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x9ba34
movq 0x18(%rsp), %rsi
callq 0x82190
movq %rbx, %rax
addq $0x218, %rsp # imm = 0x218
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x9ba59
movq 0x18(%rsp), %rsi
callq 0x82190
movq %rbx, %rdi
callq 0x83b70
nop
| _ZN3fmt3v107vformatB5cxx11ENS0_17basic_string_viewIcEENS0_17basic_format_argsINS0_20basic_format_contextINS0_8appenderEcEEEE:
push r14
push rbx
sub rsp, 218h
mov rbx, rdi
lea r14, [rsp+228h+var_208]
mov qword ptr [r14-10h], 0
lea rax, off_296C00
mov [r14-20h], rax
mov [r14-18h], r14
mov qword ptr [r14-8], 1F4h
mov rdi, rsp; int
xor r9d, r9d
call _ZN3fmt3v106detail10vformat_toIcEEvRNS1_6bufferIT_EENS0_17basic_string_viewIS4_EENS1_12vformat_argsIS4_E4typeENS1_10locale_refE; fmt::v10::detail::vformat_to<char>(fmt::v10::detail::buffer<char> &,fmt::v10::basic_string_view<char>,fmt::v10::detail::vformat_args<char>::type,fmt::v10::detail::locale_ref)
mov rsi, [rsp+228h+var_220]
lea rax, [rbx+10h]
mov rdx, [rsp+228h+var_218]
add rdx, rsi
mov [rbx], rax
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rdi, [rsp+228h+var_220]; void *
cmp rdi, r14
jz short loc_9BA34
mov rsi, [rsp+228h+var_210]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_9BA34:
mov rax, rbx
add rsp, 218h
pop rbx
pop r14
retn
mov rbx, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, r14
jz short loc_9BA59
mov rsi, [rsp+arg_10]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_9BA59:
mov rdi, rbx
call __Unwind_Resume
| _QWORD * fmt::v10::vformat[abi:cxx11](_QWORD *a1, const char *a2, long long a3, long long a4, long long a5)
{
void *v5; // rsi
char *v6; // rdx
_UNKNOWN **v8; // [rsp+0h] [rbp-228h] BYREF
void *v9; // [rsp+8h] [rbp-220h]
long long v10; // [rsp+10h] [rbp-218h]
unsigned long long v11; // [rsp+18h] [rbp-210h]
_BYTE v12[520]; // [rsp+20h] [rbp-208h] BYREF
v10 = 0LL;
v8 = &off_296C00;
v9 = v12;
v11 = 500LL;
fmt::v10::detail::vformat_to<char>((long long)&v8, a2, a3, a4, a5, 0LL);
v5 = v9;
v6 = (char *)v9 + v10;
*a1 = a1 + 2;
std::string::_M_construct<char const*>(a1, v5, v6);
if ( v9 != v12 )
operator delete(v9, v11);
return a1;
}
| vformat[abi:cxx11]:
PUSH R14
PUSH RBX
SUB RSP,0x218
MOV RBX,RDI
LEA R14,[RSP + 0x20]
MOV qword ptr [R14 + -0x10],0x0
LEA RAX,[0x396c00]
MOV qword ptr [R14 + -0x20],RAX
MOV qword ptr [R14 + -0x18],R14
MOV qword ptr [R14 + -0x8],0x1f4
LAB_0019b9f9:
MOV RDI,RSP
XOR R9D,R9D
CALL 0x00189ac9
MOV RSI,qword ptr [RSP + 0x8]
LEA RAX,[RBX + 0x10]
MOV RDX,qword ptr [RSP + 0x10]
ADD RDX,RSI
MOV qword ptr [RBX],RAX
MOV RDI,RBX
CALL 0x00180c40
LAB_0019ba20:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R14
JZ 0x0019ba34
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x00182190
LAB_0019ba34:
MOV RAX,RBX
ADD RSP,0x218
POP RBX
POP R14
RET
|
/* fmt::v10::vformat[abi:cxx11](fmt::v10::basic_string_view<char>,
fmt::v10::basic_format_args<fmt::v10::basic_format_context<fmt::v10::appender, char> >) */
long * fmt::v10::vformat_abi_cxx11_(long *param_1)
{
int **local_228;
int1 *local_220;
long local_218;
ulong local_210;
int1 local_208 [504];
local_218 = 0;
local_228 = &PTR_grow_00396c00;
local_210 = 500;
local_220 = local_208;
/* try { // try from 0019b9f9 to 0019ba1f has its CatchHandler @ 0019ba42 */
detail::vformat_to<char>(&local_228);
*param_1 = (long)(param_1 + 2);
std::__cxx11::string::_M_construct<char_const*>(param_1,local_220,local_220 + local_218);
if (local_220 != local_208) {
operator_delete(local_220,local_210);
}
return param_1;
}
| |
44,881 | ma_open | eloqsql/libmariadb/libmariadb/ma_io.c | MA_FILE *ma_open(const char *location, const char *mode, MYSQL *mysql)
{
int CodePage= -1;
FILE *fp= NULL;
MA_FILE *ma_file= NULL;
if (!location || !location[0])
return NULL;
#ifdef HAVE_REMOTEIO
if (strstr(location, "://"))
goto remote;
#endif
#ifdef _WIN32
if (mysql && mysql->charset)
CodePage= madb_get_windows_cp(mysql->charset->csname);
#endif
if (CodePage == -1)
{
if (!(fp= fopen(location, mode)))
{
return NULL;
}
}
#ifdef _WIN32
/* See CONC-44: we need to support non ascii filenames too, so we convert
current character set to wchar_t and try to open the file via _wsopen */
else
{
wchar_t *w_filename= NULL;
wchar_t *w_mode= NULL;
int len;
DWORD Length;
len= MultiByteToWideChar(CodePage, 0, location, (int)strlen(location), NULL, 0);
if (!len)
return NULL;
if (!(w_filename= (wchar_t *)calloc(1, (len + 1) * sizeof(wchar_t))))
{
my_set_error(mysql, CR_OUT_OF_MEMORY, SQLSTATE_UNKNOWN, 0);
return NULL;
}
Length= len;
len= MultiByteToWideChar(CodePage, 0, location, (int)strlen(location), w_filename, (int)Length);
if (!len)
{
/* todo: error handling */
free(w_filename);
return NULL;
}
len= (int)strlen(mode);
if (!(w_mode= (wchar_t *)calloc(1, (len + 1) * sizeof(wchar_t))))
{
my_set_error(mysql, CR_OUT_OF_MEMORY, SQLSTATE_UNKNOWN, 0);
free(w_filename);
return NULL;
}
Length= len;
len= MultiByteToWideChar(CodePage, 0, mode, (int)strlen(mode), w_mode, (int)Length);
if (!len)
{
/* todo: error handling */
free(w_filename);
free(w_mode);
return NULL;
}
fp= _wfopen(w_filename, w_mode);
free(w_filename);
free(w_mode);
}
#endif
if (fp)
{
ma_file= (MA_FILE *)malloc(sizeof(MA_FILE));
if (!ma_file)
{
fclose(fp);
my_set_error(mysql, CR_OUT_OF_MEMORY, SQLSTATE_UNKNOWN, 0);
return NULL;
}
ma_file->type= MA_FILE_LOCAL;
ma_file->ptr= (void *)fp;
}
return ma_file;
#ifdef HAVE_REMOTEIO
remote:
/* check if plugin for remote io is available and try
* to open location */
{
MYSQL mysql;
if (rio_plugin ||(rio_plugin= (struct st_mysql_client_plugin_REMOTEIO *)
mysql_client_find_plugin(&mysql, NULL, MARIADB_CLIENT_REMOTEIO_PLUGIN)))
return rio_plugin->methods->mopen(location, mode);
return NULL;
}
#endif
} | O3 | c | ma_open:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x500, %rsp # imm = 0x500
movq %fs:0x28, %rax
movq %rax, -0x28(%rbp)
testq %rdi, %rdi
je 0x2966c
movq %rdi, %r12
cmpb $0x0, (%rdi)
je 0x2966c
movq %rdx, %r15
movq %rsi, %r14
leaq 0xd631(%rip), %rsi # 0x36c22
movq %r12, %rdi
callq 0x13100
testq %rax, %rax
je 0x2963b
leaq 0x242ab(%rip), %r15 # 0x4d8b0
movq (%r15), %rax
testq %rax, %rax
jne 0x2962a
xorl %ebx, %ebx
leaq -0x520(%rbp), %rdi
xorl %esi, %esi
movl $0x64, %edx
callq 0x294d0
movq %rax, (%r15)
testq %rax, %rax
je 0x2966e
movq 0x58(%rax), %rax
movq %r12, %rdi
movq %r14, %rsi
callq *(%rax)
movq %rax, %rbx
jmp 0x2966e
movq %r12, %rdi
movq %r14, %rsi
callq 0x13520
testq %rax, %rax
je 0x2966c
movq %rax, %r14
movl $0x10, %edi
callq 0x13600
testq %rax, %rax
je 0x29690
movq %rax, %rbx
movl $0x1, (%rax)
movq %r14, 0x8(%rax)
jmp 0x2966e
xorl %ebx, %ebx
movq %fs:0x28, %rax
cmpq -0x28(%rbp), %rax
jne 0x296b7
movq %rbx, %rax
addq $0x500, %rsp # imm = 0x500
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x13460
leaq 0x22421(%rip), %rax # 0x4bac0
movq (%rax), %rdx
xorl %ebx, %ebx
movq %r15, %rdi
movl $0x7d8, %esi # imm = 0x7D8
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x160e1
jmp 0x2966e
callq 0x13500
| ma_open:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 500h
mov rax, fs:28h
mov [rbp+var_28], rax
test rdi, rdi
jz loc_2966C
mov r12, rdi
cmp byte ptr [rdi], 0
jz loc_2966C
mov r15, rdx
mov r14, rsi
lea rsi, asc_36C22; "://"
mov rdi, r12
call _strstr
test rax, rax
jz short loc_2963B
lea r15, rio_plugin
mov rax, [r15]
test rax, rax
jnz short loc_2962A
xor ebx, ebx
lea rdi, [rbp+var_520]
xor esi, esi
mov edx, 64h ; 'd'
call mysql_client_find_plugin
mov [r15], rax
test rax, rax
jz short loc_2966E
loc_2962A:
mov rax, [rax+58h]
mov rdi, r12
mov rsi, r14
call qword ptr [rax]
mov rbx, rax
jmp short loc_2966E
loc_2963B:
mov rdi, r12
mov rsi, r14
call _fopen64
test rax, rax
jz short loc_2966C
mov r14, rax
mov edi, 10h
call _malloc
test rax, rax
jz short loc_29690
mov rbx, rax
mov dword ptr [rax], 1
mov [rax+8], r14
jmp short loc_2966E
loc_2966C:
xor ebx, ebx
loc_2966E:
mov rax, fs:28h
cmp rax, [rbp+var_28]
jnz short loc_296B7
mov rax, rbx
add rsp, 500h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_29690:
mov rdi, r14
call _fclose
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
xor ebx, ebx
mov rdi, r15
mov esi, 7D8h
xor ecx, ecx
xor eax, eax
call my_set_error
jmp short loc_2966E
loc_296B7:
call ___stack_chk_fail
| long long ma_open(
_BYTE *a1,
long long a2,
long long a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
long long v12; // rcx
long long v13; // r8
long long v14; // r9
double v15; // xmm4_8
double v16; // xmm5_8
long long plugin; // rax
long long v18; // rbx
long long v19; // rax
long long v20; // r14
long long v21; // rax
char v23[1272]; // [rsp+0h] [rbp-520h] BYREF
unsigned long long v24; // [rsp+4F8h] [rbp-28h]
v24 = __readfsqword(0x28u);
if ( !a1 || !*a1 )
return 0LL;
if ( !strstr(a1, "://") )
{
v19 = fopen64(a1, a2);
if ( v19 )
{
v20 = v19;
v21 = malloc(16LL);
if ( v21 )
{
v18 = v21;
*(_DWORD *)v21 = 1;
*(_QWORD *)(v21 + 8) = v20;
}
else
{
fclose(v20);
v18 = 0LL;
my_set_error(a3, 2008, (long long)SQLSTATE_UNKNOWN, 0LL);
}
return v18;
}
return 0LL;
}
plugin = rio_plugin;
if ( rio_plugin )
return (**(long long ( ***)(_BYTE *, long long))(plugin + 88))(a1, a2);
v18 = 0LL;
plugin = mysql_client_find_plugin((long long)v23, 0LL, 100, a4, a5, a6, a7, v15, v16, a10, a11, v12, v13, v14, v23[0]);
rio_plugin = plugin;
if ( plugin )
return (**(long long ( ***)(_BYTE *, long long))(plugin + 88))(a1, a2);
return v18;
}
| ma_open:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x500
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
TEST RDI,RDI
JZ 0x0012966c
MOV R12,RDI
CMP byte ptr [RDI],0x0
JZ 0x0012966c
MOV R15,RDX
MOV R14,RSI
LEA RSI,[0x136c22]
MOV RDI,R12
CALL 0x00113100
TEST RAX,RAX
JZ 0x0012963b
LEA R15,[0x14d8b0]
MOV RAX,qword ptr [R15]
TEST RAX,RAX
JNZ 0x0012962a
XOR EBX,EBX
LEA RDI,[RBP + -0x520]
XOR ESI,ESI
MOV EDX,0x64
CALL 0x001294d0
MOV qword ptr [R15],RAX
TEST RAX,RAX
JZ 0x0012966e
LAB_0012962a:
MOV RAX,qword ptr [RAX + 0x58]
MOV RDI,R12
MOV RSI,R14
CALL qword ptr [RAX]
MOV RBX,RAX
JMP 0x0012966e
LAB_0012963b:
MOV RDI,R12
MOV RSI,R14
CALL 0x00113520
TEST RAX,RAX
JZ 0x0012966c
MOV R14,RAX
MOV EDI,0x10
CALL 0x00113600
TEST RAX,RAX
JZ 0x00129690
MOV RBX,RAX
MOV dword ptr [RAX],0x1
MOV qword ptr [RAX + 0x8],R14
JMP 0x0012966e
LAB_0012966c:
XOR EBX,EBX
LAB_0012966e:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x28]
JNZ 0x001296b7
MOV RAX,RBX
ADD RSP,0x500
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00129690:
MOV RDI,R14
CALL 0x00113460
LEA RAX,[0x14bac0]
MOV RDX,qword ptr [RAX]
XOR EBX,EBX
MOV RDI,R15
MOV ESI,0x7d8
XOR ECX,ECX
XOR EAX,EAX
CALL 0x001160e1
JMP 0x0012966e
LAB_001296b7:
CALL 0x00113500
|
int4 * ma_open(char *param_1,char *param_2,int8 param_3)
{
char *pcVar1;
int4 *puVar2;
FILE *__stream;
long in_FS_OFFSET;
int1 local_528 [1272];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
if ((param_1 != (char *)0x0) && (*param_1 != '\0')) {
pcVar1 = strstr(param_1,"://");
if (pcVar1 != (char *)0x0) {
if (rio_plugin == 0) {
puVar2 = (int4 *)0x0;
rio_plugin = mysql_client_find_plugin(local_528,0,100);
if (rio_plugin == 0) goto LAB_0012966e;
}
puVar2 = (int4 *)(*(code *)**(int8 **)(rio_plugin + 0x58))(param_1,param_2);
goto LAB_0012966e;
}
__stream = fopen64(param_1,param_2);
if (__stream != (FILE *)0x0) {
puVar2 = (int4 *)malloc(0x10);
if (puVar2 == (int4 *)0x0) {
fclose(__stream);
puVar2 = (int4 *)0x0;
my_set_error(param_3,0x7d8,SQLSTATE_UNKNOWN,0);
}
else {
*puVar2 = 1;
*(FILE **)(puVar2 + 2) = __stream;
}
goto LAB_0012966e;
}
}
puVar2 = (int4 *)0x0;
LAB_0012966e:
if (*(long *)(in_FS_OFFSET + 0x28) == local_30) {
return puVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
44,882 | js_parse_check_duplicate_parameter | bluesky950520[P]quickjs/quickjs.c | static int js_parse_check_duplicate_parameter(JSParseState *s, JSAtom name)
{
/* Check for duplicate parameter names */
JSFunctionDef *fd = s->cur_func;
int i;
for (i = 0; i < fd->arg_count; i++) {
if (fd->args[i].var_name == name)
goto duplicate;
}
for (i = 0; i < fd->var_count; i++) {
if (fd->vars[i].var_name == name)
goto duplicate;
}
return 0;
duplicate:
return js_parse_error(s, "Duplicate parameter name not allowed in this context");
} | O1 | c | js_parse_check_duplicate_parameter:
pushq %rax
movq 0x90(%rdi), %rax
movslq 0xb4(%rax), %rcx
testq %rcx, %rcx
jle 0x64d43
movq 0xa8(%rax), %rdx
shlq $0x4, %rcx
xorl %r8d, %r8d
cmpl %esi, (%rdx,%r8)
je 0x64d6e
addq $0x10, %r8
cmpq %r8, %rcx
jne 0x64d34
movslq 0xa4(%rax), %rcx
testq %rcx, %rcx
jle 0x64d6a
movq 0x90(%rax), %rax
shlq $0x4, %rcx
xorl %edx, %edx
cmpl %esi, (%rax,%rdx)
je 0x64d6e
addq $0x10, %rdx
cmpq %rdx, %rcx
jne 0x64d5c
xorl %eax, %eax
jmp 0x64d81
leaq 0x3c473(%rip), %rsi # 0xa11e8
xorl %eax, %eax
callq 0x2fce9
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
popq %rcx
retq
| js_parse_check_duplicate_parameter:
push rax
mov rax, [rdi+90h]
movsxd rcx, dword ptr [rax+0B4h]
test rcx, rcx
jle short loc_64D43
mov rdx, [rax+0A8h]
shl rcx, 4
xor r8d, r8d
loc_64D34:
cmp [rdx+r8], esi
jz short loc_64D6E
add r8, 10h
cmp rcx, r8
jnz short loc_64D34
loc_64D43:
movsxd rcx, dword ptr [rax+0A4h]
test rcx, rcx
jle short loc_64D6A
mov rax, [rax+90h]
shl rcx, 4
xor edx, edx
loc_64D5C:
cmp [rax+rdx], esi
jz short loc_64D6E
add rdx, 10h
cmp rcx, rdx
jnz short loc_64D5C
loc_64D6A:
xor eax, eax
jmp short loc_64D81
loc_64D6E:
lea rsi, aDuplicateParam; "Duplicate parameter name not allowed in"...
xor eax, eax
call js_parse_error
mov eax, 0FFFFFFFFh
loc_64D81:
pop rcx
retn
| long long js_parse_check_duplicate_parameter(
long long *a1,
int a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
long long a11,
long long a12,
long long a13,
long long a14)
{
char v14; // al
long long v15; // rax
long long v16; // rcx
long long v17; // rdx
long long v18; // rcx
long long v19; // rcx
long long v20; // rax
char v22; // [rsp-8h] [rbp-8h]
v22 = v14;
v15 = a1[18];
v16 = *(int *)(v15 + 180);
if ( v16 <= 0 )
{
LABEL_5:
v19 = *(int *)(v15 + 164);
if ( v19 <= 0 )
return 0LL;
v20 = *(_QWORD *)(v15 + 144);
v18 = 16 * v19;
v17 = 0LL;
while ( *(_DWORD *)(v20 + v17) != a2 )
{
v17 += 16LL;
if ( v18 == v17 )
return 0LL;
}
}
else
{
v17 = *(_QWORD *)(v15 + 168);
v18 = 16 * v16;
a13 = 0LL;
while ( *(_DWORD *)(v17 + a13) != a2 )
{
a13 += 16LL;
if ( v18 == a13 )
goto LABEL_5;
}
}
js_parse_error(
a1,
(long long)"Duplicate parameter name not allowed in this context",
v17,
v18,
a13,
a14,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
v22);
return 0xFFFFFFFFLL;
}
| js_parse_check_duplicate_parameter:
PUSH RAX
MOV RAX,qword ptr [RDI + 0x90]
MOVSXD RCX,dword ptr [RAX + 0xb4]
TEST RCX,RCX
JLE 0x00164d43
MOV RDX,qword ptr [RAX + 0xa8]
SHL RCX,0x4
XOR R8D,R8D
LAB_00164d34:
CMP dword ptr [RDX + R8*0x1],ESI
JZ 0x00164d6e
ADD R8,0x10
CMP RCX,R8
JNZ 0x00164d34
LAB_00164d43:
MOVSXD RCX,dword ptr [RAX + 0xa4]
TEST RCX,RCX
JLE 0x00164d6a
MOV RAX,qword ptr [RAX + 0x90]
SHL RCX,0x4
XOR EDX,EDX
LAB_00164d5c:
CMP dword ptr [RAX + RDX*0x1],ESI
JZ 0x00164d6e
ADD RDX,0x10
CMP RCX,RDX
JNZ 0x00164d5c
LAB_00164d6a:
XOR EAX,EAX
JMP 0x00164d81
LAB_00164d6e:
LEA RSI,[0x1a11e8]
XOR EAX,EAX
CALL 0x0012fce9
MOV EAX,0xffffffff
LAB_00164d81:
POP RCX
RET
|
int8 js_parse_check_duplicate_parameter(long param_1,int param_2)
{
long lVar1;
long lVar2;
lVar1 = *(long *)(param_1 + 0x90);
if (0 < (long)*(int *)(lVar1 + 0xb4)) {
lVar2 = 0;
do {
if (*(int *)(*(long *)(lVar1 + 0xa8) + lVar2) == param_2) goto LAB_00164d6e;
lVar2 = lVar2 + 0x10;
} while ((long)*(int *)(lVar1 + 0xb4) * 0x10 != lVar2);
}
if (0 < (long)*(int *)(lVar1 + 0xa4)) {
lVar2 = 0;
do {
if (*(int *)(*(long *)(lVar1 + 0x90) + lVar2) == param_2) {
LAB_00164d6e:
js_parse_error(param_1,"Duplicate parameter name not allowed in this context");
return 0xffffffff;
}
lVar2 = lVar2 + 0x10;
} while ((long)*(int *)(lVar1 + 0xa4) * 0x10 != lVar2);
}
return 0;
}
| |
44,883 | js_parse_check_duplicate_parameter | bluesky950520[P]quickjs/quickjs.c | static int js_parse_check_duplicate_parameter(JSParseState *s, JSAtom name)
{
/* Check for duplicate parameter names */
JSFunctionDef *fd = s->cur_func;
int i;
for (i = 0; i < fd->arg_count; i++) {
if (fd->args[i].var_name == name)
goto duplicate;
}
for (i = 0; i < fd->var_count; i++) {
if (fd->vars[i].var_name == name)
goto duplicate;
}
return 0;
duplicate:
return js_parse_error(s, "Duplicate parameter name not allowed in this context");
} | O2 | c | js_parse_check_duplicate_parameter:
pushq %rax
movq 0x90(%rdi), %rcx
movl 0xb4(%rcx), %eax
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
shlq $0x4, %rax
addq $0x10, %rax
leaq 0x10(%rdx), %r8
cmpq %r8, %rax
je 0x56007
movq 0xa8(%rcx), %r9
cmpl %esi, (%r9,%rdx)
movq %r8, %rdx
jne 0x55fec
jmp 0x56038
movl 0xa4(%rcx), %edx
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
shlq $0x4, %rdx
addq $0x10, %rdx
xorl %r8d, %r8d
leaq 0x10(%r8), %r9
cmpq %r9, %rdx
je 0x56049
movq 0x90(%rcx), %r10
cmpl %esi, (%r10,%r8)
movq %r9, %r8
jne 0x5601f
leaq 0x320e3(%rip), %rsi # 0x88122
xorl %eax, %eax
callq 0x28457
pushq $-0x1
popq %rax
popq %rcx
retq
| js_parse_check_duplicate_parameter:
push rax
mov rcx, [rdi+90h]
mov eax, [rcx+0B4h]
xor edx, edx
test eax, eax
cmovle eax, edx
shl rax, 4
add rax, 10h
loc_55FEC:
lea r8, [rdx+10h]
cmp rax, r8
jz short loc_56007
mov r9, [rcx+0A8h]
cmp [r9+rdx], esi
mov rdx, r8
jnz short loc_55FEC
jmp short loc_56038
loc_56007:
mov edx, [rcx+0A4h]
xor eax, eax
test edx, edx
cmovle edx, eax
shl rdx, 4
add rdx, 10h
xor r8d, r8d
loc_5601F:
lea r9, [r8+10h]
cmp rdx, r9
jz short loc_56049
mov r10, [rcx+90h]
cmp [r10+r8], esi
mov r8, r9
jnz short loc_5601F
loc_56038:
lea rsi, aDuplicateParam; "Duplicate parameter name not allowed in"...
xor eax, eax
call js_parse_error
push 0FFFFFFFFFFFFFFFFh
pop rax
loc_56049:
pop rcx
retn
| long long js_parse_check_duplicate_parameter(
long long *a1,
int a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10)
{
char v10; // al
long long v11; // rcx
long long v12; // rax
long long v13; // rdx
long long v14; // rax
long long v15; // r8
long long v16; // r9
bool v17; // zf
long long v18; // rdx
long long result; // rax
char v20; // [rsp-8h] [rbp-8h]
v20 = v10;
v11 = a1[18];
v12 = *(unsigned int *)(v11 + 180);
v13 = 0LL;
if ( (int)v12 <= 0 )
v12 = 0LL;
v14 = 16 * v12 + 16;
while ( 1 )
{
v15 = v13 + 16;
if ( v14 == v13 + 16 )
break;
v16 = *(_QWORD *)(v11 + 168);
v17 = *(_DWORD *)(v16 + v13) == a2;
v13 += 16LL;
if ( v17 )
{
LABEL_12:
js_parse_error(
a1,
(long long)"Duplicate parameter name not allowed in this context",
v13,
v11,
v15,
v16,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
v20);
return -1LL;
}
}
v18 = *(unsigned int *)(v11 + 164);
result = 0LL;
if ( (int)v18 <= 0 )
v18 = 0LL;
v13 = 16 * v18 + 16;
v15 = 0LL;
while ( 1 )
{
v16 = v15 + 16;
if ( v13 == v15 + 16 )
return result;
v17 = *(_DWORD *)(*(_QWORD *)(v11 + 144) + v15) == a2;
v15 += 16LL;
if ( v17 )
goto LABEL_12;
}
}
| js_parse_check_duplicate_parameter:
PUSH RAX
MOV RCX,qword ptr [RDI + 0x90]
MOV EAX,dword ptr [RCX + 0xb4]
XOR EDX,EDX
TEST EAX,EAX
CMOVLE EAX,EDX
SHL RAX,0x4
ADD RAX,0x10
LAB_00155fec:
LEA R8,[RDX + 0x10]
CMP RAX,R8
JZ 0x00156007
MOV R9,qword ptr [RCX + 0xa8]
CMP dword ptr [R9 + RDX*0x1],ESI
MOV RDX,R8
JNZ 0x00155fec
JMP 0x00156038
LAB_00156007:
MOV EDX,dword ptr [RCX + 0xa4]
XOR EAX,EAX
TEST EDX,EDX
CMOVLE EDX,EAX
SHL RDX,0x4
ADD RDX,0x10
XOR R8D,R8D
LAB_0015601f:
LEA R9,[R8 + 0x10]
CMP RDX,R9
JZ 0x00156049
MOV R10,qword ptr [RCX + 0x90]
CMP dword ptr [R10 + R8*0x1],ESI
MOV R8,R9
JNZ 0x0015601f
LAB_00156038:
LEA RSI,[0x188122]
XOR EAX,EAX
CALL 0x00128457
PUSH -0x1
POP RAX
LAB_00156049:
POP RCX
RET
|
int8 js_parse_check_duplicate_parameter(long param_1,int param_2)
{
int *piVar1;
long lVar2;
ulong uVar3;
ulong uVar4;
long lVar5;
lVar2 = *(long *)(param_1 + 0x90);
uVar3 = (ulong)*(uint *)(lVar2 + 0xb4);
if ((int)*(uint *)(lVar2 + 0xb4) < 1) {
uVar3 = 0;
}
uVar4 = 0;
while (uVar3 * 0x10 + 0x10 != uVar4 + 0x10) {
piVar1 = (int *)(*(long *)(lVar2 + 0xa8) + uVar4);
uVar4 = uVar4 + 0x10;
if (*piVar1 == param_2) goto LAB_00156038;
}
uVar3 = (ulong)*(uint *)(lVar2 + 0xa4);
if ((int)*(uint *)(lVar2 + 0xa4) < 1) {
uVar3 = 0;
}
lVar5 = 0;
do {
if (uVar3 * 0x10 + 0x10 == lVar5 + 0x10) {
return 0;
}
piVar1 = (int *)(*(long *)(lVar2 + 0x90) + lVar5);
lVar5 = lVar5 + 0x10;
} while (*piVar1 != param_2);
LAB_00156038:
js_parse_error(param_1,"Duplicate parameter name not allowed in this context");
return 0xffffffffffffffff;
}
| |
44,884 | ftxui::animation::easing::BounceOut(float) | Andrewchistyakov[P]flashcards_lyc/build_O3/_deps/ftxui-src/src/ftxui/component/animation.cpp | float BounceOut(float p) {
if (p < 4.f / 11.f) {
return (121.f * p * p) / 16.f;
}
if (p < 8.f / 11.f) {
return (363.f / 40.f * p * p) - (99.f / 10.f * p) + 17.f / 5.f;
}
if (p < 9.f / 10.f) {
return (4356.f / 361.f * p * p) - (35442.f / 1805.f * p) + 16061.f / 1805.f;
}
return (54.f / 5.f * p * p) - (513 / 25.f * p) + 268 / 25.f;
} | O3 | cpp | ftxui::animation::easing::BounceOut(float):
movss 0x8357(%rip), %xmm1 # 0x3f3c0
ucomiss %xmm0, %xmm1
jbe 0x3708b
movss 0x837a(%rip), %xmm1 # 0x3f3f0
mulss %xmm0, %xmm1
mulss %xmm0, %xmm1
mulss 0x836e(%rip), %xmm1 # 0x3f3f4
jmp 0x37118
movss 0x8331(%rip), %xmm1 # 0x3f3c4
ucomiss %xmm0, %xmm1
jbe 0x370be
movss 0x8344(%rip), %xmm1 # 0x3f3e4
mulss %xmm0, %xmm1
mulss %xmm0, %xmm1
mulss 0x8338(%rip), %xmm0 # 0x3f3e8
addss %xmm1, %xmm0
addss 0x8330(%rip), %xmm0 # 0x3f3ec
jmp 0x37115
movss 0x8302(%rip), %xmm1 # 0x3f3c8
ucomiss %xmm0, %xmm1
jbe 0x370f1
movss 0x8305(%rip), %xmm1 # 0x3f3d8
mulss %xmm0, %xmm1
mulss %xmm0, %xmm1
mulss 0x82f9(%rip), %xmm0 # 0x3f3dc
addss %xmm1, %xmm0
addss 0x82f1(%rip), %xmm0 # 0x3f3e0
jmp 0x37115
movss 0x82d3(%rip), %xmm1 # 0x3f3cc
mulss %xmm0, %xmm1
mulss %xmm0, %xmm1
mulss 0x82c7(%rip), %xmm0 # 0x3f3d0
addss %xmm1, %xmm0
addss 0x82bf(%rip), %xmm0 # 0x3f3d4
movaps %xmm0, %xmm1
movaps %xmm1, %xmm0
retq
| _ZN5ftxui9animation6easing9BounceOutEf:
movss xmm1, cs:dword_3F3C0
ucomiss xmm1, xmm0
jbe short loc_3708B
movss xmm1, cs:dword_3F3F0
mulss xmm1, xmm0
mulss xmm1, xmm0
mulss xmm1, cs:dword_3F3F4
jmp loc_37118
loc_3708B:
movss xmm1, cs:dword_3F3C4
ucomiss xmm1, xmm0
jbe short loc_370BE
movss xmm1, cs:dword_3F3E4
mulss xmm1, xmm0
mulss xmm1, xmm0
mulss xmm0, cs:dword_3F3E8
addss xmm0, xmm1
addss xmm0, cs:dword_3F3EC
jmp short loc_37115
loc_370BE:
movss xmm1, cs:dword_3F3C8
ucomiss xmm1, xmm0
jbe short loc_370F1
movss xmm1, cs:dword_3F3D8
mulss xmm1, xmm0
mulss xmm1, xmm0
mulss xmm0, cs:dword_3F3DC
addss xmm0, xmm1
addss xmm0, cs:dword_3F3E0
jmp short loc_37115
loc_370F1:
movss xmm1, cs:dword_3F3CC
mulss xmm1, xmm0
mulss xmm1, xmm0
mulss xmm0, cs:dword_3F3D0
addss xmm0, xmm1
addss xmm0, cs:dword_3F3D4
loc_37115:
movaps xmm1, xmm0
loc_37118:
movaps xmm0, xmm1
retn
| __m128 ftxui::animation::easing::BounceOut(ftxui::animation::easing *this, __m128 a2)
{
__int128 v2; // xmm1
if ( a2.m128_f32[0] >= 0.36363637 )
{
if ( a2.m128_f32[0] >= 0.72727275 )
{
if ( a2.m128_f32[0] >= 0.89999998 )
a2.m128_f32[0] = (float)((float)(a2.m128_f32[0] * -20.52)
+ (float)((float)(10.8 * a2.m128_f32[0]) * a2.m128_f32[0]))
+ 10.72;
else
a2.m128_f32[0] = (float)((float)(a2.m128_f32[0] * -19.635458)
+ (float)((float)(12.066482 * a2.m128_f32[0]) * a2.m128_f32[0]))
+ 8.8980608;
}
else
{
a2.m128_f32[0] = (float)((float)(a2.m128_f32[0] * -9.8999996)
+ (float)((float)(9.0749998 * a2.m128_f32[0]) * a2.m128_f32[0]))
+ 3.4000001;
}
return a2;
}
else
{
v2 = 0x42F20000u;
*(float *)&v2 = (float)((float)(121.0 * a2.m128_f32[0]) * a2.m128_f32[0]) * 0.0625;
}
return (__m128)v2;
}
| BounceOut:
MOVSS XMM1,dword ptr [0x0013f3c0]
UCOMISS XMM1,XMM0
JBE 0x0013708b
MOVSS XMM1,dword ptr [0x0013f3f0]
MULSS XMM1,XMM0
MULSS XMM1,XMM0
MULSS XMM1,dword ptr [0x0013f3f4]
JMP 0x00137118
LAB_0013708b:
MOVSS XMM1,dword ptr [0x0013f3c4]
UCOMISS XMM1,XMM0
JBE 0x001370be
MOVSS XMM1,dword ptr [0x0013f3e4]
MULSS XMM1,XMM0
MULSS XMM1,XMM0
MULSS XMM0,dword ptr [0x0013f3e8]
ADDSS XMM0,XMM1
ADDSS XMM0,dword ptr [0x0013f3ec]
JMP 0x00137115
LAB_001370be:
MOVSS XMM1,dword ptr [0x0013f3c8]
UCOMISS XMM1,XMM0
JBE 0x001370f1
MOVSS XMM1,dword ptr [0x0013f3d8]
MULSS XMM1,XMM0
MULSS XMM1,XMM0
MULSS XMM0,dword ptr [0x0013f3dc]
ADDSS XMM0,XMM1
ADDSS XMM0,dword ptr [0x0013f3e0]
JMP 0x00137115
LAB_001370f1:
MOVSS XMM1,dword ptr [0x0013f3cc]
MULSS XMM1,XMM0
MULSS XMM1,XMM0
MULSS XMM0,dword ptr [0x0013f3d0]
ADDSS XMM0,XMM1
ADDSS XMM0,dword ptr [0x0013f3d4]
LAB_00137115:
MOVAPS XMM1,XMM0
LAB_00137118:
MOVAPS XMM0,XMM1
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* ftxui::animation::easing::BounceOut(float) */
int8 ftxui::animation::easing::BounceOut(float param_1)
{
int4 in_XMM0_Db;
float fVar1;
if (DAT_0013f3c0 <= param_1) {
if (DAT_0013f3c4 <= param_1) {
if (DAT_0013f3c8 <= param_1) {
fVar1 = param_1 * _DAT_0013f3d0 + DAT_0013f3cc * param_1 * param_1 + _DAT_0013f3d4;
}
else {
fVar1 = param_1 * _DAT_0013f3dc + DAT_0013f3d8 * param_1 * param_1 + _DAT_0013f3e0;
}
}
else {
fVar1 = param_1 * _DAT_0013f3e8 + DAT_0013f3e4 * param_1 * param_1 + _DAT_0013f3ec;
}
}
else {
in_XMM0_Db = 0;
fVar1 = DAT_0013f3f0 * param_1 * param_1 * _DAT_0013f3f4;
}
return CONCAT44(in_XMM0_Db,fVar1);
}
| |
44,885 | delete_dynamic_with_callback | eloqsql/mysys/array.c | void delete_dynamic_with_callback(DYNAMIC_ARRAY *array, FREE_FUNC f) {
uint i;
char *ptr= (char*) array->buffer;
for (i= 0; i < array->elements; i++, ptr+= array->size_of_element) {
f(ptr);
}
delete_dynamic(array);
} | O3 | c | delete_dynamic_with_callback:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
je 0x92dd2
movq %rsi, %r14
movq (%rbx), %r15
xorl %r12d, %r12d
movq %r15, %rdi
callq *%r14
incl %r12d
movl 0x14(%rbx), %eax
addq %rax, %r15
cmpl 0x8(%rbx), %r12d
jb 0x92dbd
testb $0x1, 0x21(%rbx)
jne 0x92de5
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x92de5
callq 0xa0f0a
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| delete_dynamic_with_callback:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rbx, rdi
cmp dword ptr [rdi+8], 0
jz short loc_92DD2
mov r14, rsi
mov r15, [rbx]
xor r12d, r12d
loc_92DBD:
mov rdi, r15
call r14
inc r12d
mov eax, [rbx+14h]
add r15, rax
cmp r12d, [rbx+8]
jb short loc_92DBD
loc_92DD2:
test byte ptr [rbx+21h], 1
jnz short loc_92DE5
mov rdi, [rbx]
test rdi, rdi
jz short loc_92DE5
call my_free
loc_92DE5:
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long delete_dynamic_with_callback(long long *a1, void ( *a2)(long long))
{
long long v2; // r15
unsigned int v3; // r12d
long long result; // rax
if ( *((_DWORD *)a1 + 2) )
{
v2 = *a1;
v3 = 0;
do
{
a2(v2);
++v3;
result = *((unsigned int *)a1 + 5);
v2 += result;
}
while ( v3 < *((_DWORD *)a1 + 2) );
}
if ( (*((_BYTE *)a1 + 33) & 1) == 0 && *a1 )
result = my_free(*a1);
*(_OWORD *)a1 = 0LL;
return result;
}
| delete_dynamic_with_callback:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RDI
CMP dword ptr [RDI + 0x8],0x0
JZ 0x00192dd2
MOV R14,RSI
MOV R15,qword ptr [RBX]
XOR R12D,R12D
LAB_00192dbd:
MOV RDI,R15
CALL R14
INC R12D
MOV EAX,dword ptr [RBX + 0x14]
ADD R15,RAX
CMP R12D,dword ptr [RBX + 0x8]
JC 0x00192dbd
LAB_00192dd2:
TEST byte ptr [RBX + 0x21],0x1
JNZ 0x00192de5
MOV RDI,qword ptr [RBX]
TEST RDI,RDI
JZ 0x00192de5
CALL 0x001a0f0a
LAB_00192de5:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
void delete_dynamic_with_callback(long *param_1,code *param_2)
{
uint uVar1;
long lVar2;
if ((int)param_1[1] != 0) {
lVar2 = *param_1;
uVar1 = 0;
do {
(*param_2)(lVar2);
uVar1 = uVar1 + 1;
lVar2 = lVar2 + (ulong)*(uint *)((long)param_1 + 0x14);
} while (uVar1 < *(uint *)(param_1 + 1));
}
if (((*(byte *)((long)param_1 + 0x21) & 1) == 0) && (*param_1 != 0)) {
my_free();
}
*param_1 = 0;
param_1[1] = 0;
return;
}
| |
44,886 | OpenSubdiv::v3_6_0::Far::PatchTableBuilder::assignPatchPointsAndStencils(OpenSubdiv::v3_6_0::Far::PatchTableBuilder::PatchTuple const&, OpenSubdiv::v3_6_0::Far::PatchTableBuilder::PatchInfo const&, int*, OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper&, int) | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchTableFactory.cpp | int
PatchTableBuilder::assignPatchPointsAndStencils(PatchTuple const & patch,
PatchInfo const & patchInfo, Index * patchPoints,
LocalPointHelper & localHelper, int fvarInTable) {
//
// This is where the interesting/complicated new work will take place
// when a change-of-basis is determined necessary and previously assigned
// to the PatchInfo
//
// No change-of-basis means no local points or stencils associated with
// them, which should be trivial but should also only be true in the
// regular case. (It is also the case that no local points will be
// generated for irregular patches when the LegacyGregory option is
// used -- so that possibility is still accounted for here.)
//
// Regarding the return result, it should just be the size of the patch
// associated with the regular/irregular patch type chosen. This could
// be retrieved from the PatchBuilder or PatchDescriptors -- alternatively
// a return value could be removed and the client left to increment by
// such a fixed step (which is already the case for FVar channels)
//
// The more interesting size here is the number of local points/stencils
// added.
//
int fvarInRefiner = getRefinerFVarChannel(fvarInTable);
int sourcePointOffset = (fvarInTable < 0)
? _levelVertOffsets[patch.levelIndex]
: _levelFVarValueOffsets[fvarInTable][patch.levelIndex];
bool useDoubleMatrix = (fvarInTable < 0)
? _options.patchPrecisionDouble
: _options.fvarPatchPrecisionDouble;
int numPatchPoints = 0;
if (patchInfo.isRegular) {
if (!_requiresRegularLocalPoints) {
numPatchPoints = _patchBuilder->GetRegularPatchPoints(
patch.levelIndex, patch.faceIndex,
patchInfo.regBoundaryMask, patchPoints, fvarInRefiner);
// PatchBuilder set to fill missing boundary points so offset all
offsetIndices(patchPoints, numPatchPoints, sourcePointOffset);
} else {
//
// Future support for regular patches converted to another basis.
// Note the "source points" are not returned in the same
// orientation and there may be fewer than expected number in the
// case of boundaries:
/*
StackBuffer<Index,64,true> sourcePoints(
patchInfo.matrix.GetNumColumns());
_patchBuilder->GetRegularPatchSourcePoints(
patch.levelIndex, patch.faceIndex,
patchInfo.regBoundaryMask, sourcePoints, fvarInRefiner);
localHelper.AppendLocalPatchPoints(
patch.levelIndex, patch.faceIndex,
patchInfo.matrix, _patchBuilder->GetRegularPatchType(),
sourcePoints, sourcePointOffset, patchPoints);
numPatchPoints = patchInfo.matrix.GetNumRows();
*/
}
} else if (_requiresIrregularLocalPoints) {
int numSourcePoints = 0;
if (useDoubleMatrix) {
numSourcePoints = patchInfo.dMatrix.GetNumColumns();
numPatchPoints = patchInfo.dMatrix.GetNumRows();
} else {
numSourcePoints = patchInfo.fMatrix.GetNumColumns();
numPatchPoints = patchInfo.fMatrix.GetNumRows();
}
StackBuffer<Index,64,true> sourcePoints(numSourcePoints);
_patchBuilder->GetIrregularPatchSourcePoints(
patch.levelIndex, patch.faceIndex,
patchInfo.irregCornerSpans, sourcePoints, fvarInRefiner);
if (useDoubleMatrix) {
localHelper.AppendLocalPatchPoints(
patch.levelIndex, patch.faceIndex,
patchInfo.dMatrix, _patchBuilder->GetIrregularPatchType(),
sourcePoints, sourcePointOffset, patchPoints);
} else {
localHelper.AppendLocalPatchPoints(
patch.levelIndex, patch.faceIndex,
patchInfo.fMatrix, _patchBuilder->GetIrregularPatchType(),
sourcePoints, sourcePointOffset, patchPoints);
}
}
return numPatchPoints;
} | O2 | cpp | OpenSubdiv::v3_6_0::Far::PatchTableBuilder::assignPatchPointsAndStencils(OpenSubdiv::v3_6_0::Far::PatchTableBuilder::PatchTuple const&, OpenSubdiv::v3_6_0::Far::PatchTableBuilder::PatchInfo const&, int*, OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper&, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
testl %r9d, %r9d
js 0x7e1d5
movl %r9d, %eax
movq 0xa8(%r12), %rcx
movl (%rcx,%rax,4), %r9d
imulq $0x18, %rax, %rax
addq 0x90(%r12), %rax
pushq $0x12
jmp 0x7e1e0
leaq 0x78(%r12), %rax
pushq $-0x1
popq %r9
pushq $0x11
popq %rcx
movslq 0x4(%r15), %rsi
movq (%rax), %rax
pushq $0x1
popq %rbp
shll %cl, %ebp
movl (%rax,%rsi,4), %r14d
movb 0x28(%r12), %al
cmpb $0x1, (%r13)
jne 0x7e230
testb $0x2, %al
jne 0x7e234
movq 0x38(%r12), %rdi
movl (%r15), %edx
movl 0x4(%r13), %ecx
movq %rbx, %r8
callq 0x51960
xorl %edx, %edx
testl %eax, %eax
movl %eax, %ecx
cmovlel %edx, %ecx
cmpq %rdx, %rcx
je 0x7e300
addl %r14d, (%rbx,%rdx,4)
incq %rdx
jmp 0x7e21e
testb $0x4, %al
jne 0x7e23b
xorl %eax, %eax
jmp 0x7e300
movq %r8, 0x8(%rsp)
andl 0x8(%r12), %ebp
leaq 0x88(%r13), %rdx
leaq 0x8c(%r13), %rax
leaq 0x30(%r13), %rdi
leaq 0x34(%r13), %rcx
testl %ebp, %ebp
cmovneq %rax, %rcx
movl (%rcx), %esi
movq %rdx, 0x18(%rsp)
movq %rdx, %rax
movq %rdi, 0x10(%rsp)
cmoveq %rdi, %rax
movl (%rax), %eax
movl %eax, (%rsp)
leaq 0x20(%rsp), %rdi
movl %r9d, 0x4(%rsp)
callq 0x54510
movq 0x38(%r12), %rdi
movl (%r15), %edx
movl 0x4(%r15), %esi
addq $0xc, %r13
leaq 0x20(%rsp), %rax
movq (%rax), %r8
movq %r13, %rcx
movl 0x4(%rsp), %r9d
callq 0x54f00
movl (%r15), %edx
movl 0x4(%r15), %esi
movq 0x38(%r12), %rax
movl 0x2c(%rax), %r8d
movq 0x20(%rsp), %r9
testl %ebp, %ebp
je 0x7e2dc
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rcx
pushq %rbx
pushq %r14
callq 0x52930
popq %rcx
popq %rdx
jmp 0x7e2f0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rcx
pushq %rbx
pushq %r14
callq 0x53850
popq %rcx
popq %rdx
movq 0x130(%rsp), %rdi
callq 0x524d0
movl (%rsp), %eax
addq $0x138, %rsp # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x130(%rsp), %rdi
callq 0x524d0
movq %rbx, %rdi
callq 0x55300
| _ZN10OpenSubdiv6v3_6_03Far17PatchTableBuilder28assignPatchPointsAndStencilsERKNS2_10PatchTupleERKNS2_9PatchInfoEPiRNS2_16LocalPointHelperEi:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 138h
mov rbx, rcx
mov r13, rdx
mov r15, rsi
mov r12, rdi
test r9d, r9d
js short loc_7E1D5
mov eax, r9d
mov rcx, [r12+0A8h]
mov r9d, [rcx+rax*4]
imul rax, 18h
add rax, [r12+90h]
push 12h
jmp short loc_7E1E0
loc_7E1D5:
lea rax, [r12+78h]
push 0FFFFFFFFFFFFFFFFh
pop r9; int
push 11h
loc_7E1E0:
pop rcx
movsxd rsi, dword ptr [r15+4]; int
mov rax, [rax]
push 1
pop rbp
shl ebp, cl
mov r14d, [rax+rsi*4]
mov al, [r12+28h]
cmp byte ptr [r13+0], 1
jnz short loc_7E230
test al, 2
jnz short loc_7E234
mov rdi, [r12+38h]; this
mov edx, [r15]; int
mov ecx, [r13+4]; int
mov r8, rbx; int *
call __ZNK10OpenSubdiv6v3_6_03Far12PatchBuilder21GetRegularPatchPointsEiiiPii; OpenSubdiv::v3_6_0::Far::PatchBuilder::GetRegularPatchPoints(int,int,int,int *,int)
xor edx, edx
test eax, eax
mov ecx, eax
cmovle ecx, edx
loc_7E21E:
cmp rcx, rdx
jz loc_7E300
add [rbx+rdx*4], r14d
inc rdx
jmp short loc_7E21E
loc_7E230:
test al, 4
jnz short loc_7E23B
loc_7E234:
xor eax, eax
jmp loc_7E300
loc_7E23B:
mov [rsp+168h+var_160], r8
and ebp, [r12+8]
lea rdx, [r13+88h]
lea rax, [r13+8Ch]
lea rdi, [r13+30h]
lea rcx, [r13+34h]
test ebp, ebp
cmovnz rcx, rax
mov esi, [rcx]
mov [rsp+168h+var_150], rdx
mov rax, rdx
mov [rsp+168h+var_158], rdi
cmovz rax, rdi
mov eax, [rax]
mov [rsp+168h+var_168], eax
lea rdi, [rsp+168h+var_148]
mov [rsp+168h+var_164], r9d
call __ZN10OpenSubdiv6v3_6_03Vtr8internal11StackBufferIiLj64ELb1EEC2Ej; OpenSubdiv::v3_6_0::Vtr::internal::StackBuffer<int,64u,true>::StackBuffer(uint)
mov rdi, [r12+38h]
mov edx, [r15]
mov esi, [r15+4]
add r13, 0Ch
lea rax, [rsp+168h+var_148]
mov r8, [rax]
mov rcx, r13
mov r9d, [rsp+168h+var_164]
call __ZNK10OpenSubdiv6v3_6_03Far12PatchBuilder29GetIrregularPatchSourcePointsEiiPKNS0_3Vtr8internal5Level5VSpanEPii; OpenSubdiv::v3_6_0::Far::PatchBuilder::GetIrregularPatchSourcePoints(int,int,OpenSubdiv::v3_6_0::Vtr::internal::Level::VSpan const*,int *,int)
mov edx, [r15]
mov esi, [r15+4]
mov rax, [r12+38h]
mov r8d, [rax+2Ch]
mov r9, [rsp+168h+var_148]
test ebp, ebp
jz short loc_7E2DC
mov rdi, [rsp+168h+var_160]; this
mov rcx, [rsp+168h+var_150]
push rbx; __int64
push r14; int
call __ZN10OpenSubdiv6v3_6_03Far17PatchTableBuilder16LocalPointHelper22AppendLocalPatchPointsIdEEiiiRKNS1_12SparseMatrixIT_EENS1_15PatchDescriptor4TypeEPKiiPi; OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::AppendLocalPatchPoints<double>(int,int,OpenSubdiv::v3_6_0::Far::SparseMatrix<double> const&,OpenSubdiv::v3_6_0::Far::PatchDescriptor::Type,int const*,int,int *)
pop rcx
pop rdx
jmp short loc_7E2F0
loc_7E2DC:
mov rdi, [rsp+168h+var_160]; this
mov rcx, [rsp+168h+var_158]
push rbx; __int64
push r14; int
call __ZN10OpenSubdiv6v3_6_03Far17PatchTableBuilder16LocalPointHelper22AppendLocalPatchPointsIfEEiiiRKNS1_12SparseMatrixIT_EENS1_15PatchDescriptor4TypeEPKiiPi; OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::AppendLocalPatchPoints<float>(int,int,OpenSubdiv::v3_6_0::Far::SparseMatrix<float> const&,OpenSubdiv::v3_6_0::Far::PatchDescriptor::Type,int const*,int,int *)
pop rcx
pop rdx
loc_7E2F0:
mov rdi, [rsp+168h+var_38]; void *
call __ZdlPv; operator delete(void *)
mov eax, [rsp+168h+var_168]
loc_7E300:
add rsp, 138h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, [rsp+arg_128]; void *
call __ZdlPv; operator delete(void *)
mov rdi, rbx
call __Unwind_Resume
| long long OpenSubdiv::v3_6_0::Far::PatchTableBuilder::assignPatchPointsAndStencils(
long long a1,
int *a2,
long long a3,
int *a4,
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper *a5,
int a6)
{
long long v9; // rax
int v10; // r9d
_QWORD *v11; // rax
long long v12; // rsi
int v13; // r14d
char v14; // al
long long result; // rax
long long v16; // rdx
long long v17; // rcx
int v18; // ebp
unsigned int *v19; // rcx
unsigned int *v20; // rax
char v21; // [rsp-8h] [rbp-170h]
unsigned int v22; // [rsp+0h] [rbp-168h]
int v23; // [rsp+4h] [rbp-164h]
long long v25[41]; // [rsp+20h] [rbp-148h] BYREF
if ( a6 < 0 )
{
v11 = (_QWORD *)(a1 + 120);
v10 = -1;
v21 = 17;
}
else
{
v9 = (unsigned int)a6;
v10 = *(_DWORD *)(*(_QWORD *)(a1 + 168) + 4LL * (unsigned int)a6);
v11 = (_QWORD *)(*(_QWORD *)(a1 + 144) + 24 * v9);
v21 = 18;
}
v12 = a2[1];
v13 = *(_DWORD *)(*v11 + 4 * v12);
v14 = *(_BYTE *)(a1 + 40);
if ( *(_BYTE *)a3 == 1 )
{
if ( (v14 & 2) == 0 )
{
result = OpenSubdiv::v3_6_0::Far::PatchBuilder::GetRegularPatchPoints(
*(OpenSubdiv::v3_6_0::Far::PatchBuilder **)(a1 + 56),
v12,
*a2,
*(_DWORD *)(a3 + 4),
a4,
v10);
v16 = 0LL;
v17 = (unsigned int)result;
if ( (int)result <= 0 )
v17 = 0LL;
while ( v17 != v16 )
a4[v16++] += v13;
return result;
}
return 0LL;
}
if ( (v14 & 4) == 0 )
return 0LL;
v18 = *(_DWORD *)(a1 + 8) & (1 << v21);
v19 = (unsigned int *)(a3 + 52);
if ( v18 )
v19 = (unsigned int *)(a3 + 140);
v20 = (unsigned int *)(a3 + 136);
if ( !v18 )
v20 = (unsigned int *)(a3 + 48);
v22 = *v20;
v23 = v10;
OpenSubdiv::v3_6_0::Vtr::internal::StackBuffer<int,64u,true>::StackBuffer(v25, *v19);
OpenSubdiv::v3_6_0::Far::PatchBuilder::GetIrregularPatchSourcePoints(
*(_QWORD *)(a1 + 56),
a2[1],
*a2,
a3 + 12,
v25[0],
v23);
if ( v18 )
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::AppendLocalPatchPoints<double>(a5, v13, (long long)a4);
else
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::AppendLocalPatchPoints<float>(a5, v13, (long long)a4);
operator delete((void *)v25[34]);
return v22;
}
| assignPatchPointsAndStencils:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x138
MOV RBX,RCX
MOV R13,RDX
MOV R15,RSI
MOV R12,RDI
TEST R9D,R9D
JS 0x0017e1d5
MOV EAX,R9D
MOV RCX,qword ptr [R12 + 0xa8]
MOV R9D,dword ptr [RCX + RAX*0x4]
IMUL RAX,RAX,0x18
ADD RAX,qword ptr [R12 + 0x90]
PUSH 0x12
JMP 0x0017e1e0
LAB_0017e1d5:
LEA RAX,[R12 + 0x78]
PUSH -0x1
POP R9
PUSH 0x11
LAB_0017e1e0:
POP RCX
MOVSXD RSI,dword ptr [R15 + 0x4]
MOV RAX,qword ptr [RAX]
PUSH 0x1
POP RBP
SHL EBP,CL
MOV R14D,dword ptr [RAX + RSI*0x4]
MOV AL,byte ptr [R12 + 0x28]
CMP byte ptr [R13],0x1
JNZ 0x0017e230
TEST AL,0x2
JNZ 0x0017e234
MOV RDI,qword ptr [R12 + 0x38]
MOV EDX,dword ptr [R15]
MOV ECX,dword ptr [R13 + 0x4]
MOV R8,RBX
CALL 0x00151960
XOR EDX,EDX
TEST EAX,EAX
MOV ECX,EAX
CMOVLE ECX,EDX
LAB_0017e21e:
CMP RCX,RDX
JZ 0x0017e300
ADD dword ptr [RBX + RDX*0x4],R14D
INC RDX
JMP 0x0017e21e
LAB_0017e230:
TEST AL,0x4
JNZ 0x0017e23b
LAB_0017e234:
XOR EAX,EAX
JMP 0x0017e300
LAB_0017e23b:
MOV qword ptr [RSP + 0x8],R8
AND EBP,dword ptr [R12 + 0x8]
LEA RDX,[R13 + 0x88]
LEA RAX,[R13 + 0x8c]
LEA RDI,[R13 + 0x30]
LEA RCX,[R13 + 0x34]
TEST EBP,EBP
CMOVNZ RCX,RAX
MOV ESI,dword ptr [RCX]
MOV qword ptr [RSP + 0x18],RDX
MOV RAX,RDX
MOV qword ptr [RSP + 0x10],RDI
CMOVZ RAX,RDI
MOV EAX,dword ptr [RAX]
MOV dword ptr [RSP],EAX
LEA RDI,[RSP + 0x20]
MOV dword ptr [RSP + 0x4],R9D
CALL 0x00154510
MOV RDI,qword ptr [R12 + 0x38]
MOV EDX,dword ptr [R15]
MOV ESI,dword ptr [R15 + 0x4]
ADD R13,0xc
LEA RAX,[RSP + 0x20]
MOV R8,qword ptr [RAX]
LAB_0017e2a0:
MOV RCX,R13
MOV R9D,dword ptr [RSP + 0x4]
CALL 0x00154f00
MOV EDX,dword ptr [R15]
MOV ESI,dword ptr [R15 + 0x4]
MOV RAX,qword ptr [R12 + 0x38]
MOV R8D,dword ptr [RAX + 0x2c]
MOV R9,qword ptr [RSP + 0x20]
TEST EBP,EBP
JZ 0x0017e2dc
MOV RDI,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP + 0x18]
PUSH RBX
PUSH R14
CALL 0x00152930
POP RCX
POP RDX
JMP 0x0017e2f0
LAB_0017e2dc:
MOV RDI,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP + 0x10]
PUSH RBX
PUSH R14
CALL 0x00153850
POP RCX
POP RDX
LAB_0017e2f0:
MOV RDI,qword ptr [RSP + 0x130]
CALL 0x001524d0
MOV EAX,dword ptr [RSP]
LAB_0017e300:
ADD RSP,0x138
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* OpenSubdiv::v3_6_0::Far::PatchTableBuilder::assignPatchPointsAndStencils(OpenSubdiv::v3_6_0::Far::PatchTableBuilder::PatchTuple
const&, OpenSubdiv::v3_6_0::Far::PatchTableBuilder::PatchInfo const&, int*,
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper&, int) */
ulong __thiscall
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::assignPatchPointsAndStencils
(PatchTableBuilder *this,PatchTuple *param_1,PatchInfo *param_2,int *param_3,
LocalPointHelper *param_4,int param_5)
{
int iVar1;
uint uVar2;
PatchTableBuilder *pPVar3;
ulong uVar4;
PatchInfo *pPVar5;
ulong uVar6;
PatchInfo *pPVar7;
ulong uVar8;
uint uVar9;
int iVar10;
sbyte sVar11;
int *local_148 [34];
void *local_38;
if (param_5 < 0) {
pPVar3 = this + 0x78;
iVar10 = -1;
sVar11 = 0x11;
}
else {
iVar10 = *(int *)(*(long *)(this + 0xa8) + (ulong)(uint)param_5 * 4);
pPVar3 = (PatchTableBuilder *)((ulong)(uint)param_5 * 0x18 + *(long *)(this + 0x90));
sVar11 = 0x12;
}
iVar1 = *(int *)(*(long *)pPVar3 + (long)*(int *)(param_1 + 4) * 4);
if (*param_2 == (PatchInfo)0x1) {
if (((byte)this[0x28] & 2) == 0) {
uVar4 = PatchBuilder::GetRegularPatchPoints
(*(PatchBuilder **)(this + 0x38),*(int *)(param_1 + 4),*(int *)param_1,
*(int *)(param_2 + 4),param_3,iVar10);
uVar8 = 0;
uVar6 = uVar4 & 0xffffffff;
if ((int)uVar4 < 1) {
uVar6 = uVar8;
}
for (; uVar6 != uVar8; uVar8 = uVar8 + 1) {
param_3[uVar8] = param_3[uVar8] + iVar1;
}
return uVar4;
}
}
else if (((byte)this[0x28] & 4) != 0) {
uVar9 = 1 << sVar11 & *(uint *)(this + 8);
pPVar7 = param_2 + 0x34;
if (uVar9 != 0) {
pPVar7 = param_2 + 0x8c;
}
pPVar5 = param_2 + 0x88;
if (uVar9 == 0) {
pPVar5 = param_2 + 0x30;
}
uVar2 = *(uint *)pPVar5;
Vtr::internal::StackBuffer<int,64u,true>::StackBuffer
((StackBuffer<int,64u,true> *)local_148,*(uint *)pPVar7);
/* try { // try from 0017e2a0 to 0017e2ef has its CatchHandler @ 0017e312 */
PatchBuilder::GetIrregularPatchSourcePoints
(*(PatchBuilder **)(this + 0x38),*(int *)(param_1 + 4),*(int *)param_1,
(VSpan *)(param_2 + 0xc),local_148[0],iVar10);
if (uVar9 == 0) {
LocalPointHelper::AppendLocalPatchPoints<float>
(param_4,*(int4 *)(param_1 + 4),*(int4 *)param_1,param_2 + 0x30,
*(int4 *)(*(long *)(this + 0x38) + 0x2c),local_148[0],iVar1,param_3);
}
else {
LocalPointHelper::AppendLocalPatchPoints<double>
(param_4,*(int4 *)(param_1 + 4),*(int4 *)param_1,param_2 + 0x88,
*(int4 *)(*(long *)(this + 0x38) + 0x2c),local_148[0],iVar1,param_3);
}
operator_delete(local_38);
return (ulong)uVar2;
}
return 0;
}
| |
44,887 | OpenSubdiv::v3_6_0::Far::PatchTableBuilder::assignPatchPointsAndStencils(OpenSubdiv::v3_6_0::Far::PatchTableBuilder::PatchTuple const&, OpenSubdiv::v3_6_0::Far::PatchTableBuilder::PatchInfo const&, int*, OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper&, int) | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchTableFactory.cpp | int
PatchTableBuilder::assignPatchPointsAndStencils(PatchTuple const & patch,
PatchInfo const & patchInfo, Index * patchPoints,
LocalPointHelper & localHelper, int fvarInTable) {
//
// This is where the interesting/complicated new work will take place
// when a change-of-basis is determined necessary and previously assigned
// to the PatchInfo
//
// No change-of-basis means no local points or stencils associated with
// them, which should be trivial but should also only be true in the
// regular case. (It is also the case that no local points will be
// generated for irregular patches when the LegacyGregory option is
// used -- so that possibility is still accounted for here.)
//
// Regarding the return result, it should just be the size of the patch
// associated with the regular/irregular patch type chosen. This could
// be retrieved from the PatchBuilder or PatchDescriptors -- alternatively
// a return value could be removed and the client left to increment by
// such a fixed step (which is already the case for FVar channels)
//
// The more interesting size here is the number of local points/stencils
// added.
//
int fvarInRefiner = getRefinerFVarChannel(fvarInTable);
int sourcePointOffset = (fvarInTable < 0)
? _levelVertOffsets[patch.levelIndex]
: _levelFVarValueOffsets[fvarInTable][patch.levelIndex];
bool useDoubleMatrix = (fvarInTable < 0)
? _options.patchPrecisionDouble
: _options.fvarPatchPrecisionDouble;
int numPatchPoints = 0;
if (patchInfo.isRegular) {
if (!_requiresRegularLocalPoints) {
numPatchPoints = _patchBuilder->GetRegularPatchPoints(
patch.levelIndex, patch.faceIndex,
patchInfo.regBoundaryMask, patchPoints, fvarInRefiner);
// PatchBuilder set to fill missing boundary points so offset all
offsetIndices(patchPoints, numPatchPoints, sourcePointOffset);
} else {
//
// Future support for regular patches converted to another basis.
// Note the "source points" are not returned in the same
// orientation and there may be fewer than expected number in the
// case of boundaries:
/*
StackBuffer<Index,64,true> sourcePoints(
patchInfo.matrix.GetNumColumns());
_patchBuilder->GetRegularPatchSourcePoints(
patch.levelIndex, patch.faceIndex,
patchInfo.regBoundaryMask, sourcePoints, fvarInRefiner);
localHelper.AppendLocalPatchPoints(
patch.levelIndex, patch.faceIndex,
patchInfo.matrix, _patchBuilder->GetRegularPatchType(),
sourcePoints, sourcePointOffset, patchPoints);
numPatchPoints = patchInfo.matrix.GetNumRows();
*/
}
} else if (_requiresIrregularLocalPoints) {
int numSourcePoints = 0;
if (useDoubleMatrix) {
numSourcePoints = patchInfo.dMatrix.GetNumColumns();
numPatchPoints = patchInfo.dMatrix.GetNumRows();
} else {
numSourcePoints = patchInfo.fMatrix.GetNumColumns();
numPatchPoints = patchInfo.fMatrix.GetNumRows();
}
StackBuffer<Index,64,true> sourcePoints(numSourcePoints);
_patchBuilder->GetIrregularPatchSourcePoints(
patch.levelIndex, patch.faceIndex,
patchInfo.irregCornerSpans, sourcePoints, fvarInRefiner);
if (useDoubleMatrix) {
localHelper.AppendLocalPatchPoints(
patch.levelIndex, patch.faceIndex,
patchInfo.dMatrix, _patchBuilder->GetIrregularPatchType(),
sourcePoints, sourcePointOffset, patchPoints);
} else {
localHelper.AppendLocalPatchPoints(
patch.levelIndex, patch.faceIndex,
patchInfo.fMatrix, _patchBuilder->GetIrregularPatchType(),
sourcePoints, sourcePointOffset, patchPoints);
}
}
return numPatchPoints;
} | O3 | cpp | OpenSubdiv::v3_6_0::Far::PatchTableBuilder::assignPatchPointsAndStencils(OpenSubdiv::v3_6_0::Far::PatchTableBuilder::PatchTuple const&, OpenSubdiv::v3_6_0::Far::PatchTableBuilder::PatchInfo const&, int*, OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper&, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
testl %r9d, %r9d
js 0x6d652
movl %r9d, %eax
movq 0xa8(%r12), %rcx
movl (%rcx,%rax,4), %r9d
leaq (%rax,%rax,2), %rax
shlq $0x3, %rax
addq 0x90(%r12), %rax
movl $0x12, %ecx
jmp 0x6d662
leaq 0x78(%r12), %rax
movl $0xffffffff, %r9d # imm = 0xFFFFFFFF
movl $0x11, %ecx
movslq 0x4(%r15), %rsi
movq (%rax), %rax
movl $0x1, %ebp
shll %cl, %ebp
movl (%rax,%rsi,4), %r14d
movb 0x28(%r12), %al
cmpb $0x1, (%r13)
jne 0x6d6b5
testb $0x2, %al
jne 0x6d6b9
movq 0x38(%r12), %rdi
movl (%r15), %edx
movl 0x4(%r13), %ecx
movq %rbx, %r8
callq 0x39950
testl %eax, %eax
jle 0x6d7c5
movl %eax, %edx
xorl %ecx, %ecx
addl %r14d, (%rbx,%rcx,4)
incq %rcx
cmpq %rcx, %rdx
jne 0x6d6a4
jmp 0x6d7c5
testb $0x4, %al
jne 0x6d6c0
xorl %eax, %eax
jmp 0x6d7c5
movq %r8, 0x18(%rsp)
andl 0x8(%r12), %ebp
leaq 0x88(%r13), %rdx
leaq 0x8c(%r13), %rax
leaq 0x34(%r13), %rcx
testl %ebp, %ebp
cmovneq %rax, %rcx
leaq 0x30(%r13), %rdi
movq %rdx, 0x28(%rsp)
movq %rdx, %rax
movq %rdi, 0x20(%rsp)
cmoveq %rdi, %rax
movl (%rcx), %ecx
movl (%rax), %eax
movl %eax, 0x14(%rsp)
leaq 0x40(%rsp), %r8
movq %r8, -0x10(%r8)
movl %ecx, -0x8(%r8)
movl $0x40, -0x4(%r8)
movq $0x0, 0x100(%r8)
cmpl $0x41, %ecx
jb 0x6d759
movl %ecx, %edi
shlq $0x2, %rdi
movl %r9d, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
callq 0x3a210
movl 0x10(%rsp), %r9d
movq %rax, %r8
movq %rax, 0x140(%rsp)
movq %rax, 0x30(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x3c(%rsp)
movl 0x4(%r15), %esi
movq 0x38(%r12), %rdi
movl (%r15), %edx
addq $0xc, %r13
movq %r13, %rcx
callq 0x3ba80
movl (%r15), %edx
movl 0x4(%r15), %esi
movq 0x38(%r12), %rax
movl 0x2c(%rax), %r8d
movq 0x30(%rsp), %r9
testl %ebp, %ebp
je 0x6d79e
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rcx
pushq %rbx
pushq %r14
callq 0x3a2f0
addq $0x10, %rsp
jmp 0x6d7b4
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rcx
pushq %rbx
pushq %r14
callq 0x3ac10
addq $0x10, %rsp
movq 0x140(%rsp), %rdi
callq 0x3a0a0
movl 0x14(%rsp), %eax
addq $0x148, %rsp # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x140(%rsp), %rdi
callq 0x3a0a0
movq %rbx, %rdi
callq 0x3bd30
nop
| _ZN10OpenSubdiv6v3_6_03Far17PatchTableBuilder28assignPatchPointsAndStencilsERKNS2_10PatchTupleERKNS2_9PatchInfoEPiRNS2_16LocalPointHelperEi:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 148h
mov rbx, rcx
mov r13, rdx
mov r15, rsi
mov r12, rdi
test r9d, r9d
js short loc_6D652
mov eax, r9d
mov rcx, [r12+0A8h]
mov r9d, [rcx+rax*4]
lea rax, [rax+rax*2]
shl rax, 3
add rax, [r12+90h]
mov ecx, 12h
jmp short loc_6D662
loc_6D652:
lea rax, [r12+78h]
mov r9d, 0FFFFFFFFh; int
mov ecx, 11h
loc_6D662:
movsxd rsi, dword ptr [r15+4]; int
mov rax, [rax]
mov ebp, 1
shl ebp, cl
mov r14d, [rax+rsi*4]
mov al, [r12+28h]
cmp byte ptr [r13+0], 1
jnz short loc_6D6B5
test al, 2
jnz short loc_6D6B9
mov rdi, [r12+38h]; this
mov edx, [r15]; int
mov ecx, [r13+4]; int
mov r8, rbx; int *
call __ZNK10OpenSubdiv6v3_6_03Far12PatchBuilder21GetRegularPatchPointsEiiiPii; OpenSubdiv::v3_6_0::Far::PatchBuilder::GetRegularPatchPoints(int,int,int,int *,int)
test eax, eax
jle loc_6D7C5
mov edx, eax
xor ecx, ecx
loc_6D6A4:
add [rbx+rcx*4], r14d
inc rcx
cmp rdx, rcx
jnz short loc_6D6A4
jmp loc_6D7C5
loc_6D6B5:
test al, 4
jnz short loc_6D6C0
loc_6D6B9:
xor eax, eax
jmp loc_6D7C5
loc_6D6C0:
mov [rsp+178h+var_160], r8
and ebp, [r12+8]
lea rdx, [r13+88h]
lea rax, [r13+8Ch]
lea rcx, [r13+34h]
test ebp, ebp
cmovnz rcx, rax
lea rdi, [r13+30h]
mov [rsp+178h+var_150], rdx
mov rax, rdx
mov [rsp+178h+var_158], rdi
cmovz rax, rdi
mov ecx, [rcx]
mov eax, [rax]
mov [rsp+178h+var_164], eax
lea r8, [rsp+178h+var_138]
mov [r8-10h], r8
mov [r8-8], ecx
mov dword ptr [r8-4], 40h ; '@'
mov qword ptr [r8+100h], 0
cmp ecx, 41h ; 'A'
jb short loc_6D759
mov edi, ecx
shl rdi, 2; unsigned __int64
mov [rsp+178h+var_168], r9d
mov [rsp+178h+var_16C], ecx
call __Znwm; operator new(ulong)
mov r9d, [rsp+178h+var_168]
mov r8, rax
mov [rsp+178h+var_38], rax
mov [rsp+178h+var_148], rax
mov eax, [rsp+178h+var_16C]
mov [rsp+178h+var_13C], eax
mov esi, [r15+4]
loc_6D759:
mov rdi, [r12+38h]
mov edx, [r15]
add r13, 0Ch
mov rcx, r13
call __ZNK10OpenSubdiv6v3_6_03Far12PatchBuilder29GetIrregularPatchSourcePointsEiiPKNS0_3Vtr8internal5Level5VSpanEPii; OpenSubdiv::v3_6_0::Far::PatchBuilder::GetIrregularPatchSourcePoints(int,int,OpenSubdiv::v3_6_0::Vtr::internal::Level::VSpan const*,int *,int)
mov edx, [r15]
mov esi, [r15+4]
mov rax, [r12+38h]
mov r8d, [rax+2Ch]
mov r9, [rsp+178h+var_148]
test ebp, ebp
jz short loc_6D79E
mov rdi, [rsp+178h+var_160]; this
mov rcx, [rsp+178h+var_150]
push rbx; __int64
push r14; int
call __ZN10OpenSubdiv6v3_6_03Far17PatchTableBuilder16LocalPointHelper22AppendLocalPatchPointsIdEEiiiRKNS1_12SparseMatrixIT_EENS1_15PatchDescriptor4TypeEPKiiPi; OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::AppendLocalPatchPoints<double>(int,int,OpenSubdiv::v3_6_0::Far::SparseMatrix<double> const&,OpenSubdiv::v3_6_0::Far::PatchDescriptor::Type,int const*,int,int *)
add rsp, 10h
jmp short loc_6D7B4
loc_6D79E:
mov rdi, [rsp+178h+var_160]; this
mov rcx, [rsp+178h+var_158]
push rbx; __int64
push r14; int
call __ZN10OpenSubdiv6v3_6_03Far17PatchTableBuilder16LocalPointHelper22AppendLocalPatchPointsIfEEiiiRKNS1_12SparseMatrixIT_EENS1_15PatchDescriptor4TypeEPKiiPi; OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::AppendLocalPatchPoints<float>(int,int,OpenSubdiv::v3_6_0::Far::SparseMatrix<float> const&,OpenSubdiv::v3_6_0::Far::PatchDescriptor::Type,int const*,int,int *)
add rsp, 10h
loc_6D7B4:
mov rdi, [rsp+178h+var_38]; void *
call __ZdlPv; operator delete(void *)
mov eax, [rsp+178h+var_164]
loc_6D7C5:
add rsp, 148h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, [rsp+arg_138]; void *
call __ZdlPv; operator delete(void *)
mov rdi, rbx
call __Unwind_Resume
| long long OpenSubdiv::v3_6_0::Far::PatchTableBuilder::assignPatchPointsAndStencils(
long long a1,
int *a2,
long long a3,
int *a4,
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper *a5,
int a6)
{
long long v9; // rax
int v10; // r9d
_QWORD *v11; // rax
char v12; // cl
long long v13; // rsi
int v14; // r14d
char v15; // al
long long result; // rax
long long v17; // rcx
int v18; // ebp
unsigned int *v19; // rcx
unsigned int *v20; // rax
unsigned int v21; // ecx
char *v22; // r8
char *v23; // rax
int v24; // [rsp+10h] [rbp-168h]
unsigned int v25; // [rsp+14h] [rbp-164h]
char v27; // [rsp+40h] [rbp-138h] BYREF
void *v28; // [rsp+140h] [rbp-38h]
if ( a6 < 0 )
{
v11 = (_QWORD *)(a1 + 120);
v10 = -1;
v12 = 17;
}
else
{
v9 = (unsigned int)a6;
v10 = *(_DWORD *)(*(_QWORD *)(a1 + 168) + 4LL * (unsigned int)a6);
v11 = (_QWORD *)(*(_QWORD *)(a1 + 144) + 24 * v9);
v12 = 18;
}
v13 = a2[1];
v14 = *(_DWORD *)(*v11 + 4 * v13);
v15 = *(_BYTE *)(a1 + 40);
if ( *(_BYTE *)a3 == 1 )
{
if ( (v15 & 2) == 0 )
{
result = OpenSubdiv::v3_6_0::Far::PatchBuilder::GetRegularPatchPoints(
*(OpenSubdiv::v3_6_0::Far::PatchBuilder **)(a1 + 56),
v13,
*a2,
*(_DWORD *)(a3 + 4),
a4,
v10);
if ( (int)result > 0 )
{
v17 = 0LL;
do
a4[v17++] += v14;
while ( (unsigned int)result != v17 );
}
return result;
}
return 0LL;
}
if ( (v15 & 4) == 0 )
return 0LL;
v18 = *(_DWORD *)(a1 + 8) & (1 << v12);
v19 = (unsigned int *)(a3 + 52);
if ( v18 )
v19 = (unsigned int *)(a3 + 140);
v20 = (unsigned int *)(a3 + 136);
if ( !v18 )
v20 = (unsigned int *)(a3 + 48);
v21 = *v19;
v25 = *v20;
v22 = &v27;
v28 = 0LL;
if ( v21 >= 0x41 )
{
v24 = v10;
v23 = (char *)operator new(4LL * v21);
v10 = v24;
v22 = v23;
v28 = v23;
LODWORD(v13) = a2[1];
}
OpenSubdiv::v3_6_0::Far::PatchBuilder::GetIrregularPatchSourcePoints(
*(_QWORD *)(a1 + 56),
v13,
*a2,
a3 + 12,
(long long)v22,
v10);
if ( v18 )
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::AppendLocalPatchPoints<double>(a5, v14, (long long)a4);
else
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::AppendLocalPatchPoints<float>(a5, v14, (long long)a4);
operator delete(v28);
return v25;
}
| assignPatchPointsAndStencils:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x148
MOV RBX,RCX
MOV R13,RDX
MOV R15,RSI
MOV R12,RDI
TEST R9D,R9D
JS 0x0016d652
MOV EAX,R9D
MOV RCX,qword ptr [R12 + 0xa8]
MOV R9D,dword ptr [RCX + RAX*0x4]
LEA RAX,[RAX + RAX*0x2]
SHL RAX,0x3
ADD RAX,qword ptr [R12 + 0x90]
MOV ECX,0x12
JMP 0x0016d662
LAB_0016d652:
LEA RAX,[R12 + 0x78]
MOV R9D,0xffffffff
MOV ECX,0x11
LAB_0016d662:
MOVSXD RSI,dword ptr [R15 + 0x4]
MOV RAX,qword ptr [RAX]
MOV EBP,0x1
SHL EBP,CL
MOV R14D,dword ptr [RAX + RSI*0x4]
MOV AL,byte ptr [R12 + 0x28]
CMP byte ptr [R13],0x1
JNZ 0x0016d6b5
TEST AL,0x2
JNZ 0x0016d6b9
MOV RDI,qword ptr [R12 + 0x38]
MOV EDX,dword ptr [R15]
MOV ECX,dword ptr [R13 + 0x4]
MOV R8,RBX
CALL 0x00139950
TEST EAX,EAX
JLE 0x0016d7c5
MOV EDX,EAX
XOR ECX,ECX
LAB_0016d6a4:
ADD dword ptr [RBX + RCX*0x4],R14D
INC RCX
CMP RDX,RCX
JNZ 0x0016d6a4
JMP 0x0016d7c5
LAB_0016d6b5:
TEST AL,0x4
JNZ 0x0016d6c0
LAB_0016d6b9:
XOR EAX,EAX
JMP 0x0016d7c5
LAB_0016d6c0:
MOV qword ptr [RSP + 0x18],R8
AND EBP,dword ptr [R12 + 0x8]
LEA RDX,[R13 + 0x88]
LEA RAX,[R13 + 0x8c]
LEA RCX,[R13 + 0x34]
TEST EBP,EBP
CMOVNZ RCX,RAX
LEA RDI,[R13 + 0x30]
MOV qword ptr [RSP + 0x28],RDX
MOV RAX,RDX
MOV qword ptr [RSP + 0x20],RDI
CMOVZ RAX,RDI
MOV ECX,dword ptr [RCX]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RSP + 0x14],EAX
LEA R8,[RSP + 0x40]
MOV qword ptr [R8 + -0x10],R8
MOV dword ptr [R8 + -0x8],ECX
MOV dword ptr [R8 + -0x4],0x40
MOV qword ptr [R8 + 0x100],0x0
CMP ECX,0x41
JC 0x0016d759
MOV EDI,ECX
SHL RDI,0x2
MOV dword ptr [RSP + 0x10],R9D
MOV dword ptr [RSP + 0xc],ECX
CALL 0x0013a210
MOV R9D,dword ptr [RSP + 0x10]
MOV R8,RAX
MOV qword ptr [RSP + 0x140],RAX
MOV qword ptr [RSP + 0x30],RAX
MOV EAX,dword ptr [RSP + 0xc]
MOV dword ptr [RSP + 0x3c],EAX
MOV ESI,dword ptr [R15 + 0x4]
LAB_0016d759:
MOV RDI,qword ptr [R12 + 0x38]
MOV EDX,dword ptr [R15]
ADD R13,0xc
LAB_0016d765:
MOV RCX,R13
CALL 0x0013ba80
MOV EDX,dword ptr [R15]
MOV ESI,dword ptr [R15 + 0x4]
MOV RAX,qword ptr [R12 + 0x38]
MOV R8D,dword ptr [RAX + 0x2c]
MOV R9,qword ptr [RSP + 0x30]
TEST EBP,EBP
JZ 0x0016d79e
MOV RDI,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP + 0x28]
PUSH RBX
PUSH R14
CALL 0x0013a2f0
ADD RSP,0x10
JMP 0x0016d7b4
LAB_0016d79e:
MOV RDI,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP + 0x20]
PUSH RBX
PUSH R14
CALL 0x0013ac10
ADD RSP,0x10
LAB_0016d7b4:
MOV RDI,qword ptr [RSP + 0x140]
CALL 0x0013a0a0
MOV EAX,dword ptr [RSP + 0x14]
LAB_0016d7c5:
ADD RSP,0x148
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* OpenSubdiv::v3_6_0::Far::PatchTableBuilder::assignPatchPointsAndStencils(OpenSubdiv::v3_6_0::Far::PatchTableBuilder::PatchTuple
const&, OpenSubdiv::v3_6_0::Far::PatchTableBuilder::PatchInfo const&, int*,
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper&, int) */
ulong __thiscall
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::assignPatchPointsAndStencils
(PatchTableBuilder *this,PatchTuple *param_1,PatchInfo *param_2,int *param_3,
LocalPointHelper *param_4,int param_5)
{
int iVar1;
uint uVar2;
PatchTableBuilder *pPVar3;
ulong uVar4;
PatchInfo *pPVar5;
int *piVar6;
sbyte sVar7;
ulong uVar8;
PatchInfo *pPVar9;
uint uVar10;
int iVar11;
int iVar12;
int local_138 [64];
int *local_38;
if (param_5 < 0) {
pPVar3 = this + 0x78;
iVar12 = -1;
sVar7 = 0x11;
}
else {
iVar12 = *(int *)(*(long *)(this + 0xa8) + (ulong)(uint)param_5 * 4);
pPVar3 = (PatchTableBuilder *)((ulong)(uint)param_5 * 0x18 + *(long *)(this + 0x90));
sVar7 = 0x12;
}
iVar11 = *(int *)(param_1 + 4);
iVar1 = *(int *)(*(long *)pPVar3 + (long)iVar11 * 4);
if (*param_2 == (PatchInfo)0x1) {
if (((byte)this[0x28] & 2) == 0) {
uVar4 = PatchBuilder::GetRegularPatchPoints
(*(PatchBuilder **)(this + 0x38),iVar11,*(int *)param_1,
*(int *)(param_2 + 4),param_3,iVar12);
if ((int)uVar4 < 1) {
return uVar4;
}
uVar8 = 0;
do {
param_3[uVar8] = param_3[uVar8] + iVar1;
uVar8 = uVar8 + 1;
} while ((uVar4 & 0xffffffff) != uVar8);
return uVar4;
}
}
else if (((byte)this[0x28] & 4) != 0) {
uVar10 = 1 << sVar7 & *(uint *)(this + 8);
pPVar9 = param_2 + 0x34;
if (uVar10 != 0) {
pPVar9 = param_2 + 0x8c;
}
pPVar5 = param_2 + 0x88;
if (uVar10 == 0) {
pPVar5 = param_2 + 0x30;
}
uVar2 = *(uint *)pPVar5;
piVar6 = local_138;
local_38 = (int *)0x0;
if (0x40 < *(uint *)pPVar9) {
piVar6 = (int *)operator_new((ulong)*(uint *)pPVar9 << 2);
iVar11 = *(int *)(param_1 + 4);
local_38 = piVar6;
}
/* try { // try from 0016d765 to 0016d7b3 has its CatchHandler @ 0016d7d7 */
PatchBuilder::GetIrregularPatchSourcePoints
(*(PatchBuilder **)(this + 0x38),iVar11,*(int *)param_1,(VSpan *)(param_2 + 0xc),
piVar6,iVar12);
if (uVar10 == 0) {
LocalPointHelper::AppendLocalPatchPoints<float>
(param_4,*(int4 *)(param_1 + 4),*(int4 *)param_1,param_2 + 0x30,
*(int4 *)(*(long *)(this + 0x38) + 0x2c),piVar6,iVar1,param_3);
}
else {
LocalPointHelper::AppendLocalPatchPoints<double>
(param_4,*(int4 *)(param_1 + 4),*(int4 *)param_1,param_2 + 0x88,
*(int4 *)(*(long *)(this + 0x38) + 0x2c),piVar6,iVar1,param_3);
}
operator_delete(local_38);
return (ulong)uVar2;
}
return 0;
}
| |
44,888 | server_queue::start_loop() | monkey531[P]llama/examples/server/server.cpp | void start_loop() {
running = true;
while (true) {
QUE_DBG("%s", "processing new tasks\n");
while (true) {
std::unique_lock<std::mutex> lock(mutex_tasks);
if (queue_tasks.empty()) {
lock.unlock();
break;
}
server_task task = queue_tasks.front();
queue_tasks.pop_front();
lock.unlock();
QUE_DBG("processing task, id = %d\n", task.id);
callback_new_task(std::move(task));
}
// all tasks in the current loop is processed, slots data is now ready
QUE_DBG("%s", "update slots\n");
callback_update_slots();
QUE_DBG("%s", "waiting for new tasks\n");
{
std::unique_lock<std::mutex> lock(mutex_tasks);
if (queue_tasks.empty()) {
if (!running) {
QUE_DBG("%s", "terminate\n");
return;
}
condition_tasks.wait(lock, [&]{
return (!queue_tasks.empty() || !running);
});
}
}
}
} | O3 | cpp | server_queue::start_loop():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf38, %rsp # imm = 0xF38
movq %rdi, %rbx
movb $0x1, 0x4(%rdi)
leaq 0xa8(%rdi), %rax
movq %rax, (%rsp)
leaq 0x8(%rdi), %rax
movq %rax, 0x48(%rsp)
leaq 0x100(%rdi), %rax
movq %rax, 0x40(%rsp)
movl $0x720, %edx # imm = 0x720
leaq 0x7c0(%rsp), %rax
leaq (%rax,%rdx), %r12
leaq 0x50(%rsp), %rcx
addq %rcx, %rdx
movq %rdx, 0x20(%rsp)
movl $0x740, %edx # imm = 0x740
leaq (%rax,%rdx), %r13
addq %rcx, %rdx
movq %rdx, 0x18(%rsp)
movl $0x758, %ebp # imm = 0x758
addq %rbp, %rax
movq %rax, 0x38(%rsp)
addq %rcx, %rbp
leaq 0x120(%rdi), %rax
movq %rax, 0x28(%rsp)
leaq 0xd0(%rdi), %rax
movq %rax, 0x30(%rsp)
leaq 0x8(%rsp), %r15
leaq 0x28ea51(%rip), %rax # 0x2cff48
cmpl $0x0, (%rax)
jle 0x4181c
callq 0x13f3e3
movq %rax, %rdi
movl $0x1, %esi
leaq 0x10596e(%rip), %rdx # 0x146e82
movl $0xc, %ecx
leaq 0x105972(%rip), %r8 # 0x146e92
leaq 0x105976(%rip), %r9 # 0x146e9d
xorl %eax, %eax
callq 0x13f480
jmp 0x4181c
leaq 0x50(%rsp), %rdi
callq 0x5f0ac
movq 0x48(%rsp), %rdi
callq 0x58998
movq %r15, %rdi
callq 0x45554
leaq 0x28e9f2(%rip), %rax # 0x2cff48
cmpl $0x0, (%rax)
jle 0x41587
callq 0x13f3e3
movl 0x50(%rsp), %r9d
movq %rax, %rdi
movl $0x1, %esi
leaq 0x10593f(%rip), %rdx # 0x146eb3
movl $0xc, %ecx
leaq 0x105912(%rip), %r8 # 0x146e92
xorl %eax, %eax
callq 0x13f480
movq %rbp, %r14
movq %r13, %rbp
movups 0x50(%rsp), %xmm0
movaps %xmm0, 0x7c0(%rsp)
leaq 0x7d0(%rsp), %rdi
movq %r12, %r13
leaq 0x60(%rsp), %r12
movq %r12, %rsi
callq 0x58c10
movups 0x738(%rsp), %xmm0
movups %xmm0, 0xea8(%rsp)
movq 0x748(%rsp), %rax
movq %rax, 0xeb8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x6d8(%r12)
movq $0x0, 0x6e8(%r12)
movq %r13, %r12
movl 0x750(%rsp), %eax
movl 0x758(%rsp), %ecx
movl %eax, 0xec0(%rsp)
movl %ecx, 0xec8(%rsp)
movq %r13, 0xed0(%rsp)
movq 0x760(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq %rcx, %rax
je 0x4163d
movq %rax, 0xed0(%rsp)
movq 0x770(%rsp), %rax
movq %rax, 0xee0(%rsp)
jmp 0x41645
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq %rcx, %rdx
movq %rbp, %r13
movq 0x768(%rsp), %rcx
movq 0x780(%rsp), %rax
movq %rcx, 0xed8(%rsp)
movq %rdx, 0x760(%rsp)
movq $0x0, 0x768(%rsp)
movb $0x0, 0x770(%rsp)
movq %rbp, 0xef0(%rsp)
movq 0x18(%rsp), %rcx
cmpq %rcx, %rax
movq %r14, %rbp
je 0x416ae
movq %rax, 0xef0(%rsp)
movq 0x790(%rsp), %rax
movq %rax, 0xf00(%rsp)
jmp 0x416b6
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x788(%rsp), %rax
movq %rax, 0xef8(%rsp)
movq %rcx, 0x780(%rsp)
xorl %ecx, %ecx
movq %rcx, 0x788(%rsp)
movb $0x0, 0x790(%rsp)
movb 0x7a0(%rsp), %al
movb %al, 0xf10(%rsp)
movups 0x7a8(%rsp), %xmm0
movups %xmm0, 0xf18(%rsp)
movq 0x7b8(%rsp), %rax
movq %rax, 0xf28(%rsp)
movq %rcx, 0x10(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%rbp)
cmpq %rcx, 0x110(%rbx)
je 0x41993
movq 0x40(%rsp), %rdi
leaq 0x7c0(%rsp), %rsi
callq *0x118(%rbx)
movq 0x38(%rsp), %rdi
callq 0x432be
movq 0xef0(%rsp), %rdi
cmpq %r13, %rdi
je 0x41760
movq 0xf00(%rsp), %rsi
incq %rsi
callq 0x1fae0
movq 0xed0(%rsp), %rdi
cmpq %r12, %rdi
je 0x4177d
movq 0xee0(%rsp), %rsi
incq %rsi
callq 0x1fae0
movq 0xea8(%rsp), %rdi
testq %rdi, %rdi
je 0x4179a
movq 0xeb8(%rsp), %rsi
subq %rdi, %rsi
callq 0x1fae0
leaq 0x7d0(%rsp), %rdi
callq 0x4409a
movq %rbp, %rdi
callq 0x432be
movq 0x780(%rsp), %rdi
cmpq 0x18(%rsp), %rdi
je 0x417ce
movq 0x790(%rsp), %rsi
incq %rsi
callq 0x1fae0
movq 0x760(%rsp), %rdi
cmpq 0x20(%rsp), %rdi
je 0x417ed
movq 0x770(%rsp), %rsi
incq %rsi
callq 0x1fae0
movq 0x738(%rsp), %rdi
testq %rdi, %rdi
je 0x4180a
movq 0x748(%rsp), %rsi
subq %rdi, %rsi
callq 0x1fae0
leaq 0x60(%rsp), %rdi
callq 0x4409a
movq %r15, %rdi
callq 0x45466
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movq %r15, %rdi
callq 0x4547c
movb $0x1, 0x10(%rsp)
movq 0x18(%rbx), %rsi
cmpq %rsi, 0x38(%rbx)
jne 0x41533
movq %r15, %rdi
callq 0x45554
movq %r15, %rdi
callq 0x45466
leaq 0x28e6ec(%rip), %rax # 0x2cff48
cmpl $0x0, (%rax)
jle 0x4188f
callq 0x13f3e3
movq %rax, %rdi
movl $0x1, %esi
leaq 0x10560d(%rip), %rdx # 0x146e82
movl $0xc, %ecx
leaq 0x105611(%rip), %r8 # 0x146e92
leaq 0x105652(%rip), %r9 # 0x146eda
xorl %eax, %eax
callq 0x13f480
cmpq $0x0, 0x130(%rbx)
je 0x41998
movq 0x28(%rsp), %rdi
callq *0x138(%rbx)
leaq 0x28e699(%rip), %rax # 0x2cff48
cmpl $0x0, (%rax)
jle 0x418e2
callq 0x13f3e3
movq %rax, %rdi
movl $0x1, %esi
leaq 0x1055ba(%rip), %rdx # 0x146e82
movl $0xc, %ecx
leaq 0x1055be(%rip), %r8 # 0x146e92
leaq 0x10560d(%rip), %r9 # 0x146ee8
xorl %eax, %eax
callq 0x13f480
movq (%rsp), %rax
movq %rax, 0x50(%rsp)
movb $0x0, 0x58(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x4547c
movb $0x1, 0x58(%rsp)
movq 0x38(%rbx), %rax
cmpq 0x18(%rbx), %rax
jne 0x4192e
cmpb $0x1, 0x4(%rbx)
jne 0x4193d
cmpb $0x1, 0x4(%rbx)
jne 0x4192e
movq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x1f2d0
movq 0x38(%rbx), %rax
cmpq 0x18(%rbx), %rax
je 0x4190f
leaq 0x50(%rsp), %rdi
callq 0x45466
jmp 0x414f0
leaq 0x28e604(%rip), %rax # 0x2cff48
cmpl $0x0, (%rax)
jle 0x41977
callq 0x13f3e3
leaq 0x10552d(%rip), %rdx # 0x146e82
leaq 0x105536(%rip), %r8 # 0x146e92
leaq 0x10559c(%rip), %r9 # 0x146eff
movq %rax, %rdi
movl $0x1, %esi
movl $0xc, %ecx
xorl %eax, %eax
callq 0x13f480
leaq 0x50(%rsp), %rdi
callq 0x45466
addq $0xf38, %rsp # imm = 0xF38
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1f3e0
callq 0x1f3e0
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0x419d4
jmp 0x419bd
jmp 0x419ab
movq %rax, %rbx
leaq 0x7c0(%rsp), %rdi
callq 0x43fee
jmp 0x419c5
movq %rax, %rbx
jmp 0x419cf
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x43fee
leaq 0x8(%rsp), %rdi
callq 0x45466
movq %rbx, %rdi
callq 0x20380
| _ZN12server_queue10start_loopEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0F38h
mov rbx, rdi
mov byte ptr [rdi+4], 1
lea rax, [rdi+0A8h]
mov [rsp+0F68h+var_F68], rax
lea rax, [rdi+8]
mov [rsp+0F68h+var_F20], rax
lea rax, [rdi+100h]
mov [rsp+0F68h+var_F28], rax
mov edx, 720h
lea rax, [rsp+0F68h+var_7A8]
lea r12, [rax+rdx]
lea rcx, [rsp+0F68h+var_F18]
add rdx, rcx
mov [rsp+0F68h+var_F48], rdx
mov edx, 740h
lea r13, [rax+rdx]
add rdx, rcx
mov [rsp+0F68h+var_F50], rdx
mov ebp, 758h
add rax, rbp
mov [rsp+0F68h+var_F30], rax
add rbp, rcx
lea rax, [rdi+120h]
mov [rsp+0F68h+var_F40], rax
lea rax, [rdi+0D0h]
mov [rsp+0F68h+var_F38], rax
lea r15, [rsp+0F68h+var_F60]
loc_414F0:
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
jle loc_4181C
call _Z15common_log_mainv; common_log_main(void)
mov rdi, rax
mov esi, 1
lea rdx, aQue12SS; "que %12.*s: %s"
mov ecx, 0Ch
lea r8, aStartLoop; "start_loop"
lea r9, aProcessingNewT; "processing new tasks\n"
xor eax, eax
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
jmp loc_4181C
loc_41533:
lea rdi, [rsp+0F68h+var_F18]; this
call _ZN11server_taskC2ERKS_; server_task::server_task(server_task const&)
mov rdi, [rsp+0F68h+var_F20]
call _ZNSt5dequeI11server_taskSaIS0_EE9pop_frontEv; std::deque<server_task>::pop_front(void)
mov rdi, r15
call _ZNSt11unique_lockISt5mutexE6unlockEv; std::unique_lock<std::mutex>::unlock(void)
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
jle short loc_41587
call _Z15common_log_mainv; common_log_main(void)
mov r9d, dword ptr [rsp+0F68h+var_F18]
mov rdi, rax
mov esi, 1
lea rdx, aQue12SProcessi; "que %12.*s: processing task, id = %d\n"
mov ecx, 0Ch
lea r8, aStartLoop; "start_loop"
xor eax, eax
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
loc_41587:
mov r14, rbp
mov rbp, r13
movups xmm0, [rsp+0F68h+var_F18]
movaps [rsp+0F68h+var_7A8], xmm0
lea rdi, [rsp+0F68h+var_798]
mov r13, r12
lea r12, [rsp+0F68h+var_F08]
mov rsi, r12
call _ZN11slot_paramsC2EOS_; slot_params::slot_params(slot_params&&)
movups xmm0, xmmword ptr [rsp+0F68h+var_830]
movups xmmword ptr [rsp+0F68h+var_C0], xmm0
mov rax, [rsp+0F68h+var_820]
mov [rsp+0F68h+var_B0], rax
xorps xmm0, xmm0
movups xmmword ptr [r12+6D8h], xmm0
mov qword ptr [r12+6E8h], 0
mov r12, r13
mov eax, [rsp+0F68h+var_818]
mov ecx, [rsp+0F68h+var_810]
mov [rsp+0F68h+var_A8], eax
mov [rsp+0F68h+var_A0], ecx
mov [rsp+0F68h+var_98], r13
mov rax, [rsp+0F68h+var_808]
mov rcx, [rsp+0F68h+var_F48]
cmp rax, rcx
jz short loc_4163D
mov [rsp+0F68h+var_98], rax
mov rax, [rsp+0F68h+var_7F8]
mov [rsp+0F68h+var_88], rax
jmp short loc_41645
loc_4163D:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r12], xmm0
loc_41645:
mov rdx, rcx
mov r13, rbp
mov rcx, [rsp+0F68h+var_800]
mov rax, [rsp+0F68h+var_7E8]
mov [rsp+0F68h+var_90], rcx
mov [rsp+0F68h+var_808], rdx
mov [rsp+0F68h+var_800], 0
mov byte ptr [rsp+0F68h+var_7F8], 0
mov [rsp+0F68h+var_78], rbp
mov rcx, [rsp+0F68h+var_F50]
cmp rax, rcx
mov rbp, r14
jz short loc_416AE
mov [rsp+0F68h+var_78], rax
mov rax, [rsp+0F68h+var_7D8]
mov [rsp+0F68h+var_68], rax
jmp short loc_416B6
loc_416AE:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r13+0], xmm0
loc_416B6:
mov rax, [rsp+0F68h+var_7E0]
mov [rsp+0F68h+var_70], rax
mov [rsp+0F68h+var_7E8], rcx
xor ecx, ecx
mov [rsp+0F68h+var_7E0], rcx
mov byte ptr [rsp+0F68h+var_7D8], 0
mov al, [rsp+0F68h+var_7C8]
mov [rsp+0F68h+var_58], al
movups xmm0, [rsp+0F68h+var_7C0]
movups [rsp+0F68h+var_50], xmm0
mov rax, [rsp+0F68h+var_7B0]
mov [rsp+0F68h+var_40], rax
mov [rbp+10h], rcx
xorps xmm0, xmm0
movups xmmword ptr [rbp+0], xmm0
cmp [rbx+110h], rcx
jz loc_41993
mov rdi, [rsp+0F68h+var_F28]
lea rsi, [rsp+0F68h+var_7A8]
call qword ptr [rbx+118h]
mov rdi, [rsp+0F68h+var_F30]
call _ZNSt6vectorI24common_adapter_lora_infoSaIS0_EED2Ev; std::vector<common_adapter_lora_info>::~vector()
mov rdi, [rsp+0F68h+var_78]; void *
cmp rdi, r13
jz short loc_41760
mov rsi, [rsp+0F68h+var_68]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_41760:
mov rdi, [rsp+0F68h+var_98]; void *
cmp rdi, r12
jz short loc_4177D
mov rsi, [rsp+0F68h+var_88]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_4177D:
mov rdi, [rsp+0F68h+var_C0]; void *
test rdi, rdi
jz short loc_4179A
mov rsi, [rsp+0F68h+var_B0]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_4179A:
lea rdi, [rsp+0F68h+var_798]; this
call _ZN11slot_paramsD2Ev; slot_params::~slot_params()
mov rdi, rbp
call _ZNSt6vectorI24common_adapter_lora_infoSaIS0_EED2Ev; std::vector<common_adapter_lora_info>::~vector()
mov rdi, [rsp+0F68h+var_7E8]; void *
cmp rdi, [rsp+0F68h+var_F50]
jz short loc_417CE
mov rsi, [rsp+0F68h+var_7D8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_417CE:
mov rdi, [rsp+0F68h+var_808]; void *
cmp rdi, [rsp+0F68h+var_F48]
jz short loc_417ED
mov rsi, [rsp+0F68h+var_7F8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_417ED:
mov rdi, [rsp+0F68h+var_830]; void *
test rdi, rdi
jz short loc_4180A
mov rsi, [rsp+0F68h+var_820]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_4180A:
lea rdi, [rsp+0F68h+var_F08]; this
call _ZN11slot_paramsD2Ev; slot_params::~slot_params()
mov rdi, r15
call _ZNSt11unique_lockISt5mutexED2Ev; std::unique_lock<std::mutex>::~unique_lock()
loc_4181C:
mov rax, [rsp+0F68h+var_F68]
mov [rsp+0F68h+var_F60], rax
mov [rsp+0F68h+var_F58], 0
mov rdi, r15
call _ZNSt11unique_lockISt5mutexE4lockEv; std::unique_lock<std::mutex>::lock(void)
mov [rsp+0F68h+var_F58], 1
mov rsi, [rbx+18h]; server_task *
cmp [rbx+38h], rsi
jnz loc_41533
mov rdi, r15
call _ZNSt11unique_lockISt5mutexE6unlockEv; std::unique_lock<std::mutex>::unlock(void)
mov rdi, r15
call _ZNSt11unique_lockISt5mutexED2Ev; std::unique_lock<std::mutex>::~unique_lock()
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
jle short loc_4188F
call _Z15common_log_mainv; common_log_main(void)
mov rdi, rax
mov esi, 1
lea rdx, aQue12SS; "que %12.*s: %s"
mov ecx, 0Ch
lea r8, aStartLoop; "start_loop"
lea r9, aUpdateSlots; "update slots\n"
xor eax, eax
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
loc_4188F:
cmp qword ptr [rbx+130h], 0
jz loc_41998
mov rdi, [rsp+0F68h+var_F40]
call qword ptr [rbx+138h]
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
jle short loc_418E2
call _Z15common_log_mainv; common_log_main(void)
mov rdi, rax
mov esi, 1
lea rdx, aQue12SS; "que %12.*s: %s"
mov ecx, 0Ch
lea r8, aStartLoop; "start_loop"
lea r9, aWaitingForNewT; "waiting for new tasks\n"
xor eax, eax
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
loc_418E2:
mov rax, [rsp+0F68h+var_F68]
mov qword ptr [rsp+0F68h+var_F18], rax
mov byte ptr [rsp+0F68h+var_F18+8], 0
lea rdi, [rsp+0F68h+var_F18]
call _ZNSt11unique_lockISt5mutexE4lockEv; std::unique_lock<std::mutex>::lock(void)
mov byte ptr [rsp+0F68h+var_F18+8], 1
mov rax, [rbx+38h]
cmp rax, [rbx+18h]
jnz short loc_4192E
cmp byte ptr [rbx+4], 1
jnz short loc_4193D
loc_4190F:
cmp byte ptr [rbx+4], 1
jnz short loc_4192E
mov rdi, [rsp+0F68h+var_F38]
lea rsi, [rsp+0F68h+var_F18]
call __ZNSt18condition_variable4waitERSt11unique_lockISt5mutexE; std::condition_variable::wait(std::unique_lock<std::mutex> &)
mov rax, [rbx+38h]
cmp rax, [rbx+18h]
jz short loc_4190F
loc_4192E:
lea rdi, [rsp+0F68h+var_F18]
call _ZNSt11unique_lockISt5mutexED2Ev; std::unique_lock<std::mutex>::~unique_lock()
jmp loc_414F0
loc_4193D:
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
jle short loc_41977
call _Z15common_log_mainv; common_log_main(void)
lea rdx, aQue12SS; "que %12.*s: %s"
lea r8, aStartLoop; "start_loop"
lea r9, aTerminate; "terminate\n"
mov rdi, rax
mov esi, 1
mov ecx, 0Ch
xor eax, eax
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
loc_41977:
lea rdi, [rsp+0F68h+var_F18]
call _ZNSt11unique_lockISt5mutexED2Ev; std::unique_lock<std::mutex>::~unique_lock()
add rsp, 0F38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_41993:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
loc_41998:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
mov rbx, rax
lea rdi, [rsp+0F68h+var_F18]
jmp short loc_419D4
jmp short loc_419BD
jmp short $+2
loc_419AB:
mov rbx, rax
lea rdi, [rsp+0F68h+var_7A8]; this
call _ZN11server_taskD2Ev; server_task::~server_task()
jmp short loc_419C5
loc_419BD:
mov rbx, rax
jmp short loc_419CF
mov rbx, rax
loc_419C5:
lea rdi, [rsp+0F68h+var_F18]; this
call _ZN11server_taskD2Ev; server_task::~server_task()
loc_419CF:
lea rdi, [rsp+0F68h+var_F60]
loc_419D4:
call _ZNSt11unique_lockISt5mutexED2Ev; std::unique_lock<std::mutex>::~unique_lock()
mov rdi, rbx
call __Unwind_Resume
| long long server_queue::start_loop(server_queue *this)
{
int v1; // eax
int v2; // eax
const server_task *v3; // rsi
int v4; // eax
int v5; // eax
int v6; // eax
char *v8; // [rsp+8h] [rbp-F60h] BYREF
char v9; // [rsp+10h] [rbp-F58h]
__int128 *v10; // [rsp+18h] [rbp-F50h]
__int128 *v11; // [rsp+20h] [rbp-F48h]
char *v12; // [rsp+28h] [rbp-F40h]
char *v13; // [rsp+30h] [rbp-F38h]
__int128 *v14; // [rsp+38h] [rbp-F30h]
char *v15; // [rsp+40h] [rbp-F28h]
char *v16; // [rsp+48h] [rbp-F20h]
__int128 v17; // [rsp+50h] [rbp-F18h] BYREF
_BYTE v18[1752]; // [rsp+60h] [rbp-F08h] BYREF
void *v19[2]; // [rsp+738h] [rbp-830h]
long long v20; // [rsp+748h] [rbp-820h]
int v21; // [rsp+750h] [rbp-818h]
int v22; // [rsp+758h] [rbp-810h]
void *v23; // [rsp+760h] [rbp-808h]
long long v24; // [rsp+768h] [rbp-800h]
long long v25; // [rsp+770h] [rbp-7F8h] BYREF
void *v26; // [rsp+780h] [rbp-7E8h]
long long v27; // [rsp+788h] [rbp-7E0h]
long long v28; // [rsp+790h] [rbp-7D8h] BYREF
char v29; // [rsp+7A0h] [rbp-7C8h]
__int128 v30; // [rsp+7A8h] [rbp-7C0h] BYREF
long long v31; // [rsp+7B8h] [rbp-7B0h]
__int128 v32; // [rsp+7C0h] [rbp-7A8h] BYREF
_BYTE v33[1752]; // [rsp+7D0h] [rbp-798h] BYREF
void *v34[2]; // [rsp+EA8h] [rbp-C0h]
long long v35; // [rsp+EB8h] [rbp-B0h]
int v36; // [rsp+EC0h] [rbp-A8h]
int v37; // [rsp+EC8h] [rbp-A0h]
void *v38; // [rsp+ED0h] [rbp-98h]
long long v39; // [rsp+ED8h] [rbp-90h]
__int128 v40; // [rsp+EE0h] [rbp-88h] BYREF
void *v41; // [rsp+EF0h] [rbp-78h]
long long v42; // [rsp+EF8h] [rbp-70h]
__int128 v43; // [rsp+F00h] [rbp-68h] BYREF
char v44; // [rsp+F10h] [rbp-58h]
__int128 v45; // [rsp+F18h] [rbp-50h] BYREF
long long v46; // [rsp+F28h] [rbp-40h]
*((_BYTE *)this + 4) = 1;
v16 = (char *)this + 8;
v15 = (char *)this + 256;
v11 = (__int128 *)&v25;
v10 = (__int128 *)&v28;
v14 = &v45;
v12 = (char *)this + 288;
v13 = (char *)this + 208;
while ( 1 )
{
if ( common_log_verbosity_thold > 0 )
{
v1 = common_log_main();
common_log_add(
v1,
1,
(unsigned int)"que %12.*s: %s",
12,
(unsigned int)"start_loop",
(unsigned int)"processing new tasks\n");
}
while ( 1 )
{
v8 = (char *)this + 168;
v9 = 0;
std::unique_lock<std::mutex>::lock(&v8);
v9 = 1;
v3 = (const server_task *)*((_QWORD *)this + 3);
if ( *((const server_task **)this + 7) == v3 )
break;
server_task::server_task((server_task *)&v17, v3);
std::deque<server_task>::pop_front(v16);
std::unique_lock<std::mutex>::unlock(&v8);
if ( common_log_verbosity_thold > 0 )
{
v2 = common_log_main();
common_log_add(
v2,
1,
(unsigned int)"que %12.*s: processing task, id = %d\n",
12,
(unsigned int)"start_loop",
v17);
}
v32 = v17;
slot_params::slot_params(v33, v18);
*(_OWORD *)v34 = *(_OWORD *)v19;
v35 = v20;
*(_OWORD *)v19 = 0LL;
v20 = 0LL;
v36 = v21;
v37 = v22;
v38 = &v40;
if ( v23 == v11 )
{
v40 = *v11;
}
else
{
v38 = v23;
*(_QWORD *)&v40 = v25;
}
v39 = v24;
v23 = v11;
v24 = 0LL;
LOBYTE(v25) = 0;
v41 = &v43;
if ( v26 == v10 )
{
v43 = *v10;
}
else
{
v41 = v26;
*(_QWORD *)&v43 = v28;
}
v42 = v27;
v26 = v10;
v27 = 0LL;
LOBYTE(v28) = 0;
v44 = v29;
v45 = v30;
v46 = v31;
v31 = 0LL;
v30 = 0LL;
if ( !*((_QWORD *)this + 34) )
std::__throw_bad_function_call();
(*((void ( **)(char *, __int128 *))this + 35))(v15, &v32);
std::vector<common_adapter_lora_info>::~vector(v14);
if ( v41 != &v43 )
operator delete(v41, v43 + 1);
if ( v38 != &v40 )
operator delete(v38, v40 + 1);
if ( v34[0] )
operator delete(v34[0], v35 - (unsigned long long)v34[0]);
slot_params::~slot_params((slot_params *)v33);
std::vector<common_adapter_lora_info>::~vector(&v30);
if ( v26 != v10 )
operator delete(v26, v28 + 1);
if ( v23 != v11 )
operator delete(v23, v25 + 1);
if ( v19[0] )
operator delete(v19[0], v20 - (unsigned long long)v19[0]);
slot_params::~slot_params((slot_params *)v18);
std::unique_lock<std::mutex>::~unique_lock(&v8);
}
std::unique_lock<std::mutex>::unlock(&v8);
std::unique_lock<std::mutex>::~unique_lock(&v8);
if ( common_log_verbosity_thold > 0 )
{
v4 = common_log_main();
common_log_add(
v4,
1,
(unsigned int)"que %12.*s: %s",
12,
(unsigned int)"start_loop",
(unsigned int)"update slots\n");
}
if ( !*((_QWORD *)this + 38) )
std::__throw_bad_function_call();
(*((void ( **)(char *))this + 39))(v12);
if ( common_log_verbosity_thold > 0 )
{
v5 = common_log_main();
common_log_add(
v5,
1,
(unsigned int)"que %12.*s: %s",
12,
(unsigned int)"start_loop",
(unsigned int)"waiting for new tasks\n");
}
*(_QWORD *)&v17 = (char *)this + 168;
BYTE8(v17) = 0;
std::unique_lock<std::mutex>::lock(&v17);
BYTE8(v17) = 1;
if ( *((_QWORD *)this + 7) == *((_QWORD *)this + 3) )
break;
LABEL_36:
std::unique_lock<std::mutex>::~unique_lock(&v17);
}
if ( *((_BYTE *)this + 4) == 1 )
{
do
{
if ( *((_BYTE *)this + 4) != 1 )
break;
std::condition_variable::wait(v13, &v17);
}
while ( *((_QWORD *)this + 7) == *((_QWORD *)this + 3) );
goto LABEL_36;
}
if ( common_log_verbosity_thold > 0 )
{
v6 = common_log_main();
common_log_add(v6, 1, (unsigned int)"que %12.*s: %s", 12, (unsigned int)"start_loop", (unsigned int)"terminate\n");
}
return std::unique_lock<std::mutex>::~unique_lock(&v17);
}
| start_loop:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xf38
MOV RBX,RDI
MOV byte ptr [RDI + 0x4],0x1
LEA RAX,[RDI + 0xa8]
MOV qword ptr [RSP],RAX
LEA RAX,[RDI + 0x8]
MOV qword ptr [RSP + 0x48],RAX
LEA RAX,[RDI + 0x100]
MOV qword ptr [RSP + 0x40],RAX
MOV EDX,0x720
LEA RAX,[RSP + 0x7c0]
LEA R12,[RAX + RDX*0x1]
LEA RCX,[RSP + 0x50]
ADD RDX,RCX
MOV qword ptr [RSP + 0x20],RDX
MOV EDX,0x740
LEA R13,[RAX + RDX*0x1]
ADD RDX,RCX
MOV qword ptr [RSP + 0x18],RDX
MOV EBP,0x758
ADD RAX,RBP
MOV qword ptr [RSP + 0x38],RAX
ADD RBP,RCX
LEA RAX,[RDI + 0x120]
MOV qword ptr [RSP + 0x28],RAX
LEA RAX,[RDI + 0xd0]
MOV qword ptr [RSP + 0x30],RAX
LEA R15,[RSP + 0x8]
LAB_001414f0:
LEA RAX,[0x3cff48]
CMP dword ptr [RAX],0x0
JLE 0x0014181c
CALL 0x0023f3e3
MOV RDI,RAX
MOV ESI,0x1
LEA RDX,[0x246e82]
MOV ECX,0xc
LEA R8,[0x246e92]
LEA R9,[0x246e9d]
XOR EAX,EAX
CALL 0x0023f480
JMP 0x0014181c
LAB_00141533:
LEA RDI,[RSP + 0x50]
CALL 0x0015f0ac
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x00158998
LAB_00141547:
MOV RDI,R15
CALL 0x00145554
LEA RAX,[0x3cff48]
CMP dword ptr [RAX],0x0
JLE 0x00141587
CALL 0x0023f3e3
MOV R9D,dword ptr [RSP + 0x50]
MOV RDI,RAX
MOV ESI,0x1
LEA RDX,[0x246eb3]
MOV ECX,0xc
LEA R8,[0x246e92]
XOR EAX,EAX
CALL 0x0023f480
LAB_00141587:
MOV R14,RBP
MOV RBP,R13
MOVUPS XMM0,xmmword ptr [RSP + 0x50]
MOVAPS xmmword ptr [RSP + 0x7c0],XMM0
LEA RDI,[RSP + 0x7d0]
MOV R13,R12
LEA R12,[RSP + 0x60]
MOV RSI,R12
CALL 0x00158c10
MOVUPS XMM0,xmmword ptr [RSP + 0x738]
MOVUPS xmmword ptr [RSP + 0xea8],XMM0
MOV RAX,qword ptr [RSP + 0x748]
MOV qword ptr [RSP + 0xeb8],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R12 + 0x6d8],XMM0
MOV qword ptr [R12 + 0x6e8],0x0
MOV R12,R13
MOV EAX,dword ptr [RSP + 0x750]
MOV ECX,dword ptr [RSP + 0x758]
MOV dword ptr [RSP + 0xec0],EAX
MOV dword ptr [RSP + 0xec8],ECX
MOV qword ptr [RSP + 0xed0],R13
MOV RAX,qword ptr [RSP + 0x760]
MOV RCX,qword ptr [RSP + 0x20]
CMP RAX,RCX
JZ 0x0014163d
MOV qword ptr [RSP + 0xed0],RAX
MOV RAX,qword ptr [RSP + 0x770]
MOV qword ptr [RSP + 0xee0],RAX
JMP 0x00141645
LAB_0014163d:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R12],XMM0
LAB_00141645:
MOV RDX,RCX
MOV R13,RBP
MOV RCX,qword ptr [RSP + 0x768]
MOV RAX,qword ptr [RSP + 0x780]
MOV qword ptr [RSP + 0xed8],RCX
MOV qword ptr [RSP + 0x760],RDX
MOV qword ptr [RSP + 0x768],0x0
MOV byte ptr [RSP + 0x770],0x0
MOV qword ptr [RSP + 0xef0],RBP
MOV RCX,qword ptr [RSP + 0x18]
CMP RAX,RCX
MOV RBP,R14
JZ 0x001416ae
MOV qword ptr [RSP + 0xef0],RAX
MOV RAX,qword ptr [RSP + 0x790]
MOV qword ptr [RSP + 0xf00],RAX
JMP 0x001416b6
LAB_001416ae:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R13],XMM0
LAB_001416b6:
MOV RAX,qword ptr [RSP + 0x788]
MOV qword ptr [RSP + 0xef8],RAX
MOV qword ptr [RSP + 0x780],RCX
XOR ECX,ECX
MOV qword ptr [RSP + 0x788],RCX
MOV byte ptr [RSP + 0x790],0x0
MOV AL,byte ptr [RSP + 0x7a0]
MOV byte ptr [RSP + 0xf10],AL
MOVUPS XMM0,xmmword ptr [RSP + 0x7a8]
MOVUPS xmmword ptr [RSP + 0xf18],XMM0
MOV RAX,qword ptr [RSP + 0x7b8]
MOV qword ptr [RSP + 0xf28],RAX
MOV qword ptr [RBP + 0x10],RCX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBP],XMM0
CMP qword ptr [RBX + 0x110],RCX
JZ 0x00141993
LAB_00141726:
MOV RDI,qword ptr [RSP + 0x40]
LEA RSI,[RSP + 0x7c0]
CALL qword ptr [RBX + 0x118]
LAB_00141739:
MOV RDI,qword ptr [RSP + 0x38]
CALL 0x001432be
MOV RDI,qword ptr [RSP + 0xef0]
CMP RDI,R13
JZ 0x00141760
MOV RSI,qword ptr [RSP + 0xf00]
INC RSI
CALL 0x0011fae0
LAB_00141760:
MOV RDI,qword ptr [RSP + 0xed0]
CMP RDI,R12
JZ 0x0014177d
MOV RSI,qword ptr [RSP + 0xee0]
INC RSI
CALL 0x0011fae0
LAB_0014177d:
MOV RDI,qword ptr [RSP + 0xea8]
TEST RDI,RDI
JZ 0x0014179a
MOV RSI,qword ptr [RSP + 0xeb8]
SUB RSI,RDI
CALL 0x0011fae0
LAB_0014179a:
LEA RDI,[RSP + 0x7d0]
CALL 0x0014409a
MOV RDI,RBP
CALL 0x001432be
MOV RDI,qword ptr [RSP + 0x780]
CMP RDI,qword ptr [RSP + 0x18]
JZ 0x001417ce
MOV RSI,qword ptr [RSP + 0x790]
INC RSI
CALL 0x0011fae0
LAB_001417ce:
MOV RDI,qword ptr [RSP + 0x760]
CMP RDI,qword ptr [RSP + 0x20]
JZ 0x001417ed
MOV RSI,qword ptr [RSP + 0x770]
INC RSI
CALL 0x0011fae0
LAB_001417ed:
MOV RDI,qword ptr [RSP + 0x738]
TEST RDI,RDI
JZ 0x0014180a
MOV RSI,qword ptr [RSP + 0x748]
SUB RSI,RDI
CALL 0x0011fae0
LAB_0014180a:
LEA RDI,[RSP + 0x60]
CALL 0x0014409a
MOV RDI,R15
CALL 0x00145466
LAB_0014181c:
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x8],RAX
MOV byte ptr [RSP + 0x10],0x0
MOV RDI,R15
CALL 0x0014547c
MOV byte ptr [RSP + 0x10],0x1
MOV RSI,qword ptr [RBX + 0x18]
CMP qword ptr [RBX + 0x38],RSI
JNZ 0x00141533
LAB_00141845:
MOV RDI,R15
CALL 0x00145554
LAB_0014184d:
MOV RDI,R15
CALL 0x00145466
LEA RAX,[0x3cff48]
CMP dword ptr [RAX],0x0
JLE 0x0014188f
CALL 0x0023f3e3
MOV RDI,RAX
MOV ESI,0x1
LEA RDX,[0x246e82]
MOV ECX,0xc
LEA R8,[0x246e92]
LEA R9,[0x246eda]
XOR EAX,EAX
CALL 0x0023f480
LAB_0014188f:
CMP qword ptr [RBX + 0x130],0x0
JZ 0x00141998
MOV RDI,qword ptr [RSP + 0x28]
CALL qword ptr [RBX + 0x138]
LEA RAX,[0x3cff48]
CMP dword ptr [RAX],0x0
JLE 0x001418e2
CALL 0x0023f3e3
MOV RDI,RAX
MOV ESI,0x1
LEA RDX,[0x246e82]
MOV ECX,0xc
LEA R8,[0x246e92]
LEA R9,[0x246ee8]
XOR EAX,EAX
CALL 0x0023f480
LAB_001418e2:
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x50],RAX
MOV byte ptr [RSP + 0x58],0x0
LEA RDI,[RSP + 0x50]
CALL 0x0014547c
MOV byte ptr [RSP + 0x58],0x1
MOV RAX,qword ptr [RBX + 0x38]
CMP RAX,qword ptr [RBX + 0x18]
JNZ 0x0014192e
CMP byte ptr [RBX + 0x4],0x1
JNZ 0x0014193d
LAB_0014190f:
CMP byte ptr [RBX + 0x4],0x1
JNZ 0x0014192e
MOV RDI,qword ptr [RSP + 0x30]
LEA RSI,[RSP + 0x50]
CALL 0x0011f2d0
MOV RAX,qword ptr [RBX + 0x38]
CMP RAX,qword ptr [RBX + 0x18]
JZ 0x0014190f
LAB_0014192e:
LEA RDI,[RSP + 0x50]
CALL 0x00145466
JMP 0x001414f0
LAB_0014193d:
LEA RAX,[0x3cff48]
CMP dword ptr [RAX],0x0
JLE 0x00141977
LAB_00141949:
CALL 0x0023f3e3
LEA RDX,[0x246e82]
LEA R8,[0x246e92]
LEA R9,[0x246eff]
MOV RDI,RAX
MOV ESI,0x1
MOV ECX,0xc
XOR EAX,EAX
CALL 0x0023f480
LAB_00141977:
LEA RDI,[RSP + 0x50]
CALL 0x00145466
ADD RSP,0xf38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00141993:
CALL 0x0011f3e0
LAB_00141998:
CALL 0x0011f3e0
|
/* server_queue::start_loop() */
void __thiscall server_queue::start_loop(server_queue *this)
{
int8 uVar1;
server_queue *local_f60;
int1 local_f58;
long *local_f50;
long *local_f48;
server_queue *local_f40;
server_queue *local_f38;
vector<common_adapter_lora_info,std::allocator<common_adapter_lora_info>> *local_f30;
server_queue *local_f28;
server_queue *local_f20;
server_queue *local_f18;
int1 uStack_f10;
int7 uStack_f0f;
slot_params local_f08 [1752];
void *local_830;
int8 uStack_828;
long local_820;
int4 local_818;
int4 local_810;
long *local_808;
int8 local_800;
int1 local_7f8;
int7 uStack_7f7;
long *local_7e8;
int8 local_7e0;
int1 local_7d8;
int7 uStack_7d7;
int1 local_7c8;
int8 local_7c0;
int8 uStack_7b8;
int8 local_7b0;
server_queue *local_7a8;
int8 uStack_7a0;
slot_params local_798 [1752];
void *local_c0;
int8 uStack_b8;
long local_b0;
int4 local_a8;
int4 local_a0;
long *local_98;
int8 local_90;
long local_88;
long lStack_80;
long *local_78;
int8 local_70;
long local_68;
long lStack_60;
int1 local_58;
int8 local_50;
int8 uStack_48;
int8 local_40;
this[4] = (server_queue)0x1;
local_f20 = this + 8;
local_f28 = this + 0x100;
local_f48 = (long *)&local_7f8;
local_f50 = (long *)&local_7d8;
local_f30 = (vector<common_adapter_lora_info,std::allocator<common_adapter_lora_info>> *)&local_50
;
local_f40 = this + 0x120;
local_f38 = this + 0xd0;
do {
if (0 < common_log_verbosity_thold) {
uVar1 = common_log_main();
common_log_add(uVar1,1,"que %12.*s: %s",0xc,"start_loop","processing new tasks\n");
}
while( true ) {
local_f58 = 0;
local_f60 = this + 0xa8;
std::unique_lock<std::mutex>::lock((unique_lock<std::mutex> *)&local_f60);
local_f58 = 1;
if (*(server_task **)(this + 0x38) == *(server_task **)(this + 0x18)) break;
/* try { // try from 00141533 to 0014153c has its CatchHandler @ 001419bd */
server_task::server_task((server_task *)&local_f18,*(server_task **)(this + 0x18));
std::deque<server_task,std::allocator<server_task>>::pop_front
((deque<server_task,std::allocator<server_task>> *)local_f20);
/* try { // try from 00141547 to 00141586 has its CatchHandler @ 001419c2 */
std::unique_lock<std::mutex>::unlock((unique_lock<std::mutex> *)&local_f60);
if (0 < common_log_verbosity_thold) {
uVar1 = common_log_main();
common_log_add(uVar1,1,"que %12.*s: processing task, id = %d\n",0xc,"start_loop",
(ulong)local_f18 & 0xffffffff);
}
uStack_7a0 = CONCAT71(uStack_f0f,uStack_f10);
local_7a8 = local_f18;
slot_params::slot_params(local_798,local_f08);
local_c0 = local_830;
uStack_b8 = uStack_828;
local_b0 = local_820;
local_830 = (void *)0x0;
uStack_828 = 0;
local_820 = 0;
local_a8 = local_818;
local_a0 = local_810;
if (local_808 == local_f48) {
local_88 = *local_f48;
lStack_80 = local_f48[1];
local_98 = &local_88;
}
else {
local_98 = local_808;
local_88 = CONCAT71(uStack_7f7,local_7f8);
}
local_90 = local_800;
local_808 = local_f48;
local_800 = 0;
local_7f8 = 0;
if (local_7e8 == local_f50) {
local_68 = *local_f50;
lStack_60 = local_f50[1];
local_78 = &local_68;
}
else {
local_78 = local_7e8;
local_68 = CONCAT71(uStack_7d7,local_7d8);
}
local_70 = local_7e0;
local_7e8 = local_f50;
local_7e0 = 0;
local_7d8 = 0;
local_58 = local_7c8;
local_50 = local_7c0;
uStack_48 = uStack_7b8;
local_40 = local_7b0;
local_7b0 = 0;
local_7c0 = 0;
uStack_7b8 = 0;
if (*(long *)(this + 0x110) == 0) {
/* WARNING: Subroutine does not return */
/* try { // try from 00141993 to 00141997 has its CatchHandler @ 001419ab */
std::__throw_bad_function_call();
}
/* try { // try from 00141726 to 00141738 has its CatchHandler @ 001419a9 */
(**(code **)(this + 0x118))(local_f28,&local_7a8);
std::vector<common_adapter_lora_info,std::allocator<common_adapter_lora_info>>::~vector
(local_f30);
if (local_78 != &local_68) {
operator_delete(local_78,local_68 + 1);
}
if (local_98 != &local_88) {
operator_delete(local_98,local_88 + 1);
}
if (local_c0 != (void *)0x0) {
operator_delete(local_c0,local_b0 - (long)local_c0);
}
slot_params::~slot_params(local_798);
std::vector<common_adapter_lora_info,std::allocator<common_adapter_lora_info>>::~vector
((vector<common_adapter_lora_info,std::allocator<common_adapter_lora_info>> *)
&local_7c0);
if (local_7e8 != local_f50) {
operator_delete(local_7e8,CONCAT71(uStack_7d7,local_7d8) + 1);
}
if (local_808 != local_f48) {
operator_delete(local_808,CONCAT71(uStack_7f7,local_7f8) + 1);
}
if (local_830 != (void *)0x0) {
operator_delete(local_830,local_820 - (long)local_830);
}
slot_params::~slot_params(local_f08);
std::unique_lock<std::mutex>::~unique_lock((unique_lock<std::mutex> *)&local_f60);
}
/* try { // try from 00141845 to 0014184c has its CatchHandler @ 001419a7 */
std::unique_lock<std::mutex>::unlock((unique_lock<std::mutex> *)&local_f60);
std::unique_lock<std::mutex>::~unique_lock((unique_lock<std::mutex> *)&local_f60);
if (0 < common_log_verbosity_thold) {
uVar1 = common_log_main();
common_log_add(uVar1,1,"que %12.*s: %s",0xc,"start_loop","update slots\n");
}
if (*(long *)(this + 0x130) == 0) {
/* WARNING: Subroutine does not return */
std::__throw_bad_function_call();
}
(**(code **)(this + 0x138))(local_f40);
if (0 < common_log_verbosity_thold) {
uVar1 = common_log_main();
common_log_add(uVar1,1,"que %12.*s: %s",0xc,"start_loop","waiting for new tasks\n");
}
uStack_f10 = 0;
local_f18 = this + 0xa8;
std::unique_lock<std::mutex>::lock((unique_lock<std::mutex> *)&local_f18);
uStack_f10 = 1;
if (*(long *)(this + 0x38) == *(long *)(this + 0x18)) {
if (this[4] != (server_queue)0x1) {
if (0 < common_log_verbosity_thold) {
/* try { // try from 00141949 to 00141976 has its CatchHandler @ 0014199d */
uVar1 = common_log_main();
common_log_add(uVar1,1,"que %12.*s: %s",0xc,"start_loop","terminate\n");
}
std::unique_lock<std::mutex>::~unique_lock((unique_lock<std::mutex> *)&local_f18);
return;
}
do {
if (this[4] != (server_queue)0x1) break;
std::condition_variable::wait((unique_lock *)local_f38);
} while (*(long *)(this + 0x38) == *(long *)(this + 0x18));
}
std::unique_lock<std::mutex>::~unique_lock((unique_lock<std::mutex> *)&local_f18);
} while( true );
}
| |
44,889 | thr_abort_locks_for_thread | eloqsql/mysys/thr_lock.c | my_bool thr_abort_locks_for_thread(THR_LOCK *lock, my_thread_id thread_id)
{
THR_LOCK_DATA *data;
my_bool found= FALSE;
DBUG_ENTER("thr_abort_locks_for_thread");
mysql_mutex_lock(&lock->mutex);
for (data= lock->read_wait.data; data ; data= data->next)
{
if (data->owner->thread_id == thread_id) /* purecov: tested */
{
DBUG_PRINT("info",("Aborting read-wait lock"));
data->type= TL_UNLOCK; /* Mark killed */
/* It's safe to signal the cond first: we're still holding the mutex. */
found= TRUE;
mysql_cond_signal(data->cond);
data->cond= 0; /* Removed from list */
if (((*data->prev)= data->next))
data->next->prev= data->prev;
else
lock->read_wait.last= data->prev;
}
}
for (data= lock->write_wait.data; data ; data= data->next)
{
if (data->owner->thread_id == thread_id) /* purecov: tested */
{
DBUG_PRINT("info",("Aborting write-wait lock"));
data->type= TL_UNLOCK;
found= TRUE;
mysql_cond_signal(data->cond);
data->cond= 0;
if (((*data->prev)= data->next))
data->next->prev= data->prev;
else
lock->write_wait.last= data->prev;
}
}
wake_up_waiters(lock);
mysql_mutex_unlock(&lock->mutex);
DBUG_RETURN(found);
} | O0 | c | thr_abort_locks_for_thread:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
leaq 0x5c223(%rip), %rsi # 0x15b166
movl $0x545, %edx # imm = 0x545
callq 0xfd9f0
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xfeff5
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0xfefe2
jmp 0xfef77
jmp 0xfef79
movq -0x18(%rbp), %rax
movl $0x0, 0x40(%rax)
movb $0x1, -0x19(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xfeec0
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0xfefd0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0xfefe0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
jmp 0xfefe2
jmp 0xfefe4
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xfef59
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xff0a3
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0xff090
jmp 0xff022
jmp 0xff024
movq -0x18(%rbp), %rax
movl $0x0, 0x40(%rax)
movb $0x1, -0x19(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xfeec0
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0xff07b
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0xff08e
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x88(%rax)
jmp 0xff090
jmp 0xff092
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xff004
movq -0x8(%rbp), %rdi
callq 0xfddb0
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0xfda60
movb -0x19(%rbp), %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| thr_abort_locks_for_thread:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_19], 0
mov rdi, [rbp+var_8]
add rdi, 18h
lea rsi, aWorkspaceLlm4b_40; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 545h
call inline_mysql_mutex_lock_27
mov rax, [rbp+var_8]
mov rax, [rax+60h]
mov [rbp+var_18], rax
loc_FEF59:
cmp [rbp+var_18], 0
jz loc_FEFF5
mov rax, [rbp+var_18]
mov rax, [rax]
mov rax, [rax+8]
cmp rax, [rbp+var_10]
jnz short loc_FEFE2
jmp short $+2
loc_FEF77:
jmp short $+2
loc_FEF79:
mov rax, [rbp+var_18]
mov dword ptr [rax+40h], 0
mov [rbp+var_19], 1
mov rax, [rbp+var_18]
mov rdi, [rax+20h]
call inline_mysql_cond_signal_4
mov rax, [rbp+var_18]
mov qword ptr [rax+20h], 0
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov rcx, [rbp+var_18]
mov rcx, [rcx+10h]
mov [rcx], rax
cmp rax, 0
jz short loc_FEFD0
mov rax, [rbp+var_18]
mov rcx, [rax+10h]
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov [rax+10h], rcx
jmp short loc_FEFE0
loc_FEFD0:
mov rax, [rbp+var_18]
mov rcx, [rax+10h]
mov rax, [rbp+var_8]
mov [rax+68h], rcx
loc_FEFE0:
jmp short $+2
loc_FEFE2:
jmp short $+2
loc_FEFE4:
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov [rbp+var_18], rax
jmp loc_FEF59
loc_FEFF5:
mov rax, [rbp+var_8]
mov rax, [rax+80h]
mov [rbp+var_18], rax
loc_FF004:
cmp [rbp+var_18], 0
jz loc_FF0A3
mov rax, [rbp+var_18]
mov rax, [rax]
mov rax, [rax+8]
cmp rax, [rbp+var_10]
jnz short loc_FF090
jmp short $+2
loc_FF022:
jmp short $+2
loc_FF024:
mov rax, [rbp+var_18]
mov dword ptr [rax+40h], 0
mov [rbp+var_19], 1
mov rax, [rbp+var_18]
mov rdi, [rax+20h]
call inline_mysql_cond_signal_4
mov rax, [rbp+var_18]
mov qword ptr [rax+20h], 0
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov rcx, [rbp+var_18]
mov rcx, [rcx+10h]
mov [rcx], rax
cmp rax, 0
jz short loc_FF07B
mov rax, [rbp+var_18]
mov rcx, [rax+10h]
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov [rax+10h], rcx
jmp short loc_FF08E
loc_FF07B:
mov rax, [rbp+var_18]
mov rcx, [rax+10h]
mov rax, [rbp+var_8]
mov [rax+88h], rcx
loc_FF08E:
jmp short $+2
loc_FF090:
jmp short $+2
loc_FF092:
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov [rbp+var_18], rax
jmp loc_FF004
loc_FF0A3:
mov rdi, [rbp+var_8]
call wake_up_waiters
mov rdi, [rbp+var_8]
add rdi, 18h
call inline_mysql_mutex_unlock_28
mov al, [rbp+var_19]
mov [rbp+var_1A], al
mov al, [rbp+var_1A]
add rsp, 20h
pop rbp
retn
| char thr_abort_locks_for_thread(_QWORD *a1, long long a2)
{
long long v2; // rax
long long v3; // rax
char v5; // [rsp+7h] [rbp-19h]
long long i; // [rsp+8h] [rbp-18h]
long long j; // [rsp+8h] [rbp-18h]
v5 = 0;
inline_mysql_mutex_lock_27(
(long long)(a1 + 3),
(long long)"/workspace/llm4binary/github2025/eloqsql/mysys/thr_lock.c",
0x545u);
for ( i = a1[12]; i; i = *(_QWORD *)(i + 8) )
{
if ( *(_QWORD *)(*(_QWORD *)i + 8LL) == a2 )
{
*(_DWORD *)(i + 64) = 0;
v5 = 1;
inline_mysql_cond_signal_4(*(_QWORD *)(i + 32));
*(_QWORD *)(i + 32) = 0LL;
v2 = *(_QWORD *)(i + 8);
**(_QWORD **)(i + 16) = v2;
if ( v2 )
*(_QWORD *)(*(_QWORD *)(i + 8) + 16LL) = *(_QWORD *)(i + 16);
else
a1[13] = *(_QWORD *)(i + 16);
}
}
for ( j = a1[16]; j; j = *(_QWORD *)(j + 8) )
{
if ( *(_QWORD *)(*(_QWORD *)j + 8LL) == a2 )
{
*(_DWORD *)(j + 64) = 0;
v5 = 1;
inline_mysql_cond_signal_4(*(_QWORD *)(j + 32));
*(_QWORD *)(j + 32) = 0LL;
v3 = *(_QWORD *)(j + 8);
**(_QWORD **)(j + 16) = v3;
if ( v3 )
*(_QWORD *)(*(_QWORD *)(j + 8) + 16LL) = *(_QWORD *)(j + 16);
else
a1[17] = *(_QWORD *)(j + 16);
}
}
wake_up_waiters((long long)a1);
inline_mysql_mutex_unlock_28((long long)(a1 + 3));
return v5;
}
| thr_abort_locks_for_thread:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV byte ptr [RBP + -0x19],0x0
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x18
LEA RSI,[0x25b166]
MOV EDX,0x545
CALL 0x001fd9f0
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x60]
MOV qword ptr [RBP + -0x18],RAX
LAB_001fef59:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x001feff5
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x8]
CMP RAX,qword ptr [RBP + -0x10]
JNZ 0x001fefe2
JMP 0x001fef77
LAB_001fef77:
JMP 0x001fef79
LAB_001fef79:
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x40],0x0
MOV byte ptr [RBP + -0x19],0x1
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x20]
CALL 0x001feec0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x20],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX + 0x10]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JZ 0x001fefd0
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX + 0x10],RCX
JMP 0x001fefe0
LAB_001fefd0:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x68],RCX
LAB_001fefe0:
JMP 0x001fefe2
LAB_001fefe2:
JMP 0x001fefe4
LAB_001fefe4:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001fef59
LAB_001feff5:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x80]
MOV qword ptr [RBP + -0x18],RAX
LAB_001ff004:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x001ff0a3
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x8]
CMP RAX,qword ptr [RBP + -0x10]
JNZ 0x001ff090
JMP 0x001ff022
LAB_001ff022:
JMP 0x001ff024
LAB_001ff024:
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x40],0x0
MOV byte ptr [RBP + -0x19],0x1
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x20]
CALL 0x001feec0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x20],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX + 0x10]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JZ 0x001ff07b
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX + 0x10],RCX
JMP 0x001ff08e
LAB_001ff07b:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x88],RCX
LAB_001ff08e:
JMP 0x001ff090
LAB_001ff090:
JMP 0x001ff092
LAB_001ff092:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001ff004
LAB_001ff0a3:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001fddb0
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x18
CALL 0x001fda60
MOV AL,byte ptr [RBP + -0x19]
MOV byte ptr [RBP + -0x1a],AL
MOV AL,byte ptr [RBP + -0x1a]
ADD RSP,0x20
POP RBP
RET
|
int1 thr_abort_locks_for_thread(long param_1,long param_2)
{
long lVar1;
int1 local_21;
long *local_20;
local_21 = 0;
inline_mysql_mutex_lock
(param_1 + 0x18,"/workspace/llm4binary/github2025/eloqsql/mysys/thr_lock.c",0x545);
for (local_20 = *(long **)(param_1 + 0x60); local_20 != (long *)0x0;
local_20 = (long *)local_20[1]) {
if (*(long *)(*local_20 + 8) == param_2) {
*(int4 *)(local_20 + 8) = 0;
local_21 = 1;
inline_mysql_cond_signal(local_20[4]);
local_20[4] = 0;
lVar1 = local_20[1];
*(long *)local_20[2] = lVar1;
if (lVar1 == 0) {
*(long *)(param_1 + 0x68) = local_20[2];
}
else {
*(long *)(local_20[1] + 0x10) = local_20[2];
}
}
}
for (local_20 = *(long **)(param_1 + 0x80); local_20 != (long *)0x0;
local_20 = (long *)local_20[1]) {
if (*(long *)(*local_20 + 8) == param_2) {
*(int4 *)(local_20 + 8) = 0;
local_21 = 1;
inline_mysql_cond_signal(local_20[4]);
local_20[4] = 0;
lVar1 = local_20[1];
*(long *)local_20[2] = lVar1;
if (lVar1 == 0) {
*(long *)(param_1 + 0x88) = local_20[2];
}
else {
*(long *)(local_20[1] + 0x10) = local_20[2];
}
}
}
wake_up_waiters(param_1);
inline_mysql_mutex_unlock(param_1 + 0x18);
return local_21;
}
| |
44,890 | inline_mysql_file_seek | eloqsql/include/mysql/psi/mysql_file.h | static inline my_off_t
inline_mysql_file_seek(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, my_off_t pos, int whence, myf flags)
{
my_off_t result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, file, PSI_FILE_SEEK);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, (size_t) 0, src_file, src_line);
result= my_seek(file, pos, whence, flags);
PSI_FILE_CALL(end_file_wait)(locker, (size_t) 0);
return result;
}
#endif
result= my_seek(file, pos, whence, flags);
return result;
} | O0 | c | inline_mysql_file_seek:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
leaq 0x20b270(%rip), %rax # 0x2c00b8
movq (%rax), %rax
movq 0x158(%rax), %rax
movl -0x18(%rbp), %esi
leaq -0x88(%rbp), %rdi
movl $0x8, %edx
callq *%rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xb4ee3
leaq 0x20b22a(%rip), %rax # 0x2c00b8
movq (%rax), %rax
movq 0x210(%rax), %rax
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
xorl %esi, %esi
callq *%rax
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
movq -0x30(%rbp), %rcx
callq 0xf4ca0
movq %rax, -0x38(%rbp)
leaq 0x20b1f3(%rip), %rax # 0x2c00b8
movq (%rax), %rax
movq 0x218(%rax), %rax
movq -0x40(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
callq *%rax
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb4f02
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
movq -0x30(%rbp), %rcx
callq 0xf4ca0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nop
| inline_mysql_file_seek_4:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_20], rcx
mov [rbp+var_24], r8d
mov [rbp+var_30], r9
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+158h]
mov esi, [rbp+var_18]
lea rdi, [rbp+var_88]
mov edx, 8
call rax
mov [rbp+var_40], rax
cmp [rbp+var_40], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_B4EE3
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+210h]
mov rdi, [rbp+var_40]
mov rdx, [rbp+var_10]
mov ecx, [rbp+var_14]
xor esi, esi
call rax
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov edx, [rbp+var_24]
mov rcx, [rbp+var_30]
call my_seek
mov [rbp+var_38], rax
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+218h]
mov rdi, [rbp+var_40]
xor ecx, ecx
mov esi, ecx
call rax
mov rax, [rbp+var_38]
mov [rbp+var_8], rax
jmp short loc_B4F02
loc_B4EE3:
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov edx, [rbp+var_24]
mov rcx, [rbp+var_30]
call my_seek
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov [rbp+var_8], rax
loc_B4F02:
mov rax, [rbp+var_8]
add rsp, 90h
pop rbp
retn
| long long inline_mysql_file_seek_4(
long long a1,
unsigned int a2,
unsigned int a3,
long long a4,
unsigned int a5,
long long a6)
{
_BYTE v7[72]; // [rsp+8h] [rbp-88h] BYREF
long long v8; // [rsp+50h] [rbp-40h]
long long v9; // [rsp+58h] [rbp-38h]
long long v10; // [rsp+60h] [rbp-30h]
unsigned int v11; // [rsp+6Ch] [rbp-24h]
long long v12; // [rsp+70h] [rbp-20h]
unsigned int v13; // [rsp+78h] [rbp-18h]
unsigned int v14; // [rsp+7Ch] [rbp-14h]
long long v15; // [rsp+80h] [rbp-10h]
v15 = a1;
v14 = a2;
v13 = a3;
v12 = a4;
v11 = a5;
v10 = a6;
v8 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v7, a3, 8LL);
if ( !v8 )
return my_seek(v13, v12, v11, v10);
((void ( *)(long long, _QWORD, long long, _QWORD))PSI_server[66])(v8, 0LL, v15, v14);
v9 = my_seek(v13, v12, v11, v10);
((void ( *)(long long, _QWORD))PSI_server[67])(v8, 0LL);
return v9;
}
| inline_mysql_file_seek:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV dword ptr [RBP + -0x24],R8D
MOV qword ptr [RBP + -0x30],R9
LEA RAX,[0x3c00b8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x158]
MOV ESI,dword ptr [RBP + -0x18]
LEA RDI,[RBP + -0x88]
MOV EDX,0x8
CALL RAX
MOV qword ptr [RBP + -0x40],RAX
CMP qword ptr [RBP + -0x40],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001b4ee3
LEA RAX,[0x3c00b8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x210]
MOV RDI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x14]
XOR ESI,ESI
CALL RAX
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x24]
MOV RCX,qword ptr [RBP + -0x30]
CALL 0x001f4ca0
MOV qword ptr [RBP + -0x38],RAX
LEA RAX,[0x3c00b8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV RDI,qword ptr [RBP + -0x40]
XOR ECX,ECX
MOV ESI,ECX
CALL RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001b4f02
LAB_001b4ee3:
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x24]
MOV RCX,qword ptr [RBP + -0x30]
CALL 0x001f4ca0
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
LAB_001b4f02:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x90
POP RBP
RET
|
int8
inline_mysql_file_seek
(int8 param_1,int4 param_2,int4 param_3,int8 param_4,
int4 param_5,int8 param_6)
{
int1 local_90 [72];
long local_48;
int8 local_40;
int8 local_38;
int4 local_2c;
int8 local_28;
int4 local_20;
int4 local_1c;
int8 local_18;
int8 local_10;
local_38 = param_6;
local_2c = param_5;
local_28 = param_4;
local_20 = param_3;
local_1c = param_2;
local_18 = param_1;
local_48 = (**(code **)(PSI_server + 0x158))(local_90,param_3,8);
if (local_48 == 0) {
local_10 = my_seek(local_20,local_28,local_2c,local_38);
}
else {
(**(code **)(PSI_server + 0x210))(local_48,0,local_18,local_1c);
local_40 = my_seek(local_20,local_28,local_2c,local_38);
(**(code **)(PSI_server + 0x218))(local_48,0);
local_10 = local_40;
}
return local_10;
}
| |
44,891 | 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 0xde1e8
leaq 0x286fca(%rip), %r15 # 0x3651b0
jmp 0xde1ef
leaq 0x286f91(%rip), %r15 # 0x365180
testl %edx, %edx
js 0xde1fd
leal -0x25(%rdx), %eax
cmpl $-0x23, %eax
jb 0xde205
jmp 0xde219
leal 0x1(%rdx), %eax
cmpl $-0x23, %eax
jae 0xde209
xorl %ebx, %ebx
jmp 0xde26e
testq %rdi, %rdi
jns 0xde217
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 0xde25a
movq %rax, %rdi
movq %r14, %rsi
callq 0x2a4d0
movb (%r15,%rdx), %cl
movb %cl, -0x1(%r12)
decq %r12
testq %rax, %rax
jne 0xde23e
decq %rbx
movb (%r12), %al
incq %r12
movb %al, 0x1(%rbx)
incq %rbx
testb %al, %al
jne 0xde25d
movq %fs:0x28, %rax
cmpq -0x28(%rbp), %rax
jne 0xde28d
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x2a240
| 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_DE1E8
lea r15, _dig_vec_lower; "0123456789abcdefghijklmnopqrstuvwxyz"
jmp short loc_DE1EF
loc_DE1E8:
lea r15, _dig_vec_upper; "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
loc_DE1EF:
test edx, edx
js short loc_DE1FD
lea eax, [rdx-25h]
cmp eax, 0FFFFFFDDh
jb short loc_DE205
jmp short loc_DE219
loc_DE1FD:
lea eax, [rdx+1]
cmp eax, 0FFFFFFDDh
jnb short loc_DE209
loc_DE205:
xor ebx, ebx
jmp short loc_DE26E
loc_DE209:
test rdi, rdi
jns short loc_DE217
mov byte ptr [rbx], 2Dh ; '-'
inc rbx
neg rdi
loc_DE217:
neg edx
loc_DE219:
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_DE25A
loc_DE23E:
mov rdi, rax
mov rsi, r14
call _ldiv
mov cl, [r15+rdx]
mov [r12-1], cl
dec r12
test rax, rax
jnz short loc_DE23E
loc_DE25A:
dec rbx
loc_DE25D:
mov al, [r12]
inc r12
mov [rbx+1], al
inc rbx
test al, al
jnz short loc_DE25D
loc_DE26E:
mov rax, fs:28h
cmp rax, [rbp+var_28]
jnz short loc_DE28D
mov rax, rbx
add rsp, 50h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_DE28D:
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 0x001de1e8
LEA R15,[0x4651b0]
JMP 0x001de1ef
LAB_001de1e8:
LEA R15,[0x465180]
LAB_001de1ef:
TEST EDX,EDX
JS 0x001de1fd
LEA EAX,[RDX + -0x25]
CMP EAX,-0x23
JC 0x001de205
JMP 0x001de219
LAB_001de1fd:
LEA EAX,[RDX + 0x1]
CMP EAX,-0x23
JNC 0x001de209
LAB_001de205:
XOR EBX,EBX
JMP 0x001de26e
LAB_001de209:
TEST RDI,RDI
JNS 0x001de217
MOV byte ptr [RBX],0x2d
INC RBX
NEG RDI
LAB_001de217:
NEG EDX
LAB_001de219:
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 0x001de25a
LAB_001de23e:
MOV RDI,RAX
MOV RSI,R14
CALL 0x0012a4d0
MOV CL,byte ptr [R15 + RDX*0x1]
MOV byte ptr [R12 + -0x1],CL
DEC R12
TEST RAX,RAX
JNZ 0x001de23e
LAB_001de25a:
DEC RBX
LAB_001de25d:
MOV AL,byte ptr [R12]
INC R12
MOV byte ptr [RBX + 0x1],AL
INC RBX
TEST AL,AL
JNZ 0x001de25d
LAB_001de26e:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x28]
JNZ 0x001de28d
MOV RAX,RBX
ADD RSP,0x50
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001de28d:
CALL 0x0012a240
|
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_001de205;
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_001de205:
param_2 = (int1 *)0x0;
goto LAB_001de26e;
}
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_001de26e:
if (*(long *)(in_FS_OFFSET + 0x28) != local_30) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_2;
}
| |
44,892 | rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>& rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::operator[]<rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&) | mnn-tts/MNN/3rd_party/rapidjson/document.h | GenericValue& operator[](const GenericValue<Encoding, SourceAllocator>& name) {
MemberIterator member = FindMember(name);
if (member != MemberEnd())
return member->value;
else {
RAPIDJSON_ASSERT(false); // see above note
// This will generate -Wexit-time-destructors in clang
// static GenericValue NullValue;
// return NullValue;
// Use static buffer and placement-new to prevent destruction
static char buffer[sizeof(GenericValue)];
return *new (buffer) GenericValue();
}
} | O0 | c | rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>& rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::operator[]<rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&):
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rsi
movq %rsi, 0x8(%rsp)
movq 0x28(%rsp), %rdx
leaq 0x20(%rsp), %rdi
callq 0x375c0
movq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x37870
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x37520
movq 0x18(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x37850
testb $0x1, %al
jne 0x37b7a
jmp 0x37b8d
leaq 0x20(%rsp), %rdi
callq 0x379f0
addq $0x10, %rax
addq $0x38, %rsp
retq
leaq 0x7c5b(%rip), %rdi # 0x3f7ef
leaq 0x5e39(%rip), %rsi # 0x3d9d4
movl $0x473, %edx # imm = 0x473
leaq 0x7c4e(%rip), %rcx # 0x3f7f5
callq 0x30c0
nopl (%rax)
| _ZN9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEEixIS5_EERS6_RKNS0_IS2_T_EE:
sub rsp, 38h
mov [rsp+38h+var_8], rdi
mov [rsp+38h+var_10], rsi
mov rsi, [rsp+38h+var_8]
mov [rsp+38h+var_30], rsi
mov rdx, [rsp+38h+var_10]
lea rdi, [rsp+38h+var_18]
call _ZN9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE10FindMemberIS5_EENS_21GenericMemberIteratorILb0ES2_S5_EERKNS0_IS2_T_EE; rapidjson::GenericValue<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::FindMember<rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>(rapidjson::GenericValue<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&)
mov rsi, [rsp+38h+var_30]
lea rdi, [rsp+38h+var_28]
call _ZN9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEE9MemberEndEv; rapidjson::GenericValue<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::MemberEnd(void)
lea rdi, [rsp+38h+var_20]
lea rsi, [rsp+38h+var_28]
call _ZN9rapidjson21GenericMemberIteratorILb1ENS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEEC2ERKNS0_ILb0ES2_S5_EE; rapidjson::GenericMemberIterator<true,rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::GenericMemberIterator(rapidjson::GenericMemberIterator<false,rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&)
mov rsi, [rsp+38h+var_20]
lea rdi, [rsp+38h+var_18]
call _ZNK9rapidjson21GenericMemberIteratorILb0ENS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEEneENS0_ILb1ES2_S5_EE; rapidjson::GenericMemberIterator<false,rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::operator!=(rapidjson::GenericMemberIterator<true,rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>)
test al, 1
jnz short loc_37B7A
jmp short loc_37B8D
loc_37B7A:
lea rdi, [rsp+38h+var_18]
call _ZNK9rapidjson21GenericMemberIteratorILb0ENS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEEptEv; rapidjson::GenericMemberIterator<false,rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::operator->(void)
add rax, 10h
add rsp, 38h
retn
loc_37B8D:
lea rdi, aFalse; "false"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/mnn-tt"...
mov edx, 473h
lea rcx, aGenericvalueEn; "GenericValue<Encoding, Allocator> &rapi"...
call ___assert_fail
| long long rapidjson::GenericValue<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::operator[]<rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>(
unsigned int *a1,
long long a2)
{
long long v3; // [rsp+10h] [rbp-28h] BYREF
long long v4; // [rsp+18h] [rbp-20h] BYREF
_QWORD v5[3]; // [rsp+20h] [rbp-18h] BYREF
v5[2] = a1;
v5[1] = a2;
rapidjson::GenericValue<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::FindMember<rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>(
(long long)v5,
(long long)a1,
a2);
rapidjson::GenericValue<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::MemberEnd(
(long long)&v3,
a1);
rapidjson::GenericMemberIterator<true,rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::GenericMemberIterator(
&v4,
&v3);
if ( !rapidjson::GenericMemberIterator<false,rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::operator!=(
v5,
v4) )
__assert_fail(
"false",
"/workspace/llm4binary/github2025/mnn-tts/MNN/3rd_party/rapidjson/document.h",
1139LL,
"GenericValue<Encoding, Allocator> &rapidjson::GenericValue<rapidjson::UTF8<>>::operator[](const GenericValue<Encod"
"ing, SourceAllocator> &) [Encoding = rapidjson::UTF8<>, Allocator = rapidjson::MemoryPoolAllocator<>, SourceAlloca"
"tor = rapidjson::MemoryPoolAllocator<>]");
return rapidjson::GenericMemberIterator<false,rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::operator->((long long)v5)
+ 16;
}
| operator[]<rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>:
SUB RSP,0x38
MOV qword ptr [RSP + 0x30],RDI
MOV qword ptr [RSP + 0x28],RSI
MOV RSI,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x8],RSI
MOV RDX,qword ptr [RSP + 0x28]
LEA RDI,[RSP + 0x20]
CALL 0x001375c0
MOV RSI,qword ptr [RSP + 0x8]
LEA RDI,[RSP + 0x10]
CALL 0x00137870
LEA RDI,[RSP + 0x18]
LEA RSI,[RSP + 0x10]
CALL 0x00137520
MOV RSI,qword ptr [RSP + 0x18]
LEA RDI,[RSP + 0x20]
CALL 0x00137850
TEST AL,0x1
JNZ 0x00137b7a
JMP 0x00137b8d
LAB_00137b7a:
LEA RDI,[RSP + 0x20]
CALL 0x001379f0
ADD RAX,0x10
ADD RSP,0x38
RET
LAB_00137b8d:
LEA RDI,[0x13f7ef]
LEA RSI,[0x13d9d4]
MOV EDX,0x473
LEA RCX,[0x13f7f5]
CALL 0x001030c0
|
/* rapidjson::GenericValue<rapidjson::UTF8<char>,
rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator> >&
rapidjson::GenericValue<rapidjson::UTF8<char>,
rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>
>::operator[]<rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>
>(rapidjson::GenericValue<rapidjson::UTF8<char>,
rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator> > const&) */
GenericValue * __thiscall
rapidjson::
GenericValue<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::
operator[]<rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>
(GenericValue<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>
*this,GenericValue *param_1)
{
ulong uVar1;
long lVar2;
GenericMemberIterator local_28 [8];
int8 local_20;
GenericValue local_18 [8];
GenericValue *local_10;
GenericValue<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>
*local_8;
local_10 = param_1;
local_8 = this;
FindMember<rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>(local_18);
MemberEnd();
GenericMemberIterator<true,rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>
::GenericMemberIterator
((GenericMemberIterator<true,rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>
*)&local_20,local_28);
uVar1 = GenericMemberIterator<false,rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>
::operator!=((GenericMemberIterator<false,rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>
*)local_18,local_20);
if ((uVar1 & 1) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("false",
"/workspace/llm4binary/github2025/mnn-tts/MNN/3rd_party/rapidjson/document.h",
0x473,
"GenericValue<Encoding, Allocator> &rapidjson::GenericValue<rapidjson::UTF8<>>::operator[](const GenericValue<Encoding, SourceAllocator> &) [Encoding = rapidjson::UTF8<>, Allocator = rapidjson::MemoryPoolAllocator<>, SourceAllocator = rapidjson::MemoryPoolAllocator<>]"
);
}
lVar2 = GenericMemberIterator<false,rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>
::operator->((GenericMemberIterator<false,rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>
*)local_18);
return (GenericValue *)(lVar2 + 0x10);
}
| |
44,893 | nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type_name(nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type) | monkey531[P]llama/common/./json.hpp | static const char* token_type_name(const token_type t) noexcept
{
switch (t)
{
case token_type::uninitialized:
return "<uninitialized>";
case token_type::literal_true:
return "true literal";
case token_type::literal_false:
return "false literal";
case token_type::literal_null:
return "null literal";
case token_type::value_string:
return "string literal";
case token_type::value_unsigned:
case token_type::value_integer:
case token_type::value_float:
return "number literal";
case token_type::begin_array:
return "'['";
case token_type::begin_object:
return "'{'";
case token_type::end_array:
return "']'";
case token_type::end_object:
return "'}'";
case token_type::name_separator:
return "':'";
case token_type::value_separator:
return "','";
case token_type::parse_error:
return "<parse error>";
case token_type::end_of_input:
return "end of input";
case token_type::literal_or_value:
return "'[', '{', or a literal";
// LCOV_EXCL_START
default: // catch non-enum values
return "unknown token";
// LCOV_EXCL_STOP
}
} | O0 | cpp | nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type_name(nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type):
movl %edi, -0xc(%rsp)
movl -0xc(%rsp), %eax
movq %rax, -0x18(%rsp)
subq $0x10, %rax
ja 0xb1120
movq -0x18(%rsp), %rax
leaq 0x129769(%rip), %rcx # 0x1da79c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x12b2a8(%rip), %rax # 0x1dc2eb
movq %rax, -0x8(%rsp)
jmp 0xb112c
leaq 0x12b2a7(%rip), %rax # 0x1dc2fb
movq %rax, -0x8(%rsp)
jmp 0xb112c
leaq 0x12b2a3(%rip), %rax # 0x1dc308
movq %rax, -0x8(%rsp)
jmp 0xb112c
leaq 0x12b2a0(%rip), %rax # 0x1dc316
movq %rax, -0x8(%rsp)
jmp 0xb112c
leaq 0x12b29c(%rip), %rax # 0x1dc323
movq %rax, -0x8(%rsp)
jmp 0xb112c
leaq 0x12b29a(%rip), %rax # 0x1dc332
movq %rax, -0x8(%rsp)
jmp 0xb112c
leaq 0x12b298(%rip), %rax # 0x1dc341
movq %rax, -0x8(%rsp)
jmp 0xb112c
leaq 0x12b28e(%rip), %rax # 0x1dc345
movq %rax, -0x8(%rsp)
jmp 0xb112c
leaq 0x12b284(%rip), %rax # 0x1dc349
movq %rax, -0x8(%rsp)
jmp 0xb112c
leaq 0x12b27a(%rip), %rax # 0x1dc34d
movq %rax, -0x8(%rsp)
jmp 0xb112c
leaq 0x12b270(%rip), %rax # 0x1dc351
movq %rax, -0x8(%rsp)
jmp 0xb112c
leaq 0x12b266(%rip), %rax # 0x1dc355
movq %rax, -0x8(%rsp)
jmp 0xb112c
leaq 0x12b25c(%rip), %rax # 0x1dc359
movq %rax, -0x8(%rsp)
jmp 0xb112c
leaq 0x135d05(%rip), %rax # 0x1e6e10
movq %rax, -0x8(%rsp)
jmp 0xb112c
leaq 0x12b24e(%rip), %rax # 0x1dc367
movq %rax, -0x8(%rsp)
jmp 0xb112c
leaq 0x12b257(%rip), %rax # 0x1dc37e
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| _ZN8nlohmann16json_abi_v3_11_36detail10lexer_baseINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE15token_type_nameENSG_10token_typeE:
mov [rsp+var_C], edi
mov eax, [rsp+var_C]
mov [rsp+var_18], rax
sub rax, 10h; switch 17 cases
ja def_B103A; jumptable 00000000000B103A default case
mov rax, [rsp+var_18]
lea rcx, jpt_B103A
movsxd rax, ds:(jpt_B103A - 1DA79Ch)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_B103C:
lea rax, aUninitialized; jumptable 00000000000B103A case 0
mov [rsp+var_8], rax
jmp loc_B112C
loc_B104D:
lea rax, aTrueLiteral; jumptable 00000000000B103A case 1
mov [rsp+var_8], rax
jmp loc_B112C
loc_B105E:
lea rax, aFalseLiteral; jumptable 00000000000B103A case 2
mov [rsp+var_8], rax
jmp loc_B112C
loc_B106F:
lea rax, aNullLiteral; jumptable 00000000000B103A case 3
mov [rsp+var_8], rax
jmp loc_B112C
loc_B1080:
lea rax, aStringLiteral; jumptable 00000000000B103A case 4
mov [rsp+var_8], rax
jmp loc_B112C
loc_B1091:
lea rax, aNumberLiteral; jumptable 00000000000B103A cases 5-7
mov [rsp+var_8], rax
jmp loc_B112C
loc_B10A2:
lea rax, asc_1DC341; jumptable 00000000000B103A case 8
mov [rsp+var_8], rax
jmp short loc_B112C
loc_B10B0:
lea rax, asc_1DC345; jumptable 00000000000B103A case 9
mov [rsp+var_8], rax
jmp short loc_B112C
loc_B10BE:
lea rax, asc_1DC349; jumptable 00000000000B103A case 10
mov [rsp+var_8], rax
jmp short loc_B112C
loc_B10CC:
lea rax, asc_1DC34D; jumptable 00000000000B103A case 11
mov [rsp+var_8], rax
jmp short loc_B112C
loc_B10DA:
lea rax, asc_1DC351; jumptable 00000000000B103A case 12
mov [rsp+var_8], rax
jmp short loc_B112C
loc_B10E8:
lea rax, asc_1DC355; jumptable 00000000000B103A case 13
mov [rsp+var_8], rax
jmp short loc_B112C
loc_B10F6:
lea rax, aParseError_1; jumptable 00000000000B103A case 14
mov [rsp+var_8], rax
jmp short loc_B112C
loc_B1104:
lea rax, aUnexpectedEndO_7+0Bh; jumptable 00000000000B103A case 15
mov [rsp+var_8], rax
jmp short loc_B112C
loc_B1112:
lea rax, aOrALiteral; jumptable 00000000000B103A case 16
mov [rsp+var_8], rax
jmp short loc_B112C
def_B103A:
lea rax, aUnknownToken; jumptable 00000000000B103A default case
mov [rsp+var_8], rax
loc_B112C:
mov rax, [rsp+var_8]
retn
| char * nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type_name(
int a1)
{
char *v2; // [rsp+10h] [rbp-8h]
switch ( a1 )
{
case 0:
v2 = "<uninitialized>";
break;
case 1:
v2 = "true literal";
break;
case 2:
v2 = "false literal";
break;
case 3:
v2 = "null literal";
break;
case 4:
v2 = "string literal";
break;
case 5:
case 6:
case 7:
v2 = "number literal";
break;
case 8:
v2 = "'['";
break;
case 9:
v2 = "'{'";
break;
case 10:
v2 = "']'";
break;
case 11:
v2 = "'}'";
break;
case 12:
v2 = "':'";
break;
case 13:
v2 = "','";
break;
case 14:
v2 = "<parse error>";
break;
case 15:
v2 = "end of input";
break;
case 16:
v2 = "'[', '{', or a literal";
break;
default:
v2 = "unknown token";
break;
}
return v2;
}
| token_type_name:
MOV dword ptr [RSP + -0xc],EDI
MOV EAX,dword ptr [RSP + -0xc]
MOV qword ptr [RSP + -0x18],RAX
SUB RAX,0x10
JA 0x001b1120
MOV RAX,qword ptr [RSP + -0x18]
LEA RCX,[0x2da79c]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
LEA RAX,[0x2dc2eb]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001b112c
caseD_1:
LEA RAX,[0x2dc2fb]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001b112c
caseD_2:
LEA RAX,[0x2dc308]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001b112c
caseD_3:
LEA RAX,[0x2dc316]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001b112c
caseD_4:
LEA RAX,[0x2dc323]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001b112c
caseD_5:
LEA RAX,[0x2dc332]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001b112c
caseD_8:
LEA RAX,[0x2dc341]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001b112c
caseD_9:
LEA RAX,[0x2dc345]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001b112c
caseD_a:
LEA RAX,[0x2dc349]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001b112c
caseD_b:
LEA RAX,[0x2dc34d]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001b112c
caseD_c:
LEA RAX,[0x2dc351]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001b112c
caseD_d:
LEA RAX,[0x2dc355]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001b112c
caseD_e:
LEA RAX,[0x2dc359]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001b112c
caseD_f:
LEA RAX,[0x2e6e10]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001b112c
caseD_10:
LEA RAX,[0x2dc367]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001b112c
default:
LEA RAX,[0x2dc37e]
MOV qword ptr [RSP + -0x8],RAX
LAB_001b112c:
MOV RAX,qword ptr [RSP + -0x8]
RET
|
/* nlohmann::json_abi_v3_11_3::detail::lexer_base<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>
>::token_type_name(nlohmann::json_abi_v3_11_3::detail::lexer_base<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> >::token_type) */
char * nlohmann::json_abi_v3_11_3::detail::
lexer_base<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>>
::token_type_name(int4 param_1)
{
char *local_8;
switch(param_1) {
case 0:
local_8 = "<uninitialized>";
break;
case 1:
local_8 = "true literal";
break;
case 2:
local_8 = "false literal";
break;
case 3:
local_8 = "null literal";
break;
case 4:
local_8 = "string literal";
break;
case 5:
case 6:
case 7:
local_8 = "number literal";
break;
case 8:
local_8 = "\'[\'";
break;
case 9:
local_8 = "\'{\'";
break;
case 10:
local_8 = "\']\'";
break;
case 0xb:
local_8 = "\'}\'";
break;
case 0xc:
local_8 = "\':\'";
break;
case 0xd:
local_8 = "\',\'";
break;
case 0xe:
local_8 = "<parse error>";
break;
case 0xf:
local_8 = "end of input";
break;
case 0x10:
local_8 = "\'[\', \'{\', or a literal";
break;
default:
local_8 = "unknown token";
}
return local_8;
}
| |
44,894 | nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type_name(nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type) | monkey531[P]llama/common/./json.hpp | static const char* token_type_name(const token_type t) noexcept
{
switch (t)
{
case token_type::uninitialized:
return "<uninitialized>";
case token_type::literal_true:
return "true literal";
case token_type::literal_false:
return "false literal";
case token_type::literal_null:
return "null literal";
case token_type::value_string:
return "string literal";
case token_type::value_unsigned:
case token_type::value_integer:
case token_type::value_float:
return "number literal";
case token_type::begin_array:
return "'['";
case token_type::begin_object:
return "'{'";
case token_type::end_array:
return "']'";
case token_type::end_object:
return "'}'";
case token_type::name_separator:
return "':'";
case token_type::value_separator:
return "','";
case token_type::parse_error:
return "<parse error>";
case token_type::end_of_input:
return "end of input";
case token_type::literal_or_value:
return "'[', '{', or a literal";
// LCOV_EXCL_START
default: // catch non-enum values
return "unknown token";
// LCOV_EXCL_STOP
}
} | O1 | cpp | nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type_name(nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type):
cmpl $0x10, %edi
ja 0x3ad76
movl %edi, %eax
leaq 0x77a76(%rip), %rcx # 0xb27e4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0x791b0(%rip), %rax # 0xb3f2d
retq
| _ZN8nlohmann16json_abi_v3_11_36detail10lexer_baseINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE15token_type_nameENSG_10token_typeE:
cmp edi, 10h
ja short loc_3AD76
mov eax, edi
lea rcx, unk_B27E4
movsxd rax, dword ptr [rcx+rax*4]
add rax, rcx
retn
loc_3AD76:
lea rax, aUnknownToken; "unknown token"
retn
| const char * nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type_name(
unsigned int a1)
{
if ( a1 > 0x10 )
return "unknown token";
else
return (char *)dword_B27E4 + dword_B27E4[a1];
}
| token_type_name:
CMP EDI,0x10
JA 0x0013ad76
MOV EAX,EDI
LEA RCX,[0x1b27e4]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
RET
LAB_0013ad76:
LEA RAX,[0x1b3f2d]
RET
|
/* nlohmann::json_abi_v3_11_3::detail::lexer_base<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>
>::token_type_name(nlohmann::json_abi_v3_11_3::detail::lexer_base<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> >::token_type) */
char * nlohmann::json_abi_v3_11_3::detail::
lexer_base<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>>
::token_type_name(uint param_1)
{
if (param_1 < 0x11) {
return &DAT_001b27e4 + *(int *)(&DAT_001b27e4 + (ulong)param_1 * 4);
}
return "unknown token";
}
| |
44,895 | nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type_name(nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type) | monkey531[P]llama/common/./json.hpp | static const char* token_type_name(const token_type t) noexcept
{
switch (t)
{
case token_type::uninitialized:
return "<uninitialized>";
case token_type::literal_true:
return "true literal";
case token_type::literal_false:
return "false literal";
case token_type::literal_null:
return "null literal";
case token_type::value_string:
return "string literal";
case token_type::value_unsigned:
case token_type::value_integer:
case token_type::value_float:
return "number literal";
case token_type::begin_array:
return "'['";
case token_type::begin_object:
return "'{'";
case token_type::end_array:
return "']'";
case token_type::end_object:
return "'}'";
case token_type::name_separator:
return "':'";
case token_type::value_separator:
return "','";
case token_type::parse_error:
return "<parse error>";
case token_type::end_of_input:
return "end of input";
case token_type::literal_or_value:
return "'[', '{', or a literal";
// LCOV_EXCL_START
default: // catch non-enum values
return "unknown token";
// LCOV_EXCL_STOP
}
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type_name(nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type):
cmpl $0x10, %edi
ja 0x3a582
movl %edi, %eax
leaq 0x783a2(%rip), %rcx # 0xb291c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0x7684b(%rip), %rax # 0xb0dd4
retq
| _ZN8nlohmann16json_abi_v3_11_36detail10lexer_baseINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE15token_type_nameENSG_10token_typeE:
cmp edi, 10h
ja short loc_3A582
mov eax, edi
lea rcx, unk_B291C
movsxd rax, dword ptr [rcx+rax*4]
add rax, rcx
retn
loc_3A582:
lea rax, aUnknownToken; "unknown token"
retn
| const char * nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type_name(
unsigned int a1)
{
if ( a1 > 0x10 )
return "unknown token";
else
return (char *)dword_B291C + dword_B291C[a1];
}
| token_type_name:
CMP EDI,0x10
JA 0x0013a582
MOV EAX,EDI
LEA RCX,[0x1b291c]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
RET
LAB_0013a582:
LEA RAX,[0x1b0dd4]
RET
|
/* nlohmann::json_abi_v3_11_3::detail::lexer_base<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>
>::token_type_name(nlohmann::json_abi_v3_11_3::detail::lexer_base<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> >::token_type) */
char * nlohmann::json_abi_v3_11_3::detail::
lexer_base<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>>
::token_type_name(uint param_1)
{
if (param_1 < 0x11) {
return &DAT_001b291c + *(int *)(&DAT_001b291c + (ulong)param_1 * 4);
}
return "unknown token";
}
| |
44,896 | 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>::json_value::json_value(nlohmann::json_abi_v3_11_3::detail::value_t) | llama.cpp/common/json.hpp | json_value(value_t t)
{
switch (t)
{
case value_t::object:
{
object = create<object_t>();
break;
}
case value_t::array:
{
array = create<array_t>();
break;
}
case value_t::string:
{
string = create<string_t>("");
break;
}
case value_t::binary:
{
binary = create<binary_t>();
break;
}
case value_t::boolean:
{
boolean = static_cast<boolean_t>(false);
break;
}
case value_t::number_integer:
{
number_integer = static_cast<number_integer_t>(0);
break;
}
case value_t::number_unsigned:
{
number_unsigned = static_cast<number_unsigned_t>(0);
break;
}
case value_t::number_float:
{
number_float = static_cast<number_float_t>(0.0);
break;
}
case value_t::null:
{
object = nullptr; // silence warning, see #821
break;
}
case value_t::discarded:
default:
{
object = nullptr; // silence warning, see #821
if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
{
JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.11.3", nullptr)); // LCOV_EXCL_LINE
}
break;
}
}
} | O3 | cpp | 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>::json_value::json_value(nlohmann::json_abi_v3_11_3::detail::value_t):
pushq %rbx
movq %rdi, %rbx
cmpl $0x8, %esi
ja 0x75ef5
movl %esi, %eax
leaq 0x9ea04(%rip), %rcx # 0x1148f0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x0, (%rbx)
jmp 0x75f6e
movl $0x30, %edi
callq 0x21220
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %edx, %edx
movq %rdx, 0x10(%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rdx, 0x28(%rax)
jmp 0x75f6b
movb $0x0, (%rbx)
jmp 0x75f6e
movl $0x18, %edi
callq 0x21220
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
jmp 0x75f6b
leaq 0xab965(%rip), %rdi # 0x1218b1
callq 0x75f70
jmp 0x75f6b
movl $0x28, %edi
callq 0x21220
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movb $0x0, 0x20(%rax)
movq %rax, (%rbx)
popq %rbx
retq
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10json_valueC2ENS0_6detail7value_tE:
push rbx
mov rbx, rdi
cmp esi, 8; switch 9 cases
ja short def_75EF3; jumptable 0000000000075EF3 default case, cases 0,5-7
mov eax, esi
lea rcx, jpt_75EF3
movsxd rax, ds:(jpt_75EF3 - 1148F0h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
def_75EF3:
mov qword ptr [rbx], 0; jumptable 0000000000075EF3 default case, cases 0,5-7
jmp short loc_75F6E
loc_75EFE:
mov edi, 30h ; '0'; jumptable 0000000000075EF3 case 1
call __Znwm; operator new(ulong)
lea rcx, [rax+8]
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
xor edx, edx
mov [rax+10h], rdx
mov [rax+18h], rcx
mov [rax+20h], rcx
mov [rax+28h], rdx
jmp short loc_75F6B
loc_75F26:
mov byte ptr [rbx], 0; jumptable 0000000000075EF3 case 4
jmp short loc_75F6E
loc_75F2B:
mov edi, 18h; jumptable 0000000000075EF3 case 2
call __Znwm; operator new(ulong)
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
mov qword ptr [rax+10h], 0
jmp short loc_75F6B
loc_75F45:
lea rdi, aExampleToolCal+1Dh; jumptable 0000000000075EF3 case 3
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createIS9_JRA1_KcEEEPT_DpOT0_; 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>::create<std::string,char const(&)[1]>(char const(&)[1] &&)
jmp short loc_75F6B
loc_75F53:
mov edi, 28h ; '('; jumptable 0000000000075EF3 case 8
call __Znwm; operator new(ulong)
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
movups xmmword ptr [rax+10h], xmm0
mov byte ptr [rax+20h], 0
loc_75F6B:
mov [rbx], rax
loc_75F6E:
pop rbx
retn
| long long nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::json_value::json_value(
_BYTE *a1,
unsigned int a2)
{
long long result; // rax
result = a2;
switch ( a2 )
{
case 1u:
result = operator new(0x30uLL);
*(_OWORD *)result = 0LL;
*(_QWORD *)(result + 16) = 0LL;
*(_QWORD *)(result + 24) = result + 8;
*(_QWORD *)(result + 32) = result + 8;
*(_QWORD *)(result + 40) = 0LL;
goto LABEL_8;
case 2u:
result = operator new(0x18uLL);
*(_OWORD *)result = 0LL;
*(_QWORD *)(result + 16) = 0LL;
goto LABEL_8;
case 3u:
result = 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>::create<std::string,char const(&)[1]>("");
goto LABEL_8;
case 4u:
*a1 = 0;
return result;
case 8u:
result = operator new(0x28uLL);
*(_OWORD *)result = 0LL;
*(_OWORD *)(result + 16) = 0LL;
*(_BYTE *)(result + 32) = 0;
LABEL_8:
*(_QWORD *)a1 = result;
break;
default:
*(_QWORD *)a1 = 0LL;
break;
}
return result;
}
| json_value:
PUSH RBX
MOV RBX,RDI
CMP ESI,0x8
JA 0x00175ef5
MOV EAX,ESI
LEA RCX,[0x2148f0]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
MOV qword ptr [RBX],0x0
JMP 0x00175f6e
caseD_1:
MOV EDI,0x30
CALL 0x00121220
LEA RCX,[RAX + 0x8]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
XOR EDX,EDX
MOV qword ptr [RAX + 0x10],RDX
MOV qword ptr [RAX + 0x18],RCX
MOV qword ptr [RAX + 0x20],RCX
MOV qword ptr [RAX + 0x28],RDX
JMP 0x00175f6b
caseD_4:
MOV byte ptr [RBX],0x0
JMP 0x00175f6e
caseD_2:
MOV EDI,0x18
CALL 0x00121220
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOV qword ptr [RAX + 0x10],0x0
JMP 0x00175f6b
caseD_3:
LEA RDI,[0x2218b1]
CALL 0x00175f70
JMP 0x00175f6b
caseD_8:
MOV EDI,0x28
CALL 0x00121220
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOVUPS xmmword ptr [RAX + 0x10],XMM0
MOV byte ptr [RAX + 0x20],0x0
LAB_00175f6b:
MOV qword ptr [RBX],RAX
LAB_00175f6e:
POP RBX
RET
|
/* 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>::json_value::json_value(nlohmann::json_abi_v3_11_3::detail::value_t) */
void __thiscall
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>
::json_value::json_value(json_value *this,int4 param_2)
{
string *psVar1;
switch(param_2) {
default:
*(int8 *)this = 0;
return;
case 1:
psVar1 = (string *)operator_new(0x30);
*(int8 *)psVar1 = 0;
*(int8 *)(psVar1 + 8) = 0;
*(int8 *)(psVar1 + 0x10) = 0;
*(string **)(psVar1 + 0x18) = psVar1 + 8;
*(string **)(psVar1 + 0x20) = psVar1 + 8;
*(int8 *)(psVar1 + 0x28) = 0;
break;
case 2:
psVar1 = (string *)operator_new(0x18);
*(int8 *)psVar1 = 0;
*(int8 *)(psVar1 + 8) = 0;
*(int8 *)(psVar1 + 0x10) = 0;
break;
case 3:
psVar1 = create<std::__cxx11::string,char_const(&)[1]>("");
break;
case 4:
*this = (json_value)0x0;
return;
case 8:
psVar1 = (string *)operator_new(0x28);
*(int8 *)psVar1 = 0;
*(int8 *)(psVar1 + 8) = 0;
*(int8 *)(psVar1 + 0x10) = 0;
*(int8 *)(psVar1 + 0x18) = 0;
psVar1[0x20] = (string)0x0;
}
*(string **)this = psVar1;
return;
}
| |
44,897 | ma_bitmap_free_full_pages | eloqsql/storage/maria/ma_bitmap.c | my_bool _ma_bitmap_free_full_pages(MARIA_HA *info, const uchar *extents,
uint count)
{
MARIA_FILE_BITMAP *bitmap= &info->s->bitmap;
my_bool res;
DBUG_ENTER("_ma_bitmap_free_full_pages");
for (; count--; extents+= ROW_EXTENT_SIZE)
{
pgcache_page_no_t page= uint5korr(extents);
uint page_count= (uint2korr(extents + ROW_EXTENT_PAGE_SIZE) &
~START_EXTENT_BIT);
if (!(page_count & TAIL_BIT))
{
if (page == 0 && page_count == 0)
continue; /* Not used extent */
if (pagecache_delete_pages(info->s->pagecache, &info->dfile, page,
page_count, PAGECACHE_LOCK_WRITE, 1))
DBUG_RETURN(1);
mysql_mutex_lock(&bitmap->bitmap_lock);
res= _ma_bitmap_reset_full_page_bits(info, bitmap, page, page_count);
mysql_mutex_unlock(&bitmap->bitmap_lock);
if (res)
DBUG_RETURN(1);
}
}
DBUG_RETURN(0);
} | O0 | c | ma_bitmap_free_full_pages:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0xa10, %rax # imm = 0xA10
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x6215b
movq -0x18(%rbp), %rdi
callq 0x62170
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movzwl 0x5(%rax), %eax
andl $0xffffbfff, %eax # imm = 0xFFFFBFFF
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
andl $0x8000, %eax # imm = 0x8000
cmpl $0x0, %eax
jne 0x62148
cmpq $0x0, -0x38(%rbp)
jne 0x620b8
cmpl $0x0, -0x3c(%rbp)
jne 0x620b8
jmp 0x6214a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x600(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x470, %rsi # imm = 0x470
movq -0x38(%rbp), %rdx
movl -0x3c(%rbp), %ecx
movl $0x4, %r8d
movl $0x1, %r9d
callq 0x9aab0
cmpb $0x0, %al
je 0x620f5
jmp 0x620ef
movb $0x1, -0x1(%rbp)
jmp 0x62161
movq -0x28(%rbp), %rdi
addq $0x88, %rdi
leaq 0xfaca0(%rip), %rsi # 0x15cda7
movl $0xb31, %edx # imm = 0xB31
callq 0x5fdb0
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
movl -0x3c(%rbp), %ecx
callq 0x615b0
movb %al, -0x29(%rbp)
movq -0x28(%rbp), %rdi
addq $0x88, %rdi
callq 0x60060
cmpb $0x0, -0x29(%rbp)
je 0x62146
jmp 0x62140
movb $0x1, -0x1(%rbp)
jmp 0x62161
jmp 0x62148
jmp 0x6214a
movq -0x18(%rbp), %rax
addq $0x7, %rax
movq %rax, -0x18(%rbp)
jmp 0x62064
jmp 0x6215d
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _ma_bitmap_free_full_pages:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov rax, [rbp+var_10]
mov rax, [rax]
add rax, 0A10h
mov [rbp+var_28], rax
loc_62064:
mov eax, [rbp+var_1C]
mov ecx, eax
add ecx, 0FFFFFFFFh
mov [rbp+var_1C], ecx
cmp eax, 0
jz loc_6215B
mov rdi, [rbp+var_18]
call uint5korr_1
mov [rbp+var_38], rax
mov rax, [rbp+var_18]
movzx eax, word ptr [rax+5]
and eax, 0FFFFBFFFh
mov [rbp+var_3C], eax
mov eax, [rbp+var_3C]
and eax, 8000h
cmp eax, 0
jnz loc_62148
cmp [rbp+var_38], 0
jnz short loc_620B8
cmp [rbp+var_3C], 0
jnz short loc_620B8
jmp loc_6214A
loc_620B8:
mov rax, [rbp+var_10]
mov rax, [rax]
mov rdi, [rax+600h]
mov rsi, [rbp+var_10]
add rsi, 470h
mov rdx, [rbp+var_38]
mov ecx, [rbp+var_3C]
mov r8d, 4
mov r9d, 1
call pagecache_delete_pages
cmp al, 0
jz short loc_620F5
jmp short $+2
loc_620EF:
mov [rbp+var_1], 1
jmp short loc_62161
loc_620F5:
mov rdi, [rbp+var_28]
add rdi, 88h
lea rsi, aWorkspaceLlm4b_11; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 0B31h
call inline_mysql_mutex_lock_7
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_38]
mov ecx, [rbp+var_3C]
call _ma_bitmap_reset_full_page_bits
mov [rbp+var_29], al
mov rdi, [rbp+var_28]
add rdi, 88h
call inline_mysql_mutex_unlock_7
cmp [rbp+var_29], 0
jz short loc_62146
jmp short $+2
loc_62140:
mov [rbp+var_1], 1
jmp short loc_62161
loc_62146:
jmp short $+2
loc_62148:
jmp short $+2
loc_6214A:
mov rax, [rbp+var_18]
add rax, 7
mov [rbp+var_18], rax
jmp loc_62064
loc_6215B:
jmp short $+2
loc_6215D:
mov [rbp+var_1], 0
loc_62161:
mov al, [rbp+var_1]
add rsp, 40h
pop rbp
retn
| char ma_bitmap_free_full_pages(long long *a1, long long a2, int a3)
{
int v5; // [rsp+4h] [rbp-3Ch]
unsigned long long v6; // [rsp+8h] [rbp-38h]
char v7; // [rsp+17h] [rbp-29h]
long long v8; // [rsp+18h] [rbp-28h]
v8 = *a1 + 2576;
while ( a3-- )
{
v6 = uint5korr_1(a2);
v5 = *(_WORD *)(a2 + 5) & 0xBFFF;
if ( (*(_WORD *)(a2 + 5) & 0x8000) == 0 && (v6 || (*(_WORD *)(a2 + 5) & 0xBFFF) != 0) )
{
if ( (unsigned __int8)pagecache_delete_pages(
*(_QWORD *)(*a1 + 1536),
a1 + 142,
v6,
*(_WORD *)(a2 + 5) & 0xBFFF,
4LL,
1LL) )
return 1;
inline_mysql_mutex_lock_7(
v8 + 136,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c",
0xB31u);
v7 = ma_bitmap_reset_full_page_bits(a1, v8, v6, v5);
inline_mysql_mutex_unlock_7(v8 + 136);
if ( v7 )
return 1;
}
a2 += 7LL;
}
return 0;
}
| _ma_bitmap_free_full_pages:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
ADD RAX,0xa10
MOV qword ptr [RBP + -0x28],RAX
LAB_00162064:
MOV EAX,dword ptr [RBP + -0x1c]
MOV ECX,EAX
ADD ECX,-0x1
MOV dword ptr [RBP + -0x1c],ECX
CMP EAX,0x0
JZ 0x0016215b
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00162170
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,word ptr [RAX + 0x5]
AND EAX,0xffffbfff
MOV dword ptr [RBP + -0x3c],EAX
MOV EAX,dword ptr [RBP + -0x3c]
AND EAX,0x8000
CMP EAX,0x0
JNZ 0x00162148
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x001620b8
CMP dword ptr [RBP + -0x3c],0x0
JNZ 0x001620b8
JMP 0x0016214a
LAB_001620b8:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + 0x600]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x470
MOV RDX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RBP + -0x3c]
MOV R8D,0x4
MOV R9D,0x1
CALL 0x0019aab0
CMP AL,0x0
JZ 0x001620f5
JMP 0x001620ef
LAB_001620ef:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00162161
LAB_001620f5:
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x88
LEA RSI,[0x25cda7]
MOV EDX,0xb31
CALL 0x0015fdb0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RBP + -0x3c]
CALL 0x001615b0
MOV byte ptr [RBP + -0x29],AL
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x88
CALL 0x00160060
CMP byte ptr [RBP + -0x29],0x0
JZ 0x00162146
JMP 0x00162140
LAB_00162140:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00162161
LAB_00162146:
JMP 0x00162148
LAB_00162148:
JMP 0x0016214a
LAB_0016214a:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x7
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00162064
LAB_0016215b:
JMP 0x0016215d
LAB_0016215d:
MOV byte ptr [RBP + -0x1],0x0
LAB_00162161:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x40
POP RBP
RET
|
int1 _ma_bitmap_free_full_pages(long *param_1,long param_2,int param_3)
{
ushort uVar1;
long lVar2;
char cVar3;
long lVar4;
int local_24;
long local_20;
lVar2 = *param_1;
local_24 = param_3;
local_20 = param_2;
do {
if (local_24 == 0) {
return 0;
}
lVar4 = uint5korr(local_20);
uVar1 = *(ushort *)(local_20 + 5);
if (((uVar1 & 0x8000) == 0) && ((lVar4 != 0 || ((uVar1 & 0xbfff) != 0)))) {
cVar3 = pagecache_delete_pages
(*(int8 *)(*param_1 + 0x600),param_1 + 0x8e,lVar4,uVar1 & 0xbfff,4,1);
if (cVar3 != '\0') {
return 1;
}
inline_mysql_mutex_lock
(lVar2 + 0xa98,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c",
0xb31);
cVar3 = _ma_bitmap_reset_full_page_bits(param_1,lVar2 + 0xa10,lVar4,uVar1 & 0xbfff);
inline_mysql_mutex_unlock(lVar2 + 0xa98);
if (cVar3 != '\0') {
return 1;
}
}
local_20 = local_20 + 7;
local_24 = local_24 + -1;
} while( true );
}
| |
44,898 | get_all_kv_cache_types[abi:cxx11]() | monkey531[P]llama/common/arg.cpp | static std::string get_all_kv_cache_types() {
std::ostringstream msg;
for (const auto & type : kv_cache_types) {
msg << ggml_type_name(type) << (&type == &kv_cache_types.back() ? "" : ", ");
}
return msg.str();
} | O0 | cpp | get_all_kv_cache_types[abi:cxx11]():
subq $0x1d8, %rsp # imm = 0x1D8
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x1d0(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x5b150
leaq 0x22199b(%rip), %rax # 0x2a7008
movq %rax, 0x50(%rsp)
leaq 0x22198f(%rip), %rdi # 0x2a7008
callq 0xc1f40
movq %rax, 0x48(%rsp)
leaq 0x22197e(%rip), %rdi # 0x2a7008
callq 0xc1f70
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xc1fa0
testb $0x1, %al
jne 0x856ac
jmp 0x8574c
leaq 0x48(%rsp), %rdi
callq 0xc1fe0
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movl (%rax), %edi
callq 0x5b470
movq %rax, 0x10(%rsp)
jmp 0x856ce
movq 0x10(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x5aa60
movq %rax, 0x8(%rsp)
jmp 0x856e4
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
leaq 0x221914(%rip), %rdi # 0x2a7008
callq 0xc1ff0
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movq (%rsp), %rax
subq %rcx, %rax
leaq 0x184df8(%rip), %rax # 0x20a507
leaq 0x18eef4(%rip), %rsi # 0x21460a
cmoveq %rax, %rsi
callq 0x5aa60
jmp 0x85721
jmp 0x85723
leaq 0x48(%rsp), %rdi
callq 0xc2030
jmp 0x85694
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x5b070
jmp 0x85774
movq 0x18(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x5b520
jmp 0x8575d
leaq 0x58(%rsp), %rdi
callq 0x5b070
movq 0x20(%rsp), %rax
addq $0x1d8, %rsp # imm = 0x1D8
retq
movq 0x30(%rsp), %rdi
callq 0x5ac00
nop
| _ZL22get_all_kv_cache_typesB5cxx11v:
sub rsp, 1D8h
mov [rsp+1D8h+var_1C0], rdi
mov rax, rdi
mov [rsp+1D8h+var_1B8], rax
mov [rsp+1D8h+var_8], rdi
lea rdi, [rsp+1D8h+var_180]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
lea rax, _ZL14kv_cache_types; kv_cache_types
mov [rsp+1D8h+var_188], rax
lea rdi, _ZL14kv_cache_types; kv_cache_types
call _ZNKSt6vectorI9ggml_typeSaIS0_EE5beginEv; std::vector<ggml_type>::begin(void)
mov [rsp+1D8h+var_190], rax
lea rdi, _ZL14kv_cache_types; kv_cache_types
call _ZNKSt6vectorI9ggml_typeSaIS0_EE3endEv; std::vector<ggml_type>::end(void)
mov [rsp+1D8h+var_198], rax
loc_85694:
lea rdi, [rsp+1D8h+var_190]
lea rsi, [rsp+1D8h+var_198]
call _ZN9__gnu_cxxneIPK9ggml_typeSt6vectorIS1_SaIS1_EEEEbRKNS_17__normal_iteratorIT_T0_EESC_; __gnu_cxx::operator!=<ggml_type const*,std::vector<ggml_type>>(__gnu_cxx::__normal_iterator<ggml_type const*,std::vector<ggml_type>> const&,__gnu_cxx::__normal_iterator<ggml_type const*,std::vector<ggml_type>> const&)
test al, 1
jnz short loc_856AC
jmp loc_8574C
loc_856AC:
lea rdi, [rsp+1D8h+var_190]
call _ZNK9__gnu_cxx17__normal_iteratorIPK9ggml_typeSt6vectorIS1_SaIS1_EEEdeEv; __gnu_cxx::__normal_iterator<ggml_type const*,std::vector<ggml_type>>::operator*(void)
mov [rsp+1D8h+var_1A0], rax
mov rax, [rsp+1D8h+var_1A0]
mov edi, [rax]
call _ggml_type_name
mov [rsp+1D8h+var_1C8], rax
jmp short $+2
loc_856CE:
mov rsi, [rsp+1D8h+var_1C8]
lea rdi, [rsp+1D8h+var_180]
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rsp+1D8h+var_1D0], rax
jmp short $+2
loc_856E4:
mov rax, [rsp+1D8h+var_1A0]
mov [rsp+1D8h+var_1D8], rax
lea rdi, _ZL14kv_cache_types; kv_cache_types
call _ZNKSt6vectorI9ggml_typeSaIS0_EE4backEv; std::vector<ggml_type>::back(void)
mov rdi, [rsp+1D8h+var_1D0]
mov rcx, rax
mov rax, [rsp+1D8h+var_1D8]
sub rax, rcx
lea rax, aInfillMode+1Ch; ""
lea rsi, aZuD+6; ", "
cmovz rsi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short $+2
loc_85721:
jmp short $+2
loc_85723:
lea rdi, [rsp+1D8h+var_190]
call _ZN9__gnu_cxx17__normal_iteratorIPK9ggml_typeSt6vectorIS1_SaIS1_EEEppEv; __gnu_cxx::__normal_iterator<ggml_type const*,std::vector<ggml_type>>::operator++(void)
jmp loc_85694
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
lea rdi, [rsp+arg_50]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev; std::ostringstream::~ostringstream()
jmp short loc_85774
loc_8574C:
mov rdi, [rsp+1D8h+var_1C0]
lea rsi, [rsp+1D8h+var_180]
call __ZNKSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEE3strEv; std::ostringstream::str(void)
jmp short $+2
loc_8575D:
lea rdi, [rsp+1D8h+var_180]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev; std::ostringstream::~ostringstream()
mov rax, [rsp+1D8h+var_1B8]
add rsp, 1D8h
retn
loc_85774:
mov rdi, [rsp+arg_28]
call __Unwind_Resume
| long long get_all_kv_cache_types[abi:cxx11](long long a1)
{
long long v1; // rdi
char *v2; // rsi
long long v4; // [rsp+10h] [rbp-1C8h]
unsigned int *v7; // [rsp+38h] [rbp-1A0h]
long long v8; // [rsp+40h] [rbp-198h] BYREF
_QWORD v9[2]; // [rsp+48h] [rbp-190h] BYREF
_BYTE v10[376]; // [rsp+58h] [rbp-180h] BYREF
long long v11; // [rsp+1D0h] [rbp-8h]
v11 = a1;
std::ostringstream::basic_ostringstream(v10);
v9[1] = &kv_cache_types;
v9[0] = std::vector<ggml_type>::begin(&kv_cache_types);
v8 = std::vector<ggml_type>::end(&kv_cache_types);
while ( (__gnu_cxx::operator!=<ggml_type const*,std::vector<ggml_type>>(v9, &v8) & 1) != 0 )
{
v7 = (unsigned int *)__gnu_cxx::__normal_iterator<ggml_type const*,std::vector<ggml_type>>::operator*(v9);
v4 = ggml_type_name(*v7);
v1 = std::operator<<<std::char_traits<char>>(v10, v4);
v2 = ", ";
if ( v7 == (unsigned int *)std::vector<ggml_type>::back(&kv_cache_types) )
v2 = "";
std::operator<<<std::char_traits<char>>(v1, v2);
__gnu_cxx::__normal_iterator<ggml_type const*,std::vector<ggml_type>>::operator++(v9);
}
std::ostringstream::str(a1, v10);
std::ostringstream::~ostringstream(v10);
return a1;
}
| get_all_kv_cache_types[abi:cxx11]:
SUB RSP,0x1d8
MOV qword ptr [RSP + 0x18],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x1d0],RDI
LEA RDI,[RSP + 0x58]
CALL 0x0015b150
LEA RAX,[0x3a7008]
MOV qword ptr [RSP + 0x50],RAX
LEA RDI,[0x3a7008]
CALL 0x001c1f40
MOV qword ptr [RSP + 0x48],RAX
LEA RDI,[0x3a7008]
CALL 0x001c1f70
MOV qword ptr [RSP + 0x40],RAX
LAB_00185694:
LEA RDI,[RSP + 0x48]
LEA RSI,[RSP + 0x40]
CALL 0x001c1fa0
TEST AL,0x1
JNZ 0x001856ac
JMP 0x0018574c
LAB_001856ac:
LEA RDI,[RSP + 0x48]
CALL 0x001c1fe0
MOV qword ptr [RSP + 0x38],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV EDI,dword ptr [RAX]
LAB_001856c2:
CALL 0x0015b470
MOV qword ptr [RSP + 0x10],RAX
JMP 0x001856ce
LAB_001856ce:
MOV RSI,qword ptr [RSP + 0x10]
LEA RDI,[RSP + 0x58]
CALL 0x0015aa60
MOV qword ptr [RSP + 0x8],RAX
JMP 0x001856e4
LAB_001856e4:
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP],RAX
LEA RDI,[0x3a7008]
CALL 0x001c1ff0
MOV RDI,qword ptr [RSP + 0x8]
MOV RCX,RAX
MOV RAX,qword ptr [RSP]
SUB RAX,RCX
LEA RAX,[0x30a507]
LEA RSI,[0x31460a]
CMOVZ RSI,RAX
CALL 0x0015aa60
JMP 0x00185721
LAB_00185721:
JMP 0x00185723
LAB_00185723:
LEA RDI,[RSP + 0x48]
CALL 0x001c2030
JMP 0x00185694
LAB_0018574c:
MOV RDI,qword ptr [RSP + 0x18]
LEA RSI,[RSP + 0x58]
CALL 0x0015b520
LAB_0018575b:
JMP 0x0018575d
LAB_0018575d:
LEA RDI,[RSP + 0x58]
CALL 0x0015b070
MOV RAX,qword ptr [RSP + 0x20]
ADD RSP,0x1d8
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* get_all_kv_cache_types[abi:cxx11]() */
int8 get_all_kv_cache_types_abi_cxx11_(void)
{
bool bVar1;
int4 *puVar2;
char *pcVar3;
ostream *poVar4;
int4 *puVar5;
int8 in_RDI;
int8 local_198;
int8 local_190;
int1 *local_188;
ostringstream local_180 [384];
std::__cxx11::ostringstream::ostringstream(local_180);
local_188 = kv_cache_types;
local_190 = std::vector<ggml_type,std::allocator<ggml_type>>::begin
((vector<ggml_type,std::allocator<ggml_type>> *)kv_cache_types);
local_198 = std::vector<ggml_type,std::allocator<ggml_type>>::end
((vector<ggml_type,std::allocator<ggml_type>> *)kv_cache_types);
while( true ) {
bVar1 = __gnu_cxx::operator!=((__normal_iterator *)&local_190,(__normal_iterator *)&local_198);
if (!bVar1) break;
puVar2 = (int4 *)
__gnu_cxx::
__normal_iterator<ggml_type_const*,std::vector<ggml_type,std::allocator<ggml_type>>>::
operator*((__normal_iterator<ggml_type_const*,std::vector<ggml_type,std::allocator<ggml_type>>>
*)&local_190);
/* try { // try from 001856c2 to 0018575a has its CatchHandler @ 00185732 */
pcVar3 = (char *)ggml_type_name(*puVar2);
poVar4 = std::operator<<((ostream *)local_180,pcVar3);
puVar5 = (int4 *)
std::vector<ggml_type,std::allocator<ggml_type>>::back
((vector<ggml_type,std::allocator<ggml_type>> *)kv_cache_types);
pcVar3 = ", ";
if (puVar2 == puVar5) {
pcVar3 = "";
}
std::operator<<(poVar4,pcVar3);
__gnu_cxx::__normal_iterator<ggml_type_const*,std::vector<ggml_type,std::allocator<ggml_type>>>
::operator++((__normal_iterator<ggml_type_const*,std::vector<ggml_type,std::allocator<ggml_type>>>
*)&local_190);
}
std::__cxx11::ostringstream::str();
std::__cxx11::ostringstream::~ostringstream(local_180);
return in_RDI;
}
| |
44,899 | get_all_kv_cache_types[abi:cxx11]() | monkey531[P]llama/common/arg.cpp | static std::string get_all_kv_cache_types() {
std::ostringstream msg;
for (const auto & type : kv_cache_types) {
msg << ggml_type_name(type) << (&type == &kv_cache_types.back() ? "" : ", ");
}
return msg.str();
} | O2 | cpp | get_all_kv_cache_types[abi:cxx11]():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x23c00
movq 0xc90d3(%rip), %r15 # 0xffe10
movq 0xc90d4(%rip), %r12 # 0xffe18
leaq 0x74888(%rip), %r13 # 0xab5d3
leaq 0x7decd(%rip), %rbp # 0xb4c1f
cmpq %r12, %r15
je 0x36d8d
movl (%r15), %edi
callq 0x23860
movq %r14, %rdi
movq %rax, %rsi
callq 0x238b0
movq 0xc90a7(%rip), %rcx # 0xffe18
addq $-0x4, %rcx
cmpq %rcx, %r15
movq %rbp, %rsi
cmoveq %r13, %rsi
movq %rax, %rdi
callq 0x238b0
addq $0x4, %r15
jmp 0x36d52
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x23e50
movq %rsp, %rdi
callq 0x231e0
movq %rbx, %rax
addq $0x178, %rsp # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x36db9
movq %rax, %rbx
movq %rsp, %rdi
callq 0x231e0
movq %rbx, %rdi
callq 0x24030
| _ZL22get_all_kv_cache_typesB5cxx11v:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 178h
mov rbx, rdi
mov r14, rsp
mov rdi, r14
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
mov r15, cs:_ZL14kv_cache_types; kv_cache_types
mov r12, cs:qword_FFE18
lea r13, aInfillMode+1Ch; ""
lea rbp, aZuD+6; ", "
loc_36D52:
cmp r15, r12
jz short loc_36D8D
mov edi, [r15]
call _ggml_type_name
mov rdi, r14
mov rsi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rcx, cs:qword_FFE18
add rcx, 0FFFFFFFFFFFFFFFCh
cmp r15, rcx
mov rsi, rbp
cmovz rsi, r13
mov rdi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
add r15, 4
jmp short loc_36D52
loc_36D8D:
lea rsi, [rsp+1A8h+var_1A0]
mov rdi, rbx
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
mov rdi, rsp
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev; std::ostringstream::~ostringstream()
mov rax, rbx
add rsp, 178h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short $+2
loc_36DB9:
mov rbx, rax
mov rdi, rsp
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev; std::ostringstream::~ostringstream()
mov rdi, rbx
call __Unwind_Resume
| long long get_all_kv_cache_types[abi:cxx11](long long a1)
{
unsigned int *v1; // r15
long long v2; // r12
long long v3; // rax
long long v4; // rax
char *v5; // rsi
long long v7; // [rsp+0h] [rbp-1A8h] BYREF
_BYTE v8[416]; // [rsp+8h] [rbp-1A0h] BYREF
std::ostringstream::basic_ostringstream(&v7);
v1 = (unsigned int *)kv_cache_types;
v2 = qword_FFE18;
while ( v1 != (unsigned int *)v2 )
{
v3 = ggml_type_name(*v1);
v4 = std::operator<<<std::char_traits<char>>(&v7, v3);
v5 = ", ";
if ( v1 == (unsigned int *)(qword_FFE18 - 4) )
v5 = "";
std::operator<<<std::char_traits<char>>(v4, v5);
++v1;
}
std::stringbuf::str(a1, v8);
std::ostringstream::~ostringstream(&v7);
return a1;
}
| get_all_kv_cache_types[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x178
MOV RBX,RDI
MOV R14,RSP
MOV RDI,R14
CALL 0x00123c00
MOV R15,qword ptr [0x001ffe10]
MOV R12,qword ptr [0x001ffe18]
LEA R13,[0x1ab5d3]
LEA RBP,[0x1b4c1f]
LAB_00136d52:
CMP R15,R12
JZ 0x00136d8d
MOV EDI,dword ptr [R15]
LAB_00136d5a:
CALL 0x00123860
MOV RDI,R14
MOV RSI,RAX
CALL 0x001238b0
MOV RCX,qword ptr [0x001ffe18]
ADD RCX,-0x4
CMP R15,RCX
MOV RSI,RBP
CMOVZ RSI,R13
MOV RDI,RAX
CALL 0x001238b0
ADD R15,0x4
JMP 0x00136d52
LAB_00136d8d:
LEA RSI,[RSP + 0x8]
LAB_00136d92:
MOV RDI,RBX
CALL 0x00123e50
LAB_00136d9a:
MOV RDI,RSP
CALL 0x001231e0
MOV RAX,RBX
ADD RSP,0x178
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* get_all_kv_cache_types[abi:cxx11]() */
void get_all_kv_cache_types_abi_cxx11_(void)
{
int4 *puVar1;
char *pcVar2;
ostream *poVar3;
int4 *puVar4;
ostringstream aoStack_1a8 [376];
std::__cxx11::ostringstream::ostringstream(aoStack_1a8);
puVar1 = DAT_001ffe18;
for (puVar4 = kv_cache_types; puVar4 != puVar1; puVar4 = puVar4 + 1) {
/* try { // try from 00136d5a to 00136d86 has its CatchHandler @ 00136db9 */
pcVar2 = (char *)ggml_type_name(*puVar4);
poVar3 = std::operator<<((ostream *)aoStack_1a8,pcVar2);
pcVar2 = ", ";
if (puVar4 == DAT_001ffe18 + -1) {
pcVar2 = "";
}
std::operator<<(poVar3,pcVar2);
}
/* try { // try from 00136d92 to 00136d99 has its CatchHandler @ 00136db7 */
std::__cxx11::stringbuf::str();
std::__cxx11::ostringstream::~ostringstream(aoStack_1a8);
return;
}
|
Subsets and Splits
C++ Functions With Standard Library Dependencies
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ Standard Library Function Analysis
Filters C++ code examples that use standard library containers and types, providing useful insights into common programming patterns and data structures in the dataset.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.