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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
29,200 | Adpcm::Decode(unsigned char) | sp1187[P]veesem/src/core/spg200/adpcm.cc | int16_t Adpcm::Decode(uint8_t code) {
int ss = StepSizeTable[step_index_];
int e =
ss / 8 + ((code & 0x1) ? ss / 4 : 0) + ((code & 0x2) ? ss / 2 : 0) + ((code & 0x4) ? ss : 0);
if (code & 0x8) {
e = -e;
}
int sample = std::clamp(last_sample_ + e, -32768, 32767);
last_sample_ = sample;
step_index_ = std::clamp(step_index_ + StepAdjustTable[code & 0x07], 0, 88);
return sample;
} | O0 | cpp | Adpcm::Decode(unsigned char):
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movsbq (%rax), %rcx
leaq 0xd8a2b(%rip), %rax # 0xf2c50
movl (%rax,%rcx,4), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, -0x34(%rbp)
movzbl -0x9(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1a255
movl -0x10(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, -0x44(%rbp)
jmp 0x1a25c
xorl %eax, %eax
movl %eax, -0x44(%rbp)
jmp 0x1a25c
movl -0x34(%rbp), %eax
movl -0x44(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x48(%rbp)
movzbl -0x9(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x1a283
movl -0x10(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x4c(%rbp)
jmp 0x1a28a
xorl %eax, %eax
movl %eax, -0x4c(%rbp)
jmp 0x1a28a
movl -0x48(%rbp), %eax
movl -0x4c(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x50(%rbp)
movzbl -0x9(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x1a2a9
movl -0x10(%rbp), %eax
movl %eax, -0x54(%rbp)
jmp 0x1a2b0
xorl %eax, %eax
movl %eax, -0x54(%rbp)
jmp 0x1a2b0
movl -0x50(%rbp), %eax
movl -0x54(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x14(%rbp)
movzbl -0x9(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x1a2cf
xorl %eax, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x40(%rbp), %rax
movswl 0x2(%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl $0xffff8000, -0x20(%rbp) # imm = 0xFFFF8000
movl $0x7fff, -0x24(%rbp) # imm = 0x7FFF
leaq -0x1c(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0xebf0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, -0x18(%rbp)
movl -0x18(%rbp), %ecx
movw %cx, 0x2(%rax)
movsbl (%rax), %eax
movzbl -0x9(%rbp), %ecx
andl $0x7, %ecx
movslq %ecx, %rdx
leaq 0xd8a9d(%rip), %rcx # 0xf2dc0
addl (%rcx,%rdx,4), %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x58, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0xebf0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movl (%rcx), %ecx
movb %cl, (%rax)
movl -0x18(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| _ZN5Adpcm6DecodeEh:
push rbp
mov rbp, rsp
sub rsp, 60h
mov al, sil
mov [rbp+var_8], rdi
mov [rbp+var_9], al
mov rax, [rbp+var_8]
mov [rbp+var_40], rax
movsx rcx, byte ptr [rax]
lea rax, _ZN12_GLOBAL__N_113StepSizeTableE; "\a"
mov eax, [rax+rcx*4]
mov [rbp+var_10], eax
mov eax, [rbp+var_10]
mov ecx, 8
cdq
idiv ecx
mov [rbp+var_34], eax
movzx eax, [rbp+var_9]
and eax, 1
cmp eax, 0
jz short loc_1A255
mov eax, [rbp+var_10]
mov ecx, 4
cdq
idiv ecx
mov [rbp+var_44], eax
jmp short loc_1A25C
loc_1A255:
xor eax, eax
mov [rbp+var_44], eax
jmp short $+2
loc_1A25C:
mov eax, [rbp+var_34]
mov ecx, [rbp+var_44]
add eax, ecx
mov [rbp+var_48], eax
movzx eax, [rbp+var_9]
and eax, 2
cmp eax, 0
jz short loc_1A283
mov eax, [rbp+var_10]
mov ecx, 2
cdq
idiv ecx
mov [rbp+var_4C], eax
jmp short loc_1A28A
loc_1A283:
xor eax, eax
mov [rbp+var_4C], eax
jmp short $+2
loc_1A28A:
mov eax, [rbp+var_48]
mov ecx, [rbp+var_4C]
add eax, ecx
mov [rbp+var_50], eax
movzx eax, [rbp+var_9]
and eax, 4
cmp eax, 0
jz short loc_1A2A9
mov eax, [rbp+var_10]
mov [rbp+var_54], eax
jmp short loc_1A2B0
loc_1A2A9:
xor eax, eax
mov [rbp+var_54], eax
jmp short $+2
loc_1A2B0:
mov eax, [rbp+var_50]
mov ecx, [rbp+var_54]
add eax, ecx
mov [rbp+var_14], eax
movzx eax, [rbp+var_9]
and eax, 8
cmp eax, 0
jz short loc_1A2CF
xor eax, eax
sub eax, [rbp+var_14]
mov [rbp+var_14], eax
loc_1A2CF:
mov rax, [rbp+var_40]
movsx eax, word ptr [rax+2]
add eax, [rbp+var_14]
mov [rbp+var_1C], eax
mov [rbp+var_20], 0FFFF8000h
mov [rbp+var_24], 7FFFh
lea rdi, [rbp+var_1C]
lea rsi, [rbp+var_20]
lea rdx, [rbp+var_24]
call _ZSt5clampIiERKT_S2_S2_S2_; std::clamp<int>(int const&,int const&,int const&)
mov rcx, rax
mov rax, [rbp+var_40]
mov ecx, [rcx]
mov [rbp+var_18], ecx
mov ecx, [rbp+var_18]
mov [rax+2], cx
movsx eax, byte ptr [rax]
movzx ecx, [rbp+var_9]
and ecx, 7
movsxd rdx, ecx
lea rcx, _ZN12_GLOBAL__N_115StepAdjustTableE; `anonymous namespace'::StepAdjustTable
add eax, [rcx+rdx*4]
mov [rbp+var_28], eax
mov [rbp+var_2C], 0
mov [rbp+var_30], 58h ; 'X'
lea rdi, [rbp+var_28]
lea rsi, [rbp+var_2C]
lea rdx, [rbp+var_30]
call _ZSt5clampIiERKT_S2_S2_S2_; std::clamp<int>(int const&,int const&,int const&)
mov rcx, rax
mov rax, [rbp+var_40]
mov ecx, [rcx]
mov [rax], cl
mov eax, [rbp+var_18]
add rsp, 60h
pop rbp
retn
| long long Adpcm::Decode(Adpcm *this, char a2)
{
int v3; // [rsp+Ch] [rbp-54h]
int v4; // [rsp+14h] [rbp-4Ch]
int v5; // [rsp+1Ch] [rbp-44h]
int v6; // [rsp+30h] [rbp-30h] BYREF
int v7; // [rsp+34h] [rbp-2Ch] BYREF
int v8; // [rsp+38h] [rbp-28h] BYREF
int v9; // [rsp+3Ch] [rbp-24h] BYREF
int v10; // [rsp+40h] [rbp-20h] BYREF
int v11; // [rsp+44h] [rbp-1Ch] BYREF
unsigned int v12; // [rsp+48h] [rbp-18h]
int v13; // [rsp+4Ch] [rbp-14h]
int v14; // [rsp+50h] [rbp-10h]
char v15; // [rsp+57h] [rbp-9h]
Adpcm *v16; // [rsp+58h] [rbp-8h]
v16 = this;
v15 = a2;
v14 = *(_DWORD *)&`anonymous namespace'::StepSizeTable[4 * *(char *)this];
if ( (a2 & 1) != 0 )
v5 = v14 / 4;
else
v5 = 0;
if ( (v15 & 2) != 0 )
v4 = v14 / 2;
else
v4 = 0;
if ( (v15 & 4) != 0 )
v3 = v14;
else
v3 = 0;
v13 = v3 + v4 + v5 + v14 / 8;
if ( (v15 & 8) != 0 )
v13 = -v13;
v11 = v13 + *((__int16 *)this + 1);
v10 = -32768;
v9 = 0x7FFF;
v12 = *std::clamp<int>(&v11, &v10, &v9);
*((_WORD *)this + 1) = v12;
v8 = `anonymous namespace'::StepAdjustTable[v15 & 7] + *(char *)this;
v7 = 0;
v6 = 88;
*(_BYTE *)this = *std::clamp<int>(&v8, &v7, &v6);
return v12;
}
| Decode:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV AL,SIL
MOV qword ptr [RBP + -0x8],RDI
MOV byte ptr [RBP + -0x9],AL
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x40],RAX
MOVSX RCX,byte ptr [RAX]
LEA RAX,[0x1f2c50]
MOV EAX,dword ptr [RAX + RCX*0x4]
MOV dword ptr [RBP + -0x10],EAX
MOV EAX,dword ptr [RBP + -0x10]
MOV ECX,0x8
CDQ
IDIV ECX
MOV dword ptr [RBP + -0x34],EAX
MOVZX EAX,byte ptr [RBP + -0x9]
AND EAX,0x1
CMP EAX,0x0
JZ 0x0011a255
MOV EAX,dword ptr [RBP + -0x10]
MOV ECX,0x4
CDQ
IDIV ECX
MOV dword ptr [RBP + -0x44],EAX
JMP 0x0011a25c
LAB_0011a255:
XOR EAX,EAX
MOV dword ptr [RBP + -0x44],EAX
JMP 0x0011a25c
LAB_0011a25c:
MOV EAX,dword ptr [RBP + -0x34]
MOV ECX,dword ptr [RBP + -0x44]
ADD EAX,ECX
MOV dword ptr [RBP + -0x48],EAX
MOVZX EAX,byte ptr [RBP + -0x9]
AND EAX,0x2
CMP EAX,0x0
JZ 0x0011a283
MOV EAX,dword ptr [RBP + -0x10]
MOV ECX,0x2
CDQ
IDIV ECX
MOV dword ptr [RBP + -0x4c],EAX
JMP 0x0011a28a
LAB_0011a283:
XOR EAX,EAX
MOV dword ptr [RBP + -0x4c],EAX
JMP 0x0011a28a
LAB_0011a28a:
MOV EAX,dword ptr [RBP + -0x48]
MOV ECX,dword ptr [RBP + -0x4c]
ADD EAX,ECX
MOV dword ptr [RBP + -0x50],EAX
MOVZX EAX,byte ptr [RBP + -0x9]
AND EAX,0x4
CMP EAX,0x0
JZ 0x0011a2a9
MOV EAX,dword ptr [RBP + -0x10]
MOV dword ptr [RBP + -0x54],EAX
JMP 0x0011a2b0
LAB_0011a2a9:
XOR EAX,EAX
MOV dword ptr [RBP + -0x54],EAX
JMP 0x0011a2b0
LAB_0011a2b0:
MOV EAX,dword ptr [RBP + -0x50]
MOV ECX,dword ptr [RBP + -0x54]
ADD EAX,ECX
MOV dword ptr [RBP + -0x14],EAX
MOVZX EAX,byte ptr [RBP + -0x9]
AND EAX,0x8
CMP EAX,0x0
JZ 0x0011a2cf
XOR EAX,EAX
SUB EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x14],EAX
LAB_0011a2cf:
MOV RAX,qword ptr [RBP + -0x40]
MOVSX EAX,word ptr [RAX + 0x2]
ADD EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x1c],EAX
MOV dword ptr [RBP + -0x20],0xffff8000
MOV dword ptr [RBP + -0x24],0x7fff
LEA RDI,[RBP + -0x1c]
LEA RSI,[RBP + -0x20]
LEA RDX,[RBP + -0x24]
CALL 0x0010ebf0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RCX]
MOV dword ptr [RBP + -0x18],ECX
MOV ECX,dword ptr [RBP + -0x18]
MOV word ptr [RAX + 0x2],CX
MOVSX EAX,byte ptr [RAX]
MOVZX ECX,byte ptr [RBP + -0x9]
AND ECX,0x7
MOVSXD RDX,ECX
LEA RCX,[0x1f2dc0]
ADD EAX,dword ptr [RCX + RDX*0x4]
MOV dword ptr [RBP + -0x28],EAX
MOV dword ptr [RBP + -0x2c],0x0
MOV dword ptr [RBP + -0x30],0x58
LEA RDI,[RBP + -0x28]
LEA RSI,[RBP + -0x2c]
LEA RDX,[RBP + -0x30]
CALL 0x0010ebf0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RCX]
MOV byte ptr [RAX],CL
MOV EAX,dword ptr [RBP + -0x18]
ADD RSP,0x60
POP RBP
RET
|
/* Adpcm::Decode(unsigned char) */
int __thiscall Adpcm::Decode(Adpcm *this,uchar param_1)
{
int *piVar1;
int local_5c;
int local_54;
int local_4c;
int local_38 [3];
int local_2c [3];
int local_20;
int local_1c;
int local_18;
byte local_11;
Adpcm *local_10;
local_18 = *(int *)((anonymous_namespace)::StepSizeTable + (long)(char)*this * 4);
if ((param_1 & 1) == 0) {
local_4c = 0;
}
else {
local_4c = local_18 / 4;
}
if ((param_1 & 2) == 0) {
local_54 = 0;
}
else {
local_54 = local_18 / 2;
}
local_5c = local_18;
if ((param_1 & 4) == 0) {
local_5c = 0;
}
local_1c = local_18 / 8 + local_4c + local_54 + local_5c;
if ((param_1 & 8) != 0) {
local_1c = -local_1c;
}
local_2c[2] = *(short *)(this + 2) + local_1c;
local_2c[1] = 0xffff8000;
local_2c[0] = 0x7fff;
local_11 = param_1;
local_10 = this;
piVar1 = std::clamp<int>(local_2c + 2,local_2c + 1,local_2c);
local_20 = *piVar1;
*(short *)(this + 2) = (short)local_20;
local_38[2] = (int)(char)*this +
*(int *)((anonymous_namespace)::StepAdjustTable + (long)(int)(local_11 & 7) * 4);
local_38[1] = 0;
local_38[0] = 0x58;
piVar1 = std::clamp<int>(local_38 + 2,local_38 + 1,local_38);
*this = SUB41(*piVar1,0);
return local_20;
}
| |
29,201 | extent_to_bitmap_blocks | eloqsql/storage/maria/ma_blockrec.c | static my_bool extent_to_bitmap_blocks(MARIA_HA *info,
MARIA_BITMAP_BLOCKS *blocks,
pgcache_page_no_t head_page,
uint extent_count,
const uchar *extent_info)
{
MARIA_BITMAP_BLOCK *block, *start_block;
MARIA_SHARE *share= info->s;
uint i, tail_page;
DBUG_ENTER("extent_to_bitmap_blocks");
if (allocate_dynamic(&info->bitmap_blocks, extent_count + 2))
DBUG_RETURN(1);
block= blocks->block= dynamic_element(&info->bitmap_blocks, 0,
MARIA_BITMAP_BLOCK*);
blocks->count= extent_count + 1;
blocks->tail_page_skipped= blocks->page_skipped= 0;
block->page= head_page;
block->page_count= 1;
block->used= BLOCKUSED_USED | BLOCKUSED_USE_ORG_BITMAP;
/* Impossible value, will force storage of real value */
block->org_bitmap_value= 255;
start_block= block++;
for (i=0 ;
i++ < extent_count ;
block++, extent_info+= ROW_EXTENT_SIZE)
{
uint page_count= uint2korr(extent_info + ROW_EXTENT_PAGE_SIZE);
if (page_count & START_EXTENT_BIT)
{
page_count&= ~START_EXTENT_BIT;
start_block->sub_blocks= (uint) (block - start_block);
start_block= block;
}
block->page= page_korr(extent_info);
block->page_count= page_count;
block->sub_blocks= 0;
if (block->page_count == 0)
{
/* Extend allocated but not used by write_block_record() */
DBUG_ASSERT(block->page == 0);
/* This is the last block */
blocks->count= i;
break;
}
if ((tail_page= page_count & TAIL_BIT))
page_count= 1;
/* Check if wrong data */
if (block->page == 0 || page_count == 0 ||
(block->page + page_count) * share->block_size >
share->state.state.data_file_length)
{
DBUG_PRINT("error", ("page: %lu page_count: %u tail: %u length: %ld data_length: %ld",
(ulong) block->page,
(block->page_count & ~TAIL_BIT),
(uint) MY_TEST(block->page_count & TAIL_BIT),
(ulong) ((block->page + (page_count & ~TAIL_BIT)) *
share->block_size),
(ulong) share->state.state.data_file_length));
DBUG_RETURN(1);
}
if (tail_page)
{
block->org_bitmap_value= _ma_bitmap_get_page_bits(info, &share->bitmap,
block->page);
block->used= (BLOCKUSED_TAIL | BLOCKUSED_USED |
BLOCKUSED_USE_ORG_BITMAP);
}
else
{
my_bool res;
mysql_mutex_lock(&share->bitmap.bitmap_lock);
res= _ma_bitmap_set_full_page_bits(info, &share->bitmap,
block->page, page_count);
mysql_mutex_unlock(&share->bitmap.bitmap_lock);
if (res)
DBUG_RETURN(1);
block->used= BLOCKUSED_USED;
}
}
start_block->sub_blocks= (uint) (block - start_block);
DBUG_RETURN(0);
} | O0 | c | extent_to_bitmap_blocks:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq $0x2c0, %rdi # imm = 0x2C0
movl -0x24(%rbp), %esi
addl $0x2, %esi
callq 0xdc580
cmpb $0x0, %al
je 0x57fbb
jmp 0x57fb2
movb $0x1, -0x1(%rbp)
jmp 0x58211
movq -0x10(%rbp), %rax
movq 0x2c0(%rax), %rax
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
movq %rax, -0x38(%rbp)
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0xd(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0xc(%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x38(%rbp), %rax
movb $0x3, 0x14(%rax)
movq -0x38(%rbp), %rax
movb $-0x1, 0x15(%rax)
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, -0x38(%rbp)
movq %rax, -0x40(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x4c(%rbp)
cmpl -0x24(%rbp), %eax
jae 0x581ef
movq -0x30(%rbp), %rax
movzwl 0x5(%rax), %eax
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %eax
andl $0x4000, %eax # imm = 0x4000
cmpl $0x0, %eax
je 0x5808b
movl -0x54(%rbp), %eax
andl $0xffffbfff, %eax # imm = 0xFFFFBFFF
movl %eax, -0x54(%rbp)
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
subq %rcx, %rax
movl $0x18, %ecx
cqto
idivq %rcx
movl %eax, %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
callq 0x556f0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movl -0x54(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x38(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x580d0
jmp 0x580bf
jmp 0x580c1
movl -0x4c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x581ef
movl -0x54(%rbp), %eax
andl $0x8000, %eax # imm = 0x8000
movl %eax, -0x50(%rbp)
cmpl $0x0, %eax
je 0x580e7
movl $0x1, -0x54(%rbp)
movq -0x38(%rbp), %rax
cmpq $0x0, (%rax)
je 0x5811c
cmpl $0x0, -0x54(%rbp)
je 0x5811c
movq -0x38(%rbp), %rax
movq (%rax), %rax
movl -0x54(%rbp), %ecx
addq %rcx, %rax
movq -0x48(%rbp), %rcx
movl 0x7bc(%rcx), %ecx
imulq %rcx, %rax
movq -0x48(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jbe 0x5812b
jmp 0x5811e
jmp 0x58120
jmp 0x58122
movb $0x1, -0x1(%rbp)
jmp 0x58211
cmpl $0x0, -0x50(%rbp)
je 0x5815f
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq $0xa10, %rsi # imm = 0xA10
movq -0x38(%rbp), %rax
movq (%rax), %rdx
callq 0x5ec40
movb %al, %cl
movq -0x38(%rbp), %rax
movb %cl, 0x15(%rax)
movq -0x38(%rbp), %rax
movb $0x7, 0x14(%rax)
jmp 0x581d0
movq -0x48(%rbp), %rdi
addq $0xa10, %rdi # imm = 0xA10
addq $0x88, %rdi
leaq 0xfa3b9(%rip), %rsi # 0x152531
movl $0x97d, %edx # imm = 0x97D
callq 0x56410
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq $0xa10, %rsi # imm = 0xA10
movq -0x38(%rbp), %rax
movq (%rax), %rdx
movl -0x54(%rbp), %ecx
callq 0x5ef60
movb %al, -0x55(%rbp)
movq -0x48(%rbp), %rdi
addq $0xa10, %rdi # imm = 0xA10
addq $0x88, %rdi
callq 0x56480
cmpb $0x0, -0x55(%rbp)
je 0x581c8
jmp 0x581c2
movb $0x1, -0x1(%rbp)
jmp 0x58211
movq -0x38(%rbp), %rax
movb $0x1, 0x14(%rax)
jmp 0x581d2
movq -0x38(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
addq $0x7, %rax
movq %rax, -0x30(%rbp)
jmp 0x5802e
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
subq %rcx, %rax
movl $0x18, %ecx
cqto
idivq %rcx
movl %eax, %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x10(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| extent_to_bitmap_blocks:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov [rbp+var_30], r8
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_48], rax
mov rdi, [rbp+var_10]
add rdi, 2C0h
mov esi, [rbp+var_24]
add esi, 2
call allocate_dynamic
cmp al, 0
jz short loc_57FBB
jmp short $+2
loc_57FB2:
mov [rbp+var_1], 1
jmp loc_58211
loc_57FBB:
mov rax, [rbp+var_10]
mov rax, [rax+2C0h]
mov rcx, [rbp+var_18]
mov [rcx], rax
mov [rbp+var_38], rax
mov ecx, [rbp+var_24]
add ecx, 1
mov rax, [rbp+var_18]
mov [rax+8], ecx
mov rax, [rbp+var_18]
mov byte ptr [rax+0Dh], 0
mov rax, [rbp+var_18]
mov byte ptr [rax+0Ch], 0
mov rcx, [rbp+var_20]
mov rax, [rbp+var_38]
mov [rax], rcx
mov rax, [rbp+var_38]
mov dword ptr [rax+8], 1
mov rax, [rbp+var_38]
mov byte ptr [rax+14h], 3
mov rax, [rbp+var_38]
mov byte ptr [rax+15h], 0FFh
mov rax, [rbp+var_38]
mov rcx, rax
add rcx, 18h
mov [rbp+var_38], rcx
mov [rbp+var_40], rax
mov [rbp+var_4C], 0
loc_5802E:
mov eax, [rbp+var_4C]
mov ecx, eax
add ecx, 1
mov [rbp+var_4C], ecx
cmp eax, [rbp+var_24]
jnb loc_581EF
mov rax, [rbp+var_30]
movzx eax, word ptr [rax+5]
mov [rbp+var_54], eax
mov eax, [rbp+var_54]
and eax, 4000h
cmp eax, 0
jz short loc_5808B
mov eax, [rbp+var_54]
and eax, 0FFFFBFFFh
mov [rbp+var_54], eax
mov rax, [rbp+var_38]
mov rcx, [rbp+var_40]
sub rax, rcx
mov ecx, 18h
cqo
idiv rcx
mov ecx, eax
mov rax, [rbp+var_40]
mov [rax+10h], ecx
mov rax, [rbp+var_38]
mov [rbp+var_40], rax
loc_5808B:
mov rdi, [rbp+var_30]
call uint5korr_0
mov rcx, rax
mov rax, [rbp+var_38]
mov [rax], rcx
mov ecx, [rbp+var_54]
mov rax, [rbp+var_38]
mov [rax+8], ecx
mov rax, [rbp+var_38]
mov dword ptr [rax+10h], 0
mov rax, [rbp+var_38]
cmp dword ptr [rax+8], 0
jnz short loc_580D0
jmp short $+2
loc_580BF:
jmp short $+2
loc_580C1:
mov ecx, [rbp+var_4C]
mov rax, [rbp+var_18]
mov [rax+8], ecx
jmp loc_581EF
loc_580D0:
mov eax, [rbp+var_54]
and eax, 8000h
mov [rbp+var_50], eax
cmp eax, 0
jz short loc_580E7
mov [rbp+var_54], 1
loc_580E7:
mov rax, [rbp+var_38]
cmp qword ptr [rax], 0
jz short loc_5811C
cmp [rbp+var_54], 0
jz short loc_5811C
mov rax, [rbp+var_38]
mov rax, [rax]
mov ecx, [rbp+var_54]
add rax, rcx
mov rcx, [rbp+var_48]
mov ecx, [rcx+7BCh]
imul rax, rcx
mov rcx, [rbp+var_48]
cmp rax, [rcx+40h]
jbe short loc_5812B
loc_5811C:
jmp short $+2
loc_5811E:
jmp short $+2
loc_58120:
jmp short $+2
loc_58122:
mov [rbp+var_1], 1
jmp loc_58211
loc_5812B:
cmp [rbp+var_50], 0
jz short loc_5815F
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_48]
add rsi, 0A10h
mov rax, [rbp+var_38]
mov rdx, [rax]
call _ma_bitmap_get_page_bits
mov cl, al
mov rax, [rbp+var_38]
mov [rax+15h], cl
mov rax, [rbp+var_38]
mov byte ptr [rax+14h], 7
jmp short loc_581D0
loc_5815F:
mov rdi, [rbp+var_48]
add rdi, 0A10h
add rdi, 88h
lea rsi, aWorkspaceLlm4b_9; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 97Dh
call inline_mysql_mutex_lock_6
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_48]
add rsi, 0A10h
mov rax, [rbp+var_38]
mov rdx, [rax]
mov ecx, [rbp+var_54]
call _ma_bitmap_set_full_page_bits
mov [rbp+var_55], al
mov rdi, [rbp+var_48]
add rdi, 0A10h
add rdi, 88h
call inline_mysql_mutex_unlock_6
cmp [rbp+var_55], 0
jz short loc_581C8
jmp short $+2
loc_581C2:
mov [rbp+var_1], 1
jmp short loc_58211
loc_581C8:
mov rax, [rbp+var_38]
mov byte ptr [rax+14h], 1
loc_581D0:
jmp short $+2
loc_581D2:
mov rax, [rbp+var_38]
add rax, 18h
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
add rax, 7
mov [rbp+var_30], rax
jmp loc_5802E
loc_581EF:
mov rax, [rbp+var_38]
mov rcx, [rbp+var_40]
sub rax, rcx
mov ecx, 18h
cqo
idiv rcx
mov ecx, eax
mov rax, [rbp+var_40]
mov [rax+10h], ecx
mov [rbp+var_1], 0
loc_58211:
mov al, [rbp+var_1]
add rsp, 60h
pop rbp
retn
| char extent_to_bitmap_blocks(long long *a1, long long a2, long long a3, unsigned int a4, long long a5)
{
long long v5; // rax
unsigned int v6; // eax
char v8; // [rsp+Bh] [rbp-55h]
unsigned int v9; // [rsp+Ch] [rbp-54h]
int v10; // [rsp+10h] [rbp-50h]
unsigned int v11; // [rsp+14h] [rbp-4Ch]
long long v12; // [rsp+18h] [rbp-48h]
unsigned long long *v13; // [rsp+20h] [rbp-40h]
unsigned long long *v14; // [rsp+28h] [rbp-38h]
v12 = *a1;
if ( (unsigned __int8)allocate_dynamic(a1 + 88, a4 + 2) )
return 1;
v5 = a1[88];
*(_QWORD *)a2 = v5;
*(_DWORD *)(a2 + 8) = a4 + 1;
*(_BYTE *)(a2 + 13) = 0;
*(_BYTE *)(a2 + 12) = 0;
*(_QWORD *)v5 = a3;
*(_DWORD *)(v5 + 8) = 1;
*(_BYTE *)(v5 + 20) = 3;
*(_BYTE *)(v5 + 21) = -1;
v14 = (unsigned long long *)(v5 + 24);
v13 = (unsigned long long *)v5;
v11 = 0;
while ( 1 )
{
v6 = v11++;
if ( v6 >= a4 )
break;
v9 = *(unsigned __int16 *)(a5 + 5);
if ( (v9 & 0x4000) != 0 )
{
v9 &= ~0x4000u;
*((_DWORD *)v13 + 4) = ((char *)v14 - (char *)v13) / 24;
v13 = v14;
}
*v14 = uint5korr_0((unsigned int *)a5);
*((_DWORD *)v14 + 2) = v9;
*((_DWORD *)v14 + 4) = 0;
if ( !*((_DWORD *)v14 + 2) )
{
*(_DWORD *)(a2 + 8) = v11;
break;
}
v10 = v9 & 0x8000;
if ( (v9 & 0x8000) != 0 )
v9 = 1;
if ( !*v14 || !v9 || *(unsigned int *)(v12 + 1980) * (v9 + *v14) > *(_QWORD *)(v12 + 64) )
return 1;
if ( v10 )
{
*((_BYTE *)v14 + 21) = ma_bitmap_get_page_bits(a1, v12 + 2576, *v14);
*((_BYTE *)v14 + 20) = 7;
}
else
{
inline_mysql_mutex_lock_6(
v12 + 2712,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_blockrec.c",
0x97Du);
v8 = ma_bitmap_set_full_page_bits(a1, v12 + 2576, *v14, v9);
inline_mysql_mutex_unlock_6(v12 + 2712);
if ( v8 )
return 1;
*((_BYTE *)v14 + 20) = 1;
}
v14 += 3;
a5 += 7LL;
}
*((_DWORD *)v13 + 4) = ((char *)v14 - (char *)v13) / 24;
return 0;
}
| extent_to_bitmap_blocks:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV qword ptr [RBP + -0x30],R8
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x48],RAX
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x2c0
MOV ESI,dword ptr [RBP + -0x24]
ADD ESI,0x2
CALL 0x001dc580
CMP AL,0x0
JZ 0x00157fbb
JMP 0x00157fb2
LAB_00157fb2:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00158211
LAB_00157fbb:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x2c0]
MOV RCX,qword ptr [RBP + -0x18]
MOV qword ptr [RCX],RAX
MOV qword ptr [RBP + -0x38],RAX
MOV ECX,dword ptr [RBP + -0x24]
ADD ECX,0x1
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x8],ECX
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0xd],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0xc],0x0
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x8],0x1
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x14],0x3
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x15],0xff
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,RAX
ADD RCX,0x18
MOV qword ptr [RBP + -0x38],RCX
MOV qword ptr [RBP + -0x40],RAX
MOV dword ptr [RBP + -0x4c],0x0
LAB_0015802e:
MOV EAX,dword ptr [RBP + -0x4c]
MOV ECX,EAX
ADD ECX,0x1
MOV dword ptr [RBP + -0x4c],ECX
CMP EAX,dword ptr [RBP + -0x24]
JNC 0x001581ef
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,word ptr [RAX + 0x5]
MOV dword ptr [RBP + -0x54],EAX
MOV EAX,dword ptr [RBP + -0x54]
AND EAX,0x4000
CMP EAX,0x0
JZ 0x0015808b
MOV EAX,dword ptr [RBP + -0x54]
AND EAX,0xffffbfff
MOV dword ptr [RBP + -0x54],EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x40]
SUB RAX,RCX
MOV ECX,0x18
CQO
IDIV RCX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x40],RAX
LAB_0015808b:
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x001556f0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],RCX
MOV ECX,dword ptr [RBP + -0x54]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x8],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x10],0x0
MOV RAX,qword ptr [RBP + -0x38]
CMP dword ptr [RAX + 0x8],0x0
JNZ 0x001580d0
JMP 0x001580bf
LAB_001580bf:
JMP 0x001580c1
LAB_001580c1:
MOV ECX,dword ptr [RBP + -0x4c]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x8],ECX
JMP 0x001581ef
LAB_001580d0:
MOV EAX,dword ptr [RBP + -0x54]
AND EAX,0x8000
MOV dword ptr [RBP + -0x50],EAX
CMP EAX,0x0
JZ 0x001580e7
MOV dword ptr [RBP + -0x54],0x1
LAB_001580e7:
MOV RAX,qword ptr [RBP + -0x38]
CMP qword ptr [RAX],0x0
JZ 0x0015811c
CMP dword ptr [RBP + -0x54],0x0
JZ 0x0015811c
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x54]
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x48]
MOV ECX,dword ptr [RCX + 0x7bc]
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x48]
CMP RAX,qword ptr [RCX + 0x40]
JBE 0x0015812b
LAB_0015811c:
JMP 0x0015811e
LAB_0015811e:
JMP 0x00158120
LAB_00158120:
JMP 0x00158122
LAB_00158122:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00158211
LAB_0015812b:
CMP dword ptr [RBP + -0x50],0x0
JZ 0x0015815f
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x48]
ADD RSI,0xa10
MOV RAX,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RAX]
CALL 0x0015ec40
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x15],CL
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x14],0x7
JMP 0x001581d0
LAB_0015815f:
MOV RDI,qword ptr [RBP + -0x48]
ADD RDI,0xa10
ADD RDI,0x88
LEA RSI,[0x252531]
MOV EDX,0x97d
CALL 0x00156410
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x48]
ADD RSI,0xa10
MOV RAX,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x54]
CALL 0x0015ef60
MOV byte ptr [RBP + -0x55],AL
MOV RDI,qword ptr [RBP + -0x48]
ADD RDI,0xa10
ADD RDI,0x88
CALL 0x00156480
CMP byte ptr [RBP + -0x55],0x0
JZ 0x001581c8
JMP 0x001581c2
LAB_001581c2:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00158211
LAB_001581c8:
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x14],0x1
LAB_001581d0:
JMP 0x001581d2
LAB_001581d2:
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x18
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x7
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0015802e
LAB_001581ef:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x40]
SUB RAX,RCX
MOV ECX,0x18
CQO
IDIV RCX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV dword ptr [RAX + 0x10],ECX
MOV byte ptr [RBP + -0x1],0x0
LAB_00158211:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x60
POP RBP
RET
|
int1
extent_to_bitmap_blocks(long *param_1,long *param_2,long param_3,uint param_4,long param_5)
{
long lVar1;
long *plVar2;
char cVar3;
int1 uVar4;
uint uVar5;
long lVar6;
ulong uVar7;
uint local_5c;
uint local_54;
long *local_48;
long *local_40;
long local_38;
int1 local_9;
lVar1 = *param_1;
cVar3 = allocate_dynamic(param_1 + 0x58,param_4 + 2);
if (cVar3 == '\0') {
local_48 = (long *)param_1[0x58];
*param_2 = (long)local_48;
*(uint *)(param_2 + 1) = param_4 + 1;
*(int1 *)((long)param_2 + 0xd) = 0;
*(int1 *)((long)param_2 + 0xc) = 0;
*local_48 = param_3;
*(int4 *)(local_48 + 1) = 1;
*(int1 *)((long)local_48 + 0x14) = 3;
*(int1 *)((long)local_48 + 0x15) = 0xff;
local_54 = 0;
local_38 = param_5;
plVar2 = local_48;
while( true ) {
local_40 = plVar2 + 3;
if (param_4 <= local_54) break;
local_5c = (uint)*(ushort *)(local_38 + 5);
if ((*(ushort *)(local_38 + 5) & 0x4000) != 0) {
local_5c = local_5c & 0xffffbfff;
*(int *)(local_48 + 2) = (int)(((long)local_40 - (long)local_48) / 0x18);
local_48 = local_40;
}
lVar6 = uint5korr(local_38);
*local_40 = lVar6;
*(uint *)(plVar2 + 4) = local_5c;
*(int4 *)(plVar2 + 5) = 0;
if ((int)plVar2[4] == 0) {
*(uint *)(param_2 + 1) = local_54 + 1;
break;
}
uVar5 = local_5c & 0x8000;
if (uVar5 != 0) {
local_5c = 1;
}
if (((*local_40 == 0) || (local_5c == 0)) ||
(uVar7 = (*local_40 + (ulong)local_5c) * (ulong)*(uint *)(lVar1 + 0x7bc),
*(ulong *)(lVar1 + 0x40) <= uVar7 && uVar7 - *(ulong *)(lVar1 + 0x40) != 0)) {
return 1;
}
if (uVar5 == 0) {
inline_mysql_mutex_lock
(lVar1 + 0xa98,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_blockrec.c",0x97d);
cVar3 = _ma_bitmap_set_full_page_bits(param_1,lVar1 + 0xa10,*local_40,local_5c);
inline_mysql_mutex_unlock(lVar1 + 0xa98);
if (cVar3 != '\0') {
return 1;
}
*(int1 *)((long)plVar2 + 0x2c) = 1;
}
else {
uVar4 = _ma_bitmap_get_page_bits(param_1,lVar1 + 0xa10,*local_40);
*(int1 *)((long)plVar2 + 0x2d) = uVar4;
*(int1 *)((long)plVar2 + 0x2c) = 7;
}
local_38 = local_38 + 7;
local_54 = local_54 + 1;
plVar2 = local_40;
}
*(int *)(local_48 + 2) = (int)(((long)local_40 - (long)local_48) / 0x18);
local_9 = 0;
}
else {
local_9 = 1;
}
return local_9;
}
| |
29,202 | nglog::(anonymous namespace)::PrettyDuration[abi:cxx11](std::chrono::duration<int, std::ratio<1l, 1l>> const&) | ng-log[P]ng-log/src/logging.cc | string PrettyDuration(const std::chrono::duration<int>& secs) {
std::stringstream result;
int mins = secs.count() / 60;
int hours = mins / 60;
mins = mins % 60;
int s = secs.count() % 60;
result.fill('0');
result << hours << ':' << setw(2) << mins << ':' << setw(2) << s;
return result.str();
} | O0 | cpp | nglog::(anonymous namespace)::PrettyDuration[abi:cxx11](std::chrono::duration<int, std::ratio<1l, 1l>> const&):
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp # imm = 0x220
movq %rdi, -0x1d0(%rbp)
movq %rdi, %rax
movq %rax, -0x1c8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x9500
movq -0x10(%rbp), %rdi
callq 0x1f460
movl %eax, -0x1c0(%rbp)
jmp 0x1afd1
movl -0x1c0(%rbp), %ecx
movslq %ecx, %rax
imulq $-0x77777777, %rax, %rax # imm = 0x88888889
shrq $0x20, %rax
addl %ecx, %eax
movl %eax, %ecx
shrl $0x1f, %ecx
sarl $0x5, %eax
addl %ecx, %eax
movl %eax, -0x19c(%rbp)
movslq -0x19c(%rbp), %rax
movl %eax, %ecx
imulq $-0x77777777, %rax, %rax # imm = 0x88888889
shrq $0x20, %rax
addl %ecx, %eax
movl %eax, %ecx
shrl $0x1f, %ecx
sarl $0x5, %eax
addl %ecx, %eax
movl %eax, -0x1b0(%rbp)
movslq -0x19c(%rbp), %rcx
movl %ecx, %eax
imulq $-0x77777777, %rcx, %rcx # imm = 0x88888889
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
sarl $0x5, %ecx
addl %edx, %ecx
imull $0x3c, %ecx, %ecx
subl %ecx, %eax
movl %eax, -0x19c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1f460
movl %eax, -0x1d4(%rbp)
jmp 0x1b059
movl -0x1d4(%rbp), %eax
movslq %eax, %rcx
imulq $-0x77777777, %rcx, %rcx # imm = 0x88888889
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
sarl $0x5, %ecx
addl %edx, %ecx
imull $0x3c, %ecx, %ecx
subl %ecx, %eax
movl %eax, -0x1b4(%rbp)
movq -0x198(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x198(%rbp,%rax), %rdi
movl $0x30, %esi
callq 0x97d0
jmp 0x1b0a3
leaq -0x188(%rbp), %rdi
movl -0x1b0(%rbp), %esi
callq 0x9d10
movq %rax, -0x1e0(%rbp)
jmp 0x1b0be
movq -0x1e0(%rbp), %rdi
movl $0x3a, %esi
callq 0x98a0
movq %rax, -0x1e8(%rbp)
jmp 0x1b0d8
movl $0x2, %edi
callq 0x1d730
movl %eax, -0x1ec(%rbp)
jmp 0x1b0ea
movq -0x1e8(%rbp), %rdi
movl -0x1ec(%rbp), %eax
movl %eax, -0x1b8(%rbp)
movl -0x1b8(%rbp), %esi
callq 0x9870
movq %rax, -0x1f8(%rbp)
jmp 0x1b111
movq -0x1f8(%rbp), %rdi
movl -0x19c(%rbp), %esi
callq 0x9d10
movq %rax, -0x200(%rbp)
jmp 0x1b12c
movq -0x200(%rbp), %rdi
movl $0x3a, %esi
callq 0x98a0
movq %rax, -0x208(%rbp)
jmp 0x1b146
movl $0x2, %edi
callq 0x1d730
movl %eax, -0x20c(%rbp)
jmp 0x1b158
movq -0x208(%rbp), %rdi
movl -0x20c(%rbp), %eax
movl %eax, -0x1bc(%rbp)
movl -0x1bc(%rbp), %esi
callq 0x9870
movq %rax, -0x218(%rbp)
jmp 0x1b17f
movq -0x218(%rbp), %rdi
movl -0x1b4(%rbp), %esi
callq 0x9d10
jmp 0x1b193
movq -0x1d0(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x96d0
jmp 0x1b1a8
leaq -0x198(%rbp), %rdi
callq 0x9560
movq -0x1c8(%rbp), %rax
addq $0x220, %rsp # imm = 0x220
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x9560
movq -0x1a8(%rbp), %rdi
callq 0x9d40
nop
| _ZN5nglog12_GLOBAL__N_114PrettyDurationB5cxx11ERKNSt6chrono8durationIiSt5ratioILl1ELl1EEEE:
push rbp
mov rbp, rsp
sub rsp, 220h
mov [rbp+var_1D0], rdi
mov rax, rdi
mov [rbp+var_1C8], rax
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
lea rdi, [rbp+var_198]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(void)
mov rdi, [rbp+var_10]
call _ZNKSt6chrono8durationIiSt5ratioILl1ELl1EEE5countEv; std::chrono::duration<int,std::ratio<1l,1l>>::count(void)
mov [rbp+var_1C0], eax
jmp short $+2
loc_1AFD1:
mov ecx, [rbp+var_1C0]
movsxd rax, ecx
imul rax, 0FFFFFFFF88888889h
shr rax, 20h
add eax, ecx
mov ecx, eax
shr ecx, 1Fh
sar eax, 5
add eax, ecx
mov [rbp+var_19C], eax
movsxd rax, [rbp+var_19C]
mov ecx, eax
imul rax, 0FFFFFFFF88888889h
shr rax, 20h
add eax, ecx
mov ecx, eax
shr ecx, 1Fh
sar eax, 5
add eax, ecx
mov [rbp+var_1B0], eax
movsxd rcx, [rbp+var_19C]
mov eax, ecx
imul rcx, 0FFFFFFFF88888889h
shr rcx, 20h
add ecx, eax
mov edx, ecx
shr edx, 1Fh
sar ecx, 5
add ecx, edx
imul ecx, 3Ch ; '<'
sub eax, ecx
mov [rbp+var_19C], eax
mov rdi, [rbp+var_10]
call _ZNKSt6chrono8durationIiSt5ratioILl1ELl1EEE5countEv; std::chrono::duration<int,std::ratio<1l,1l>>::count(void)
mov [rbp+var_1D4], eax
jmp short $+2
loc_1B059:
mov eax, [rbp+var_1D4]
movsxd rcx, eax
imul rcx, 0FFFFFFFF88888889h
shr rcx, 20h
add ecx, eax
mov edx, ecx
shr edx, 1Fh
sar ecx, 5
add ecx, edx
imul ecx, 3Ch ; '<'
sub eax, ecx
mov [rbp+var_1B4], eax
mov rax, [rbp+var_198]
mov rax, [rax-18h]
lea rdi, [rbp+rax+var_198]
mov esi, 30h ; '0'
call __ZNSt9basic_iosIcSt11char_traitsIcEE4fillEc; std::ios::fill(char)
jmp short $+2
loc_1B0A3:
lea rdi, [rbp+var_188]
mov esi, [rbp+var_1B0]
call __ZNSolsEi; std::ostream::operator<<(int)
mov [rbp+var_1E0], rax
jmp short $+2
loc_1B0BE:
mov rdi, [rbp+var_1E0]
mov esi, 3Ah ; ':'
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_c; std::operator<<<std::char_traits<char>>(std::ostream &,char)
mov [rbp+var_1E8], rax
jmp short $+2
loc_1B0D8:
mov edi, 2; int
call _ZSt4setwi; std::setw(int)
mov [rbp+var_1EC], eax
jmp short $+2
loc_1B0EA:
mov rdi, [rbp+var_1E8]
mov eax, [rbp+var_1EC]
mov [rbp+var_1B8], eax
mov esi, [rbp+var_1B8]
call __ZStlsIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_St5_Setw; std::operator<<<char,std::char_traits<char>>(std::ostream &,std::_Setw)
mov [rbp+var_1F8], rax
jmp short $+2
loc_1B111:
mov rdi, [rbp+var_1F8]
mov esi, [rbp+var_19C]
call __ZNSolsEi; std::ostream::operator<<(int)
mov [rbp+var_200], rax
jmp short $+2
loc_1B12C:
mov rdi, [rbp+var_200]
mov esi, 3Ah ; ':'
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_c; std::operator<<<std::char_traits<char>>(std::ostream &,char)
mov [rbp+var_208], rax
jmp short $+2
loc_1B146:
mov edi, 2; int
call _ZSt4setwi; std::setw(int)
mov [rbp+var_20C], eax
jmp short $+2
loc_1B158:
mov rdi, [rbp+var_208]
mov eax, [rbp+var_20C]
mov [rbp+var_1BC], eax
mov esi, [rbp+var_1BC]
call __ZStlsIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_St5_Setw; std::operator<<<char,std::char_traits<char>>(std::ostream &,std::_Setw)
mov [rbp+var_218], rax
jmp short $+2
loc_1B17F:
mov rdi, [rbp+var_218]
mov esi, [rbp+var_1B4]
call __ZNSolsEi; std::ostream::operator<<(int)
jmp short $+2
loc_1B193:
mov rdi, [rbp+var_1D0]
lea rsi, [rbp+var_198]
call __ZNKSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEE3strEv; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::str(void)
jmp short $+2
loc_1B1A8:
lea rdi, [rbp+var_198]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
mov rax, [rbp+var_1C8]
add rsp, 220h
pop rbp
retn
mov rcx, rax
mov eax, edx
mov [rbp+var_1A8], rcx
mov [rbp+var_1AC], eax
lea rdi, [rbp+var_198]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
mov rdi, [rbp+var_1A8]
call __Unwind_Resume
| long long nglog::`anonymous namespace'::PrettyDuration[abi:cxx11](long long a1, long long a2)
{
long long v3; // [rsp+8h] [rbp-218h]
long long v4; // [rsp+18h] [rbp-208h]
long long v5; // [rsp+20h] [rbp-200h]
long long v6; // [rsp+28h] [rbp-1F8h]
long long v7; // [rsp+38h] [rbp-1E8h]
long long v8; // [rsp+40h] [rbp-1E0h]
int v9; // [rsp+60h] [rbp-1C0h]
unsigned int v10; // [rsp+64h] [rbp-1BCh]
unsigned int v11; // [rsp+68h] [rbp-1B8h]
unsigned int v12; // [rsp+6Ch] [rbp-1B4h]
_QWORD v13[2]; // [rsp+88h] [rbp-198h] BYREF
_BYTE v14[376]; // [rsp+98h] [rbp-188h] BYREF
long long v15; // [rsp+210h] [rbp-10h]
long long v16; // [rsp+218h] [rbp-8h]
v16 = a1;
v15 = a2;
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(v13);
v9 = std::chrono::duration<int,std::ratio<1l,1l>>::count(v15);
v12 = (int)std::chrono::duration<int,std::ratio<1l,1l>>::count(v15) % 60;
std::ios::fill((char *)v13 + *(_QWORD *)(v13[0] - 24LL), 48LL);
v8 = std::ostream::operator<<(v14, (unsigned int)(v9 / 60 / 60));
v7 = std::operator<<<std::char_traits<char>>(v8, 58LL);
v11 = std::setw(2);
v6 = std::operator<<<char,std::char_traits<char>>(v7, v11);
v5 = std::ostream::operator<<(v6, (unsigned int)(v9 / 60 % 60));
v4 = std::operator<<<std::char_traits<char>>(v5, 58LL);
v10 = std::setw(2);
v3 = std::operator<<<char,std::char_traits<char>>(v4, v10);
std::ostream::operator<<(v3, v12);
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::str(a1, v13);
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream(v13);
return a1;
}
| PrettyDuration[abi:cxx11]:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x220
MOV qword ptr [RBP + -0x1d0],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0x1c8],RAX
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
LEA RDI,[RBP + -0x198]
CALL 0x00109500
MOV RDI,qword ptr [RBP + -0x10]
LAB_0011afc4:
CALL 0x0011f460
MOV dword ptr [RBP + -0x1c0],EAX
JMP 0x0011afd1
LAB_0011afd1:
MOV ECX,dword ptr [RBP + -0x1c0]
MOVSXD RAX,ECX
IMUL RAX,RAX,-0x77777777
SHR RAX,0x20
ADD EAX,ECX
MOV ECX,EAX
SHR ECX,0x1f
SAR EAX,0x5
ADD EAX,ECX
MOV dword ptr [RBP + -0x19c],EAX
MOVSXD RAX,dword ptr [RBP + -0x19c]
MOV ECX,EAX
IMUL RAX,RAX,-0x77777777
SHR RAX,0x20
ADD EAX,ECX
MOV ECX,EAX
SHR ECX,0x1f
SAR EAX,0x5
ADD EAX,ECX
MOV dword ptr [RBP + -0x1b0],EAX
MOVSXD RCX,dword ptr [RBP + -0x19c]
MOV EAX,ECX
IMUL RCX,RCX,-0x77777777
SHR RCX,0x20
ADD ECX,EAX
MOV EDX,ECX
SHR EDX,0x1f
SAR ECX,0x5
ADD ECX,EDX
IMUL ECX,ECX,0x3c
SUB EAX,ECX
MOV dword ptr [RBP + -0x19c],EAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0011f460
MOV dword ptr [RBP + -0x1d4],EAX
JMP 0x0011b059
LAB_0011b059:
MOV EAX,dword ptr [RBP + -0x1d4]
MOVSXD RCX,EAX
IMUL RCX,RCX,-0x77777777
SHR RCX,0x20
ADD ECX,EAX
MOV EDX,ECX
SHR EDX,0x1f
SAR ECX,0x5
ADD ECX,EDX
IMUL ECX,ECX,0x3c
SUB EAX,ECX
MOV dword ptr [RBP + -0x1b4],EAX
MOV RAX,qword ptr [RBP + -0x198]
MOV RAX,qword ptr [RAX + -0x18]
LEA RDI,[RBP + RAX*0x1 + -0x198]
MOV ESI,0x30
CALL 0x001097d0
JMP 0x0011b0a3
LAB_0011b0a3:
LEA RDI,[RBP + -0x188]
MOV ESI,dword ptr [RBP + -0x1b0]
CALL 0x00109d10
MOV qword ptr [RBP + -0x1e0],RAX
JMP 0x0011b0be
LAB_0011b0be:
MOV RDI,qword ptr [RBP + -0x1e0]
MOV ESI,0x3a
CALL 0x001098a0
MOV qword ptr [RBP + -0x1e8],RAX
JMP 0x0011b0d8
LAB_0011b0d8:
MOV EDI,0x2
CALL 0x0011d730
MOV dword ptr [RBP + -0x1ec],EAX
JMP 0x0011b0ea
LAB_0011b0ea:
MOV RDI,qword ptr [RBP + -0x1e8]
MOV EAX,dword ptr [RBP + -0x1ec]
MOV dword ptr [RBP + -0x1b8],EAX
MOV ESI,dword ptr [RBP + -0x1b8]
CALL 0x00109870
MOV qword ptr [RBP + -0x1f8],RAX
JMP 0x0011b111
LAB_0011b111:
MOV RDI,qword ptr [RBP + -0x1f8]
MOV ESI,dword ptr [RBP + -0x19c]
CALL 0x00109d10
MOV qword ptr [RBP + -0x200],RAX
JMP 0x0011b12c
LAB_0011b12c:
MOV RDI,qword ptr [RBP + -0x200]
MOV ESI,0x3a
CALL 0x001098a0
MOV qword ptr [RBP + -0x208],RAX
JMP 0x0011b146
LAB_0011b146:
MOV EDI,0x2
CALL 0x0011d730
MOV dword ptr [RBP + -0x20c],EAX
JMP 0x0011b158
LAB_0011b158:
MOV RDI,qword ptr [RBP + -0x208]
MOV EAX,dword ptr [RBP + -0x20c]
MOV dword ptr [RBP + -0x1bc],EAX
MOV ESI,dword ptr [RBP + -0x1bc]
CALL 0x00109870
MOV qword ptr [RBP + -0x218],RAX
JMP 0x0011b17f
LAB_0011b17f:
MOV RDI,qword ptr [RBP + -0x218]
MOV ESI,dword ptr [RBP + -0x1b4]
CALL 0x00109d10
JMP 0x0011b193
LAB_0011b193:
MOV RDI,qword ptr [RBP + -0x1d0]
LEA RSI,[RBP + -0x198]
CALL 0x001096d0
LAB_0011b1a6:
JMP 0x0011b1a8
LAB_0011b1a8:
LEA RDI,[RBP + -0x198]
CALL 0x00109560
MOV RAX,qword ptr [RBP + -0x1c8]
ADD RSP,0x220
POP RBP
RET
|
/* nglog::(anonymous namespace)::PrettyDuration[abi:cxx11](std::chrono::duration<int, std::ratio<1l,
1l> > const&) */
_anonymous_namespace_ * __thiscall
nglog::(anonymous_namespace)::PrettyDuration_abi_cxx11_
(_anonymous_namespace_ *this,duration *param_1)
{
int iVar1;
int iVar2;
int4 uVar3;
ostream *poVar4;
long local_1a0 [2];
ostream local_190 [376];
duration<int,std::ratio<1l,1l>> *local_18;
_anonymous_namespace_ *local_10;
local_18 = (duration<int,std::ratio<1l,1l>> *)param_1;
local_10 = this;
std::__cxx11::stringstream::stringstream((stringstream *)local_1a0);
/* try { // try from 0011afc4 to 0011b1a5 has its CatchHandler @ 0011b1c4 */
iVar1 = std::chrono::duration<int,std::ratio<1l,1l>>::count(local_18);
iVar2 = std::chrono::duration<int,std::ratio<1l,1l>>::count(local_18);
std::ios::fill((char)local_1a0 + (char)*(int8 *)(local_1a0[0] + -0x18));
poVar4 = (ostream *)std::ostream::operator<<(local_190,(iVar1 / 0x3c) / 0x3c);
poVar4 = std::operator<<(poVar4,':');
uVar3 = std::setw(2);
poVar4 = std::operator<<(poVar4,uVar3);
poVar4 = (ostream *)std::ostream::operator<<(poVar4,(iVar1 / 0x3c) % 0x3c);
poVar4 = std::operator<<(poVar4,':');
uVar3 = std::setw(2);
poVar4 = std::operator<<(poVar4,uVar3);
std::ostream::operator<<(poVar4,iVar2 % 0x3c);
std::__cxx11::stringstream::str();
std::__cxx11::stringstream::~stringstream((stringstream *)local_1a0);
return this;
}
| |
29,203 | uf_prespace_selected | eloqsql/storage/myisam/mi_packrec.c | static void uf_prespace_selected(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
uchar *to, uchar *end)
{
uint spaces;
if (get_bit(bit_buff))
{
if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
{
bit_buff->error=1;
return;
}
bfill((uchar*) to,spaces,' ');
if (to+spaces != end)
decode_bytes(rec,bit_buff,to+spaces,end);
}
else
decode_bytes(rec,bit_buff,to,end);
} | O0 | c | uf_prespace_selected:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0xbd7fa
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rdx
movl 0x4(%rdx), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rdx)
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0xbd822
jmp 0xbd8da
movq -0x10(%rbp), %rdi
callq 0xbc3a0
movq -0x10(%rbp), %rax
movl $0x1f, 0x4(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x0, %eax
je 0xbd8da
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jb 0xbd865
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x1c(%rcx), %esi
movq -0x10(%rbp), %rdx
movl 0x4(%rdx), %ecx
subl %esi, %ecx
movl %ecx, 0x4(%rdx)
shrl %cl, %eax
movq -0x8(%rbp), %rcx
movl 0x1c(%rcx), %ecx
movl %ecx, %edx
leaq 0x201de3(%rip), %rcx # 0x2bf640
andl (%rcx,%rdx,4), %eax
movl %eax, -0x28(%rbp)
jmp 0xbd878
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %esi
callq 0xbab50
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
cmpq -0x20(%rbp), %rax
jbe 0xbd89a
movq -0x10(%rbp), %rax
movl $0x1, 0x28(%rax)
jmp 0xbd8ef
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %edx
movl $0x20, %esi
callq 0x2a2c0
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
addq %rcx, %rax
cmpq -0x20(%rbp), %rax
je 0xbd8d8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x24(%rbp), %eax
addq %rax, %rdx
movq -0x20(%rbp), %rcx
callq 0xbcab0
jmp 0xbd8ef
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xbcab0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| uf_prespace_selected_0:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov rax, [rbp+var_10]
cmp dword ptr [rax+4], 0
jz short loc_BD7FA
mov rax, [rbp+var_10]
mov eax, [rax]
mov rdx, [rbp+var_10]
mov ecx, [rdx+4]
add ecx, 0FFFFFFFFh
mov [rdx+4], ecx
mov edx, 1
shl edx, cl
mov ecx, edx
and eax, ecx
cmp eax, 0
jnz short loc_BD822
jmp loc_BD8DA
loc_BD7FA:
mov rdi, [rbp+var_10]
call fill_buffer_0
mov rax, [rbp+var_10]
mov dword ptr [rax+4], 1Fh
mov rax, [rbp+var_10]
mov eax, [rax]
and eax, 80000000h
cmp eax, 0
jz loc_BD8DA
loc_BD822:
mov rax, [rbp+var_10]
mov eax, [rax+4]
mov rcx, [rbp+var_8]
cmp eax, [rcx+1Ch]
jb short loc_BD865
mov rax, [rbp+var_10]
mov eax, [rax]
mov rcx, [rbp+var_8]
mov esi, [rcx+1Ch]
mov rdx, [rbp+var_10]
mov ecx, [rdx+4]
sub ecx, esi
mov [rdx+4], ecx
shr eax, cl
mov rcx, [rbp+var_8]
mov ecx, [rcx+1Ch]
mov edx, ecx
lea rcx, mask_0
and eax, [rcx+rdx*4]
mov [rbp+var_28], eax
jmp short loc_BD878
loc_BD865:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_8]
mov esi, [rax+1Ch]
call fill_and_get_bits_0
mov [rbp+var_28], eax
loc_BD878:
mov ecx, [rbp+var_28]
mov [rbp+var_24], ecx
mov rax, [rbp+var_18]
mov ecx, ecx
add rax, rcx
cmp rax, [rbp+var_20]
jbe short loc_BD89A
mov rax, [rbp+var_10]
mov dword ptr [rax+28h], 1
jmp short loc_BD8EF
loc_BD89A:
mov rdi, [rbp+var_18]
mov eax, [rbp+var_24]
mov edx, eax
mov esi, 20h ; ' '
call _memset
mov rax, [rbp+var_18]
mov ecx, [rbp+var_24]
add rax, rcx
cmp rax, [rbp+var_20]
jz short loc_BD8D8
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov eax, [rbp+var_24]
add rdx, rax
mov rcx, [rbp+var_20]
call decode_bytes_0
loc_BD8D8:
jmp short loc_BD8EF
loc_BD8DA:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
call decode_bytes_0
loc_BD8EF:
add rsp, 30h
pop rbp
retn
| long long uf_prespace_selected_0(long long a1, int *a2, _BYTE *a3, _BYTE *a4)
{
int v4; // eax
int v5; // ecx
unsigned int v6; // eax
int v7; // ecx
long long result; // rax
unsigned int bits_0; // [rsp+8h] [rbp-28h]
if ( a2[1] )
{
v4 = *a2;
v5 = a2[1] - 1;
a2[1] = v5;
if ( ((1 << v5) & v4) == 0 )
return decode_bytes_0(a1, (long long)a2, a3, a4);
}
else
{
fill_buffer_0((long long)a2);
a2[1] = 31;
if ( *a2 >= 0 )
return decode_bytes_0(a1, (long long)a2, a3, a4);
}
if ( (unsigned int)a2[1] < *(_DWORD *)(a1 + 28) )
{
bits_0 = fill_and_get_bits_0(a2, *(_DWORD *)(a1 + 28));
}
else
{
v6 = *a2;
v7 = a2[1] - *(_DWORD *)(a1 + 28);
a2[1] = v7;
bits_0 = mask_0[*(unsigned int *)(a1 + 28)] & (v6 >> v7);
}
if ( &a3[bits_0] <= a4 )
{
memset(a3, 32LL, bits_0);
result = (long long)&a3[bits_0];
if ( (_BYTE *)result != a4 )
return decode_bytes_0(a1, (long long)a2, &a3[bits_0], a4);
}
else
{
result = (long long)a2;
a2[10] = 1;
}
return result;
}
| uf_prespace_selected:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x4],0x0
JZ 0x001bd7fa
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RDX + 0x4]
ADD ECX,-0x1
MOV dword ptr [RDX + 0x4],ECX
MOV EDX,0x1
SHL EDX,CL
MOV ECX,EDX
AND EAX,ECX
CMP EAX,0x0
JNZ 0x001bd822
JMP 0x001bd8da
LAB_001bd7fa:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001bc3a0
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x4],0x1f
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
AND EAX,0x80000000
CMP EAX,0x0
JZ 0x001bd8da
LAB_001bd822:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x4]
MOV RCX,qword ptr [RBP + -0x8]
CMP EAX,dword ptr [RCX + 0x1c]
JC 0x001bd865
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RCX + 0x1c]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RDX + 0x4]
SUB ECX,ESI
MOV dword ptr [RDX + 0x4],ECX
SHR EAX,CL
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX + 0x1c]
MOV EDX,ECX
LEA RCX,[0x3bf640]
AND EAX,dword ptr [RCX + RDX*0x4]
MOV dword ptr [RBP + -0x28],EAX
JMP 0x001bd878
LAB_001bd865:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RAX + 0x1c]
CALL 0x001bab50
MOV dword ptr [RBP + -0x28],EAX
LAB_001bd878:
MOV ECX,dword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x24],ECX
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,ECX
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x001bd89a
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x28],0x1
JMP 0x001bd8ef
LAB_001bd89a:
MOV RDI,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x24]
MOV EDX,EAX
MOV ESI,0x20
CALL 0x0012a2c0
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x24]
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x20]
JZ 0x001bd8d8
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x24]
ADD RDX,RAX
MOV RCX,qword ptr [RBP + -0x20]
CALL 0x001bcab0
LAB_001bd8d8:
JMP 0x001bd8ef
LAB_001bd8da:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
CALL 0x001bcab0
LAB_001bd8ef:
ADD RSP,0x30
POP RBP
RET
|
void uf_prespace_selected(long param_1,uint *param_2,void *param_3,ulong param_4)
{
uint uVar1;
uint local_30;
if (param_2[1] == 0) {
fill_buffer(param_2);
param_2[1] = 0x1f;
uVar1 = *param_2 & 0x80000000;
}
else {
uVar1 = param_2[1];
param_2[1] = uVar1 - 1;
uVar1 = *param_2 & 1 << ((byte)(uVar1 - 1) & 0x1f);
}
if (uVar1 == 0) {
decode_bytes(param_1,param_2,param_3,param_4);
}
else {
if (param_2[1] < *(uint *)(param_1 + 0x1c)) {
local_30 = fill_and_get_bits(param_2,*(int4 *)(param_1 + 0x1c));
}
else {
uVar1 = param_2[1] - *(int *)(param_1 + 0x1c);
param_2[1] = uVar1;
local_30 = *param_2 >> ((byte)uVar1 & 0x1f) &
*(uint *)(mask + (ulong)*(uint *)(param_1 + 0x1c) * 4);
}
if (param_4 < (long)param_3 + (ulong)local_30) {
param_2[10] = 1;
}
else {
memset(param_3,0x20,(ulong)local_30);
if ((long)param_3 + (ulong)local_30 != param_4) {
decode_bytes(param_1,param_2,(long)param_3 + (ulong)local_30,param_4);
}
}
}
return;
}
| |
29,204 | html_emit_create | navaro[P]qoraal-tictactoe/src/services/www/parts/html.c | int32_t
html_emit_create (HTML_EMIT_T* emit)
{
if (os_event_create (&emit->complete) != EOK) {
html_emit_delete (emit) ;
return EFAIL ;
}
if (os_sem_create (&emit->lock, 1) != EOK) {
html_emit_delete (emit) ;
return EFAIL ;
}
return EOK ;
} | O3 | c | html_emit_create:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x18, %rdi
callq 0x15383
testl %eax, %eax
jne 0x13d41
leaq 0x10(%rbx), %rdi
movl $0x1, %esi
callq 0x15099
testl %eax, %eax
je 0x13d55
movq %rbx, %rdi
callq 0x13d59
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %eax, %eax
jmp 0x13d4e
| html_emit_create:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
add rdi, 18h
call os_event_create
test eax, eax
jnz short loc_13D41
lea rdi, [rbx+10h]
mov esi, 1
call os_sem_create
test eax, eax
jz short loc_13D55
loc_13D41:
mov rdi, rbx
call html_emit_delete
mov eax, 0FFFFFFFFh
loc_13D4E:
add rsp, 8
pop rbx
pop rbp
retn
loc_13D55:
xor eax, eax
jmp short loc_13D4E
| long long html_emit_create(long long a1)
{
if ( !(unsigned int)os_event_create(a1 + 24) && !(unsigned int)os_sem_create(a1 + 16, 1LL) )
return 0LL;
html_emit_delete(a1);
return 0xFFFFFFFFLL;
}
| html_emit_create:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
ADD RDI,0x18
CALL 0x00115383
TEST EAX,EAX
JNZ 0x00113d41
LEA RDI,[RBX + 0x10]
MOV ESI,0x1
CALL 0x00115099
TEST EAX,EAX
JZ 0x00113d55
LAB_00113d41:
MOV RDI,RBX
CALL 0x00113d59
MOV EAX,0xffffffff
LAB_00113d4e:
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_00113d55:
XOR EAX,EAX
JMP 0x00113d4e
|
int8 html_emit_create(long param_1)
{
int iVar1;
iVar1 = os_event_create(param_1 + 0x18);
if ((iVar1 == 0) && (iVar1 = os_sem_create(param_1 + 0x10,1), iVar1 == 0)) {
return 0;
}
html_emit_delete(param_1);
return 0xffffffff;
}
| |
29,205 | fn_ext | eloqsql/mysys/mf_fn_ext.c | char *fn_ext(const char *name)
{
register const char *pos, *gpos;
DBUG_ENTER("fn_ext");
DBUG_PRINT("mfunkt",("name: '%s'",name));
#if defined(FN_DEVCHAR) || defined(BASKSLASH_MBTAIL)
{
char buff[FN_REFLEN];
size_t res_length;
gpos= name+ dirname_part(buff,(char*) name, &res_length);
}
#else
if (!(gpos= strrchr(name, FN_LIBCHAR)))
gpos= name;
#endif
pos= strchr(gpos, FN_EXTCHAR);
DBUG_RETURN((char*) (pos ? pos : strend(gpos)));
} | O0 | c | fn_ext:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x2732e
movq -0x8(%rbp), %rdi
movl $0x2f, %esi
callq 0x242f0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x2734e
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x2e, %esi
callq 0x24100
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x27371
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x2737e
movq -0x18(%rbp), %rdi
callq 0x7d490
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
| fn_ext:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
jmp short $+2
loc_2732E:
mov rdi, [rbp+var_8]
mov esi, 2Fh ; '/'
call _strrchr
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_2734E
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
loc_2734E:
mov rdi, [rbp+var_18]
mov esi, 2Eh ; '.'
call _strchr
mov [rbp+var_10], rax
cmp [rbp+var_10], 0
jz short loc_27371
mov rax, [rbp+var_10]
mov [rbp+var_20], rax
jmp short loc_2737E
loc_27371:
mov rdi, [rbp+var_18]
call strend
mov [rbp+var_20], rax
loc_2737E:
mov rax, [rbp+var_20]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
add rsp, 30h
pop rbp
retn
| long long fn_ext(long long a1)
{
long long v3; // [rsp+18h] [rbp-18h]
long long v4; // [rsp+20h] [rbp-10h]
v3 = strrchr(a1, 47LL);
if ( !v3 )
v3 = a1;
v4 = strchr(v3, 46LL);
if ( v4 )
return v4;
else
return strend(v3);
}
| fn_ext:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
JMP 0x0012732e
LAB_0012732e:
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,0x2f
CALL 0x001242f0
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x0012734e
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
LAB_0012734e:
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,0x2e
CALL 0x00124100
MOV qword ptr [RBP + -0x10],RAX
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00127371
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0012737e
LAB_00127371:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x0017d490
MOV qword ptr [RBP + -0x20],RAX
LAB_0012737e:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RSP,0x30
POP RBP
RET
|
char * fn_ext(char *param_1)
{
int8 local_28;
int8 local_20;
local_20 = strrchr(param_1,0x2f);
if (local_20 == (char *)0x0) {
local_20 = param_1;
}
local_28 = strchr(local_20,0x2e);
if (local_28 == (char *)0x0) {
local_28 = (char *)strend(local_20);
}
return local_28;
}
| |
29,206 | my_cset_init_8bit | eloqsql/strings/ctype-simple.c | static my_bool
my_cset_init_8bit(struct charset_info_st *cs, MY_CHARSET_LOADER *loader)
{
cs->state|= my_8bit_charset_flags_from_data(cs);
cs->caseup_multiply= 1;
cs->casedn_multiply= 1;
cs->pad_char= ' ';
if (!cs->to_lower || !cs->to_upper || !cs->m_ctype || !cs->tab_to_uni)
return TRUE;
return create_fromuni(cs, loader);
} | O0 | c | my_cset_init_8bit:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x455b0
movl %eax, %ecx
movq -0x10(%rbp), %rax
orl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x94(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x95(%rax)
movq -0x10(%rbp), %rax
movb $0x20, 0xb0(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x46372
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x46372
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x46372
movq -0x10(%rbp), %rax
cmpq $0x0, 0x68(%rax)
jne 0x46378
movb $0x1, -0x1(%rbp)
jmp 0x46388
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x46460
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_cset_init_8bit:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rdi, [rbp+var_10]
call my_8bit_charset_flags_from_data
mov ecx, eax
mov rax, [rbp+var_10]
or ecx, [rax+0Ch]
mov [rax+0Ch], ecx
mov rax, [rbp+var_10]
mov byte ptr [rax+94h], 1
mov rax, [rbp+var_10]
mov byte ptr [rax+95h], 1
mov rax, [rbp+var_10]
mov byte ptr [rax+0B0h], 20h ; ' '
mov rax, [rbp+var_10]
cmp qword ptr [rax+48h], 0
jz short loc_46372
mov rax, [rbp+var_10]
cmp qword ptr [rax+50h], 0
jz short loc_46372
mov rax, [rbp+var_10]
cmp qword ptr [rax+40h], 0
jz short loc_46372
mov rax, [rbp+var_10]
cmp qword ptr [rax+68h], 0
jnz short loc_46378
loc_46372:
mov [rbp+var_1], 1
jmp short loc_46388
loc_46378:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call create_fromuni
mov [rbp+var_1], al
loc_46388:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
| char my_cset_init_8bit(long long a1, long long a2)
{
*(_DWORD *)(a1 + 12) |= my_8bit_charset_flags_from_data(a1);
*(_BYTE *)(a1 + 148) = 1;
*(_BYTE *)(a1 + 149) = 1;
*(_BYTE *)(a1 + 176) = 32;
if ( *(_QWORD *)(a1 + 72) && *(_QWORD *)(a1 + 80) && *(_QWORD *)(a1 + 64) && *(_QWORD *)(a1 + 104) )
return create_fromuni(a1, a2);
else
return 1;
}
| my_cset_init_8bit:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001455b0
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
OR ECX,dword ptr [RAX + 0xc]
MOV dword ptr [RAX + 0xc],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x94],0x1
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x95],0x1
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0xb0],0x20
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x48],0x0
JZ 0x00146372
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x50],0x0
JZ 0x00146372
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x40],0x0
JZ 0x00146372
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x68],0x0
JNZ 0x00146378
LAB_00146372:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00146388
LAB_00146378:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00146460
MOV byte ptr [RBP + -0x1],AL
LAB_00146388:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int1 my_cset_init_8bit(long param_1,int8 param_2)
{
uint uVar1;
int1 local_9;
uVar1 = my_8bit_charset_flags_from_data(param_1);
*(uint *)(param_1 + 0xc) = uVar1 | *(uint *)(param_1 + 0xc);
*(int1 *)(param_1 + 0x94) = 1;
*(int1 *)(param_1 + 0x95) = 1;
*(int1 *)(param_1 + 0xb0) = 0x20;
if ((((*(long *)(param_1 + 0x48) == 0) || (*(long *)(param_1 + 0x50) == 0)) ||
(*(long *)(param_1 + 0x40) == 0)) || (*(long *)(param_1 + 0x68) == 0)) {
local_9 = 1;
}
else {
local_9 = create_fromuni(param_1,param_2);
}
return local_9;
}
| |
29,207 | ma_log_new | eloqsql/storage/maria/ma_write.c | my_bool _ma_log_new(MARIA_PAGE *ma_page, my_bool root_page)
{
LSN lsn;
uchar log_data[FILEID_STORE_SIZE + PAGE_STORE_SIZE * 2 + KEY_NR_STORE_SIZE
+1];
uint page_length;
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 2];
MARIA_HA *info= ma_page->info;
MARIA_SHARE *share= info->s;
my_off_t page= ma_page->pos / share->block_size;
DBUG_ENTER("_ma_log_new");
DBUG_PRINT("enter", ("page: %lu", (ulong) page));
DBUG_ASSERT(share->now_transactional);
/* Store address of new root page */
page_store(log_data + FILEID_STORE_SIZE, page);
/* Store link to next unused page */
if (info->key_del_used == 2)
page= 0; /* key_del not changed */
else
page= ((share->key_del_current == HA_OFFSET_ERROR) ? IMPOSSIBLE_PAGE_NO :
share->key_del_current / share->block_size);
page_store(log_data + FILEID_STORE_SIZE + PAGE_STORE_SIZE, page);
key_nr_store(log_data + FILEID_STORE_SIZE + PAGE_STORE_SIZE*2,
ma_page->keyinfo->key_nr);
log_data[FILEID_STORE_SIZE + PAGE_STORE_SIZE*2 + KEY_NR_STORE_SIZE]=
(uchar) root_page;
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= log_data;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= sizeof(log_data);
page_length= ma_page->size - LSN_STORE_SIZE;
log_array[TRANSLOG_INTERNAL_PARTS + 1].str= ma_page->buff + LSN_STORE_SIZE;
log_array[TRANSLOG_INTERNAL_PARTS + 1].length= page_length;
/* Remember new page length for future log entires for same page */
ma_page->org_size= ma_page->size;
if (translog_write_record(&lsn, LOGREC_REDO_INDEX_NEW_PAGE,
info->trn, info,
(translog_size_t)
(sizeof(log_data) + page_length),
TRANSLOG_INTERNAL_PARTS + 2, log_array,
log_data, NULL))
DBUG_RETURN(1);
DBUG_RETURN(0);
} | O0 | c | ma_log_new:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movb %sil, %al
movq %fs:0x28, %rcx
movq %rcx, -0x8(%rbp)
movq %rdi, -0x20(%rbp)
movb %al, -0x21(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x90(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x90(%rbp), %rcx
movl 0x7bc(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x98(%rbp)
jmp 0x69014
jmp 0x69016
jmp 0x69018
jmp 0x6901a
leaq -0x16(%rbp), %rax
addq $0x2, %rax
movq %rax, -0xa0(%rbp)
movq -0x98(%rbp), %rax
movl %eax, %ecx
movq -0xa0(%rbp), %rax
movl %ecx, (%rax)
movq -0x98(%rbp), %rax
shrq $0x20, %rax
movb %al, %cl
movq -0xa0(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x88(%rbp), %rax
movzbl 0x67e(%rax), %eax
cmpl $0x2, %eax
jne 0x69072
movq $0x0, -0x98(%rbp)
jmp 0x690cb
movq -0x90(%rbp), %rax
cmpq $-0x1, 0x700(%rax)
jne 0x69096
movabsq $0xffffffffff, %rax # imm = 0xFFFFFFFFFF
movq %rax, -0xb0(%rbp)
jmp 0x690bd
movq -0x90(%rbp), %rax
movq 0x700(%rax), %rax
movq -0x90(%rbp), %rcx
movl 0x7bc(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
movq %rax, -0x98(%rbp)
jmp 0x690cd
leaq -0x16(%rbp), %rax
addq $0x2, %rax
addq $0x5, %rax
movq %rax, -0xa8(%rbp)
movq -0x98(%rbp), %rax
movl %eax, %ecx
movq -0xa8(%rbp), %rax
movl %ecx, (%rax)
movq -0x98(%rbp), %rax
shrq $0x20, %rax
movb %al, %cl
movq -0xa8(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movb 0xa5(%rax), %al
movb %al, -0xa(%rbp)
movb -0x21(%rbp), %al
movb %al, -0x9(%rbp)
leaq -0x16(%rbp), %rax
movq %rax, -0x60(%rbp)
movq $0xe, -0x58(%rbp)
movq -0x20(%rbp), %rax
movl 0x20(%rax), %eax
subl $0x7, %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x7, %rax
movq %rax, -0x50(%rbp)
movl -0x34(%rbp), %eax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x88(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x88(%rbp), %rcx
movl -0x34(%rbp), %eax
addq $0xe, %rax
movl %eax, %r8d
leaq -0x80(%rbp), %r10
leaq -0x16(%rbp), %rax
leaq -0x30(%rbp), %rdi
movl $0xd, %esi
movl $0x4, %r9d
xorl %r11d, %r11d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
callq 0x32d40
cmpb $0x0, %al
je 0x691bb
jmp 0x691b5
movb $0x1, -0x17(%rbp)
jmp 0x691c1
jmp 0x691bd
movb $0x0, -0x17(%rbp)
movb -0x17(%rbp), %al
movb %al, -0xb1(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x691eb
movb -0xb1(%rbp), %al
addq $0xd0, %rsp
popq %rbp
retq
callq 0x2a260
| _ma_log_new:
push rbp
mov rbp, rsp
sub rsp, 0D0h
mov al, sil
mov rcx, fs:28h
mov [rbp+var_8], rcx
mov [rbp+var_20], rdi
mov [rbp+var_21], al
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_88], rax
mov rax, [rbp+var_88]
mov rax, [rax]
mov [rbp+var_90], rax
mov rax, [rbp+var_20]
mov rax, [rax+18h]
mov rcx, [rbp+var_90]
mov ecx, [rcx+7BCh]
xor edx, edx
div rcx
mov [rbp+var_98], rax
jmp short $+2
loc_69014:
jmp short $+2
loc_69016:
jmp short $+2
loc_69018:
jmp short $+2
loc_6901A:
lea rax, [rbp+var_16]
add rax, 2
mov [rbp+var_A0], rax
mov rax, [rbp+var_98]
mov ecx, eax
mov rax, [rbp+var_A0]
mov [rax], ecx
mov rax, [rbp+var_98]
shr rax, 20h
mov cl, al
mov rax, [rbp+var_A0]
mov [rax+4], cl
mov rax, [rbp+var_88]
movzx eax, byte ptr [rax+67Eh]
cmp eax, 2
jnz short loc_69072
mov [rbp+var_98], 0
jmp short loc_690CB
loc_69072:
mov rax, [rbp+var_90]
cmp qword ptr [rax+700h], 0FFFFFFFFFFFFFFFFh
jnz short loc_69096
mov rax, 0FFFFFFFFFFh
mov [rbp+var_B0], rax
jmp short loc_690BD
loc_69096:
mov rax, [rbp+var_90]
mov rax, [rax+700h]
mov rcx, [rbp+var_90]
mov ecx, [rcx+7BCh]
xor edx, edx
div rcx
mov [rbp+var_B0], rax
loc_690BD:
mov rax, [rbp+var_B0]
mov [rbp+var_98], rax
loc_690CB:
jmp short $+2
loc_690CD:
lea rax, [rbp+var_16]
add rax, 2
add rax, 5
mov [rbp+var_A8], rax
mov rax, [rbp+var_98]
mov ecx, eax
mov rax, [rbp+var_A8]
mov [rax], ecx
mov rax, [rbp+var_98]
shr rax, 20h
mov cl, al
mov rax, [rbp+var_A8]
mov [rax+4], cl
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov al, [rax+0A5h]
mov [rbp+var_A], al
mov al, [rbp+var_21]
mov [rbp+var_9], al
lea rax, [rbp+var_16]
mov [rbp+var_60], rax
mov [rbp+var_58], 0Eh
mov rax, [rbp+var_20]
mov eax, [rax+20h]
sub eax, 7
mov [rbp+var_34], eax
mov rax, [rbp+var_20]
mov rax, [rax+10h]
add rax, 7
mov [rbp+var_50], rax
mov eax, [rbp+var_34]
mov [rbp+var_48], rax
mov rax, [rbp+var_20]
mov ecx, [rax+20h]
mov rax, [rbp+var_20]
mov [rax+24h], ecx
mov rax, [rbp+var_88]
mov rdx, [rax+8]
mov rcx, [rbp+var_88]
mov eax, [rbp+var_34]
add rax, 0Eh
mov r8d, eax
lea r10, [rbp+var_80]
lea rax, [rbp+var_16]
lea rdi, [rbp+var_30]
mov esi, 0Dh
mov r9d, 4
xor r11d, r11d
mov [rsp+0D0h+var_D0], r10
mov [rsp+0D0h+var_C8], rax
mov [rsp+0D0h+var_C0], 0
call translog_write_record
cmp al, 0
jz short loc_691BB
jmp short $+2
loc_691B5:
mov [rbp+var_17], 1
jmp short loc_691C1
loc_691BB:
jmp short $+2
loc_691BD:
mov [rbp+var_17], 0
loc_691C1:
mov al, [rbp+var_17]
mov [rbp+var_B1], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_691EB
mov al, [rbp+var_B1]
add rsp, 0D0h
pop rbp
retn
loc_691EB:
call ___stack_chk_fail
| bool ma_log_new(long long **a1, char a2)
{
unsigned long long v3; // [rsp+20h] [rbp-B0h]
unsigned long long v4; // [rsp+38h] [rbp-98h]
unsigned long long v5; // [rsp+38h] [rbp-98h]
long long v6; // [rsp+40h] [rbp-90h]
long long *v7; // [rsp+48h] [rbp-88h]
_QWORD v8[9]; // [rsp+50h] [rbp-80h] BYREF
unsigned int v9; // [rsp+9Ch] [rbp-34h]
_BYTE v10[15]; // [rsp+A0h] [rbp-30h] BYREF
char v11; // [rsp+AFh] [rbp-21h]
long long **v12; // [rsp+B0h] [rbp-20h]
__int16 v13; // [rsp+BAh] [rbp-16h] BYREF
int v14; // [rsp+BCh] [rbp-14h]
char v15; // [rsp+C0h] [rbp-10h]
int v16; // [rsp+C1h] [rbp-Fh]
char v17; // [rsp+C5h] [rbp-Bh]
char v18; // [rsp+C6h] [rbp-Ah]
char v19; // [rsp+C7h] [rbp-9h]
unsigned long long v20; // [rsp+C8h] [rbp-8h]
v20 = __readfsqword(0x28u);
v12 = a1;
v11 = a2;
v7 = *a1;
v6 = **a1;
v4 = (unsigned long long)a1[3] / *(unsigned int *)(v6 + 1980);
v14 = v4;
v15 = BYTE4(v4);
if ( *((_BYTE *)v7 + 1662) == 2 )
{
v5 = 0LL;
}
else
{
if ( *(_QWORD *)(v6 + 1792) == -1LL )
v3 = 0xFFFFFFFFFFLL;
else
v3 = *(_QWORD *)(v6 + 1792) / (unsigned long long)*(unsigned int *)(v6 + 1980);
v5 = v3;
}
v16 = v5;
v17 = BYTE4(v5);
v18 = *((_BYTE *)v12[1] + 165);
v19 = v11;
v8[4] = &v13;
v8[5] = 14LL;
v9 = *((_DWORD *)v12 + 8) - 7;
v8[6] = (char *)v12[2] + 7;
v8[7] = v9;
*((_DWORD *)v12 + 9) = *((_DWORD *)v12 + 8);
return translog_write_record((long long)v10, 0xDu, v7[1], v7, v9 + 14, 4u, v8, &v13, 0LL) != 0;
}
| _ma_log_new:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xd0
MOV AL,SIL
MOV RCX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RCX
MOV qword ptr [RBP + -0x20],RDI
MOV byte ptr [RBP + -0x21],AL
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr [RBP + -0x88]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x90],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RBP + -0x90]
MOV ECX,dword ptr [RCX + 0x7bc]
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x98],RAX
JMP 0x00169014
LAB_00169014:
JMP 0x00169016
LAB_00169016:
JMP 0x00169018
LAB_00169018:
JMP 0x0016901a
LAB_0016901a:
LEA RAX,[RBP + -0x16]
ADD RAX,0x2
MOV qword ptr [RBP + -0xa0],RAX
MOV RAX,qword ptr [RBP + -0x98]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0xa0]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x98]
SHR RAX,0x20
MOV CL,AL
MOV RAX,qword ptr [RBP + -0xa0]
MOV byte ptr [RAX + 0x4],CL
MOV RAX,qword ptr [RBP + -0x88]
MOVZX EAX,byte ptr [RAX + 0x67e]
CMP EAX,0x2
JNZ 0x00169072
MOV qword ptr [RBP + -0x98],0x0
JMP 0x001690cb
LAB_00169072:
MOV RAX,qword ptr [RBP + -0x90]
CMP qword ptr [RAX + 0x700],-0x1
JNZ 0x00169096
MOV RAX,0xffffffffff
MOV qword ptr [RBP + -0xb0],RAX
JMP 0x001690bd
LAB_00169096:
MOV RAX,qword ptr [RBP + -0x90]
MOV RAX,qword ptr [RAX + 0x700]
MOV RCX,qword ptr [RBP + -0x90]
MOV ECX,dword ptr [RCX + 0x7bc]
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0xb0],RAX
LAB_001690bd:
MOV RAX,qword ptr [RBP + -0xb0]
MOV qword ptr [RBP + -0x98],RAX
LAB_001690cb:
JMP 0x001690cd
LAB_001690cd:
LEA RAX,[RBP + -0x16]
ADD RAX,0x2
ADD RAX,0x5
MOV qword ptr [RBP + -0xa8],RAX
MOV RAX,qword ptr [RBP + -0x98]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0xa8]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x98]
SHR RAX,0x20
MOV CL,AL
MOV RAX,qword ptr [RBP + -0xa8]
MOV byte ptr [RAX + 0x4],CL
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV AL,byte ptr [RAX + 0xa5]
MOV byte ptr [RBP + -0xa],AL
MOV AL,byte ptr [RBP + -0x21]
MOV byte ptr [RBP + -0x9],AL
LEA RAX,[RBP + -0x16]
MOV qword ptr [RBP + -0x60],RAX
MOV qword ptr [RBP + -0x58],0xe
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x20]
SUB EAX,0x7
MOV dword ptr [RBP + -0x34],EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x10]
ADD RAX,0x7
MOV qword ptr [RBP + -0x50],RAX
MOV EAX,dword ptr [RBP + -0x34]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x24],ECX
MOV RAX,qword ptr [RBP + -0x88]
MOV RDX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x88]
MOV EAX,dword ptr [RBP + -0x34]
ADD RAX,0xe
MOV R8D,EAX
LEA R10,[RBP + -0x80]
LEA RAX,[RBP + -0x16]
LEA RDI,[RBP + -0x30]
MOV ESI,0xd
MOV R9D,0x4
XOR R11D,R11D
MOV qword ptr [RSP],R10
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],0x0
CALL 0x00132d40
CMP AL,0x0
JZ 0x001691bb
JMP 0x001691b5
LAB_001691b5:
MOV byte ptr [RBP + -0x17],0x1
JMP 0x001691c1
LAB_001691bb:
JMP 0x001691bd
LAB_001691bd:
MOV byte ptr [RBP + -0x17],0x0
LAB_001691c1:
MOV AL,byte ptr [RBP + -0x17]
MOV byte ptr [RBP + -0xb1],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001691eb
MOV AL,byte ptr [RBP + -0xb1]
ADD RSP,0xd0
POP RBP
RET
LAB_001691eb:
CALL 0x0012a260
|
int8 _ma_log_new(long *param_1,int1 param_2)
{
long *plVar1;
long lVar2;
char cVar3;
ulong uVar4;
long in_FS_OFFSET;
ulong local_b8;
ulong local_a0;
int1 local_88 [32];
int1 *local_68;
int8 local_60;
long local_58;
ulong local_50;
uint local_3c;
int1 local_38 [15];
int1 local_29;
long *local_28;
int1 local_1f;
int1 local_1e [2];
int4 local_1c;
int1 local_18;
int4 local_17;
int1 local_13;
int1 local_12;
int1 local_11;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
plVar1 = (long *)*param_1;
lVar2 = *plVar1;
uVar4 = (ulong)param_1[3] / (ulong)*(uint *)(lVar2 + 0x7bc);
local_1c = (int4)uVar4;
local_18 = (int1)(uVar4 >> 0x20);
if (*(char *)((long)plVar1 + 0x67e) == '\x02') {
local_a0 = 0;
}
else {
if (*(long *)(lVar2 + 0x700) == -1) {
local_b8 = 0xffffffffff;
}
else {
local_b8 = *(ulong *)(lVar2 + 0x700) / (ulong)*(uint *)(lVar2 + 0x7bc);
}
local_a0 = local_b8;
}
local_17 = (int4)local_a0;
local_13 = (int1)(local_a0 >> 0x20);
local_12 = *(int1 *)(param_1[1] + 0xa5);
local_68 = local_1e;
local_60 = 0xe;
local_3c = (int)param_1[4] - 7;
local_58 = param_1[2] + 7;
local_50 = (ulong)local_3c;
*(int *)((long)param_1 + 0x24) = (int)param_1[4];
local_29 = param_2;
local_28 = param_1;
local_11 = param_2;
cVar3 = translog_write_record
(local_38,0xd,plVar1[1],plVar1,(int)param_1[4] + 7,4,local_88,local_1e,0);
local_1f = cVar3 != '\0';
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),local_1f);
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
29,208 | ma_log_new | eloqsql/storage/maria/ma_write.c | my_bool _ma_log_new(MARIA_PAGE *ma_page, my_bool root_page)
{
LSN lsn;
uchar log_data[FILEID_STORE_SIZE + PAGE_STORE_SIZE * 2 + KEY_NR_STORE_SIZE
+1];
uint page_length;
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 2];
MARIA_HA *info= ma_page->info;
MARIA_SHARE *share= info->s;
my_off_t page= ma_page->pos / share->block_size;
DBUG_ENTER("_ma_log_new");
DBUG_PRINT("enter", ("page: %lu", (ulong) page));
DBUG_ASSERT(share->now_transactional);
/* Store address of new root page */
page_store(log_data + FILEID_STORE_SIZE, page);
/* Store link to next unused page */
if (info->key_del_used == 2)
page= 0; /* key_del not changed */
else
page= ((share->key_del_current == HA_OFFSET_ERROR) ? IMPOSSIBLE_PAGE_NO :
share->key_del_current / share->block_size);
page_store(log_data + FILEID_STORE_SIZE + PAGE_STORE_SIZE, page);
key_nr_store(log_data + FILEID_STORE_SIZE + PAGE_STORE_SIZE*2,
ma_page->keyinfo->key_nr);
log_data[FILEID_STORE_SIZE + PAGE_STORE_SIZE*2 + KEY_NR_STORE_SIZE]=
(uchar) root_page;
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= log_data;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= sizeof(log_data);
page_length= ma_page->size - LSN_STORE_SIZE;
log_array[TRANSLOG_INTERNAL_PARTS + 1].str= ma_page->buff + LSN_STORE_SIZE;
log_array[TRANSLOG_INTERNAL_PARTS + 1].length= page_length;
/* Remember new page length for future log entires for same page */
ma_page->org_size= ma_page->size;
if (translog_write_record(&lsn, LOGREC_REDO_INDEX_NEW_PAGE,
info->trn, info,
(translog_size_t)
(sizeof(log_data) + page_length),
TRANSLOG_INTERNAL_PARTS + 2, log_array,
log_data, NULL))
DBUG_RETURN(1);
DBUG_RETURN(0);
} | O3 | c | ma_log_new:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq (%rdi), %rcx
movq 0x18(%rdi), %rax
movq (%rcx), %r10
movl 0x7bc(%r10), %r9d
xorl %r8d, %r8d
xorl %edx, %edx
divq %r9
movl %eax, -0x14(%rbp)
shrq $0x20, %rax
movb %al, -0x10(%rbp)
cmpb $0x2, 0x67e(%rcx)
je 0x56f16
movq 0x700(%r10), %rax
cmpq $-0x1, %rax
je 0x56f0c
xorl %edx, %edx
divq %r9
movq %rax, %r8
jmp 0x56f16
movabsq $0xffffffffff, %r8 # imm = 0xFFFFFFFFFF
leaq -0x16(%rbp), %rax
movl %r8d, 0x7(%rax)
shrq $0x20, %r8
movb %r8b, 0xb(%rax)
movq 0x8(%rdi), %rdx
movb 0xa5(%rdx), %dl
movb %dl, 0xc(%rax)
movb %sil, 0xd(%rax)
leaq -0x60(%rbp), %r10
movq %rax, 0x20(%r10)
movq $0xe, 0x28(%r10)
movl 0x20(%rdi), %r8d
leal -0x7(%r8), %edx
movq 0x10(%rdi), %rsi
addq $0x7, %rsi
movq %rsi, 0x30(%r10)
movq %rdx, 0x38(%r10)
movl %r8d, 0x24(%rdi)
movq 0x8(%rcx), %rdx
addl $0x7, %r8d
subq $0x8, %rsp
leaq -0x20(%rbp), %rdi
movl $0xd, %esi
movl $0x4, %r9d
pushq $0x0
pushq %rax
pushq %r10
callq 0x29c84
addq $0x20, %rsp
testb %al, %al
setne %al
movq %fs:0x28, %rcx
cmpq -0x8(%rbp), %rcx
jne 0x56fa6
addq $0x60, %rsp
popq %rbp
retq
callq 0x29260
| _ma_log_new:
push rbp
mov rbp, rsp
sub rsp, 60h
mov rax, fs:28h
mov [rbp+var_8], rax
mov rcx, [rdi]
mov rax, [rdi+18h]
mov r10, [rcx]
mov r9d, [r10+7BCh]
xor r8d, r8d
xor edx, edx
div r9
mov [rbp+var_14], eax
shr rax, 20h
mov [rbp+var_10], al
cmp byte ptr [rcx+67Eh], 2
jz short loc_56F16
mov rax, [r10+700h]
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_56F0C
xor edx, edx
div r9
mov r8, rax
jmp short loc_56F16
loc_56F0C:
mov r8, 0FFFFFFFFFFh
loc_56F16:
lea rax, [rbp+var_16]
mov [rax+7], r8d
shr r8, 20h
mov [rax+0Bh], r8b
mov rdx, [rdi+8]
mov dl, [rdx+0A5h]
mov [rax+0Ch], dl
mov [rax+0Dh], sil
lea r10, [rbp+var_60]
mov [r10+20h], rax
mov qword ptr [r10+28h], 0Eh
mov r8d, [rdi+20h]
lea edx, [r8-7]
mov rsi, [rdi+10h]
add rsi, 7
mov [r10+30h], rsi
mov [r10+38h], rdx
mov [rdi+24h], r8d
mov rdx, [rcx+8]
add r8d, 7
sub rsp, 8
lea rdi, [rbp+var_20]
mov esi, 0Dh
mov r9d, 4
push 0
push rax
push r10
call translog_write_record
add rsp, 20h
test al, al
setnz al
mov rcx, fs:28h
cmp rcx, [rbp+var_8]
jnz short loc_56FA6
add rsp, 60h
pop rbp
retn
loc_56FA6:
call ___stack_chk_fail
| bool ma_log_new(long long **a1, char a2)
{
long long *v2; // rcx
long long v3; // r10
unsigned long long v4; // r9
long long v5; // r8
unsigned long long v6; // rax
int v7; // r8d
__int128 v9; // [rsp+0h] [rbp-60h] BYREF
__int16 *v10; // [rsp+20h] [rbp-40h]
long long v11; // [rsp+28h] [rbp-38h]
long long v12; // [rsp+30h] [rbp-30h]
long long v13; // [rsp+38h] [rbp-28h]
_BYTE v14[10]; // [rsp+40h] [rbp-20h] BYREF
__int16 v15; // [rsp+4Ah] [rbp-16h] BYREF
int v16; // [rsp+4Ch] [rbp-14h]
char v17; // [rsp+50h] [rbp-10h]
int v18; // [rsp+51h] [rbp-Fh]
char v19; // [rsp+55h] [rbp-Bh]
char v20; // [rsp+56h] [rbp-Ah]
char v21; // [rsp+57h] [rbp-9h]
unsigned long long v22; // [rsp+58h] [rbp-8h]
v22 = __readfsqword(0x28u);
v2 = *a1;
v3 = **a1;
v4 = *(unsigned int *)(v3 + 1980);
v5 = 0LL;
v6 = (unsigned long long)a1[3] / v4;
v16 = v6;
v17 = BYTE4(v6);
if ( *((_BYTE *)v2 + 1662) != 2 )
{
if ( *(_QWORD *)(v3 + 1792) == -1LL )
v5 = 0xFFFFFFFFFFLL;
else
v5 = *(_QWORD *)(v3 + 1792) / v4;
}
v18 = v5;
v19 = BYTE4(v5);
v20 = *((_BYTE *)a1[1] + 165);
v21 = a2;
v10 = &v15;
v11 = 14LL;
v7 = *((_DWORD *)a1 + 8);
v12 = (long long)a1[2] + 7;
v13 = (unsigned int)(v7 - 7);
*((_DWORD *)a1 + 9) = v7;
return (unsigned __int8)translog_write_record((unsigned long long)v14, &byte_9[4], v2[1], v2, v7 + 7, 4, &v9, &v15, 0LL) != 0;
}
| _ma_log_new:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV RCX,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x18]
MOV R10,qword ptr [RCX]
MOV R9D,dword ptr [R10 + 0x7bc]
XOR R8D,R8D
XOR EDX,EDX
DIV R9
MOV dword ptr [RBP + -0x14],EAX
SHR RAX,0x20
MOV byte ptr [RBP + -0x10],AL
CMP byte ptr [RCX + 0x67e],0x2
JZ 0x00156f16
MOV RAX,qword ptr [R10 + 0x700]
CMP RAX,-0x1
JZ 0x00156f0c
XOR EDX,EDX
DIV R9
MOV R8,RAX
JMP 0x00156f16
LAB_00156f0c:
MOV R8,0xffffffffff
LAB_00156f16:
LEA RAX,[RBP + -0x16]
MOV dword ptr [RAX + 0x7],R8D
SHR R8,0x20
MOV byte ptr [RAX + 0xb],R8B
MOV RDX,qword ptr [RDI + 0x8]
MOV DL,byte ptr [RDX + 0xa5]
MOV byte ptr [RAX + 0xc],DL
MOV byte ptr [RAX + 0xd],SIL
LEA R10,[RBP + -0x60]
MOV qword ptr [R10 + 0x20],RAX
MOV qword ptr [R10 + 0x28],0xe
MOV R8D,dword ptr [RDI + 0x20]
LEA EDX,[R8 + -0x7]
MOV RSI,qword ptr [RDI + 0x10]
ADD RSI,0x7
MOV qword ptr [R10 + 0x30],RSI
MOV qword ptr [R10 + 0x38],RDX
MOV dword ptr [RDI + 0x24],R8D
MOV RDX,qword ptr [RCX + 0x8]
ADD R8D,0x7
SUB RSP,0x8
LEA RDI,[RBP + -0x20]
MOV ESI,0xd
MOV R9D,0x4
PUSH 0x0
PUSH RAX
PUSH R10
CALL 0x00129c84
ADD RSP,0x20
TEST AL,AL
SETNZ AL
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x8]
JNZ 0x00156fa6
ADD RSP,0x60
POP RBP
RET
LAB_00156fa6:
CALL 0x00129260
|
bool _ma_log_new(long *param_1,int1 param_2)
{
int iVar1;
long *plVar2;
int1 auVar3 [16];
int1 auVar4 [16];
char cVar5;
ulong uVar6;
ulong uVar7;
long in_FS_OFFSET;
int1 local_68 [32];
int1 *local_48;
int8 local_40;
long local_38;
ulong local_30;
int1 local_28 [10];
int1 local_1e [2];
int4 local_1c;
int1 local_18;
int4 local_17;
int1 local_13;
int1 local_12;
int1 local_11;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
plVar2 = (long *)*param_1;
uVar7 = CONCAT44(0,*(uint *)(*plVar2 + 0x7bc));
uVar6 = 0;
auVar3._8_8_ = 0;
auVar3._0_8_ = uVar7;
auVar4._8_8_ = 0;
auVar4._0_8_ = param_1[3];
local_1c = SUB164(auVar4 / auVar3,0);
local_18 = SUB161(auVar4 / auVar3,4);
if (*(char *)((long)plVar2 + 0x67e) != '\x02') {
uVar6 = *(ulong *)(*plVar2 + 0x700);
if (uVar6 == 0xffffffffffffffff) {
uVar6 = 0xffffffffff;
}
else {
uVar6 = uVar6 / uVar7;
}
}
local_48 = local_1e;
local_17 = (int4)uVar6;
local_13 = (int1)(uVar6 >> 0x20);
local_12 = *(int1 *)(param_1[1] + 0xa5);
local_40 = 0xe;
iVar1 = (int)param_1[4];
local_30 = (ulong)(iVar1 - 7);
local_38 = param_1[2] + 7;
*(int *)((long)param_1 + 0x24) = iVar1;
local_11 = param_2;
cVar5 = translog_write_record(local_28,0xd,plVar2[1],plVar2,iVar1 + 7,4,local_68,local_48,0);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return cVar5 != '\0';
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
29,209 | SchemaConverter::_resolve_ref(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/json-schema-to-grammar.cpp | std::string _resolve_ref(const std::string & ref) {
std::string ref_name = ref.substr(ref.find_last_of('/') + 1);
if (_rules.find(ref_name) == _rules.end() && _refs_being_resolved.find(ref) == _refs_being_resolved.end()) {
_refs_being_resolved.insert(ref);
json resolved = _refs[ref];
ref_name = visit(resolved, ref_name);
_refs_being_resolved.erase(ref);
}
return ref_name;
} | O3 | cpp | SchemaConverter::_resolve_ref(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %rdi
movl $0x2f, %esi
movq $-0x1, %rdx
callq 0x1aeb0
leaq 0x1(%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq $-0x1, %rcx
callq 0x1a7a0
leaq 0x28(%r15), %rdi
movq %rbx, %rsi
callq 0xa0b40
leaq 0x30(%r15), %rcx
cmpq %rcx, %rax
jne 0xa39b9
leaq 0x90(%r15), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0xa5a1c
testq %rax, %rax
jne 0xa39b9
leaq 0x18(%rsp), %rdx
movq %r12, (%rdx)
movq %r12, %rdi
movq %r14, %rsi
callq 0x81a5e
leaq 0x58(%r15), %rdi
movq %r14, %rsi
callq 0xa5a56
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x2faf6
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r15, %rsi
movq %rbx, %rcx
callq 0xa0cc2
leaq 0x18(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1a900
movq (%r15), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0xa3997
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a740
movq %r12, %rdi
movq %r14, %rsi
callq 0xa5eac
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x426e2
movq %r14, %rdi
callq 0x4f2d0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xa39ca
movq %rax, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x426e2
movq %r15, %rdi
callq 0x4f2d0
jmp 0xa39ef
jmp 0xa39ec
jmp 0xa39ec
jmp 0xa39ec
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0xa3a06
movq (%rbx), %rsi
incq %rsi
callq 0x1a740
movq %r14, %rdi
callq 0x1ad30
| _ZN15SchemaConverter12_resolve_refERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r15
push r14
push r12
push rbx
sub rsp, 38h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov rdi, rdx
mov esi, 2Fh ; '/'
mov rdx, 0FFFFFFFFFFFFFFFFh
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5rfindEcm; std::string::rfind(char,ulong)
lea rdx, [rax+1]
mov rdi, rbx
mov rsi, r14
mov rcx, 0FFFFFFFFFFFFFFFFh
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
lea rdi, [r15+28h]
mov rsi, rbx
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_S5_ESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EE4findERS7_; std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::string>>>::find(std::string const&)
lea rcx, [r15+30h]
cmp rax, rcx
jnz loc_A39B9
lea r12, [r15+90h]
mov rdi, r12
mov rsi, r14
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_SaIS5_ENSt8__detail9_IdentityESt8equal_toIS5_ESt4hashIS5_ENS7_18_Mod_range_hashingENS7_20_Default_ranged_hashENS7_20_Prime_rehash_policyENS7_17_Hashtable_traitsILb1ELb1ELb1EEEE4findERKS5_; std::_Hashtable<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>::find(std::string const&)
test rax, rax
jnz loc_A39B9
lea rdx, [rsp+58h+var_40]
mov [rdx], r12
mov rdi, r12
mov rsi, r14
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_SaIS5_ENSt8__detail9_IdentityESt8equal_toIS5_ESt4hashIS5_ENS7_18_Mod_range_hashingENS7_20_Default_ranged_hashENS7_20_Prime_rehash_policyENS7_17_Hashtable_traitsILb1ELb1ELb1EEEE9_M_insertIRKS5_NS7_10_AllocNodeISaINS7_10_Hash_nodeIS5_Lb1EEEEEEEESt4pairINS7_14_Node_iteratorIS5_Lb1ELb1EEEbEOT_RKT0_St17integral_constantIbLb1EE; std::_Hashtable<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>::_M_insert<std::string const&,std::__detail::_AllocNode<std::allocator<std::__detail::_Hash_node<std::string,true>>>>(std::string const&,std::__detail::_AllocNode<std::allocator<std::__detail::_Hash_node<std::string,true>>> const&,std::integral_constant<bool,true>)
lea rdi, [r15+58h]
mov rsi, r14
call _ZNSt8__detail9_Map_baseINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS6_N8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS6_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESaISI_ENS_10_Select1stESt8equal_toIS6_ESt4hashIS6_ENS_18_Mod_range_hashingENS_20_Default_ranged_hashENS_20_Prime_rehash_policyENS_17_Hashtable_traitsILb1ELb0ELb1EEELb1EEixERS8_; std::__detail::_Map_base<std::string,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::allocator<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::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>,true>::operator[](std::string const&)
lea rdi, [rsp+58h+var_50]
mov rsi, rax
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::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&)
lea rdi, [rsp+58h+var_40]
lea rdx, [rsp+58h+var_50]
mov rsi, r15
mov rcx, rbx
call _ZN15SchemaConverter5visitERKN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEERKSA_; SchemaConverter::visit(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::string const&)
lea r15, [rsp+58h+var_40]
mov rdi, rbx
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [r15]; void *
lea rax, [rsp+58h+var_30]
cmp rdi, rax
jz short loc_A3997
mov rsi, [rsp+58h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A3997:
mov rdi, r12
mov rsi, r14
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_SaIS5_ENSt8__detail9_IdentityESt8equal_toIS5_ESt4hashIS5_ENS7_18_Mod_range_hashingENS7_20_Default_ranged_hashENS7_20_Prime_rehash_policyENS7_17_Hashtable_traitsILb1ELb1ELb1EEEE8_M_eraseESt17integral_constantIbLb1EERKS5_; std::_Hashtable<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>::_M_erase(std::integral_constant<bool,true>,std::string const&)
lea r14, [rsp+58h+var_50]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_A39B9:
mov rax, rbx
add rsp, 38h
pop rbx
pop r12
pop r14
pop r15
retn
jmp short $+2
loc_A39CA:
mov r14, rax
lea r15, [rsp+arg_0]
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp short loc_A39EF
jmp short loc_A39EC
jmp short loc_A39EC
jmp short $+2
loc_A39EC:
mov r14, rax
loc_A39EF:
mov rdi, [rbx]; void *
add rbx, 10h
cmp rdi, rbx
jz short loc_A3A06
mov rsi, [rbx]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A3A06:
mov rdi, r14
call __Unwind_Resume
| long long SchemaConverter::_resolve_ref(long long a1, long long a2, long long a3, __m128d a4)
{
long long v5; // rax
int v6; // edx
int v7; // ecx
int v8; // r8d
int v9; // r9d
long long v10; // rax
void **v12[2]; // [rsp+8h] [rbp-50h] BYREF
void *v13[2]; // [rsp+18h] [rbp-40h] BYREF
long long v14; // [rsp+28h] [rbp-30h] BYREF
v5 = std::string::rfind(a3, 47LL, -1LL);
std::string::substr(a1, a3, v5 + 1, -1LL);
if ( std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::string>>>::find(
a2 + 40,
a1) == a2 + 48
&& !std::_Hashtable<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>::find(
a2 + 144,
a3) )
{
v13[0] = (void *)(a2 + 144);
std::_Hashtable<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>::_M_insert<std::string const&,std::__detail::_AllocNode<std::allocator<std::__detail::_Hash_node<std::string,true>>>>(
a2 + 144,
a3,
v13);
v10 = std::__detail::_Map_base<std::string,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::allocator<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::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>,true>::operator[](
(int)a2 + 88,
a3,
v6,
v7,
v8,
v9);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
(long long)v12,
v10);
SchemaConverter::visit(v13, a2, (long long)v12, a1, a4);
std::string::operator=(a1, v13);
if ( v13[0] != &v14 )
operator delete(v13[0], v14 + 1);
std::_Hashtable<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>::_M_erase(
a2 + 144,
a3);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v12);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v12);
}
return a1;
}
| _resolve_ref:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV RDI,RDX
MOV ESI,0x2f
MOV RDX,-0x1
CALL 0x0011aeb0
LEA RDX,[RAX + 0x1]
MOV RDI,RBX
MOV RSI,R14
MOV RCX,-0x1
CALL 0x0011a7a0
LEA RDI,[R15 + 0x28]
LAB_001a38fc:
MOV RSI,RBX
CALL 0x001a0b40
LEA RCX,[R15 + 0x30]
CMP RAX,RCX
JNZ 0x001a39b9
LEA R12,[R15 + 0x90]
LAB_001a3918:
MOV RDI,R12
MOV RSI,R14
CALL 0x001a5a1c
TEST RAX,RAX
JNZ 0x001a39b9
LEA RDX,[RSP + 0x18]
MOV qword ptr [RDX],R12
LAB_001a3934:
MOV RDI,R12
MOV RSI,R14
CALL 0x00181a5e
LEA RDI,[R15 + 0x58]
LAB_001a3943:
MOV RSI,R14
CALL 0x001a5a56
LEA RDI,[RSP + 0x8]
MOV RSI,RAX
CALL 0x0012faf6
LAB_001a3958:
LEA RDI,[RSP + 0x18]
LEA RDX,[RSP + 0x8]
MOV RSI,R15
MOV RCX,RBX
CALL 0x001a0cc2
LEA R15,[RSP + 0x18]
MOV RDI,RBX
MOV RSI,R15
CALL 0x0011a900
MOV RDI,qword ptr [R15]
LEA RAX,[RSP + 0x28]
CMP RDI,RAX
JZ 0x001a3997
MOV RSI,qword ptr [RSP + 0x28]
INC RSI
CALL 0x0011a740
LAB_001a3997:
MOV RDI,R12
MOV RSI,R14
CALL 0x001a5eac
LAB_001a39a2:
LEA R14,[RSP + 0x8]
MOV RDI,R14
XOR ESI,ESI
CALL 0x001426e2
MOV RDI,R14
CALL 0x0014f2d0
LAB_001a39b9:
MOV RAX,RBX
ADD RSP,0x38
POP RBX
POP R12
POP R14
POP R15
RET
|
/* SchemaConverter::_resolve_ref(std::__cxx11::string const&) */
string * SchemaConverter::_resolve_ref(string *param_1)
{
_Hashtable<std::__cxx11::string,std::__cxx11::string,std::allocator<std::__cxx11::string>,std::__detail::_Identity,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>
*this;
string *psVar1;
long lVar2;
basic_json *pbVar3;
string *in_RDX;
string *in_RSI;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_50 [16];
_Hashtable<std::__cxx11::string,std::__cxx11::string,std::allocator<std::__cxx11::string>,std::__detail::_Identity,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>
*local_40 [2];
long local_30 [2];
std::__cxx11::string::rfind((char)in_RDX,0x2f);
std::__cxx11::string::substr((ulong)param_1,(ulong)in_RDX);
/* try { // try from 001a38fc to 001a3903 has its CatchHandler @ 001a39ec */
psVar1 = (string *)
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::__cxx11::string>,std::_Select1st<std::pair<std::__cxx11::string_const,std::__cxx11::string>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
::find((_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::__cxx11::string>,std::_Select1st<std::pair<std::__cxx11::string_const,std::__cxx11::string>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
*)(in_RSI + 0x28),param_1);
if (psVar1 == in_RSI + 0x30) {
this = (_Hashtable<std::__cxx11::string,std::__cxx11::string,std::allocator<std::__cxx11::string>,std::__detail::_Identity,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>
*)(in_RSI + 0x90);
/* try { // try from 001a3918 to 001a3922 has its CatchHandler @ 001a39ea */
lVar2 = std::
_Hashtable<std::__cxx11::string,std::__cxx11::string,std::allocator<std::__cxx11::string>,std::__detail::_Identity,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>
::find(this,in_RDX);
if (lVar2 == 0) {
local_40[0] = this;
/* try { // try from 001a3934 to 001a393e has its CatchHandler @ 001a39e6 */
std::
_Hashtable<std::__cxx11::string,std::__cxx11::string,std::allocator<std::__cxx11::string>,std::__detail::_Identity,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>
::
_M_insert<std::__cxx11::string_const&,std::__detail::_AllocNode<std::allocator<std::__detail::_Hash_node<std::__cxx11::string,true>>>>
(this);
/* try { // try from 001a3943 to 001a3957 has its CatchHandler @ 001a39e8 */
pbVar3 = (basic_json *)
std::__detail::
_Map_base<std::__cxx11::string,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>>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>,true>
::operator[]((_Map_base<std::__cxx11::string,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>>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>,true>
*)(in_RSI + 0x58),in_RDX);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(local_50,pbVar3);
/* try { // try from 001a3958 to 001a396c has its CatchHandler @ 001a39ca */
visit((basic_json *)local_40,in_RSI);
std::__cxx11::string::operator=(param_1,(string *)local_40);
if (local_40[0] !=
(_Hashtable<std::__cxx11::string,std::__cxx11::string,std::allocator<std::__cxx11::string>,std::__detail::_Identity,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>
*)local_30) {
operator_delete(local_40[0],local_30[0] + 1);
}
/* try { // try from 001a3997 to 001a39a1 has its CatchHandler @ 001a39c8 */
std::
_Hashtable<std::__cxx11::string,std::__cxx11::string,std::allocator<std::__cxx11::string>,std::__detail::_Identity,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>
::_M_erase(this);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81((data *)local_50,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)local_50);
}
}
return param_1;
}
| |
29,210 | translog_set_file_size | eloqsql/storage/maria/ma_loghandler.c | void translog_set_file_size(uint32 size)
{
struct st_translog_buffer *old_buffer= NULL;
DBUG_ENTER("translog_set_file_size");
translog_lock();
DBUG_PRINT("enter", ("Size: %lu", (ulong) size));
DBUG_ASSERT(size % TRANSLOG_PAGE_SIZE == 0);
DBUG_ASSERT(size >= TRANSLOG_MIN_FILE_SIZE);
log_descriptor.log_file_max_size= size;
/* if current file longer then finish it*/
if (LSN_OFFSET(log_descriptor.horizon) >= log_descriptor.log_file_max_size)
{
old_buffer= log_descriptor.bc.buffer;
translog_buffer_next(&log_descriptor.horizon, &log_descriptor.bc, 1);
translog_buffer_unlock(old_buffer);
}
translog_unlock();
if (old_buffer)
{
translog_buffer_lock(old_buffer);
translog_buffer_flush(old_buffer);
translog_buffer_unlock(old_buffer);
}
DBUG_VOID_RETURN;
} | O3 | c | translog_set_file_size:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
callq 0x43693
movl %ebx, 0x3de4f4(%rip) # 0x426bc0
cmpl %ebx, 0xbdf126(%rip) # 0xc277f8
jae 0x486d8
xorl %ebx, %ebx
jmp 0x48713
movq 0xbdf149(%rip), %rbx # 0xc27828
leaq 0xbdf112(%rip), %rdi # 0xc277f8
leaq 0xbdf113(%rip), %rsi # 0xc27800
movl $0x1, %edx
callq 0x487a7
movq 0x1000d0(%rbx), %rdi
testq %rdi, %rdi
jne 0x48792
leaq 0x100090(%rbx), %rdi
callq 0x2a1f0
movq 0xbdf10e(%rip), %r14 # 0xc27828
movq 0x1000d0(%r14), %rdi
testq %rdi, %rdi
jne 0x4876e
addq $0x100090, %r14 # imm = 0x100090
movq %r14, %rdi
callq 0x2a1f0
testq %rbx, %rbx
je 0x48769
movq %rbx, %rdi
callq 0x43733
movq %rbx, %rdi
callq 0x47401
movq 0x1000d0(%rbx), %rdi
testq %rdi, %rdi
jne 0x48780
addq $0x100090, %rbx # imm = 0x100090
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2a1f0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3662a3(%rip), %rax # 0x3aea18
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x48726
leaq 0x366291(%rip), %rax # 0x3aea18
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x48756
leaq 0x36627f(%rip), %rax # 0x3aea18
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x48707
| translog_set_file_size:
push rbp
mov rbp, rsp
push r14
push rbx
mov ebx, edi
call translog_lock
mov cs:dword_426BC0, ebx
cmp dword ptr cs:qword_C277F8, ebx
jnb short loc_486D8
xor ebx, ebx
jmp short loc_48713
loc_486D8:
mov rbx, qword ptr cs:xmmword_C27820+8
lea rdi, qword_C277F8
lea rsi, xmmword_C27800
mov edx, 1
call translog_buffer_next
mov rdi, [rbx+1000D0h]
test rdi, rdi
jnz loc_48792
loc_48707:
lea rdi, [rbx+100090h]
call _pthread_mutex_unlock
loc_48713:
mov r14, qword ptr cs:xmmword_C27820+8
mov rdi, [r14+1000D0h]
test rdi, rdi
jnz short loc_4876E
loc_48726:
add r14, 100090h
mov rdi, r14
call _pthread_mutex_unlock
test rbx, rbx
jz short loc_48769
mov rdi, rbx
call translog_buffer_lock
mov rdi, rbx
call translog_buffer_flush
mov rdi, [rbx+1000D0h]
test rdi, rdi
jnz short loc_48780
loc_48756:
add rbx, 100090h
mov rdi, rbx
pop rbx
pop r14
pop rbp
jmp _pthread_mutex_unlock
loc_48769:
pop rbx
pop r14
pop rbp
retn
loc_4876E:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_48726
loc_48780:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_48756
loc_48792:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_48707
| long long translog_set_file_size(unsigned int a1)
{
long long v1; // rbx
long long v2; // r14
long long result; // rax
translog_lock();
dword_426BC0 = a1;
if ( (unsigned int)qword_C277F8 >= a1 )
{
v1 = *((_QWORD *)&xmmword_C27820 + 1);
translog_buffer_next(&qword_C277F8, &xmmword_C27800, 1LL);
if ( *(_QWORD *)(v1 + 1048784) )
PSI_server[44]();
pthread_mutex_unlock(v1 + 1048720);
}
else
{
v1 = 0LL;
}
v2 = *((_QWORD *)&xmmword_C27820 + 1);
if ( *(_QWORD *)(*((_QWORD *)&xmmword_C27820 + 1) + 1048784LL) )
PSI_server[44]();
result = pthread_mutex_unlock(v2 + 1048720);
if ( v1 )
{
translog_buffer_lock(v1);
translog_buffer_flush(v1);
if ( *(_QWORD *)(v1 + 1048784) )
PSI_server[44]();
return pthread_mutex_unlock(v1 + 1048720);
}
return result;
}
| translog_set_file_size:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV EBX,EDI
CALL 0x00143693
MOV dword ptr [0x00526bc0],EBX
CMP dword ptr [0x00d277f8],EBX
JNC 0x001486d8
XOR EBX,EBX
JMP 0x00148713
LAB_001486d8:
MOV RBX,qword ptr [0x00d27828]
LEA RDI,[0xd277f8]
LEA RSI,[0xd27800]
MOV EDX,0x1
CALL 0x001487a7
MOV RDI,qword ptr [RBX + 0x1000d0]
TEST RDI,RDI
JNZ 0x00148792
LAB_00148707:
LEA RDI,[RBX + 0x100090]
CALL 0x0012a1f0
LAB_00148713:
MOV R14,qword ptr [0x00d27828]
MOV RDI,qword ptr [R14 + 0x1000d0]
TEST RDI,RDI
JNZ 0x0014876e
LAB_00148726:
ADD R14,0x100090
MOV RDI,R14
CALL 0x0012a1f0
TEST RBX,RBX
JZ 0x00148769
MOV RDI,RBX
CALL 0x00143733
MOV RDI,RBX
CALL 0x00147401
MOV RDI,qword ptr [RBX + 0x1000d0]
TEST RDI,RDI
JNZ 0x00148780
LAB_00148756:
ADD RBX,0x100090
MOV RDI,RBX
POP RBX
POP R14
POP RBP
JMP 0x0012a1f0
LAB_00148769:
POP RBX
POP R14
POP RBP
RET
LAB_0014876e:
LEA RAX,[0x4aea18]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00148726
LAB_00148780:
LEA RAX,[0x4aea18]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00148756
LAB_00148792:
LEA RAX,[0x4aea18]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00148707
|
void translog_set_file_size(uint param_1)
{
long lVar1;
long lVar2;
translog_lock();
lVar2 = DAT_00d27828;
DAT_00526bc0 = param_1;
if ((uint)DAT_00d277f8 < param_1) {
lVar2 = 0;
}
else {
translog_buffer_next(&DAT_00d277f8,&DAT_00d27800,1);
if (*(long *)((long)&Elf64_Phdr_ARRAY_00100040[2].p_filesz + lVar2) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)((long)&Elf64_Phdr_ARRAY_00100040[1].p_paddr + lVar2));
}
lVar1 = DAT_00d27828;
if (*(long *)((long)&Elf64_Phdr_ARRAY_00100040[2].p_filesz + DAT_00d27828) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)((long)&Elf64_Phdr_ARRAY_00100040[1].p_paddr + lVar1));
if (lVar2 != 0) {
translog_buffer_lock(lVar2);
translog_buffer_flush(lVar2);
if (*(long *)((long)&Elf64_Phdr_ARRAY_00100040[2].p_filesz + lVar2) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)((long)&Elf64_Phdr_ARRAY_00100040[1].p_paddr + lVar2));
return;
}
return;
}
| |
29,211 | my_snprintf | eloqsql/strings/my_vsnprintf.c | size_t my_snprintf(char* to, size_t n, const char* fmt, ...)
{
size_t result;
va_list args;
va_start(args,fmt);
result= my_vsnprintf(to, n, fmt, args);
va_end(args);
return result;
} | O3 | c | my_snprintf:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdx, %r10
movq %rsi, %rdx
movq %rdi, %rsi
leaq -0xd0(%rbp), %rdi
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0xee35b
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)
leaq -0x20(%rbp), %r8
movq %rdi, 0x10(%r8)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%r8)
movabsq $0x3000000018, %rax # imm = 0x3000000018
movq %rax, (%r8)
leaq 0x31d651(%rip), %rdi # 0x40b9d0
movq %r10, %rcx
callq 0xed128
addq $0xd0, %rsp
popq %rbp
retq
| my_snprintf:
push rbp
mov rbp, rsp
sub rsp, 0D0h
mov r10, rdx
mov rdx, rsi
mov rsi, rdi
lea rdi, [rbp+var_D0]
mov [rdi+18h], rcx
mov [rdi+20h], r8
mov [rdi+28h], r9
test al, al
jz short loc_EE35B
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_EE35B:
lea r8, [rbp+var_20]
mov [r8+10h], rdi
lea rax, [rbp+arg_0]
mov [r8+8], rax
mov rax, 3000000018h
mov [r8], rax
lea rdi, my_charset_latin1
mov rcx, r10
call my_vsnprintf_ex
add rsp, 0D0h
pop rbp
retn
| unsigned long long my_snprintf(
unsigned long long a1,
long long a2,
unsigned __int8 *a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
char v16; // [rsp+0h] [rbp-D0h] BYREF
long long v17; // [rsp+18h] [rbp-B8h]
long long v18; // [rsp+20h] [rbp-B0h]
long long v19; // [rsp+28h] [rbp-A8h]
__m128 v20; // [rsp+30h] [rbp-A0h]
__m128 v21; // [rsp+40h] [rbp-90h]
__m128 v22; // [rsp+50h] [rbp-80h]
__m128 v23; // [rsp+60h] [rbp-70h]
__m128 v24; // [rsp+70h] [rbp-60h]
__m128 v25; // [rsp+80h] [rbp-50h]
__m128 v26; // [rsp+90h] [rbp-40h]
__m128 v27; // [rsp+A0h] [rbp-30h]
_QWORD v28[4]; // [rsp+B0h] [rbp-20h] BYREF
v20 = a7;
v21 = a8;
v22 = a9;
v23 = a10;
v24 = a11;
v25 = a12;
v26 = a13;
v27 = a14;
v17 = a4;
v18 = a5;
v19 = a6;
v28[2] = &v16;
v28[1] = &a15;
v28[0] = 0x3000000018LL;
return my_vsnprintf_ex((long long)my_charset_latin1, a1, a2, a3, (unsigned int *)v28);
}
| my_snprintf:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xd0
MOV R10,RDX
MOV RDX,RSI
MOV RSI,RDI
LEA RDI,[RBP + -0xd0]
MOV qword ptr [RDI + 0x18],RCX
MOV qword ptr [RDI + 0x20],R8
MOV qword ptr [RDI + 0x28],R9
TEST AL,AL
JZ 0x001ee35b
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_001ee35b:
LEA R8,[RBP + -0x20]
MOV qword ptr [R8 + 0x10],RDI
LEA RAX,[RBP + 0x10]
MOV qword ptr [R8 + 0x8],RAX
MOV RAX,0x3000000018
MOV qword ptr [R8],RAX
LEA RDI,[0x50b9d0]
MOV RCX,R10
CALL 0x001ed128
ADD RSP,0xd0
POP RBP
RET
|
void my_snprintf(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int8 param_9,int8 param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
char in_AL;
int1 local_d8 [24];
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;
int8 local_28;
int1 *local_20;
int1 *local_18;
local_18 = local_d8;
if (in_AL != '\0') {
local_a8 = param_1;
local_98 = param_2;
local_88 = param_3;
local_78 = param_4;
local_68 = param_5;
local_58 = param_6;
local_48 = param_7;
local_38 = param_8;
}
local_20 = &stack0x00000008;
local_28 = 0x3000000018;
local_c0 = param_12;
local_b8 = param_13;
local_b0 = param_14;
my_vsnprintf_ex(&my_charset_latin1,param_9,param_10,param_11);
return;
}
| |
29,212 | ma_block_start_trans | eloqsql/storage/maria/ma_state.c | my_bool _ma_block_start_trans(void* param)
{
MARIA_HA *info=(MARIA_HA*) param;
DBUG_ENTER("_ma_block_start_trans");
if (info->s->lock_key_trees)
{
/*
Assume for now that this doesn't fail (It can only fail in
out of memory conditions)
TODO: Fix this by having one extra state pre-allocated
*/
DBUG_RETURN(_ma_setup_live_state(info));
}
else
{
/*
We come here in the following cases:
- The table is a temporary table
- It's a table which is crash safe but not yet versioned, for
example a table with fulltext or rtree keys
Set the current state to point to save_state so that the
block_format code don't count the same record twice.
Copy also the current state. This may have been wrong if the
same file was used several times in the last statement
*/
info->state= info->state_start;
*info->state= info->s->state.state;
}
/*
Info->trn is set if this table is already handled and we are
called from maria_versioning()
*/
if (info->s->base.born_transactional && !info->trn)
{
/*
Assume for now that this doesn't fail (It can only fail in
out of memory conditions)
*/
DBUG_RETURN(maria_create_trn_hook(info) != 0);
}
DBUG_RETURN(0);
} | O0 | c | ma_block_start_trans:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, 0x7e3(%rax)
je 0x46bb4
jmp 0x46ba6
movq -0x18(%rbp), %rdi
callq 0x45d90
movb %al, -0x1(%rbp)
jmp 0x46c27
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
addq $0x18, %rsi
movl $0x38, %edx
callq 0x2a0b0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl 0x44c(%rax), %eax
cmpl $0x0, %eax
je 0x46c21
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x46c21
jmp 0x46c01
leaq 0x440030(%rip), %rax # 0x486c38
movq (%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x1(%rbp)
jmp 0x46c27
jmp 0x46c23
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
| _ma_block_start_trans:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rax, [rax]
cmp byte ptr [rax+7E3h], 0
jz short loc_46BB4
jmp short $+2
loc_46BA6:
mov rdi, [rbp+var_18]
call _ma_setup_live_state
mov [rbp+var_1], al
jmp short loc_46C27
loc_46BB4:
mov rax, [rbp+var_18]
mov rcx, [rax+60h]
mov rax, [rbp+var_18]
mov [rax+20h], rcx
mov rax, [rbp+var_18]
mov rdi, [rax+20h]
mov rax, [rbp+var_18]
mov rsi, [rax]
add rsi, 18h
mov edx, 38h ; '8'
call _memcpy
mov rax, [rbp+var_18]
mov rax, [rax]
movsx eax, byte ptr [rax+44Ch]
cmp eax, 0
jz short loc_46C21
mov rax, [rbp+var_18]
cmp qword ptr [rax+8], 0
jnz short loc_46C21
jmp short $+2
loc_46C01:
lea rax, maria_create_trn_hook
mov rax, [rax]
mov rdi, [rbp+var_18]
call rax
cmp eax, 0
setnz al
and al, 1
movzx eax, al
mov [rbp+var_1], al
jmp short loc_46C27
loc_46C21:
jmp short $+2
loc_46C23:
mov [rbp+var_1], 0
loc_46C27:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
| char ma_block_start_trans(long long *a1)
{
if ( *(_BYTE *)(*a1 + 2019) )
return ma_setup_live_state(a1);
a1[4] = a1[12];
memcpy(a1[4], *a1 + 24, 56LL);
return *(_BYTE *)(*a1 + 1100) && !a1[1] && (unsigned int)maria_create_trn_hook(a1) != 0;
}
| _ma_block_start_trans:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
CMP byte ptr [RAX + 0x7e3],0x0
JZ 0x00146bb4
JMP 0x00146ba6
LAB_00146ba6:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00145d90
MOV byte ptr [RBP + -0x1],AL
JMP 0x00146c27
LAB_00146bb4:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX + 0x60]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x20],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RAX]
ADD RSI,0x18
MOV EDX,0x38
CALL 0x0012a0b0
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOVSX EAX,byte ptr [RAX + 0x44c]
CMP EAX,0x0
JZ 0x00146c21
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x8],0x0
JNZ 0x00146c21
JMP 0x00146c01
LAB_00146c01:
LEA RAX,[0x586c38]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RBP + -0x18]
CALL RAX
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x1],AL
JMP 0x00146c27
LAB_00146c21:
JMP 0x00146c23
LAB_00146c23:
MOV byte ptr [RBP + -0x1],0x0
LAB_00146c27:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int1 _ma_block_start_trans(long *param_1)
{
int iVar1;
int1 local_9;
if (*(char *)(*param_1 + 0x7e3) == '\0') {
param_1[4] = param_1[0xc];
memcpy((void *)param_1[4],(void *)(*param_1 + 0x18),0x38);
if ((*(char *)(*param_1 + 0x44c) == '\0') || (param_1[1] != 0)) {
local_9 = 0;
}
else {
iVar1 = (*maria_create_trn_hook)(param_1);
local_9 = iVar1 != 0;
}
}
else {
local_9 = _ma_setup_live_state(param_1);
}
return local_9;
}
| |
29,213 | do_state_timer2 | navaro[P]qoraal-tictactoe/build_O3/_deps/qoraal_engine-src/src/parts/engine.c | int32_t
do_state_timer2 (PENGINE_T instance, uint32_t parm, uint32_t flags, uint32_t mult)
{
int32_t value ;
int32_t ret ;
if (flags & (PART_ACTION_FLAG_VALIDATE)) {
return parts_valadate_int (instance, parm, flags, 0, INT_MAX) ;
}
value = parts_get_int (instance, parm, flags, 0, INT_MAX) ;
ret = inst_set_task (instance, STATE_TASK_TIMER2, 0) ;
if (value) {
value *= mult ;
PENGINE_EVENT_T task = engine_port_event_create (action_state_task_cb) ;
if (!task ||
(engine_port_event_queue (task, ENGINE_EVENT_ID_GET(_state_timer2),
STATE_TASK_TIMER2, (uintptr_t) instance, value) != ENGINE_OK)) {
return ENGINE_FAIL ;
}
inst_set_task (instance, STATE_TASK_TIMER2, task) ;
}
return ret / mult ;
} | O3 | c | do_state_timer2:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
testb $0x1, %dl
jne 0x7a46
movl %ecx, %ebx
movq %r14, %rdi
xorl %ecx, %ecx
movl $0x7fffffff, %r8d # imm = 0x7FFFFFFF
callq 0x82dd
movl %eax, %r12d
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x78bc
testl %r12d, %r12d
je 0x7a2d
movl %eax, -0x2c(%rbp)
leaq 0x8b(%rip), %rdi # 0x7a64
callq 0xda2d
movl $0xffffffff, %r13d # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x7a34
movq %rax, %r15
imull %ebx, %r12d
leaq 0x1ad01(%rip), %rax # 0x226f8
subl 0x365e3(%rip), %eax # 0x3dfe0
shrl $0x4, %eax
movzwl %ax, %esi
movq %r15, %rdi
movl $0x2, %edx
movq %r14, %rcx
movl %r12d, %r8d
callq 0xdb3e
testl %eax, %eax
jne 0x7a34
movq %r14, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0x78bc
movl -0x2c(%rbp), %eax
xorl %edx, %edx
divl %ebx
movl %eax, %r13d
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
xorl %ecx, %ecx
movl $0x7fffffff, %r8d # imm = 0x7FFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8254
| do_state_timer2:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rdi
test dl, 1
jnz loc_7A46
mov ebx, ecx
mov rdi, r14
xor ecx, ecx
mov r8d, 7FFFFFFFh
call parts_get_int
mov r12d, eax
mov rdi, r14
mov esi, 2
xor edx, edx
call inst_set_task
test r12d, r12d
jz short loc_7A2D
mov [rbp+var_2C], eax
lea rdi, action_state_task_cb
call engine_port_event_create
mov r13d, 0FFFFFFFFh
test rax, rax
jz short loc_7A34
mov r15, rax
imul r12d, ebx
lea rax, __engine_event__state_timer2
sub eax, dword ptr cs:__engine_event_base___ptr_0
shr eax, 4
movzx esi, ax
mov rdi, r15
mov edx, 2
mov rcx, r14
mov r8d, r12d
call engine_port_event_queue
test eax, eax
jnz short loc_7A34
mov rdi, r14
mov esi, 2
mov rdx, r15
call inst_set_task
mov eax, [rbp+var_2C]
loc_7A2D:
xor edx, edx
div ebx
mov r13d, eax
loc_7A34:
mov eax, r13d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7A46:
mov rdi, r14
xor ecx, ecx
mov r8d, 7FFFFFFFh
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp parts_valadate_int
| long long do_state_timer2(long long a1, long long a2, long long a3, unsigned int a4)
{
int v5; // r12d
unsigned int v6; // eax
long long v7; // rax
unsigned int v8; // r13d
long long v9; // r15
unsigned int v11; // [rsp+0h] [rbp-2Ch]
if ( (a3 & 1) == 0 )
{
v5 = parts_get_int(a1, a2, a3, 0LL, 0x7FFFFFFFLL);
v6 = inst_set_task(a1, 2, 0LL);
if ( v5 )
{
v11 = v6;
v7 = engine_port_event_create(action_state_task_cb);
v8 = -1;
if ( !v7 )
return v8;
v9 = v7;
if ( (unsigned int)engine_port_event_queue(
v7,
(unsigned __int16)(((unsigned int)_engine_event__state_timer2
- (unsigned int)_engine_event_base__) >> 4),
2LL,
a1,
a4 * v5) )
return v8;
inst_set_task(a1, 2, v9);
v6 = v11;
}
return v6 / a4;
}
return parts_valadate_int(a1, a2, a3, 0LL, 0x7FFFFFFFLL);
}
| do_state_timer2:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDI
TEST DL,0x1
JNZ 0x00107a46
MOV EBX,ECX
MOV RDI,R14
XOR ECX,ECX
MOV R8D,0x7fffffff
CALL 0x001082dd
MOV R12D,EAX
MOV RDI,R14
MOV ESI,0x2
XOR EDX,EDX
CALL 0x001078bc
TEST R12D,R12D
JZ 0x00107a2d
MOV dword ptr [RBP + -0x2c],EAX
LEA RDI,[0x107a64]
CALL 0x0010da2d
MOV R13D,0xffffffff
TEST RAX,RAX
JZ 0x00107a34
MOV R15,RAX
IMUL R12D,EBX
LEA RAX,[0x1226f8]
SUB EAX,dword ptr [0x0013dfe0]
SHR EAX,0x4
MOVZX ESI,AX
MOV RDI,R15
MOV EDX,0x2
MOV RCX,R14
MOV R8D,R12D
CALL 0x0010db3e
TEST EAX,EAX
JNZ 0x00107a34
MOV RDI,R14
MOV ESI,0x2
MOV RDX,R15
CALL 0x001078bc
MOV EAX,dword ptr [RBP + -0x2c]
LAB_00107a2d:
XOR EDX,EDX
DIV EBX
MOV R13D,EAX
LAB_00107a34:
MOV EAX,R13D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00107a46:
MOV RDI,R14
XOR ECX,ECX
MOV R8D,0x7fffffff
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00108254
|
ulong do_state_timer2(int8 param_1,int8 param_2,ulong param_3,uint param_4)
{
int iVar1;
ulong uVar2;
long lVar3;
if ((param_3 & 1) != 0) {
uVar2 = parts_valadate_int(param_1,param_2,param_3,0,0x7fffffff);
return uVar2;
}
iVar1 = parts_get_int(param_1,param_2,param_3,0,0x7fffffff);
uVar2 = inst_set_task(param_1,2,0);
if (iVar1 != 0) {
lVar3 = engine_port_event_create(action_state_task_cb);
if (lVar3 == 0) {
return 0xffffffff;
}
iVar1 = engine_port_event_queue
(lVar3,0x1226f8U - (int)PTR___engine_event__console_char_0013dfe0 >> 4 &
0xffff,2,param_1,iVar1 * param_4);
if (iVar1 != 0) {
return 0xffffffff;
}
inst_set_task(param_1,2,lVar3);
uVar2 = uVar2 & 0xffffffff;
}
return (uVar2 & 0xffffffff) / (ulong)param_4;
}
| |
29,214 | js_std_file_eof | bluesky950520[P]quickjs/quickjs-libc.c | static JSValue js_std_file_eof(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
FILE *f = js_std_file_get(ctx, this_val);
if (!f)
return JS_EXCEPTION;
return JS_NewBool(ctx, feof(f));
} | O0 | c | js_std_file_eof:
subq $0x68, %rsp
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rdi, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq %r8, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x19d70
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x192e0
movl $0x0, 0x38(%rsp)
movq $0x6, 0x40(%rsp)
jmp 0x1932d
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0xe5c0
movq (%rsp), %rcx
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
testl %eax, %eax
setne %al
movzbl %al, %eax
movl %eax, 0x58(%rsp)
movq $0x1, 0x60(%rsp)
movq 0x58(%rsp), %rcx
movq 0x60(%rsp), %rax
movq %rcx, 0x38(%rsp)
movq %rax, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rdx
addq $0x68, %rsp
retq
nopl (%rax)
| js_std_file_eof:
sub rsp, 68h
mov [rsp+68h+var_40], rsi
mov [rsp+68h+var_38], rdx
mov [rsp+68h+var_48], rdi
mov [rsp+68h+var_4C], ecx
mov [rsp+68h+var_58], r8
mov rdi, [rsp+68h+var_48]
mov rsi, [rsp+68h+var_40]
mov rdx, [rsp+68h+var_38]
call js_std_file_get
mov [rsp+68h+var_60], rax
cmp [rsp+68h+var_60], 0
jnz short loc_192E0
mov dword ptr [rsp+68h+var_30], 0
mov [rsp+68h+var_28], 6
jmp short loc_1932D
loc_192E0:
mov rax, [rsp+68h+var_48]
mov [rsp+68h+var_68], rax
mov rdi, [rsp+68h+var_60]
call _feof
mov rcx, [rsp+68h+var_68]
mov [rsp+68h+var_18], rcx
mov [rsp+68h+var_1C], eax
mov eax, [rsp+68h+var_1C]
test eax, eax
setnz al
movzx eax, al
mov dword ptr [rsp+68h+var_10], eax
mov [rsp+68h+var_8], 1
mov rcx, [rsp+68h+var_10]
mov rax, [rsp+68h+var_8]
mov [rsp+68h+var_30], rcx
mov [rsp+68h+var_28], rax
loc_1932D:
mov rax, [rsp+68h+var_30]
mov rdx, [rsp+68h+var_28]
add rsp, 68h
retn
| long long js_std_file_eof(long long a1, long long a2, long long a3)
{
long long v4; // [rsp+8h] [rbp-60h]
long long v5; // [rsp+38h] [rbp-30h]
long long v6; // [rsp+58h] [rbp-10h]
v4 = js_std_file_get(a1, a2, a3);
if ( v4 )
{
LODWORD(v6) = feof(v4) != 0;
return v6;
}
else
{
LODWORD(v5) = 0;
}
return v5;
}
| js_std_file_eof:
SUB RSP,0x68
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x30],RDX
MOV qword ptr [RSP + 0x20],RDI
MOV dword ptr [RSP + 0x1c],ECX
MOV qword ptr [RSP + 0x10],R8
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
CALL 0x00119d70
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x8],0x0
JNZ 0x001192e0
MOV dword ptr [RSP + 0x38],0x0
MOV qword ptr [RSP + 0x40],0x6
JMP 0x0011932d
LAB_001192e0:
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x0010e5c0
MOV RCX,qword ptr [RSP]
MOV qword ptr [RSP + 0x50],RCX
MOV dword ptr [RSP + 0x4c],EAX
MOV EAX,dword ptr [RSP + 0x4c]
TEST EAX,EAX
SETNZ AL
MOVZX EAX,AL
MOV dword ptr [RSP + 0x58],EAX
MOV qword ptr [RSP + 0x60],0x1
MOV RCX,qword ptr [RSP + 0x58]
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x38],RCX
MOV qword ptr [RSP + 0x40],RAX
LAB_0011932d:
MOV RAX,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x40]
ADD RSP,0x68
RET
|
int1 [16] js_std_file_eof(int8 param_1,int8 param_2,int8 param_3)
{
int1 auVar1 [16];
int iVar2;
FILE *__stream;
int4 local_30;
int4 uStack_2c;
int8 local_28;
int4 uStack_c;
__stream = (FILE *)js_std_file_get(param_1,param_2,param_3);
if (__stream == (FILE *)0x0) {
local_30 = 0;
local_28 = 6;
}
else {
iVar2 = feof(__stream);
local_30 = (uint)(iVar2 != 0);
uStack_2c = uStack_c;
local_28 = 1;
}
auVar1._4_4_ = uStack_2c;
auVar1._0_4_ = local_30;
auVar1._8_8_ = local_28;
return auVar1;
}
| |
29,215 | add_ic_slot | bluesky950520[P]quickjs/quickjs.c | static void add_ic_slot(JSContext *ctx, JSInlineCacheUpdate *icu,
JSAtom atom, JSObject *object, uint32_t prop_offset)
{
int32_t i;
uint32_t h;
JSInlineCacheHashSlot *ch;
JSInlineCacheRingSlot *cr;
JSInlineCache *ic;
JSShape *sh;
if (!icu)
return;
ic = icu->ic;
if (!ic)
return;
sh = object->shape;
if (!sh->is_hashed)
return;
cr = NULL;
h = get_index_hash(atom, ic->hash_bits);
for (ch = ic->hash[h]; ch != NULL; ch = ch->next) {
if (ch->atom == atom) {
cr = ic->cache + ch->index;
break;
}
}
assert(cr != NULL);
i = cr->index;
do {
if (sh == cr->shape[i]) {
cr->prop_offset[i] = prop_offset;
goto end;
}
i = (i + 1) % countof(cr->shape);
} while (i != cr->index);
js_free_shape_null(ctx->rt, cr->shape[i]);
cr->shape[i] = js_dup_shape(sh);
cr->prop_offset[i] = prop_offset;
end:
icu->offset = ch->index;
} | O2 | c | add_ic_slot:
testq %rsi, %rsi
je 0x39b76
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq (%rsi), %rax
testq %rax, %rax
je 0x39b68
movq 0x18(%rcx), %r12
cmpb $0x0, 0x18(%r12)
je 0x39b68
movl %r8d, %ebx
imull $0x9e370001, %edx, %r15d # imm = 0x9E370001
movb 0x8(%rax), %sil
xorl %ecx, %ecx
subb %sil, %cl
shrl %cl, %r15d
xorl %r13d, %r13d
shlq $0x3, %r15
addq 0x10(%rax), %r15
movq (%r15), %r15
testq %r15, %r15
je 0x39b29
cmpl %edx, (%r15)
je 0x39b1d
addq $0x8, %r15
jmp 0x39b0a
movl 0x4(%r15), %ecx
imulq $0x38, %rcx, %r13
addq 0x18(%rax), %r13
movzbl 0x34(%r13), %eax
movl %eax, %ebp
movl %ebp, %ebp
cmpq (%r13,%rbp,8), %r12
je 0x39b5b
incl %ebp
andl $0x3, %ebp
cmpl %eax, %ebp
jne 0x39b30
movq 0x18(%rdi), %rdi
movl %eax, %ebp
movq (%r13,%rbp,8), %rsi
callq 0x1dd2b
incl (%r12)
movq %r12, (%r13,%rbp,8)
movl %ebx, 0x20(%r13,%rbp,4)
movl 0x4(%r15), %eax
movl %eax, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| add_ic_slot:
test rsi, rsi
jz locret_39B76
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rsi
mov rax, [rsi]
test rax, rax
jz loc_39B68
mov r12, [rcx+18h]
cmp byte ptr [r12+18h], 0
jz short loc_39B68
mov ebx, r8d
imul r15d, edx, 9E370001h
mov sil, [rax+8]
xor ecx, ecx
sub cl, sil
shr r15d, cl
xor r13d, r13d
shl r15, 3
add r15, [rax+10h]
loc_39B0A:
mov r15, [r15]
test r15, r15
jz short loc_39B29
cmp [r15], edx
jz short loc_39B1D
add r15, 8
jmp short loc_39B0A
loc_39B1D:
mov ecx, [r15+4]
imul r13, rcx, 38h ; '8'
add r13, [rax+18h]
loc_39B29:
movzx eax, byte ptr [r13+34h]
mov ebp, eax
loc_39B30:
mov ebp, ebp
cmp r12, [r13+rbp*8+0]
jz short loc_39B5B
inc ebp
and ebp, 3
cmp ebp, eax
jnz short loc_39B30
mov rdi, [rdi+18h]
mov ebp, eax
mov rsi, [r13+rbp*8+0]
call js_free_shape_null
inc dword ptr [r12]
mov [r13+rbp*8+0], r12
loc_39B5B:
mov [r13+rbp*4+20h], ebx
mov eax, [r15+4]
mov [r14+8], eax
loc_39B68:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
locret_39B76:
retn
| long long add_ic_slot(long long a1, long long *a2, int a3, long long a4, int a5)
{
long long result; // rax
long long v6; // r12
long long v8; // r13
_DWORD **i; // r15
_DWORD *v10; // r15
long long v11; // rbp
if ( a2 )
{
result = *a2;
if ( *a2 )
{
v6 = *(_QWORD *)(a4 + 24);
if ( *(_BYTE *)(v6 + 24) )
{
v8 = 0LL;
for ( i = (_DWORD **)(*(_QWORD *)(result + 16)
+ 8LL * ((unsigned int)(-1640562687 * a3) >> -*(_BYTE *)(result + 8)));
;
i = (_DWORD **)(v10 + 2) )
{
v10 = *i;
if ( !v10 )
break;
if ( *v10 == a3 )
{
v8 = *(_QWORD *)(result + 24) + 56LL * (unsigned int)v10[1];
break;
}
}
LODWORD(v11) = *(unsigned __int8 *)(v8 + 52);
while ( 1 )
{
v11 = (unsigned int)v11;
if ( v6 == *(_QWORD *)(v8 + 8LL * (unsigned int)v11) )
break;
LODWORD(v11) = ((_BYTE)v11 + 1) & 3;
if ( (_DWORD)v11 == *(unsigned __int8 *)(v8 + 52) )
{
v11 = *(unsigned __int8 *)(v8 + 52);
js_free_shape_null(*(_QWORD *)(a1 + 24), *(_QWORD *)(v8 + 8 * v11));
++*(_DWORD *)v6;
*(_QWORD *)(v8 + 8 * v11) = v6;
break;
}
}
*(_DWORD *)(v8 + 4 * v11 + 32) = a5;
result = (unsigned int)v10[1];
*((_DWORD *)a2 + 2) = result;
}
}
}
return result;
}
| add_ic_slot:
TEST RSI,RSI
JZ 0x00139b76
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RAX,qword ptr [RSI]
TEST RAX,RAX
JZ 0x00139b68
MOV R12,qword ptr [RCX + 0x18]
CMP byte ptr [R12 + 0x18],0x0
JZ 0x00139b68
MOV EBX,R8D
IMUL R15D,EDX,-0x61c8ffff
MOV SIL,byte ptr [RAX + 0x8]
XOR ECX,ECX
SUB CL,SIL
SHR R15D,CL
XOR R13D,R13D
SHL R15,0x3
ADD R15,qword ptr [RAX + 0x10]
LAB_00139b0a:
MOV R15,qword ptr [R15]
TEST R15,R15
JZ 0x00139b29
CMP dword ptr [R15],EDX
JZ 0x00139b1d
ADD R15,0x8
JMP 0x00139b0a
LAB_00139b1d:
MOV ECX,dword ptr [R15 + 0x4]
IMUL R13,RCX,0x38
ADD R13,qword ptr [RAX + 0x18]
LAB_00139b29:
MOVZX EAX,byte ptr [R13 + 0x34]
MOV EBP,EAX
LAB_00139b30:
MOV EBP,EBP
CMP R12,qword ptr [R13 + RBP*0x8]
JZ 0x00139b5b
INC EBP
AND EBP,0x3
CMP EBP,EAX
JNZ 0x00139b30
MOV RDI,qword ptr [RDI + 0x18]
MOV EBP,EAX
MOV RSI,qword ptr [R13 + RBP*0x8]
CALL 0x0011dd2b
INC dword ptr [R12]
MOV qword ptr [R13 + RBP*0x8],R12
LAB_00139b5b:
MOV dword ptr [R13 + RBP*0x4 + 0x20],EBX
MOV EAX,dword ptr [R15 + 0x4]
MOV dword ptr [R14 + 0x8],EAX
LAB_00139b68:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
LAB_00139b76:
RET
|
void add_ic_slot(long param_1,long *param_2,int param_3,long param_4,int4 param_5)
{
byte bVar1;
long lVar2;
int *piVar3;
uint uVar4;
ulong uVar5;
long lVar6;
int *piVar7;
if (((param_2 != (long *)0x0) && (lVar2 = *param_2, lVar2 != 0)) &&
(piVar3 = *(int **)(param_4 + 0x18), (char)piVar3[6] != '\0')) {
lVar6 = 0;
for (piVar7 = (int *)((ulong)((uint)(param_3 * -0x61c8ffff) >> (-*(char *)(lVar2 + 8) & 0x1fU))
* 8 + *(long *)(lVar2 + 0x10)); piVar7 = *(int **)piVar7,
piVar7 != (int *)0x0; piVar7 = piVar7 + 2) {
if (*piVar7 == param_3) {
lVar6 = (ulong)(uint)piVar7[1] * 0x38 + *(long *)(lVar2 + 0x18);
break;
}
}
bVar1 = *(byte *)(lVar6 + 0x34);
uVar4 = (uint)bVar1;
do {
uVar5 = (ulong)uVar4;
if (piVar3 == *(int **)(lVar6 + uVar5 * 8)) goto LAB_00139b5b;
uVar4 = uVar4 + 1 & 3;
} while (uVar4 != bVar1);
uVar5 = (ulong)bVar1;
js_free_shape_null(*(int8 *)(param_1 + 0x18),*(int8 *)(lVar6 + uVar5 * 8));
*piVar3 = *piVar3 + 1;
*(int **)(lVar6 + uVar5 * 8) = piVar3;
LAB_00139b5b:
*(int4 *)(lVar6 + 0x20 + uVar5 * 4) = param_5;
*(int *)(param_2 + 1) = piVar7[1];
}
return;
}
| |
29,216 | ma_bitmap_flushable | eloqsql/storage/maria/ma_bitmap.c | void _ma_bitmap_flushable(MARIA_HA *info, int non_flushable_inc)
{
MARIA_SHARE *share= info->s;
MARIA_FILE_BITMAP *bitmap;
DBUG_ENTER("_ma_bitmap_flushable");
/*
Not transactional tables are never automaticly flushed and needs no
protection
*/
if (!share->now_transactional)
DBUG_VOID_RETURN;
bitmap= &share->bitmap;
mysql_mutex_lock(&bitmap->bitmap_lock);
if (non_flushable_inc == -1)
{
DBUG_ASSERT((int) bitmap->non_flushable > 0);
DBUG_ASSERT(info->non_flushable_state == 1);
if (--bitmap->non_flushable == 0)
{
/*
We unlock and unpin pages locked and pinned by other threads. It does
not seem to be an issue as all bitmap changes are serialized with
the bitmap's mutex.
*/
_ma_bitmap_unpin_all(share);
if (unlikely(bitmap->waiting_for_non_flushable))
{
DBUG_PRINT("info", ("bitmap flushable waking up flusher"));
mysql_cond_broadcast(&bitmap->bitmap_cond);
}
}
DBUG_PRINT("info", ("bitmap->non_flushable: %u", bitmap->non_flushable));
mysql_mutex_unlock(&bitmap->bitmap_lock);
info->non_flushable_state= 0;
DBUG_VOID_RETURN;
}
DBUG_ASSERT(non_flushable_inc == 1);
DBUG_ASSERT(info->non_flushable_state == 0);
bitmap->waiting_for_flush_all_requested++;
while (unlikely(bitmap->flush_all_requested))
{
/*
Some other thread is waiting for the bitmap to become
flushable. Not the moment to make the bitmap unflushable or more
unflushable; let's rather back off and wait. If we didn't do this, with
multiple writers, there may always be one thread causing the bitmap to
be unflushable and _ma_bitmap_flush_all() would wait for long.
There should not be a deadlock because if our thread increased
non_flushable (and thus _ma_bitmap_flush_all() is waiting for at least
our thread), it is not going to increase it more so is not going to come
here.
*/
DBUG_PRINT("info", ("waiting for bitmap flusher"));
mysql_cond_wait(&bitmap->bitmap_cond, &bitmap->bitmap_lock);
}
bitmap->waiting_for_flush_all_requested--;
bitmap->non_flushable++;
DBUG_PRINT("info", ("bitmap->non_flushable: %u", bitmap->non_flushable));
mysql_mutex_unlock(&bitmap->bitmap_lock);
info->non_flushable_state= 1;
DBUG_VOID_RETURN;
} | O0 | c | ma_bitmap_flushable:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, 0x7e7(%rax)
jne 0x6619e
jmp 0x66199
jmp 0x662dc
movq -0x18(%rbp), %rax
addq $0xa10, %rax # imm = 0xA10
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x88, %rdi
leaq 0xf5bb8(%rip), %rsi # 0x15bd76
movl $0xa4d, %edx # imm = 0xA4D
callq 0x64580
cmpl $-0x1, -0xc(%rbp)
jne 0x66246
jmp 0x661d0
jmp 0x661d2
jmp 0x661d4
jmp 0x661d6
movq -0x20(%rbp), %rcx
movl 0x38(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x38(%rcx)
cmpl $0x0, %eax
jne 0x6621f
movq -0x18(%rbp), %rdi
callq 0x64cd0
movq -0x20(%rbp), %rax
cmpl $0x0, 0x3c(%rax)
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x6621d
jmp 0x6620b
jmp 0x6620d
movq -0x20(%rbp), %rdi
addq $0xd0, %rdi
callq 0x64ae0
jmp 0x6621f
jmp 0x66221
jmp 0x66223
movq -0x20(%rbp), %rdi
addq $0x88, %rdi
callq 0x64830
movq -0x8(%rbp), %rax
movl $0x0, 0x644(%rax)
jmp 0x662dc
jmp 0x66248
jmp 0x6624a
jmp 0x6624c
jmp 0x6624e
movq -0x20(%rbp), %rax
movl 0x34(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x34(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x30(%rax)
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x662a0
jmp 0x66275
jmp 0x66277
movq -0x20(%rbp), %rdi
addq $0xd0, %rdi
movq -0x20(%rbp), %rsi
addq $0x88, %rsi
leaq 0xf5ae2(%rip), %rdx # 0x15bd76
movl $0xa78, %ecx # imm = 0xA78
callq 0x64a40
jmp 0x6625b
movq -0x20(%rbp), %rax
movl 0x34(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x34(%rax)
movq -0x20(%rbp), %rax
movl 0x38(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x38(%rax)
jmp 0x662bc
movq -0x20(%rbp), %rdi
addq $0x88, %rdi
callq 0x64830
movq -0x8(%rbp), %rax
movl $0x1, 0x644(%rax)
jmp 0x662dc
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ma_bitmap_flushable:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
cmp byte ptr [rax+7E7h], 0
jnz short loc_6619E
jmp short $+2
loc_66199:
jmp loc_662DC
loc_6619E:
mov rax, [rbp+var_18]
add rax, 0A10h
mov [rbp+var_20], rax
mov rdi, [rbp+var_20]
add rdi, 88h
lea rsi, aWorkspaceLlm4b_11; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 0A4Dh
call inline_mysql_mutex_lock_8
cmp [rbp+var_C], 0FFFFFFFFh
jnz short loc_66246
jmp short $+2
loc_661D0:
jmp short $+2
loc_661D2:
jmp short $+2
loc_661D4:
jmp short $+2
loc_661D6:
mov rcx, [rbp+var_20]
mov eax, [rcx+38h]
add eax, 0FFFFFFFFh
mov [rcx+38h], eax
cmp eax, 0
jnz short loc_6621F
mov rdi, [rbp+var_18]
call _ma_bitmap_unpin_all
mov rax, [rbp+var_20]
cmp dword ptr [rax+3Ch], 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_6621D
jmp short $+2
loc_6620B:
jmp short $+2
loc_6620D:
mov rdi, [rbp+var_20]
add rdi, 0D0h
call inline_mysql_cond_broadcast_1
loc_6621D:
jmp short $+2
loc_6621F:
jmp short $+2
loc_66221:
jmp short $+2
loc_66223:
mov rdi, [rbp+var_20]
add rdi, 88h
call inline_mysql_mutex_unlock_8
mov rax, [rbp+var_8]
mov dword ptr [rax+644h], 0
jmp loc_662DC
loc_66246:
jmp short $+2
loc_66248:
jmp short $+2
loc_6624A:
jmp short $+2
loc_6624C:
jmp short $+2
loc_6624E:
mov rax, [rbp+var_20]
mov ecx, [rax+34h]
add ecx, 1
mov [rax+34h], ecx
loc_6625B:
mov rax, [rbp+var_20]
cmp dword ptr [rax+30h], 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_662A0
jmp short $+2
loc_66275:
jmp short $+2
loc_66277:
mov rdi, [rbp+var_20]
add rdi, 0D0h
mov rsi, [rbp+var_20]
add rsi, 88h
lea rdx, aWorkspaceLlm4b_11; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 0A78h
call inline_mysql_cond_wait_2
jmp short loc_6625B
loc_662A0:
mov rax, [rbp+var_20]
mov ecx, [rax+34h]
add ecx, 0FFFFFFFFh
mov [rax+34h], ecx
mov rax, [rbp+var_20]
mov ecx, [rax+38h]
add ecx, 1
mov [rax+38h], ecx
jmp short $+2
loc_662BC:
mov rdi, [rbp+var_20]
add rdi, 88h
call inline_mysql_mutex_unlock_8
mov rax, [rbp+var_8]
mov dword ptr [rax+644h], 1
jmp short $+2
loc_662DC:
add rsp, 20h
pop rbp
retn
| _DWORD * ma_bitmap_flushable(_DWORD *a1, int a2)
{
_DWORD *result; // rax
int v3; // eax
_DWORD *v4; // [rsp+8h] [rbp-18h]
v4 = *(_DWORD **)a1;
result = *(_DWORD **)a1;
if ( *(_BYTE *)(*(_QWORD *)a1 + 2023LL) )
{
inline_mysql_mutex_lock_8(
(long long)(v4 + 678),
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c",
0xA4Du);
if ( a2 == -1 )
{
v3 = v4[658] - 1;
v4[658] = v3;
if ( !v3 )
{
ma_bitmap_unpin_all((long long)v4);
if ( v4[659] )
inline_mysql_cond_broadcast_1((long long)(v4 + 696));
}
inline_mysql_mutex_unlock_8((long long)(v4 + 678));
result = a1;
a1[401] = 0;
}
else
{
++v4[657];
while ( v4[656] )
inline_mysql_cond_wait_2(
(long long)(v4 + 696),
(long long)(v4 + 678),
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c",
0xA78u);
--v4[657];
++v4[658];
inline_mysql_mutex_unlock_8((long long)(v4 + 678));
result = a1;
a1[401] = 1;
}
}
return result;
}
| _ma_bitmap_flushable:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
CMP byte ptr [RAX + 0x7e7],0x0
JNZ 0x0016619e
JMP 0x00166199
LAB_00166199:
JMP 0x001662dc
LAB_0016619e:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0xa10
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x88
LEA RSI,[0x25bd76]
MOV EDX,0xa4d
CALL 0x00164580
CMP dword ptr [RBP + -0xc],-0x1
JNZ 0x00166246
JMP 0x001661d0
LAB_001661d0:
JMP 0x001661d2
LAB_001661d2:
JMP 0x001661d4
LAB_001661d4:
JMP 0x001661d6
LAB_001661d6:
MOV RCX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RCX + 0x38]
ADD EAX,-0x1
MOV dword ptr [RCX + 0x38],EAX
CMP EAX,0x0
JNZ 0x0016621f
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00164cd0
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX + 0x3c],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0016621d
JMP 0x0016620b
LAB_0016620b:
JMP 0x0016620d
LAB_0016620d:
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0xd0
CALL 0x00164ae0
LAB_0016621d:
JMP 0x0016621f
LAB_0016621f:
JMP 0x00166221
LAB_00166221:
JMP 0x00166223
LAB_00166223:
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x88
CALL 0x00164830
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x644],0x0
JMP 0x001662dc
LAB_00166246:
JMP 0x00166248
LAB_00166248:
JMP 0x0016624a
LAB_0016624a:
JMP 0x0016624c
LAB_0016624c:
JMP 0x0016624e
LAB_0016624e:
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x34]
ADD ECX,0x1
MOV dword ptr [RAX + 0x34],ECX
LAB_0016625b:
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX + 0x30],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001662a0
JMP 0x00166275
LAB_00166275:
JMP 0x00166277
LAB_00166277:
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0xd0
MOV RSI,qword ptr [RBP + -0x20]
ADD RSI,0x88
LEA RDX,[0x25bd76]
MOV ECX,0xa78
CALL 0x00164a40
JMP 0x0016625b
LAB_001662a0:
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x34]
ADD ECX,-0x1
MOV dword ptr [RAX + 0x34],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x38]
ADD ECX,0x1
MOV dword ptr [RAX + 0x38],ECX
JMP 0x001662bc
LAB_001662bc:
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x88
CALL 0x00164830
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x644],0x1
JMP 0x001662dc
LAB_001662dc:
ADD RSP,0x20
POP RBP
RET
|
void _ma_bitmap_flushable(long *param_1,int param_2)
{
long lVar1;
int iVar2;
lVar1 = *param_1;
if (*(char *)(lVar1 + 0x7e7) != '\0') {
inline_mysql_mutex_lock
(lVar1 + 0xa98,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c",
0xa4d);
if (param_2 == -1) {
iVar2 = *(int *)(lVar1 + 0xa48) + -1;
*(int *)(lVar1 + 0xa48) = iVar2;
if ((iVar2 == 0) && (_ma_bitmap_unpin_all(lVar1), *(int *)(lVar1 + 0xa4c) != 0)) {
inline_mysql_cond_broadcast(lVar1 + 0xae0);
}
inline_mysql_mutex_unlock(lVar1 + 0xa98);
*(int4 *)((long)param_1 + 0x644) = 0;
}
else {
*(int *)(lVar1 + 0xa44) = *(int *)(lVar1 + 0xa44) + 1;
while (*(int *)(lVar1 + 0xa40) != 0) {
inline_mysql_cond_wait
(lVar1 + 0xae0,lVar1 + 0xa98,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c",0xa78);
}
*(int *)(lVar1 + 0xa44) = *(int *)(lVar1 + 0xa44) + -1;
*(int *)(lVar1 + 0xa48) = *(int *)(lVar1 + 0xa48) + 1;
inline_mysql_mutex_unlock(lVar1 + 0xa98);
*(int4 *)((long)param_1 + 0x644) = 1;
}
}
return;
}
| |
29,217 | my_thread_global_end | eloqsql/mysys/my_thr_init.c | void my_thread_global_end(void)
{
struct timespec abstime;
my_bool all_threads_killed= 1;
set_timespec(abstime, my_thread_end_wait_time);
mysql_mutex_lock(&THR_LOCK_threads);
while (THR_thread_count > 0)
{
int error= mysql_cond_timedwait(&THR_COND_threads, &THR_LOCK_threads,
&abstime);
if (error == ETIMEDOUT || error == ETIME)
{
#ifdef HAVE_PTHREAD_KILL
/*
We shouldn't give an error here, because if we don't have
pthread_kill(), programs like mysqld can't ensure that all threads
are killed when we enter here.
*/
if (THR_thread_count)
fprintf(stderr,
"Error in my_thread_global_end(): %d threads didn't exit\n",
THR_thread_count);
#endif
all_threads_killed= 0;
break;
}
}
mysql_mutex_unlock(&THR_LOCK_threads);
my_thread_destroy_common_mutex();
/*
Only destroy the mutex & conditions if we don't have other threads around
that could use them.
*/
if (all_threads_killed)
{
my_thread_destroy_internal_mutex();
}
my_thread_global_init_done= 0;
} | O0 | c | my_thread_global_end:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb $0x1, -0x11(%rbp)
callq 0x2f2e0
movq %rax, -0x28(%rbp)
imulq $0x3e8, -0x28(%rbp), %rax # imm = 0x3E8
leaq 0x1a81cc(%rip), %rcx # 0x1cf4b0
movl (%rcx), %ecx
imulq $0x3b9aca00, %rcx, %rcx # imm = 0x3B9ACA00
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x3b9aca00, %ecx # imm = 0x3B9ACA00
xorl %edx, %edx
divq %rcx
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movl $0x3b9aca00, %ecx # imm = 0x3B9ACA00
xorl %edx, %edx
divq %rcx
movq %rdx, -0x8(%rbp)
leaq 0x360231(%rip), %rdi # 0x387550
leaq 0x53384(%rip), %rsi # 0x7a6aa
movl $0xce, %edx
callq 0x273d0
leaq 0x360019(%rip), %rax # 0x387350
cmpl $0x0, (%rax)
jbe 0x273a4
leaq 0x36029d(%rip), %rdi # 0x3875e0
leaq 0x360206(%rip), %rsi # 0x387550
leaq -0x10(%rbp), %rdx
leaq 0x53355(%rip), %rcx # 0x7a6aa
movl $0xd2, %r8d
callq 0x27440
movl %eax, -0x2c(%rbp)
cmpl $0x6e, -0x2c(%rbp)
je 0x2736f
cmpl $0x3e, -0x2c(%rbp)
jne 0x273a2
leaq 0x35ffda(%rip), %rax # 0x387350
cmpl $0x0, (%rax)
je 0x2739c
movq 0x1a7c5e(%rip), %rax # 0x1cefe0
movq (%rax), %rdi
leaq 0x35ffc4(%rip), %rax # 0x387350
movl (%rax), %edx
leaq 0x53352(%rip), %rsi # 0x7a6e7
movb $0x0, %al
callq 0x24400
movb $0x0, -0x11(%rbp)
jmp 0x273a4
jmp 0x27330
leaq 0x3601a5(%rip), %rdi # 0x387550
callq 0x274c0
callq 0x26da0
cmpb $0x0, -0x11(%rbp)
je 0x273c0
callq 0x26e50
movb $0x0, 0x360251(%rip) # 0x387618
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| my_thread_global_end:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_11], 1
call my_hrtime
mov [rbp+var_28], rax
imul rax, [rbp+var_28], 3E8h
lea rcx, my_thread_end_wait_time
mov ecx, [rcx]
imul rcx, 3B9ACA00h
add rax, rcx
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov ecx, 3B9ACA00h
xor edx, edx
div rcx
mov [rbp+var_10], rax
mov rax, [rbp+var_20]
mov ecx, 3B9ACA00h
xor edx, edx
div rcx
mov [rbp+var_8], rdx
lea rdi, THR_LOCK_threads
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 0CEh
call inline_mysql_mutex_lock
loc_27330:
lea rax, THR_thread_count
cmp dword ptr [rax], 0
jbe short loc_273A4
lea rdi, THR_COND_threads
lea rsi, THR_LOCK_threads
lea rdx, [rbp+var_10]
lea rcx, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eloqsq"...
mov r8d, 0D2h
call inline_mysql_cond_timedwait
mov [rbp+var_2C], eax
cmp [rbp+var_2C], 6Eh ; 'n'
jz short loc_2736F
cmp [rbp+var_2C], 3Eh ; '>'
jnz short loc_273A2
loc_2736F:
lea rax, THR_thread_count
cmp dword ptr [rax], 0
jz short loc_2739C
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rax, THR_thread_count
mov edx, [rax]
lea rsi, aErrorInMyThrea; "Error in my_thread_global_end(): %d thr"...
mov al, 0
call _fprintf
loc_2739C:
mov [rbp+var_11], 0
jmp short loc_273A4
loc_273A2:
jmp short loc_27330
loc_273A4:
lea rdi, THR_LOCK_threads
call inline_mysql_mutex_unlock
call my_thread_destroy_common_mutex
cmp [rbp+var_11], 0
jz short loc_273C0
call my_thread_destroy_internal_mutex
loc_273C0:
mov cs:my_thread_global_init_done, 0
add rsp, 30h
pop rbp
retn
| long long my_thread_global_end()
{
long long result; // rax
int v1; // [rsp+4h] [rbp-2Ch]
unsigned long long v2; // [rsp+10h] [rbp-20h]
char v3; // [rsp+1Fh] [rbp-11h]
_QWORD v4[2]; // [rsp+20h] [rbp-10h] BYREF
v3 = 1;
v2 = 1000000000LL * my_thread_end_wait_time + 1000 * my_hrtime();
v4[0] = v2 / 0x3B9ACA00;
v4[1] = v2 % 0x3B9ACA00;
inline_mysql_mutex_lock(&THR_LOCK_threads, "/workspace/llm4binary/github2025/eloqsql/mysys/my_thr_init.c", 206LL);
while ( THR_thread_count )
{
v1 = inline_mysql_cond_timedwait(
&THR_COND_threads,
&THR_LOCK_threads,
v4,
"/workspace/llm4binary/github2025/eloqsql/mysys/my_thr_init.c",
210LL);
if ( v1 == 110 || v1 == 62 )
{
if ( THR_thread_count )
fprintf(stderr, "Error in my_thread_global_end(): %d threads didn't exit\n", THR_thread_count);
v3 = 0;
break;
}
}
inline_mysql_mutex_unlock(&THR_LOCK_threads);
result = my_thread_destroy_common_mutex();
if ( v3 )
result = my_thread_destroy_internal_mutex();
my_thread_global_init_done = 0;
return result;
}
| my_thread_global_end:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV byte ptr [RBP + -0x11],0x1
CALL 0x0012f2e0
MOV qword ptr [RBP + -0x28],RAX
IMUL RAX,qword ptr [RBP + -0x28],0x3e8
LEA RCX,[0x2cf4b0]
MOV ECX,dword ptr [RCX]
IMUL RCX,RCX,0x3b9aca00
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,0x3b9aca00
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,0x3b9aca00
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x8],RDX
LEA RDI,[0x487550]
LEA RSI,[0x17a6aa]
MOV EDX,0xce
CALL 0x001273d0
LAB_00127330:
LEA RAX,[0x487350]
CMP dword ptr [RAX],0x0
JBE 0x001273a4
LEA RDI,[0x4875e0]
LEA RSI,[0x487550]
LEA RDX,[RBP + -0x10]
LEA RCX,[0x17a6aa]
MOV R8D,0xd2
CALL 0x00127440
MOV dword ptr [RBP + -0x2c],EAX
CMP dword ptr [RBP + -0x2c],0x6e
JZ 0x0012736f
CMP dword ptr [RBP + -0x2c],0x3e
JNZ 0x001273a2
LAB_0012736f:
LEA RAX,[0x487350]
CMP dword ptr [RAX],0x0
JZ 0x0012739c
MOV RAX,qword ptr [0x002cefe0]
MOV RDI,qword ptr [RAX]
LEA RAX,[0x487350]
MOV EDX,dword ptr [RAX]
LEA RSI,[0x17a6e7]
MOV AL,0x0
CALL 0x00124400
LAB_0012739c:
MOV byte ptr [RBP + -0x11],0x0
JMP 0x001273a4
LAB_001273a2:
JMP 0x00127330
LAB_001273a4:
LEA RDI,[0x487550]
CALL 0x001274c0
CALL 0x00126da0
CMP byte ptr [RBP + -0x11],0x0
JZ 0x001273c0
CALL 0x00126e50
LAB_001273c0:
MOV byte ptr [0x00487618],0x0
ADD RSP,0x30
POP RBP
RET
|
void my_thread_global_end(void)
{
bool bVar1;
int iVar2;
long lVar3;
ulong local_18;
ulong local_10;
bVar1 = true;
lVar3 = my_hrtime();
local_10 = lVar3 * 1000 + (ulong)my_thread_end_wait_time * 1000000000;
local_18 = local_10 / 1000000000;
local_10 = local_10 % 1000000000;
inline_mysql_mutex_lock
(THR_LOCK_threads,"/workspace/llm4binary/github2025/eloqsql/mysys/my_thr_init.c",0xce);
do {
if (THR_thread_count == 0) goto LAB_001273a4;
iVar2 = inline_mysql_cond_timedwait
(THR_COND_threads,THR_LOCK_threads,&local_18,
"/workspace/llm4binary/github2025/eloqsql/mysys/my_thr_init.c",0xd2);
} while ((iVar2 != 0x6e) && (iVar2 != 0x3e));
if (THR_thread_count != 0) {
fprintf(*(FILE **)PTR_stderr_002cefe0,
"Error in my_thread_global_end(): %d threads didn\'t exit\n",(ulong)THR_thread_count);
}
bVar1 = false;
LAB_001273a4:
inline_mysql_mutex_unlock(THR_LOCK_threads);
my_thread_destroy_common_mutex();
if (bVar1) {
my_thread_destroy_internal_mutex();
}
my_thread_global_init_done = 0;
return;
}
| |
29,218 | common_params_sampling::print[abi:cxx11]() const | monkey531[P]llama/common/sampling.cpp | std::string common_params_sampling::print() const {
char result[1024];
snprintf(result, sizeof(result),
"\trepeat_last_n = %d, repeat_penalty = %.3f, frequency_penalty = %.3f, presence_penalty = %.3f\n"
"\tdry_multiplier = %.3f, dry_base = %.3f, dry_allowed_length = %d, dry_penalty_last_n = %d\n"
"\ttop_k = %d, top_p = %.3f, min_p = %.3f, xtc_probability = %.3f, xtc_threshold = %.3f, typical_p = %.3f, temp = %.3f\n"
"\tmirostat = %d, mirostat_lr = %.3f, mirostat_ent = %.3f",
penalty_last_n, penalty_repeat, penalty_freq, penalty_present,
dry_multiplier, dry_base, dry_allowed_length, dry_penalty_last_n,
top_k, top_p, min_p, xtc_probability, xtc_threshold, typ_p, temp,
mirostat, mirostat_eta, mirostat_tau);
return std::string(result);
} | O3 | cpp | common_params_sampling::print[abi:cxx11]() const:
pushq %r14
pushq %rbx
subq $0x448, %rsp # imm = 0x448
movq %rdi, %rbx
movl 0x10(%rsi), %eax
cvtss2sd 0x38(%rsi), %xmm0
cvtss2sd 0x3c(%rsi), %xmm1
cvtss2sd 0x40(%rsi), %xmm2
cvtss2sd 0x44(%rsi), %xmm3
cvtss2sd 0x48(%rsi), %xmm4
movl 0x34(%rsi), %ecx
movl 0x4c(%rsi), %r8d
cvtss2sd 0x14(%rsi), %xmm5
cvtss2sd 0x18(%rsi), %xmm6
cvtss2sd 0x1c(%rsi), %xmm7
cvtss2sd 0x20(%rsi), %xmm8
cvtss2sd 0x24(%rsi), %xmm9
movl 0x50(%rsi), %r9d
cvtss2sd 0x28(%rsi), %xmm10
movl 0x54(%rsi), %edx
cvtss2sd 0x5c(%rsi), %xmm11
cvtss2sd 0x58(%rsi), %xmm12
movsd %xmm12, 0x30(%rsp)
movsd %xmm11, 0x28(%rsp)
movl %edx, 0x20(%rsp)
movsd %xmm10, 0x18(%rsp)
movsd %xmm9, 0x10(%rsp)
movsd %xmm8, 0x8(%rsp)
movl %eax, (%rsp)
leaq 0x28413(%rip), %rdx # 0xf7110
leaq 0x40(%rsp), %r14
movl $0x400, %esi # imm = 0x400
movq %r14, %rdi
movb $0x8, %al
callq 0x1bdc0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x1b3e0
leaq (%rsp,%rax), %rdx
addq $0x40, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21ce4
movq %rbx, %rax
addq $0x448, %rsp # imm = 0x448
popq %rbx
popq %r14
retq
| _ZNK22common_params_sampling5printB5cxx11Ev:
push r14
push rbx
sub rsp, 448h
mov rbx, rdi
mov eax, [rsi+10h]
cvtss2sd xmm0, dword ptr [rsi+38h]
cvtss2sd xmm1, dword ptr [rsi+3Ch]
cvtss2sd xmm2, dword ptr [rsi+40h]
cvtss2sd xmm3, dword ptr [rsi+44h]
cvtss2sd xmm4, dword ptr [rsi+48h]
mov ecx, [rsi+34h]
mov r8d, [rsi+4Ch]
cvtss2sd xmm5, dword ptr [rsi+14h]
cvtss2sd xmm6, dword ptr [rsi+18h]
cvtss2sd xmm7, dword ptr [rsi+1Ch]
cvtss2sd xmm8, dword ptr [rsi+20h]
cvtss2sd xmm9, dword ptr [rsi+24h]
mov r9d, [rsi+50h]
cvtss2sd xmm10, dword ptr [rsi+28h]
mov edx, [rsi+54h]
cvtss2sd xmm11, dword ptr [rsi+5Ch]
cvtss2sd xmm12, dword ptr [rsi+58h]
movsd [rsp+458h+var_428], xmm12
movsd [rsp+458h+var_430], xmm11
mov [rsp+458h+var_438], edx
movsd [rsp+458h+var_440], xmm10
movsd [rsp+458h+var_448], xmm9
movsd [rsp+458h+var_450], xmm8
mov [rsp+458h+var_458], eax
lea rdx, aRepeatLastNDRe; "\trepeat_last_n = %d, repeat_penalty = "...
lea r14, [rsp+458h+var_418]
mov esi, 400h
mov rdi, r14
mov al, 8
call _snprintf
lea rax, [rbx+10h]
mov [rbx], rax
mov rdi, r14
call _strlen
lea rdx, [rsp+rax+458h+var_458]
add rdx, 40h ; '@'
mov rdi, rbx
mov rsi, r14
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rax, rbx
add rsp, 448h
pop rbx
pop r14
retn
| _QWORD * common_params_sampling::print[abi:cxx11](_QWORD *a1, long long a2)
{
long long v2; // rax
_BYTE v4[1048]; // [rsp+40h] [rbp-418h] BYREF
snprintf(
v4,
1024LL,
"\trepeat_last_n = %d, repeat_penalty = %.3f, frequency_penalty = %.3f, presence_penalty = %.3f\n"
"\tdry_multiplier = %.3f, dry_base = %.3f, dry_allowed_length = %d, dry_penalty_last_n = %d\n"
"\ttop_k = %d, top_p = %.3f, min_p = %.3f, xtc_probability = %.3f, xtc_threshold = %.3f, typical_p = %.3f, temp = %.3"
"f\n"
"\tmirostat = %d, mirostat_lr = %.3f, mirostat_ent = %.3f",
*(_DWORD *)(a2 + 52),
*(float *)(a2 + 56),
*(float *)(a2 + 60),
*(float *)(a2 + 64),
*(float *)(a2 + 68),
*(float *)(a2 + 72),
*(_DWORD *)(a2 + 76),
*(_DWORD *)(a2 + 80),
*(_DWORD *)(a2 + 16),
*(float *)(a2 + 20),
*(float *)(a2 + 24),
*(float *)(a2 + 28),
*(float *)(a2 + 32),
*(float *)(a2 + 36),
*(float *)(a2 + 40),
*(_DWORD *)(a2 + 84),
*(float *)(a2 + 92),
*(float *)(a2 + 88));
*a1 = a1 + 2;
v2 = strlen(v4);
std::string::_M_construct<char const*>((long long)a1, v4, (long long)&v4[v2]);
return a1;
}
| print[abi:cxx11]:
PUSH R14
PUSH RBX
SUB RSP,0x448
MOV RBX,RDI
MOV EAX,dword ptr [RSI + 0x10]
CVTSS2SD XMM0,dword ptr [RSI + 0x38]
CVTSS2SD XMM1,dword ptr [RSI + 0x3c]
CVTSS2SD XMM2,dword ptr [RSI + 0x40]
CVTSS2SD XMM3,dword ptr [RSI + 0x44]
CVTSS2SD XMM4,dword ptr [RSI + 0x48]
MOV ECX,dword ptr [RSI + 0x34]
MOV R8D,dword ptr [RSI + 0x4c]
CVTSS2SD XMM5,dword ptr [RSI + 0x14]
CVTSS2SD XMM6,dword ptr [RSI + 0x18]
CVTSS2SD XMM7,dword ptr [RSI + 0x1c]
CVTSS2SD XMM8,dword ptr [RSI + 0x20]
CVTSS2SD XMM9,dword ptr [RSI + 0x24]
MOV R9D,dword ptr [RSI + 0x50]
CVTSS2SD XMM10,dword ptr [RSI + 0x28]
MOV EDX,dword ptr [RSI + 0x54]
CVTSS2SD XMM11,dword ptr [RSI + 0x5c]
CVTSS2SD XMM12,dword ptr [RSI + 0x58]
MOVSD qword ptr [RSP + 0x30],XMM12
MOVSD qword ptr [RSP + 0x28],XMM11
MOV dword ptr [RSP + 0x20],EDX
MOVSD qword ptr [RSP + 0x18],XMM10
MOVSD qword ptr [RSP + 0x10],XMM9
MOVSD qword ptr [RSP + 0x8],XMM8
MOV dword ptr [RSP],EAX
LEA RDX,[0x1f7110]
LEA R14,[RSP + 0x40]
MOV ESI,0x400
MOV RDI,R14
MOV AL,0x8
CALL 0x0011bdc0
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
MOV RDI,R14
CALL 0x0011b3e0
LEA RDX,[RSP + RAX*0x1]
ADD RDX,0x40
MOV RDI,RBX
MOV RSI,R14
CALL 0x00121ce4
MOV RAX,RBX
ADD RSP,0x448
POP RBX
POP R14
RET
|
/* common_params_sampling::print[abi:cxx11]() const */
void common_params_sampling::print_abi_cxx11_(void)
{
long in_RSI;
long *in_RDI;
char local_418 [1032];
snprintf(local_418,0x400,
"\trepeat_last_n = %d, repeat_penalty = %.3f, frequency_penalty = %.3f, presence_penalty = %.3f\n\tdry_multiplier = %.3f, dry_base = %.3f, dry_allowed_length = %d, dry_penalty_last_n = %d\n\ttop_k = %d, top_p = %.3f, min_p = %.3f, xtc_probability = %.3f, xtc_threshold = %.3f, typical_p = %.3f, temp = %.3f\n\tmirostat = %d, mirostat_lr = %.3f, mirostat_ent = %.3f"
,(double)*(float *)(in_RSI + 0x38),(double)*(float *)(in_RSI + 0x3c),
(double)*(float *)(in_RSI + 0x40),(double)*(float *)(in_RSI + 0x44),
(double)*(float *)(in_RSI + 0x48),(double)*(float *)(in_RSI + 0x14),
(double)*(float *)(in_RSI + 0x18),(double)*(float *)(in_RSI + 0x1c),
(ulong)*(uint *)(in_RSI + 0x34),(ulong)*(uint *)(in_RSI + 0x4c),
(ulong)*(uint *)(in_RSI + 0x50),*(int4 *)(in_RSI + 0x10),
(double)*(float *)(in_RSI + 0x20),(double)*(float *)(in_RSI + 0x24),
(double)*(float *)(in_RSI + 0x28),*(int4 *)(in_RSI + 0x54),
(double)*(float *)(in_RSI + 0x5c),(double)*(float *)(in_RSI + 0x58));
*in_RDI = (long)(in_RDI + 2);
strlen(local_418);
std::__cxx11::string::_M_construct<char_const*>();
return;
}
| |
29,219 | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::skip_bom() | llama.cpp/common/json.hpp | bool skip_bom()
{
if (get() == 0xEF)
{
// check if we completely parse the BOM
return get() == 0xBB && get() == 0xBF;
}
// the first character is not the beginning of the BOM; unget it to
// process is later
unget();
return true;
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::skip_bom():
pushq %rbx
movq %rdi, %rbx
callq 0x22760
cmpl $0xef, %eax
je 0x92ef0
movq %rbx, %rdi
callq 0x937e6
movb $0x1, %al
popq %rbx
retq
movq %rbx, %rdi
callq 0x22760
cmpl $0xbb, %eax
je 0x92f03
xorl %eax, %eax
jmp 0x92eee
movq %rbx, %rdi
callq 0x22760
cmpl $0xbf, %eax
sete %al
jmp 0x92eee
nop
| _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE8skip_bomEv:
push rbx
mov rbx, rdi
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
cmp eax, 0EFh
jz short loc_92EF0
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE5ungetEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::unget(void)
mov al, 1
loc_92EEE:
pop rbx
retn
loc_92EF0:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
cmp eax, 0BBh
jz short loc_92F03
xor eax, eax
jmp short loc_92EEE
loc_92F03:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
cmp eax, 0BFh
setz al
jmp short loc_92EEE
| bool nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::skip_bom(
__m128i *a1)
{
if ( (unsigned int)nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1) == 239 )
return (unsigned int)nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1) == 187
&& (unsigned int)nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1) == 191;
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::unget(a1);
return 1;
}
| skip_bom:
PUSH RBX
MOV RBX,RDI
CALL 0x00122760
CMP EAX,0xef
JZ 0x00192ef0
MOV RDI,RBX
CALL 0x001937e6
MOV AL,0x1
LAB_00192eee:
POP RBX
RET
LAB_00192ef0:
MOV RDI,RBX
CALL 0x00122760
CMP EAX,0xbb
JZ 0x00192f03
XOR EAX,EAX
JMP 0x00192eee
LAB_00192f03:
MOV RDI,RBX
CALL 0x00122760
CMP EAX,0xbf
SETZ AL
JMP 0x00192eee
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > > >::skip_bom() */
bool __thiscall
nlohmann::json_abi_v3_11_3::detail::
lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::skip_bom(lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*this)
{
int iVar1;
bool bVar2;
iVar1 = get(this);
if (iVar1 == 0xef) {
iVar1 = get(this);
if (iVar1 == 0xbb) {
iVar1 = get(this);
bVar2 = iVar1 == 0xbf;
}
else {
bVar2 = false;
}
}
else {
unget(this);
bVar2 = true;
}
return bVar2;
}
| |
29,220 | minja::Parser::consumeToken(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, minja::SpaceHandling) | monkey531[P]llama/common/minja.hpp | std::string consumeToken(const std::string & token, SpaceHandling space_handling = SpaceHandling::Strip) {
auto start = it;
consumeSpaces(space_handling);
if (std::distance(it, end) >= (int64_t) token.size() && std::string(it, it + token.size()) == token) {
it += token.size();
return token;
}
it = start;
return "";
} | O3 | cpp | minja::Parser::consumeToken(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, minja::SpaceHandling):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x20(%rsi), %r13
movq %rsi, %rdi
movl %ecx, %esi
callq 0x88376
movq 0x18(%r15), %rax
movq 0x20(%r15), %rsi
subq %rsi, %rax
movq 0x8(%r14), %rdx
cmpq %rdx, %rax
jl 0x87b10
addq %rsi, %rdx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x741e6
movq 0x8(%r12), %rdx
cmpq 0x8(%r14), %rdx
jne 0x87ac6
movq 0x8(%rsp), %r12
testq %rdx, %rdx
je 0x87acf
movq (%r14), %rsi
movq %r12, %rdi
callq 0x1bac0
testl %eax, %eax
sete %bpl
jmp 0x87ad2
movq 0x8(%rsp), %r12
xorl %ebp, %ebp
jmp 0x87ad2
movb $0x1, %bpl
leaq 0x18(%rsp), %rax
cmpq %rax, %r12
je 0x87aec
movq 0x18(%rsp), %rsi
incq %rsi
movq %r12, %rdi
callq 0x1ba60
testb %bpl, %bpl
je 0x87b10
movq 0x8(%r14), %rdx
addq %rdx, 0x20(%r15)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x26152
jmp 0x87b2d
movq %r13, 0x20(%r15)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x674ba(%rip), %rdx # 0xeefdc
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x261e8
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN5minja6Parser12consumeTokenERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_13SpaceHandlingE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov r13, [rsi+20h]
mov rdi, rsi
mov esi, ecx
call _ZN5minja6Parser13consumeSpacesENS_13SpaceHandlingE; minja::Parser::consumeSpaces(minja::SpaceHandling)
mov rax, [r15+18h]
mov rsi, [r15+20h]
sub rax, rsi
mov rdx, [r14+8]
cmp rax, rdx
jl loc_87B10
add rdx, rsi
lea rax, [rsp+58h+var_40]
mov [rax-10h], rax
lea r12, [rsp+58h+var_50]
mov rdi, r12
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIN9__gnu_cxx17__normal_iteratorIPKcS4_EEEEvT_SB_St20forward_iterator_tag; std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::forward_iterator_tag)
mov rdx, [r12+8]
cmp rdx, [r14+8]
jnz short loc_87AC6
mov r12, [rsp+58h+var_50]
test rdx, rdx
jz short loc_87ACF
mov rsi, [r14]
mov rdi, r12
call _bcmp
test eax, eax
setz bpl
jmp short loc_87AD2
loc_87AC6:
mov r12, [rsp+58h+var_50]
xor ebp, ebp
jmp short loc_87AD2
loc_87ACF:
mov bpl, 1
loc_87AD2:
lea rax, [rsp+58h+var_40]
cmp r12, rax
jz short loc_87AEC
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
mov rdi, r12; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_87AEC:
test bpl, bpl
jz short loc_87B10
mov rdx, [r14+8]
add [r15+20h], rdx
lea rax, [rbx+10h]
mov [rbx], rax
mov rsi, [r14]
add rdx, rsi
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
jmp short loc_87B2D
loc_87B10:
mov [r15+20h], r13
lea rax, [rbx+10h]
mov [rbx], rax
lea rdx, aErrorWhileHand_0+34h; ""
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_87B2D:
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| _QWORD * minja::Parser::consumeToken(_QWORD *a1, long long a2, _BYTE **a3, unsigned int a4)
{
long long v6; // r13
_BYTE *v7; // rsi
_BYTE *v8; // rdx
_QWORD *v9; // r12
bool v10; // bp
_BYTE *v11; // rdx
void *v13; // [rsp+8h] [rbp-50h] BYREF
_BYTE *v14; // [rsp+10h] [rbp-48h]
_QWORD v15[8]; // [rsp+18h] [rbp-40h] BYREF
v6 = *(_QWORD *)(a2 + 32);
minja::Parser::consumeSpaces(a2, a4);
v7 = *(_BYTE **)(a2 + 32);
v8 = a3[1];
if ( *(_QWORD *)(a2 + 24) - (_QWORD)v7 < (long long)v8 )
goto LABEL_11;
v13 = v15;
std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(
(long long)&v13,
v7,
(long long)&v8[(_QWORD)v7]);
if ( v14 == a3[1] )
{
v9 = v13;
v10 = !v14 || (unsigned int)bcmp(v13, *a3) == 0;
}
else
{
v9 = v13;
v10 = 0;
}
if ( v9 != v15 )
operator delete(v9, v15[0] + 1LL);
if ( v10 )
{
v11 = a3[1];
*(_QWORD *)(a2 + 32) += v11;
*a1 = a1 + 2;
std::string::_M_construct<char *>((long long)a1, *a3, (long long)&v11[(_QWORD)*a3]);
}
else
{
LABEL_11:
*(_QWORD *)(a2 + 32) = v6;
*a1 = a1 + 2;
std::string::_M_construct<char const*>((long long)a1, "", (long long)"");
}
return a1;
}
| consumeToken:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV R13,qword ptr [RSI + 0x20]
MOV RDI,RSI
MOV ESI,ECX
CALL 0x00188376
MOV RAX,qword ptr [R15 + 0x18]
MOV RSI,qword ptr [R15 + 0x20]
SUB RAX,RSI
MOV RDX,qword ptr [R14 + 0x8]
CMP RAX,RDX
JL 0x00187b10
ADD RDX,RSI
LEA RAX,[RSP + 0x18]
MOV qword ptr [RAX + -0x10],RAX
LEA R12,[RSP + 0x8]
MOV RDI,R12
CALL 0x001741e6
MOV RDX,qword ptr [R12 + 0x8]
CMP RDX,qword ptr [R14 + 0x8]
JNZ 0x00187ac6
MOV R12,qword ptr [RSP + 0x8]
TEST RDX,RDX
JZ 0x00187acf
MOV RSI,qword ptr [R14]
MOV RDI,R12
CALL 0x0011bac0
TEST EAX,EAX
SETZ BPL
JMP 0x00187ad2
LAB_00187ac6:
MOV R12,qword ptr [RSP + 0x8]
XOR EBP,EBP
JMP 0x00187ad2
LAB_00187acf:
MOV BPL,0x1
LAB_00187ad2:
LEA RAX,[RSP + 0x18]
CMP R12,RAX
JZ 0x00187aec
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
MOV RDI,R12
CALL 0x0011ba60
LAB_00187aec:
TEST BPL,BPL
JZ 0x00187b10
MOV RDX,qword ptr [R14 + 0x8]
ADD qword ptr [R15 + 0x20],RDX
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
MOV RSI,qword ptr [R14]
ADD RDX,RSI
MOV RDI,RBX
CALL 0x00126152
JMP 0x00187b2d
LAB_00187b10:
MOV qword ptr [R15 + 0x20],R13
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LEA RDX,[0x1eefdc]
MOV RDI,RBX
MOV RSI,RDX
CALL 0x001261e8
LAB_00187b2d:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* minja::Parser::consumeToken(std::__cxx11::string const&, minja::SpaceHandling) */
long * minja::Parser::consumeToken(long *param_1,Parser *param_2,long *param_3,int4 param_4)
{
int8 uVar1;
long lVar2;
long *plVar3;
int iVar4;
bool bVar5;
long *local_50;
size_t local_48;
long local_40 [2];
uVar1 = *(int8 *)(param_2 + 0x20);
consumeSpaces(param_2,param_4);
lVar2 = *(long *)(param_2 + 0x20);
if (param_3[1] <= *(long *)(param_2 + 0x18) - lVar2) {
local_50 = local_40;
std::__cxx11::string::
_M_construct<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>
(&local_50,lVar2,param_3[1] + lVar2);
plVar3 = local_50;
if (local_48 == param_3[1]) {
if (local_48 == 0) {
bVar5 = true;
}
else {
iVar4 = bcmp(local_50,(void *)*param_3,local_48);
bVar5 = iVar4 == 0;
}
}
else {
bVar5 = false;
}
if (plVar3 != local_40) {
operator_delete(plVar3,local_40[0] + 1);
}
if (bVar5) {
lVar2 = param_3[1];
*(long *)(param_2 + 0x20) = *(long *)(param_2 + 0x20) + lVar2;
*param_1 = (long)(param_1 + 2);
std::__cxx11::string::_M_construct<char*>(param_1,*param_3,lVar2 + *param_3);
return param_1;
}
}
*(int8 *)(param_2 + 0x20) = uVar1;
*param_1 = (long)(param_1 + 2);
std::__cxx11::string::_M_construct<char_const*>(param_1,"");
return param_1;
}
| |
29,221 | ma_write_init_default | eloqsql/storage/maria/ma_write.c | MARIA_RECORD_POS _ma_write_init_default(MARIA_HA *info,
const uchar *record
__attribute__((unused)))
{
return ((info->s->state.dellink != HA_OFFSET_ERROR &&
!info->append_insert_at_end) ?
info->s->state.dellink :
info->state->data_file_length);
} | O0 | c | ma_write_init_default:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $-0x1, 0xc8(%rax)
je 0x666fe
movq -0x8(%rbp), %rax
cmpb $0x0, 0x681(%rax)
jne 0x666fe
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0xc8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6670e
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ma_write_init_default:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov rax, [rax]
cmp qword ptr [rax+0C8h], 0FFFFFFFFFFFFFFFFh
jz short loc_666FE
mov rax, [rbp+var_8]
cmp byte ptr [rax+681h], 0
jnz short loc_666FE
mov rax, [rbp+var_8]
mov rax, [rax]
mov rax, [rax+0C8h]
mov [rbp+var_18], rax
jmp short loc_6670E
loc_666FE:
mov rax, [rbp+var_8]
mov rax, [rax+20h]
mov rax, [rax+28h]
mov [rbp+var_18], rax
loc_6670E:
mov rax, [rbp+var_18]
pop rbp
retn
| long long ma_write_init_default(long long a1)
{
if ( *(_QWORD *)(*(_QWORD *)a1 + 200LL) == -1LL || *(_BYTE *)(a1 + 1665) )
return *(_QWORD *)(*(_QWORD *)(a1 + 32) + 40LL);
else
return *(_QWORD *)(*(_QWORD *)a1 + 200LL);
}
| _ma_write_init_default:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
CMP qword ptr [RAX + 0xc8],-0x1
JZ 0x001666fe
MOV RAX,qword ptr [RBP + -0x8]
CMP byte ptr [RAX + 0x681],0x0
JNZ 0x001666fe
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0xc8]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0016670e
LAB_001666fe:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x18],RAX
LAB_0016670e:
MOV RAX,qword ptr [RBP + -0x18]
POP RBP
RET
|
int8 _ma_write_init_default(long *param_1)
{
int8 local_20;
if ((*(long *)(*param_1 + 200) == -1) || (*(char *)((long)param_1 + 0x681) != '\0')) {
local_20 = *(int8 *)(param_1[4] + 0x28);
}
else {
local_20 = *(int8 *)(*param_1 + 200);
}
return local_20;
}
| |
29,222 | mysql_ping_start_internal | eloqsql/libmariadb/libmariadb/mariadb_async.c | static void
mysql_ping_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_ping,
(parms->mysql),
parms->mysql,
int,
r_int)
} | O3 | c | mysql_ping_start_internal:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rdi
movq 0x480(%rdi), %rax
movq 0x28(%rax), %rbx
callq 0x1f689
movl %eax, 0x8(%rbx)
movl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| mysql_ping_start_internal:
push rbp
mov rbp, rsp
push rbx
push rax
mov rdi, [rdi]
mov rax, [rdi+480h]
mov rbx, [rax+28h]
call mysql_ping
mov [rbx+8], eax
mov dword ptr [rbx], 0
add rsp, 8
pop rbx
pop rbp
retn
| long long mysql_ping_start_internal(long long *a1)
{
long long v1; // rdi
_DWORD *v2; // rbx
long long result; // rax
v1 = *a1;
v2 = *(_DWORD **)(*(_QWORD *)(v1 + 1152) + 40LL);
result = mysql_ping(v1);
v2[2] = result;
*v2 = 0;
return result;
}
| mysql_ping_start_internal:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RDI,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x480]
MOV RBX,qword ptr [RAX + 0x28]
CALL 0x0011f689
MOV dword ptr [RBX + 0x8],EAX
MOV dword ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void mysql_ping_start_internal(long *param_1)
{
int4 *puVar1;
int4 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_ping();
puVar1[2] = uVar2;
*puVar1 = 0;
return;
}
| |
29,223 | my_stat | eloqsql/mysys/my_lib.c | MY_STAT *my_stat(const char *path, MY_STAT *stat_area, myf my_flags)
{
int m_used;
DBUG_ENTER("my_stat");
DBUG_PRINT("my", ("path: '%s' stat_area: %p MyFlags: %lu", path,
stat_area, my_flags));
if ((m_used= (stat_area == NULL)))
if (!(stat_area= (MY_STAT *) my_malloc(key_memory_MY_STAT, sizeof(MY_STAT),
my_flags)))
goto error;
#ifndef _WIN32
if (!stat((char *) path, (struct stat *) stat_area))
{
MSAN_STAT_WORKAROUND(stat_area);
DBUG_RETURN(stat_area);
}
#else
if (!my_win_stat(path, stat_area))
DBUG_RETURN(stat_area);
#endif
DBUG_PRINT("error",("Got errno: %d from stat", errno));
my_errno= errno;
if (m_used) /* Free if new area */
my_free(stat_area);
error:
if (my_flags & (MY_FAE+MY_WME))
{
my_error(EE_STAT, MYF(ME_BELL), path, my_errno);
DBUG_RETURN((MY_STAT *) NULL);
}
DBUG_RETURN((MY_STAT *) NULL);
} | O0 | c | my_stat:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
jmp 0xfbbb6
cmpq $0x0, -0x18(%rbp)
sete %al
movb %al, %cl
andb $0x1, %cl
movzbl %cl, %ecx
movl %ecx, -0x24(%rbp)
testb $0x1, %al
jne 0xfbbcf
jmp 0xfbbf4
leaq 0xb92ad2(%rip), %rax # 0xc8e6a8
movl (%rax), %edi
movq -0x20(%rbp), %rdx
movl $0x90, %esi
callq 0xfc020
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xfbbf2
jmp 0xfbc3b
jmp 0xfbbf4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2a840
cmpl $0x0, %eax
jne 0xfbc12
jmp 0xfbc08
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xfbc81
jmp 0xfbc14
jmp 0xfbc16
callq 0x2a7d0
movl (%rax), %eax
movl %eax, -0x28(%rbp)
callq 0xfe880
movl -0x28(%rbp), %ecx
movl %ecx, (%rax)
cmpl $0x0, -0x24(%rbp)
je 0xfbc39
movq -0x18(%rbp), %rdi
callq 0xfc3a0
jmp 0xfbc3b
movq -0x20(%rbp), %rax
andq $0x18, %rax
cmpq $0x0, %rax
je 0xfbc77
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0xfe880
movq -0x30(%rbp), %rdx
movl (%rax), %ecx
movl $0xd, %edi
movl $0x4, %esi
movb $0x0, %al
callq 0xf3f50
movq $0x0, -0x8(%rbp)
jmp 0xfbc81
jmp 0xfbc79
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| my_stat:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
jmp short $+2
loc_FBBB6:
cmp [rbp+var_18], 0
setz al
mov cl, al
and cl, 1
movzx ecx, cl
mov [rbp+var_24], ecx
test al, 1
jnz short loc_FBBCF
jmp short loc_FBBF4
loc_FBBCF:
lea rax, key_memory_MY_STAT
mov edi, [rax]
mov rdx, [rbp+var_20]
mov esi, 90h
call my_malloc
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_FBBF2
jmp short loc_FBC3B
loc_FBBF2:
jmp short $+2
loc_FBBF4:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call _stat64
cmp eax, 0
jnz short loc_FBC12
jmp short $+2
loc_FBC08:
mov rax, [rbp+var_18]
mov [rbp+var_8], rax
jmp short loc_FBC81
loc_FBC12:
jmp short $+2
loc_FBC14:
jmp short $+2
loc_FBC16:
call ___errno_location
mov eax, [rax]
mov [rbp+var_28], eax
call _my_thread_var
mov ecx, [rbp+var_28]
mov [rax], ecx
cmp [rbp+var_24], 0
jz short loc_FBC39
mov rdi, [rbp+var_18]
call my_free
loc_FBC39:
jmp short $+2
loc_FBC3B:
mov rax, [rbp+var_20]
and rax, 18h
cmp rax, 0
jz short loc_FBC77
mov rax, [rbp+var_10]
mov [rbp+var_30], rax
call _my_thread_var
mov rdx, [rbp+var_30]
mov ecx, [rax]
mov edi, 0Dh
mov esi, 4
mov al, 0
call my_error
mov [rbp+var_8], 0
jmp short loc_FBC81
loc_FBC77:
jmp short $+2
loc_FBC79:
mov [rbp+var_8], 0
loc_FBC81:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
| const char * my_stat(const char *a1, const char *a2, long long a3)
{
const char *v3; // rdi
const char *v4; // rsi
unsigned int *v5; // rax
int v7; // [rsp+8h] [rbp-28h]
BOOL v8; // [rsp+Ch] [rbp-24h]
char v9; // [rsp+10h] [rbp-20h]
const char *v10; // [rsp+18h] [rbp-18h]
v10 = a2;
v9 = a3;
v8 = a2 == 0LL;
if ( a2
|| (v3 = (const char *)key_memory_MY_STAT,
v4 = (const char *)&qword_90,
(v10 = (const char *)my_malloc(key_memory_MY_STAT, 144LL, a3)) != 0LL) )
{
v3 = a1;
v4 = v10;
if ( !(unsigned int)stat64(a1, v10) )
return v10;
v7 = *(_DWORD *)__errno_location();
*(_DWORD *)my_thread_var(a1, v10) = v7;
if ( v8 )
{
v3 = v10;
my_free(v10);
}
}
if ( (v9 & 0x18) != 0 )
{
v5 = (unsigned int *)my_thread_var(v3, v4);
my_error(0xDu, 4LL, a1, *v5);
}
return 0LL;
}
| my_stat:
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
JMP 0x001fbbb6
LAB_001fbbb6:
CMP qword ptr [RBP + -0x18],0x0
SETZ AL
MOV CL,AL
AND CL,0x1
MOVZX ECX,CL
MOV dword ptr [RBP + -0x24],ECX
TEST AL,0x1
JNZ 0x001fbbcf
JMP 0x001fbbf4
LAB_001fbbcf:
LEA RAX,[0xd8e6a8]
MOV EDI,dword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x20]
MOV ESI,0x90
CALL 0x001fc020
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x001fbbf2
JMP 0x001fbc3b
LAB_001fbbf2:
JMP 0x001fbbf4
LAB_001fbbf4:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0012a840
CMP EAX,0x0
JNZ 0x001fbc12
JMP 0x001fbc08
LAB_001fbc08:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001fbc81
LAB_001fbc12:
JMP 0x001fbc14
LAB_001fbc14:
JMP 0x001fbc16
LAB_001fbc16:
CALL 0x0012a7d0
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x28],EAX
CALL 0x001fe880
MOV ECX,dword ptr [RBP + -0x28]
MOV dword ptr [RAX],ECX
CMP dword ptr [RBP + -0x24],0x0
JZ 0x001fbc39
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001fc3a0
LAB_001fbc39:
JMP 0x001fbc3b
LAB_001fbc3b:
MOV RAX,qword ptr [RBP + -0x20]
AND RAX,0x18
CMP RAX,0x0
JZ 0x001fbc77
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x30],RAX
CALL 0x001fe880
MOV RDX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RAX]
MOV EDI,0xd
MOV ESI,0x4
MOV AL,0x0
CALL 0x001f3f50
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001fbc81
LAB_001fbc77:
JMP 0x001fbc79
LAB_001fbc79:
MOV qword ptr [RBP + -0x8],0x0
LAB_001fbc81:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
stat64 * my_stat(char *param_1,stat64 *param_2,ulong param_3)
{
int iVar1;
int *piVar2;
int4 *puVar3;
stat64 *local_20;
local_20 = param_2;
if ((param_2 != (stat64 *)0x0) ||
(local_20 = (stat64 *)my_malloc(key_memory_MY_STAT,0x90,param_3), local_20 != (stat64 *)0x0)) {
iVar1 = stat64(param_1,local_20);
if (iVar1 == 0) {
return local_20;
}
piVar2 = __errno_location();
iVar1 = *piVar2;
piVar2 = (int *)_my_thread_var();
*piVar2 = iVar1;
if (param_2 == (stat64 *)0x0) {
my_free(local_20);
}
}
if ((param_3 & 0x18) != 0) {
puVar3 = (int4 *)_my_thread_var();
my_error(0xd,4,param_1,*puVar3);
}
return (stat64 *)0x0;
}
| |
29,224 | nlohmann::json_abi_v3_11_3::detail::invalid_iterator nlohmann::json_abi_v3_11_3::detail::invalid_iterator::create<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>*, 0>(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*) | monkey531[P]llama/common/json.hpp | static invalid_iterator create(int id_, const std::string& what_arg, BasicJsonContext context)
{
const std::string w = concat(exception::name("invalid_iterator", id_), exception::diagnostics(context), what_arg);
return {id_, w.c_str()};
} | O1 | cpp | nlohmann::json_abi_v3_11_3::detail::invalid_iterator nlohmann::json_abi_v3_11_3::detail::invalid_iterator::create<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>*, 0>(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x92c85(%rip), %rsi # 0xf0c22
leaq 0x92c8e(%rip), %rdx # 0xf0c32
leaq 0x28(%rsp), %rdi
callq 0x21d38
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movl %ebp, %edx
callq 0x57d6a
leaq 0x78(%rsp), %r14
movq %r14, -0x10(%r14)
xorl %eax, %eax
movq %rax, -0x8(%r14)
movb %al, (%r14)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb %al, (%r12)
movq 0x8(%r15), %rsi
addq 0x50(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x1bd60
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0x1b260
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0x1b260
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq 0x8(%rsp), %rdi
callq 0x1b260
movq 0x68(%rsp), %rdi
cmpq %r14, %rdi
je 0x5e047
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x1b8b0
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5e062
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x1b8b0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x5e079
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1b8b0
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x57fd8
leaq 0xcfe41(%rip), %rax # 0x12ded0
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x5e0ad
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8b0
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x5e13b
movq 0x18(%rsp), %rsi
jmp 0x5e133
movq %rax, %rbx
jmp 0x5e124
movq %rax, %rbx
jmp 0x5e13b
movq %rdx, %rbx
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x5e0fd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8b0
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rdx
leaq 0x88(%rsp), %r12
movq %r14, %rsi
movq %r15, %rcx
movl %ebx, %r8d
movq %r12, %r9
callq 0x1c59c
movq (%r12), %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x5e13b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1b8b0
movq %rbx, %rdi
callq 0x1bf70
nop
| _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 98h
mov r15, rdx
mov ebp, esi
mov rbx, rdi
lea r13, [rsp+0C8h+var_90]
mov [r13-10h], r13
lea rsi, aInvalidIterato; "invalid_iterator"
lea rdx, aInvalidIterato+10h; ""
lea rdi, [rsp+0C8h+var_A0]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rdi, [rsp+0C8h+var_80]; int
lea rsi, [rsp+0C8h+var_A0]; int
mov edx, ebp; int
call _ZN8nlohmann16json_abi_v3_11_36detail9exception4nameERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi; nlohmann::json_abi_v3_11_3::detail::exception::name(std::string const&,int)
lea r14, [rsp+0C8h+var_50]
mov [r14-10h], r14
xor eax, eax
mov [r14-8], rax
mov [r14], al
lea r12, [rsp+0C8h+var_B0]
mov [r12-10h], r12
mov [r12-8], rax
mov [r12], al
mov rsi, [r15+8]
add rsi, [rsp+0C8h+var_78]
lea rdi, [rsp+0C8h+var_C0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
mov rsi, qword ptr [rsp+0C8h+var_80]
mov rdx, [rsp+0C8h+var_78]
lea rdi, [rsp+0C8h+var_C0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
mov rsi, [rsp+0C8h+var_60]
mov rdx, [rsp+0C8h+var_58]
lea rdi, [rsp+0C8h+var_C0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
mov rsi, [r15]
mov rdx, [r15+8]
lea rdi, [rsp+0C8h+var_C0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
mov rdi, [rsp+0C8h+var_60]; void *
cmp rdi, r14
jz short loc_5E047
mov rsi, [rsp+0C8h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5E047:
lea rax, [rsp+0C8h+var_70]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_5E062
mov rsi, [rsp+0C8h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5E062:
mov rdi, [rsp+0C8h+var_A0]; void *
cmp rdi, r13
jz short loc_5E079
mov rsi, [rsp+0C8h+var_90]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5E079:
mov rdx, [rsp+0C8h+var_C0]; char *
mov rdi, rbx; this
mov esi, ebp; int
call _ZN8nlohmann16json_abi_v3_11_36detail9exceptionC2EiPKc; nlohmann::json_abi_v3_11_3::detail::exception::exception(int,char const*)
lea rax, _ZTVN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorE; `vtable for'nlohmann::json_abi_v3_11_3::detail::invalid_iterator
add rax, 10h
mov [rbx], rax
mov rdi, [rsp+0C8h+var_C0]; void *
cmp rdi, r12
jz short loc_5E0AD
mov rsi, [rsp+0C8h+var_B0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5E0AD:
mov rax, rbx
add rsp, 98h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, [rsp+arg_0]
cmp rdi, r12
jz short loc_5E13B
mov rsi, [rsp+arg_10]
jmp short loc_5E133
mov rbx, rax
jmp short loc_5E124
mov rbx, rax
jmp short loc_5E13B
mov rbx, rdx
mov r15, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, r12
jz short loc_5E0FD
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5E0FD:
lea rdi, [rsp+arg_60]
lea rdx, [rsp+arg_40]
lea r12, [rsp+arg_80]
mov rsi, r14
mov rcx, r15
mov r8d, ebx
mov r9, r12
call _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ__cold_1
mov rbx, [r12]
loc_5E124:
mov rdi, [rsp+arg_20]; void *
cmp rdi, r13
jz short loc_5E13B
mov rsi, [rsp+arg_30]
loc_5E133:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5E13B:
mov rdi, rbx
call __Unwind_Resume
| nlohmann::json_abi_v3_11_3::detail::exception * ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
nlohmann::json_abi_v3_11_3::detail::exception *this,
int a2,
_QWORD *a3)
{
char *v5[2]; // [rsp+8h] [rbp-C0h] BYREF
_QWORD v6[2]; // [rsp+18h] [rbp-B0h] BYREF
void *v7[2]; // [rsp+28h] [rbp-A0h] BYREF
_QWORD v8[2]; // [rsp+38h] [rbp-90h] BYREF
int v9[2]; // [rsp+48h] [rbp-80h] BYREF
long long v10; // [rsp+50h] [rbp-78h]
long long v11; // [rsp+58h] [rbp-70h] BYREF
void *v12; // [rsp+68h] [rbp-60h]
long long v13; // [rsp+70h] [rbp-58h]
_QWORD v14[10]; // [rsp+78h] [rbp-50h] BYREF
v7[0] = v8;
std::string::_M_construct<char const*>(v7, "invalid_iterator", (long long)"");
nlohmann::json_abi_v3_11_3::detail::exception::name((long long)v9, (long long)v7, a2);
v12 = v14;
v13 = 0LL;
LOBYTE(v14[0]) = 0;
v5[0] = (char *)v6;
v5[1] = 0LL;
LOBYTE(v6[0]) = 0;
std::string::reserve(v5, v10 + a3[1]);
std::string::_M_append(v5, *(_QWORD *)v9, v10);
std::string::_M_append(v5, v12, v13);
std::string::_M_append(v5, *a3, a3[1]);
if ( v12 != v14 )
operator delete(v12, v14[0] + 1LL);
if ( *(long long **)v9 != &v11 )
operator delete(*(void **)v9, v11 + 1);
if ( v7[0] != v8 )
operator delete(v7[0], v8[0] + 1LL);
nlohmann::json_abi_v3_11_3::detail::exception::exception(this, a2, v5[0]);
*(_QWORD *)this = &`vtable for'nlohmann::json_abi_v3_11_3::detail::invalid_iterator + 2;
if ( (_QWORD *)v5[0] != v6 )
operator delete(v5[0], v6[0] + 1LL);
return this;
}
| |||
29,225 | nlohmann::json_abi_v3_11_3::detail::invalid_iterator nlohmann::json_abi_v3_11_3::detail::invalid_iterator::create<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>*, 0>(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*) | monkey531[P]llama/common/json.hpp | static invalid_iterator create(int id_, const std::string& what_arg, BasicJsonContext context)
{
const std::string w = concat(exception::name("invalid_iterator", id_), exception::diagnostics(context), what_arg);
return {id_, w.c_str()};
} | O2 | cpp | nlohmann::json_abi_v3_11_3::detail::invalid_iterator nlohmann::json_abi_v3_11_3::detail::invalid_iterator::create<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>*, 0>(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r15
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x4a9af(%rip), %rsi # 0xb2c34
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x27852
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movl %ebp, %edx
callq 0x3ddf4
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x4216e
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r14, %rcx
callq 0x3dd8b
leaq 0x8(%rsp), %rdi
callq 0x251b8
leaq 0x48(%rsp), %rdi
callq 0x251b8
leaq 0x28(%rsp), %rdi
callq 0x251b8
movq 0x68(%rsp), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x432fe
leaq 0x68(%rsp), %rdi
callq 0x251b8
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
jmp 0x68341
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x251b8
jmp 0x6832d
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x251b8
jmp 0x6833c
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x251b8
jmp 0x6834b
movq %rax, %rbx
movq %rbx, %rdi
callq 0x24f60
nop
| _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_:
push rbp
push r15
push r14
push rbx
sub rsp, 88h
mov r15, rcx
mov r14, rdx
mov ebp, esi
mov rbx, rdi
lea rsi, aInvalidIterato; "invalid_iterator"
lea rdi, [rsp+0A8h+var_80]
lea rdx, [rsp+0A8h+var_A1]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rdi, [rsp+0A8h+var_60]
lea rsi, [rsp+0A8h+var_80]
mov edx, ebp
call _ZN8nlohmann16json_abi_v3_11_36detail9exception4nameERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi; nlohmann::json_abi_v3_11_3::detail::exception::name(std::string const&,int)
lea rdi, [rsp+0A8h+var_A0]
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_36detail9exception11diagnosticsINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEESC_PKT_; nlohmann::json_abi_v3_11_3::detail::exception::diagnostics<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const*)
lea rdi, [rsp+0A8h+var_40]
lea rsi, [rsp+0A8h+var_60]
lea rdx, [rsp+0A8h+var_A0]
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJS8_S8_RKS8_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,std::string,std::string,std::string const&>(std::string,std::string,std::string const&)
lea rdi, [rsp+0A8h+var_A0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+0A8h+var_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+0A8h+var_80]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdx, [rsp+0A8h+var_40]; char *
mov rdi, rbx; this
mov esi, ebp; int
call _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorC2EiPKc; nlohmann::json_abi_v3_11_3::detail::invalid_iterator::invalid_iterator(int,char const*)
lea rdi, [rsp+0A8h+var_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rax, rbx
add rsp, 88h
pop rbx
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rdi, [rsp+arg_60]
jmp short loc_68341
mov rbx, rax
lea rdi, [rsp+arg_0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_6832D
mov rbx, rax
loc_6832D:
lea rdi, [rsp+arg_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_6833C
mov rbx, rax
loc_6833C:
lea rdi, [rsp+arg_20]; void *
loc_68341:
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_6834B
mov rbx, rax
loc_6834B:
mov rdi, rbx
call __Unwind_Resume
| nlohmann::json_abi_v3_11_3::detail::invalid_iterator * ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
nlohmann::json_abi_v3_11_3::detail::invalid_iterator *this,
int a2,
long long a3)
{
_QWORD v5[4]; // [rsp+8h] [rbp-A0h] BYREF
_QWORD v6[4]; // [rsp+28h] [rbp-80h] BYREF
_BYTE v7[32]; // [rsp+48h] [rbp-60h] BYREF
char *v8[8]; // [rsp+68h] [rbp-40h] BYREF
std::string::basic_string<std::allocator<char>>(v6, (long long)"invalid_iterator");
nlohmann::json_abi_v3_11_3::detail::exception::name((long long)v7, (long long)v6, a2);
nlohmann::json_abi_v3_11_3::detail::exception::diagnostics<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>>(v5);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,std::string,std::string,std::string const&>(
(long long)v8,
(long long)v7,
(long long)v5,
a3);
std::string::~string(v5);
std::string::~string(v7);
std::string::~string(v6);
nlohmann::json_abi_v3_11_3::detail::invalid_iterator::invalid_iterator(this, a2, v8[0]);
std::string::~string(v8);
return this;
}
| _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x88
MOV R15,RCX
MOV R14,RDX
MOV EBP,ESI
MOV RBX,RDI
LAB_0016827e:
LEA RSI,[0x1b2c34]
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x7]
CALL 0x00127852
LAB_00168294:
LEA RDI,[RSP + 0x48]
LEA RSI,[RSP + 0x28]
MOV EDX,EBP
CALL 0x0013ddf4
LAB_001682a5:
LEA RDI,[RSP + 0x8]
MOV RSI,R15
CALL 0x0014216e
LAB_001682b2:
LEA RDI,[RSP + 0x68]
LEA RSI,[RSP + 0x48]
LEA RDX,[RSP + 0x8]
MOV RCX,R14
CALL 0x0013dd8b
LEA RDI,[RSP + 0x8]
CALL 0x001251b8
LEA RDI,[RSP + 0x48]
CALL 0x001251b8
LEA RDI,[RSP + 0x28]
CALL 0x001251b8
MOV RDX,qword ptr [RSP + 0x68]
LAB_001682ec:
MOV RDI,RBX
MOV ESI,EBP
CALL 0x001432fe
LAB_001682f6:
LEA RDI,[RSP + 0x68]
CALL 0x001251b8
MOV RAX,RBX
ADD RSP,0x88
POP RBX
POP R14
POP R15
POP RBP
RET
|
invalid_iterator *
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(invalid_iterator *param_1,int param_2,string *param_3)
{
allocator local_a1;
string local_a0 [32];
string local_80 [32];
exception local_60 [32];
char *local_40 [4];
/* try { // try from 0016827e to 00168293 has its CatchHandler @ 00168348 */
std::__cxx11::string::string<std::allocator<char>>(local_80,"invalid_iterator",&local_a1);
/* try { // try from 00168294 to 001682a4 has its CatchHandler @ 00168339 */
nlohmann::json_abi_v3_11_3::detail::exception::name(local_60,local_80,param_2);
/* try { // try from 001682a5 to 001682b1 has its CatchHandler @ 0016832a */
nlohmann::json_abi_v3_11_3::detail::exception::
diagnostics<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(local_a0);
/* try { // try from 001682b2 to 001682c8 has its CatchHandler @ 0016831b */
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,std::__cxx11::string,std::__cxx11::string,std::__cxx11::string_const&>
((detail *)local_40,(string *)local_60,local_a0,param_3);
std::__cxx11::string::~string(local_a0);
std::__cxx11::string::~string((string *)local_60);
std::__cxx11::string::~string(local_80);
/* try { // try from 001682ec to 001682f5 has its CatchHandler @ 00168311 */
nlohmann::json_abi_v3_11_3::detail::invalid_iterator::invalid_iterator
(param_1,param_2,local_40[0]);
std::__cxx11::string::~string((string *)local_40);
return param_1;
}
| |
29,226 | nglog::LogMessage::LogMessage(char const*, int, nglog::internal::CheckOpString const&) | ng-log[P]ng-log/src/logging.cc | LogMessage::LogMessage(const char* file, int line,
const internal::CheckOpString& result)
: allocated_(nullptr) {
Init(file, line, NGLOG_FATAL, &LogMessage::SendToLog);
stream() << "Check failed: " << (*result.str_) << " ";
} | O1 | cpp | nglog::LogMessage::LogMessage(char const*, int, nglog::internal::CheckOpString const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, (%rdi)
addq $0x10, %rdi
callq 0xe198
leaq 0x63(%rip), %r8 # 0x9fe2
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl $0x3, %ecx
xorl %r9d, %r9d
callq 0x98d6
movl $0x7538, %r14d # imm = 0x7538
addq 0x8(%r15), %r14
leaq 0x18605(%rip), %rsi # 0x225aa
movl $0xe, %edx
movq %r14, %rdi
callq 0x7610
movq (%rbx), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r14, %rdi
callq 0x7610
leaq 0x19d14(%rip), %rsi # 0x23cdf
movl $0x1, %edx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7610
| _ZN5nglog10LogMessageC2EPKciRKNS_8internal13CheckOpStringE:
push rbp; Alternative name is 'nglog::LogMessage::LogMessage(char const*, int, nglog::internal::CheckOpString const&)'
push r15
push r14
push rbx
push rax
mov rbx, rcx
mov ebp, edx
mov r14, rsi
mov r15, rdi
mov qword ptr [rdi], 0
add rdi, 10h; this
call _ZN5nglog14LogMessageTimeC2Ev; nglog::LogMessageTime::LogMessageTime(void)
lea r8, _ZN5nglog10LogMessage9SendToLogEv; nglog::LogMessage::SendToLog(void)
mov rdi, r15
mov rsi, r14
mov edx, ebp
mov ecx, 3
xor r9d, r9d
call _ZN5nglog10LogMessage4InitEPKciNS_11LogSeverityEMS0_FvvE; nglog::LogMessage::Init(char const*,int,nglog::LogSeverity,void (nglog::LogMessage::*)(void))
mov r14d, 7538h
add r14, [r15+8]
lea rsi, aCheckFailed; "Check failed: "
mov edx, 0Eh
mov rdi, r14
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rax, [rbx]
mov rsi, [rax]
mov rdx, [rax+8]
mov rdi, r14
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, asc_23CDC+3; " "
mov edx, 1
mov rdi, rax
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
| long long nglog::LogMessage::LogMessage(_QWORD *a1, nglog::tools *a2, int a3, _QWORD **a4)
{
long long v6; // r14
long long v7; // rax
*a1 = 0LL;
nglog::LogMessageTime::LogMessageTime((nglog::LogMessageTime *)(a1 + 2));
nglog::LogMessage::Init((long long)a1, a2, a3, 3, (long long)nglog::LogMessage::SendToLog, 0LL);
v6 = a1[1] + 30008LL;
std::__ostream_insert<char,std::char_traits<char>>(v6, "Check failed: ", 14LL);
v7 = std::__ostream_insert<char,std::char_traits<char>>(v6, **a4, (*a4)[1]);
return std::__ostream_insert<char,std::char_traits<char>>(v7, " ", 1LL);
}
| LogMessage:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV EBP,EDX
MOV R14,RSI
MOV R15,RDI
MOV qword ptr [RDI],0x0
ADD RDI,0x10
CALL 0x0010e198
LEA R8,[0x109fe2]
MOV RDI,R15
MOV RSI,R14
MOV EDX,EBP
MOV ECX,0x3
XOR R9D,R9D
CALL 0x001098d6
MOV R14D,0x7538
ADD R14,qword ptr [R15 + 0x8]
LEA RSI,[0x1225aa]
MOV EDX,0xe
MOV RDI,R14
CALL 0x00107610
MOV RAX,qword ptr [RBX]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
MOV RDI,R14
CALL 0x00107610
LEA RSI,[0x123cdf]
MOV EDX,0x1
MOV RDI,RAX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x00107610
|
/* nglog::LogMessage::LogMessage(char const*, int, nglog::internal::CheckOpString const&) */
void __thiscall
nglog::LogMessage::LogMessage(LogMessage *this,char *param_1,int param_2,CheckOpString *param_3)
{
long lVar1;
ostream *poVar2;
*(int8 *)this = 0;
LogMessageTime::LogMessageTime((LogMessageTime *)(this + 0x10));
Init(this,param_1,param_2,3,SendToLog,0);
lVar1 = *(long *)(this + 8);
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)(lVar1 + 0x7538),"Check failed: ",0xe);
poVar2 = std::__ostream_insert<char,std::char_traits<char>>
((ostream *)(lVar1 + 0x7538),(char *)**(int8 **)param_3,
(*(int8 **)param_3)[1]);
std::__ostream_insert<char,std::char_traits<char>>(poVar2," ",1);
return;
}
| |
29,227 | nglog::LogMessage::LogMessage(char const*, int, nglog::internal::CheckOpString const&) | ng-log[P]ng-log/src/logging.cc | LogMessage::LogMessage(const char* file, int line,
const internal::CheckOpString& result)
: allocated_(nullptr) {
Init(file, line, NGLOG_FATAL, &LogMessage::SendToLog);
stream() << "Check failed: " << (*result.str_) << " ";
} | O2 | cpp | nglog::LogMessage::LogMessage(char const*, int, nglog::internal::CheckOpString const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
andq $0x0, (%rdi)
addq $0x10, %rdi
callq 0xc3a0
leaq 0x4c(%rip), %r8 # 0x9750
pushq $0x3
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
xorl %r9d, %r9d
callq 0x9202
movl $0x7538, %edi # imm = 0x7538
addq 0x8(%r15), %rdi
leaq 0x13e7b(%rip), %rsi # 0x1d5a2
callq 0x7580
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x74d0
leaq 0x15591(%rip), %rsi # 0x1eccf
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7580
| _ZN5nglog10LogMessageC2EPKciRKNS_8internal13CheckOpStringE:
push rbp; Alternative name is 'nglog::LogMessage::LogMessage(char const*, int, nglog::internal::CheckOpString const&)'
push r15
push r14
push rbx
push rax
mov rbx, rcx
mov ebp, edx
mov r14, rsi
mov r15, rdi
and qword ptr [rdi], 0
add rdi, 10h; this
call _ZN5nglog14LogMessageTimeC2Ev; nglog::LogMessageTime::LogMessageTime(void)
lea r8, _ZN5nglog10LogMessage9SendToLogEv; nglog::LogMessage::SendToLog(void)
push 3
pop rcx
mov rdi, r15
mov rsi, r14
mov edx, ebp
xor r9d, r9d
call _ZN5nglog10LogMessage4InitEPKciNS_11LogSeverityEMS0_FvvE; nglog::LogMessage::Init(char const*,int,nglog::LogSeverity,void (nglog::LogMessage::*)(void))
mov edi, 7538h
add rdi, [r15+8]
lea rsi, aCheckFailed; "Check failed: "
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rsi, [rbx]
mov rdi, rax
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
lea rsi, asc_1ECCC+3; " "
mov rdi, rax
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
| long long nglog::LogMessage::LogMessage(_QWORD *a1, nglog::tools *a2, int a3, _QWORD *a4)
{
long long v6; // rdx
long long v7; // rcx
long long v8; // r8
long long v9; // r9
long long v10; // rax
long long v11; // rax
long long v12; // rdx
long long v13; // rcx
long long v14; // r8
long long v15; // r9
*a1 = 0LL;
nglog::LogMessageTime::LogMessageTime((nglog::LogMessageTime *)(a1 + 2));
nglog::LogMessage::Init((long long)a1, a2, a3, 3u, (long long)nglog::LogMessage::SendToLog, 0LL);
v10 = std::operator<<<std::char_traits<char>>(a1[1] + 30008LL, "Check failed: ", v6, v7, v8, v9);
v11 = std::operator<<<char>(v10, *a4);
return std::operator<<<std::char_traits<char>>(v11, " ", v12, v13, v14, v15);
}
| LogMessage:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV EBP,EDX
MOV R14,RSI
MOV R15,RDI
AND qword ptr [RDI],0x0
ADD RDI,0x10
CALL 0x0010c3a0
LEA R8,[0x109750]
PUSH 0x3
POP RCX
MOV RDI,R15
MOV RSI,R14
MOV EDX,EBP
XOR R9D,R9D
CALL 0x00109202
MOV EDI,0x7538
ADD RDI,qword ptr [R15 + 0x8]
LEA RSI,[0x11d5a2]
CALL 0x00107580
MOV RSI,qword ptr [RBX]
MOV RDI,RAX
CALL 0x001074d0
LEA RSI,[0x11eccf]
MOV RDI,RAX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x00107580
|
/* nglog::LogMessage::LogMessage(char const*, int, nglog::internal::CheckOpString const&) */
void __thiscall
nglog::LogMessage::LogMessage(LogMessage *this,char *param_1,int param_2,CheckOpString *param_3)
{
ostream *poVar1;
*(int8 *)this = 0;
LogMessageTime::LogMessageTime((LogMessageTime *)(this + 0x10));
Init(this,param_1,param_2,3,SendToLog,0);
poVar1 = std::operator<<((ostream *)(*(long *)(this + 8) + 0x7538),"Check failed: ");
poVar1 = std::operator<<(poVar1,*(string **)param_3);
std::operator<<(poVar1," ");
return;
}
| |
29,228 | LefDefParser::lefiViaLayer::xl(int) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiVia.cpp | double
lefiViaLayer::xl(int index)
{
char msg[160];
if (index < 0 || index >= numRects_) {
sprintf(msg, "ERROR (LEFPARS-1420): The index number %d given for the VIA LAYER RECTANGLE is invalid.\nValid index is from 0 to %d", index, numRects_);
lefiError(0, 1420, msg);
return 0;
}
return xl_[index];
} | O3 | cpp | LefDefParser::lefiViaLayer::xl(int):
movl %esi, %edx
testl %esi, %esi
setns %al
movl 0x18(%rdi), %ecx
cmpl %esi, %ecx
setg %sil
testb %sil, %al
je 0xe553
movq 0x20(%rdi), %rax
movl %edx, %ecx
movsd (%rax,%rcx,8), %xmm0
retq
pushq %rbx
subq $0xa0, %rsp
leaq 0x4be80(%rip), %rsi # 0x5a3e2
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2050
xorl %edi, %edi
movl $0x58c, %esi # imm = 0x58C
movq %rbx, %rdx
callq 0x33d78
xorps %xmm0, %xmm0
addq $0xa0, %rsp
popq %rbx
retq
| _ZN12LefDefParser12lefiViaLayer2xlEi:
mov edx, esi
test esi, esi
setns al
mov ecx, [rdi+18h]
cmp ecx, esi
setnle sil
test al, sil
jz short loc_E553
mov rax, [rdi+20h]
mov ecx, edx
movsd xmm0, qword ptr [rax+rcx*8]
retn
loc_E553:
push rbx
sub rsp, 0A0h
lea rsi, aErrorLefpars14; "ERROR (LEFPARS-1420): The index number "...
mov rbx, rsp
mov rdi, rbx
xor eax, eax
call _sprintf
xor edi, edi; this
mov esi, 58Ch; int
mov rdx, rbx; int
call _ZN12LefDefParser9lefiErrorEiiPKc; LefDefParser::lefiError(int,int,char const*)
xorps xmm0, xmm0
add rsp, 0A0h
pop rbx
retn
| double LefDefParser::lefiViaLayer::xl(LefDefParser::lefiViaLayer *this, unsigned int a2)
{
const char *v3; // rcx
_BYTE v4[168]; // [rsp-A8h] [rbp-A8h] BYREF
if ( *((_DWORD *)this + 6) > (int)a2 && (a2 & 0x80000000) == 0 )
return *(double *)(*((_QWORD *)this + 4) + 8LL * a2);
sprintf(
v4,
"ERROR (LEFPARS-1420): The index number %d given for the VIA LAYER RECTANGLE is invalid.\n"
"Valid index is from 0 to %d",
a2);
LefDefParser::lefiError(0LL, 1420, (int)v4, v3);
return 0.0;
}
| xl:
MOV EDX,ESI
TEST ESI,ESI
SETNS AL
MOV ECX,dword ptr [RDI + 0x18]
CMP ECX,ESI
SETG SIL
TEST AL,SIL
JZ 0x0010e553
MOV RAX,qword ptr [RDI + 0x20]
MOV ECX,EDX
MOVSD XMM0,qword ptr [RAX + RCX*0x8]
RET
LAB_0010e553:
PUSH RBX
SUB RSP,0xa0
LEA RSI,[0x15a3e2]
MOV RBX,RSP
MOV RDI,RBX
XOR EAX,EAX
CALL 0x00102050
XOR EDI,EDI
MOV ESI,0x58c
MOV RDX,RBX
CALL 0x00133d78
XORPS XMM0,XMM0
ADD RSP,0xa0
POP RBX
RET
|
/* LefDefParser::lefiViaLayer::xl(int) */
int8 __thiscall LefDefParser::lefiViaLayer::xl(lefiViaLayer *this,int param_1)
{
char acStack_a8 [160];
if (-1 < param_1 && param_1 < *(int *)(this + 0x18)) {
return *(int8 *)(*(long *)(this + 0x20) + (ulong)(uint)param_1 * 8);
}
sprintf(acStack_a8,
"ERROR (LEFPARS-1420): The index number %d given for the VIA LAYER RECTANGLE is invalid.\nValid index is from 0 to %d"
);
lefiError(0,0x58c,acStack_a8);
return 0;
}
| |
29,229 | ftxui::GlyphCount(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Andrewchistyakov[P]flashcards_lyc/build_O2/_deps/ftxui-src/src/ftxui/screen/string.cpp | int GlyphCount(const std::string& input) {
int size = 0;
size_t start = 0;
size_t end = 0;
while (start < input.size()) {
uint32_t codepoint = 0;
const bool eaten = EatCodePoint(input, start, &end, &codepoint);
start = end;
// Ignore invalid characters:
if (!eaten || IsControl(codepoint)) {
continue;
}
// Ignore combining characters, except when they don't have a preceding to
// combine with.
if (IsCombining(codepoint)) {
if (size == 0) {
size++;
}
continue;
}
size++;
}
return size;
} | O2 | cpp | ftxui::GlyphCount(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 $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
andq $0x0, (%r14)
movq 0x8(%rdi), %r13
xorl %r12d, %r12d
leaq 0xc(%rsp), %r15
xorl %ebp, %ebp
cmpq %r13, %r12
jae 0x317e7
andl $0x0, 0xc(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x31040
movq 0x10(%rsp), %r12
testb %al, %al
je 0x31792
movl 0xc(%rsp), %edi
testl %edi, %edi
je 0x31792
cmpl $0x1f, %edi
ja 0x317ca
cmpl $0xa, %edi
jne 0x31792
jmp 0x317d2
leal -0x7f(%rdi), %eax
cmpl $0x21, %eax
jb 0x31792
callq 0x3114e
testb %al, %al
je 0x317e3
cmpl $0x1, %ebp
adcl $0x0, %ebp
jmp 0x31792
incl %ebp
jmp 0x31792
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN5ftxui10GlyphCountERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
lea r14, [rsp+48h+var_3C+4]
and qword ptr [r14], 0
mov r13, [rdi+8]
xor r12d, r12d
lea r15, [rsp+48h+var_3C]
xor ebp, ebp
loc_31792:
cmp r12, r13
jnb short loc_317E7
and dword ptr [rsp+48h+var_3C], 0
mov rdi, rbx
mov rsi, r12; unsigned int
mov rdx, r14
mov rcx, r15
call _ZN5ftxui12EatCodePointERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEmPmPj; ftxui::EatCodePoint(std::string const&,ulong,ulong *,uint *)
mov r12, [rsp+48h+var_3C+4]
test al, al
jz short loc_31792
mov edi, dword ptr [rsp+48h+var_3C]; this
test edi, edi
jz short loc_31792
cmp edi, 1Fh
ja short loc_317CA
cmp edi, 0Ah
jnz short loc_31792
jmp short loc_317D2
loc_317CA:
lea eax, [rdi-7Fh]
cmp eax, 21h ; '!'
jb short loc_31792
loc_317D2:
call _ZN5ftxui11IsCombiningEj; ftxui::IsCombining(uint)
test al, al
jz short loc_317E3
cmp ebp, 1
adc ebp, 0
jmp short loc_31792
loc_317E3:
inc ebp
jmp short loc_31792
loc_317E7:
mov eax, ebp
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ftxui::GlyphCount(long long *a1)
{
unsigned long long v1; // r13
unsigned long long v2; // r12
unsigned int v3; // ebp
char v4; // al
unsigned int v6[15]; // [rsp+Ch] [rbp-3Ch] BYREF
*(_QWORD *)&v6[1] = 0LL;
v1 = a1[1];
v2 = 0LL;
v3 = 0;
while ( v2 < v1 )
{
v6[0] = 0;
v4 = ftxui::EatCodePoint(a1, v2, &v6[1], (int *)v6);
v2 = *(_QWORD *)&v6[1];
if ( v4 && v6[0] )
{
if ( v6[0] > 0x1F )
{
if ( v6[0] - 127 >= 0x21 )
{
LABEL_9:
if ( (unsigned __int8)ftxui::IsCombining((ftxui *)v6[0]) )
v3 += v3 == 0;
else
++v3;
}
}
else if ( v6[0] == 10 )
{
goto LABEL_9;
}
}
}
return v3;
}
| GlyphCount:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
LEA R14,[RSP + 0x10]
AND qword ptr [R14],0x0
MOV R13,qword ptr [RDI + 0x8]
XOR R12D,R12D
LEA R15,[RSP + 0xc]
XOR EBP,EBP
LAB_00131792:
CMP R12,R13
JNC 0x001317e7
AND dword ptr [RSP + 0xc],0x0
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R14
MOV RCX,R15
CALL 0x00131040
MOV R12,qword ptr [RSP + 0x10]
TEST AL,AL
JZ 0x00131792
MOV EDI,dword ptr [RSP + 0xc]
TEST EDI,EDI
JZ 0x00131792
CMP EDI,0x1f
JA 0x001317ca
CMP EDI,0xa
JNZ 0x00131792
JMP 0x001317d2
LAB_001317ca:
LEA EAX,[RDI + -0x7f]
CMP EAX,0x21
JC 0x00131792
LAB_001317d2:
CALL 0x0013114e
TEST AL,AL
JZ 0x001317e3
CMP EBP,0x1
ADC EBP,0x0
JMP 0x00131792
LAB_001317e3:
INC EBP
JMP 0x00131792
LAB_001317e7:
MOV EAX,EBP
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* ftxui::GlyphCount(std::__cxx11::string const&) */
int ftxui::GlyphCount(string *param_1)
{
ulong uVar1;
char cVar2;
int iVar3;
ulong uVar4;
uint local_3c;
ulong local_38;
local_38 = 0;
uVar1 = *(ulong *)(param_1 + 8);
uVar4 = 0;
iVar3 = 0;
LAB_00131792:
do {
do {
if (uVar1 <= uVar4) {
return iVar3;
}
local_3c = 0;
cVar2 = EatCodePoint(param_1,uVar4,&local_38,&local_3c);
uVar4 = local_38;
} while ((cVar2 == '\0') || (local_3c == 0));
if (0x1f < local_3c) goto LAB_001317ca;
} while (local_3c != 10);
goto LAB_001317d2;
LAB_001317ca:
if (0x20 < local_3c - 0x7f) {
LAB_001317d2:
cVar2 = IsCombining(local_3c);
if (cVar2 == '\0') {
iVar3 = iVar3 + 1;
}
else {
iVar3 = iVar3 + (uint)(iVar3 == 0);
}
}
goto LAB_00131792;
}
| |
29,230 | inline_mysql_file_create_with_symlink | eloqsql/include/mysql/psi/mysql_file.h | static inline File
inline_mysql_file_create_with_symlink(
#ifdef HAVE_PSI_FILE_INTERFACE
PSI_file_key key, const char *src_file, uint src_line,
#endif
const char *linkname, const char *filename, int create_flags,
int access_flags, myf flags)
{
File file;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_name_locker)(&state, key, PSI_FILE_CREATE, filename,
&locker);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_open_wait)(locker, src_file, src_line);
file= my_create_with_symlink(linkname, filename, create_flags, access_flags,
flags);
PSI_FILE_CALL(end_file_open_wait_and_bind_to_descriptor)(locker, file);
return file;
}
#endif
file= my_create_with_symlink(linkname, filename, create_flags, access_flags,
flags);
return file;
} | O3 | c | inline_mysql_file_create_with_symlink:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, %rbx
movl %r8d, %r14d
movq %rcx, %r15
movq %rdx, %r12
movl %esi, -0x2c(%rbp)
movl %edi, %esi
leaq 0x2f4a03(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %r13
xorl %edx, %edx
movq %r13, %r8
callq *0x148(%rax)
movq %rax, (%r13)
testq %rax, %rax
jne 0x91652
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
movl %r14d, %ecx
movq %rbx, %r8
callq 0xa1948
movl %eax, %ebx
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2f49b7(%rip), %r13 # 0x386010
movq (%r13), %rcx
leaq 0x4a952(%rip), %rsi # 0xdbfb6
movq %rax, %rdi
movl -0x2c(%rbp), %edx
callq *0x1f0(%rcx)
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
movl %r14d, %ecx
movq %rbx, %r8
callq 0xa1948
movl %eax, %ebx
movq (%r13), %rax
movq -0x38(%rbp), %rdi
movl %ebx, %esi
callq *0x200(%rax)
jmp 0x91641
| inline_mysql_file_create_with_symlink_0:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov rbx, r9
mov r14d, r8d
mov r15, rcx
mov r12, rdx
mov [rbp+var_2C], esi
mov esi, edi
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_80]
lea r13, [rbp+var_38]
xor edx, edx
mov r8, r13
call qword ptr [rax+148h]
mov [r13+0], rax
test rax, rax
jnz short loc_91652
mov rdi, r12
mov rsi, r15
xor edx, edx
mov ecx, r14d
mov r8, rbx
call my_create_with_symlink
mov ebx, eax
loc_91641:
mov eax, ebx
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_91652:
lea r13, PSI_server
mov rcx, [r13+0]
lea rsi, aWorkspaceLlm4b_19; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, rax
mov edx, [rbp+var_2C]
call qword ptr [rcx+1F0h]
mov rdi, r12
mov rsi, r15
xor edx, edx
mov ecx, r14d
mov r8, rbx
call my_create_with_symlink
mov ebx, eax
mov rax, [r13+0]
mov rdi, [rbp+var_38]
mov esi, ebx
call qword ptr [rax+200h]
jmp short loc_91641
| long long inline_mysql_file_create_with_symlink_0(
unsigned int a1,
unsigned int a2,
long long a3,
long long a4,
unsigned int a5,
long long a6)
{
long long v10; // rax
_BYTE v12[72]; // [rsp+0h] [rbp-80h] BYREF
long long v13; // [rsp+48h] [rbp-38h] BYREF
unsigned int v14; // [rsp+54h] [rbp-2Ch]
v14 = a2;
v10 = ((long long ( *)(_BYTE *, _QWORD, _QWORD, long long, long long *))PSI_server[41])(v12, a1, 0LL, a4, &v13);
v13 = v10;
if ( v10 )
{
((void ( *)(long long, const char *, _QWORD))PSI_server[62])(
v10,
"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_create.c",
v14);
a6 = (unsigned int)my_create_with_symlink(a3, a4, 0LL, a5, a6);
((void ( *)(long long, long long))PSI_server[64])(v13, a6);
}
else
{
LODWORD(a6) = my_create_with_symlink(a3, a4, 0LL, a5, a6);
}
return (unsigned int)a6;
}
| inline_mysql_file_create_with_symlink:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV RBX,R9
MOV R14D,R8D
MOV R15,RCX
MOV R12,RDX
MOV dword ptr [RBP + -0x2c],ESI
MOV ESI,EDI
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x80]
LEA R13,[RBP + -0x38]
XOR EDX,EDX
MOV R8,R13
CALL qword ptr [RAX + 0x148]
MOV qword ptr [R13],RAX
TEST RAX,RAX
JNZ 0x00191652
MOV RDI,R12
MOV RSI,R15
XOR EDX,EDX
MOV ECX,R14D
MOV R8,RBX
CALL 0x001a1948
MOV EBX,EAX
LAB_00191641:
MOV EAX,EBX
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00191652:
LEA R13,[0x486010]
MOV RCX,qword ptr [R13]
LEA RSI,[0x1dbfb6]
MOV RDI,RAX
MOV EDX,dword ptr [RBP + -0x2c]
CALL qword ptr [RCX + 0x1f0]
MOV RDI,R12
MOV RSI,R15
XOR EDX,EDX
MOV ECX,R14D
MOV R8,RBX
CALL 0x001a1948
MOV EBX,EAX
MOV RAX,qword ptr [R13]
MOV RDI,qword ptr [RBP + -0x38]
MOV ESI,EBX
CALL qword ptr [RAX + 0x200]
JMP 0x00191641
|
int4
inline_mysql_file_create_with_symlink
(int4 param_1,int4 param_2,int8 param_3,int8 param_4,
int4 param_5,int8 param_6)
{
int4 uVar1;
int1 local_88 [72];
long local_40;
int4 local_34;
local_34 = param_2;
local_40 = (**(code **)(PSI_server + 0x148))(local_88,param_1,0,param_4,&local_40);
if (local_40 == 0) {
uVar1 = my_create_with_symlink(param_3,param_4,0,param_5,param_6);
}
else {
(**(code **)(PSI_server + 0x1f0))
(local_40,"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_create.c",
local_34);
uVar1 = my_create_with_symlink(param_3,param_4,0,param_5,param_6);
(**(code **)(PSI_server + 0x200))(local_40,uVar1);
}
return uVar1;
}
| |
29,231 | Test_CleanImmediatelyWithRelativePrefix_logging::RunTest() | ng-log[P]ng-log/src/cleanup_with_relative_prefix_unittest.cc | TEST(CleanImmediatelyWithRelativePrefix, logging) {
using namespace std::chrono_literals;
nglog::EnableLogCleaner(0h);
nglog::SetLogFilenameExtension(".relativefoo");
nglog::SetLogDestination(NGLOG_INFO, "test_subdir/test_cleanup_");
for (unsigned i = 0; i < 1000; ++i) {
LOG(INFO) << "cleanup test";
}
nglog::DisableLogCleaner();
} | O2 | cpp | Test_CleanImmediatelyWithRelativePrefix_logging::RunTest():
pushq %rbx
subq $0x30, %rsp
movq %rsp, %rdi
callq 0xa652
callq 0x9b3a
movq %rsp, %rdi
callq 0xa694
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xa694
movq %rbx, %rdi
callq 0x8a40
nop
| _ZN47Test_CleanImmediatelyWithRelativePrefix_logging3RunEv:
push rbx
sub rsp, 30h
mov rdi, rsp; this
call _ZN5nglog9FlagSaverC2Ev; nglog::FlagSaver::FlagSaver(void)
call _ZN47Test_CleanImmediatelyWithRelativePrefix_logging7RunTestEv; Test_CleanImmediatelyWithRelativePrefix_logging::RunTest(void)
mov rdi, rsp; this
call _ZN5nglog9FlagSaverD2Ev; nglog::FlagSaver::~FlagSaver()
add rsp, 30h
pop rbx
retn
mov rbx, rax
mov rdi, rsp; this
call _ZN5nglog9FlagSaverD2Ev; nglog::FlagSaver::~FlagSaver()
mov rdi, rbx
call __Unwind_Resume
| void Test_CleanImmediatelyWithRelativePrefix_logging::Run(
Test_CleanImmediatelyWithRelativePrefix_logging *this,
const char *a2)
{
_BYTE v2[56]; // [rsp+0h] [rbp-38h] BYREF
nglog::FlagSaver::FlagSaver((nglog::FlagSaver *)v2);
Test_CleanImmediatelyWithRelativePrefix_logging::RunTest((Test_CleanImmediatelyWithRelativePrefix_logging *)v2, a2);
nglog::FlagSaver::~FlagSaver((nglog::FlagSaver *)v2);
}
| Run:
PUSH RBX
SUB RSP,0x30
MOV RDI,RSP
CALL 0x0010a652
LAB_0010a4b5:
CALL 0x00109b3a
LAB_0010a4ba:
MOV RDI,RSP
CALL 0x0010a694
ADD RSP,0x30
POP RBX
RET
|
/* Test_CleanImmediatelyWithRelativePrefix_logging::Run() */
void Test_CleanImmediatelyWithRelativePrefix_logging::Run(void)
{
FlagSaver aFStack_38 [48];
nglog::FlagSaver::FlagSaver(aFStack_38);
/* try { // try from 0010a4b5 to 0010a4b9 has its CatchHandler @ 0010a4c8 */
RunTest();
nglog::FlagSaver::~FlagSaver(aFStack_38);
return;
}
| |
29,232 | google::protobuf::internal::SerialArena::AllocateNewBlock(unsigned long, google::protobuf::internal::AllocationPolicy const*) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/arena.cc | void SerialArena::AllocateNewBlock(size_t n, const AllocationPolicy* policy) {
// Sync limit to block
head_->start = reinterpret_cast<CleanupNode*>(limit_);
// Record how much used in this block.
size_t used = ptr_ - head_->Pointer(kBlockHeaderSize);
size_t wasted = head_->size - used;
space_used_ += used;
// TODO(sbenza): Evaluate if pushing unused space into the cached blocks is a
// win. In preliminary testing showed increased memory savings as expected,
// but with a CPU regression. The regression might have been an artifact of
// the microbenchmark.
auto mem = AllocateMemory(policy, head_->size, n);
// We don't want to emit an expensive RMW instruction that requires
// exclusive access to a cacheline. Hence we write it in terms of a
// regular add.
auto relaxed = std::memory_order_relaxed;
space_allocated_.store(space_allocated_.load(relaxed) + mem.size, relaxed);
ThreadSafeArenaStats::RecordAllocateStats(arena_stats_, /*requested=*/n,
/*allocated=*/mem.size, wasted);
head_ = new (mem.ptr) Block{head_, mem.size};
ptr_ = head_->Pointer(kBlockHeaderSize);
limit_ = head_->Pointer(head_->size);
#ifdef ADDRESS_SANITIZER
ASAN_POISON_MEMORY_REGION(ptr_, limit_ - ptr_);
#endif // ADDRESS_SANITIZER
} | O0 | cpp | google::protobuf::internal::SerialArena::AllocateNewBlock(unsigned long, google::protobuf::internal::AllocationPolicy const*):
subq $0xb8, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x8(%rax), %rcx
movq 0x30(%rax), %rdx
movq %rdx, 0x10(%rcx)
movq 0x8(%rax), %rdi
movq 0x28(%rax), %rax
movq %rax, 0x20(%rsp)
movl $0x18, %esi
callq 0x1674d0
movq 0x20(%rsp), %rcx
movq %rax, %rdx
movq 0x28(%rsp), %rax
subq %rdx, %rcx
movq %rcx, 0x60(%rsp)
movq 0x8(%rax), %rcx
movq 0x8(%rcx), %rcx
movq 0x60(%rsp), %rdx
subq %rdx, %rcx
movq %rcx, 0x58(%rsp)
movq 0x60(%rsp), %rdx
movq 0x18(%rax), %rcx
addq %rdx, %rcx
movq %rcx, 0x18(%rax)
movq 0x68(%rsp), %rdi
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x70(%rsp), %rdx
callq 0x165730
movq 0x28(%rsp), %rcx
movq %rax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movl $0x0, 0x44(%rsp)
addq $0x20, %rcx
movq %rcx, 0x30(%rsp)
movl 0x44(%rsp), %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x38(%rsp)
movl 0xac(%rsp), %edi
movl $0xffff, %esi # imm = 0xFFFF
callq 0x8ec90
movl %eax, 0x40(%rsp)
jmp 0x16554b
movl 0x40(%rsp), %eax
movl %eax, 0xa8(%rsp)
movl 0xac(%rsp), %eax
movl %eax, 0x1c(%rsp)
decl %eax
subl $0x2, %eax
jb 0x165587
jmp 0x16556a
movl 0x1c(%rsp), %eax
subl $0x5, %eax
je 0x165599
jmp 0x165575
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq %rax, 0xa0(%rsp)
jmp 0x1655b3
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq %rax, 0xa0(%rsp)
jmp 0x1655b3
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq %rax, 0xa0(%rsp)
jmp 0x1655b3
movq %rax, %rdi
callq 0x9cf00
movq 0x30(%rsp), %rdx
movq 0xa0(%rsp), %rcx
movq 0x50(%rsp), %rax
addq %rax, %rcx
movl 0x44(%rsp), %eax
movq %rdx, 0x98(%rsp)
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x8c(%rsp), %edi
movl $0xffff, %esi # imm = 0xFFFF
callq 0x8ec90
movl %eax, 0x88(%rsp)
movl 0x8c(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x90(%rsp), %rcx
movq %rcx, 0x80(%rsp)
subl $0x3, %eax
je 0x165647
jmp 0x16562a
movl 0x18(%rsp), %eax
subl $0x5, %eax
je 0x165659
jmp 0x165635
movq 0x10(%rsp), %rax
movq 0x80(%rsp), %rcx
movq %rcx, (%rax)
jmp 0x165669
movq 0x10(%rsp), %rax
movq 0x80(%rsp), %rcx
movq %rcx, (%rax)
jmp 0x165669
movq 0x10(%rsp), %rcx
movq 0x80(%rsp), %rax
xchgq %rax, (%rcx)
movq 0x28(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x70(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x58(%rsp), %rcx
callq 0x167480
movq 0x28(%rsp), %rax
movq 0x48(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x8(%rax), %rsi
movq 0x50(%rsp), %rdx
callq 0x1674a0
movq 0x8(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rdi
movl $0x18, %esi
callq 0x1674d0
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x8(%rax), %rdi
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x1674d0
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x30(%rax)
addq $0xb8, %rsp
retq
| _ZN6google8protobuf8internal11SerialArena16AllocateNewBlockEmPKNS1_16AllocationPolicyE:
sub rsp, 0B8h
mov [rsp+0B8h+var_40], rdi
mov [rsp+0B8h+var_48], rsi
mov [rsp+0B8h+var_50], rdx
mov rax, [rsp+0B8h+var_40]
mov [rsp+0B8h+var_90], rax
mov rcx, [rax+8]
mov rdx, [rax+30h]
mov [rcx+10h], rdx
mov rdi, [rax+8]; this
mov rax, [rax+28h]
mov [rsp+0B8h+var_98], rax
mov esi, 18h; unsigned __int64
call _ZN6google8protobuf8internal11SerialArena5Block7PointerEm; google::protobuf::internal::SerialArena::Block::Pointer(ulong)
mov rcx, [rsp+0B8h+var_98]
mov rdx, rax
mov rax, [rsp+0B8h+var_90]
sub rcx, rdx
mov [rsp+0B8h+var_58], rcx
mov rcx, [rax+8]
mov rcx, [rcx+8]
mov rdx, [rsp+0B8h+var_58]
sub rcx, rdx
mov [rsp+0B8h+var_60], rcx
mov rdx, [rsp+0B8h+var_58]
mov rcx, [rax+18h]
add rcx, rdx; unsigned __int64
mov [rax+18h], rcx
mov rdi, [rsp+0B8h+var_50]; this
mov rax, [rax+8]
mov rsi, [rax+8]; google::protobuf::internal::AllocationPolicy *
mov rdx, [rsp+0B8h+var_48]; unsigned __int64
call _ZN6google8protobuf8internalL14AllocateMemoryEPKNS1_16AllocationPolicyEmm; google::protobuf::internal::AllocateMemory(google::protobuf::internal::AllocationPolicy const*,ulong,ulong)
mov rcx, [rsp+0B8h+var_90]
mov [rsp+0B8h+var_70], rax
mov [rsp+0B8h+var_68], rdx
mov [rsp+0B8h+var_74], 0
add rcx, 20h ; ' '
mov [rsp+0B8h+var_88], rcx
mov eax, [rsp+0B8h+var_74]
mov [rsp+0B8h+var_8], rcx
mov [rsp+0B8h+var_C], eax
mov rax, [rsp+0B8h+var_8]
mov [rsp+0B8h+var_80], rax
mov edi, [rsp+0B8h+var_C]
mov esi, 0FFFFh
call __ZStanSt12memory_orderSt23__memory_order_modifier; std::operator&(std::memory_order,std::__memory_order_modifier)
mov [rsp+0B8h+var_78], eax
jmp short $+2
loc_16554B:
mov eax, [rsp+0B8h+var_78]
mov [rsp+0B8h+var_10], eax
mov eax, [rsp+0B8h+var_C]
mov [rsp+0B8h+var_9C], eax
dec eax
sub eax, 2
jb short loc_165587
jmp short $+2
loc_16556A:
mov eax, [rsp+0B8h+var_9C]
sub eax, 5
jz short loc_165599
jmp short $+2
loc_165575:
mov rax, [rsp+0B8h+var_80]
mov rax, [rax]
mov [rsp+0B8h+var_18], rax
jmp short loc_1655B3
loc_165587:
mov rax, [rsp+0B8h+var_80]
mov rax, [rax]
mov [rsp+0B8h+var_18], rax
jmp short loc_1655B3
loc_165599:
mov rax, [rsp+0B8h+var_80]
mov rax, [rax]
mov [rsp+0B8h+var_18], rax
jmp short loc_1655B3
mov rdi, rax
call __clang_call_terminate
loc_1655B3:
mov rdx, [rsp+0B8h+var_88]
mov rcx, [rsp+0B8h+var_18]
mov rax, [rsp+0B8h+var_68]
add rcx, rax
mov eax, [rsp+0B8h+var_74]
mov [rsp+0B8h+var_20], rdx
mov [rsp+0B8h+var_28], rcx
mov [rsp+0B8h+var_2C], eax
mov rax, [rsp+0B8h+var_20]
mov [rsp+0B8h+var_A8], rax
mov edi, [rsp+0B8h+var_2C]
mov esi, 0FFFFh
call __ZStanSt12memory_orderSt23__memory_order_modifier; std::operator&(std::memory_order,std::__memory_order_modifier)
mov [rsp+0B8h+var_30], eax
mov eax, [rsp+0B8h+var_2C]
mov [rsp+0B8h+var_A0], eax
mov rcx, [rsp+0B8h+var_28]
mov [rsp+0B8h+var_38], rcx
sub eax, 3
jz short loc_165647
jmp short $+2
loc_16562A:
mov eax, [rsp+0B8h+var_A0]
sub eax, 5
jz short loc_165659
jmp short $+2
loc_165635:
mov rax, [rsp+0B8h+var_A8]
mov rcx, [rsp+0B8h+var_38]
mov [rax], rcx
jmp short loc_165669
loc_165647:
mov rax, [rsp+0B8h+var_A8]
mov rcx, [rsp+0B8h+var_38]
mov [rax], rcx
jmp short loc_165669
loc_165659:
mov rcx, [rsp+0B8h+var_A8]
mov rax, [rsp+0B8h+var_38]
xchg rax, [rcx]
loc_165669:
mov rax, [rsp+0B8h+var_90]
mov rdi, [rax+38h]
mov rsi, [rsp+0B8h+var_48]
mov rdx, [rsp+0B8h+var_68]
mov rcx, [rsp+0B8h+var_60]
call _ZN6google8protobuf8internal20ThreadSafeArenaStats19RecordAllocateStatsEPS2_mmm; google::protobuf::internal::ThreadSafeArenaStats::RecordAllocateStats(google::protobuf::internal::ThreadSafeArenaStats*,ulong,ulong,ulong)
mov rax, [rsp+0B8h+var_90]
mov rdi, [rsp+0B8h+var_70]
mov [rsp+0B8h+var_B0], rdi
mov rsi, [rax+8]
mov rdx, [rsp+0B8h+var_68]
call _ZN6google8protobuf8internal11SerialArena5BlockC2EPS3_m; google::protobuf::internal::SerialArena::Block::Block(google::protobuf::internal::SerialArena::Block*,ulong)
mov rcx, [rsp+0B8h+var_B0]
mov rax, [rsp+0B8h+var_90]
mov [rax+8], rcx
mov rdi, [rax+8]; this
mov esi, 18h; unsigned __int64
call _ZN6google8protobuf8internal11SerialArena5Block7PointerEm; google::protobuf::internal::SerialArena::Block::Pointer(ulong)
mov rcx, rax
mov rax, [rsp+0B8h+var_90]
mov [rax+28h], rcx
mov rdi, [rax+8]; this
mov rax, [rax+8]
mov rsi, [rax+8]; unsigned __int64
call _ZN6google8protobuf8internal11SerialArena5Block7PointerEm; google::protobuf::internal::SerialArena::Block::Pointer(ulong)
mov rcx, rax
mov rax, [rsp+0B8h+var_90]
mov [rax+30h], rcx
add rsp, 0B8h
retn
| google::protobuf::internal::SerialArena * google::protobuf::internal::SerialArena::AllocateNewBlock(
google::protobuf::internal::SerialArena *this,
unsigned long long a2,
const google::protobuf::internal::AllocationPolicy *a3)
{
unsigned long long v3; // rcx
unsigned long long v4; // rdx
long long v5; // rcx
google::protobuf::internal::SerialArena *result; // rax
long long v7; // [rsp+20h] [rbp-98h]
google::protobuf::internal::SerialArena::Block *Memory; // [rsp+48h] [rbp-70h]
unsigned long long v9; // [rsp+50h] [rbp-68h]
long long v10; // [rsp+58h] [rbp-60h]
long long v11; // [rsp+60h] [rbp-58h]
long long v13; // [rsp+A0h] [rbp-18h]
*(_QWORD *)(*((_QWORD *)this + 1) + 16LL) = *((_QWORD *)this + 6);
v7 = *((_QWORD *)this + 5);
v11 = v7
- google::protobuf::internal::SerialArena::Block::Pointer(
*((google::protobuf::internal::SerialArena::Block **)this + 1),
0x18uLL);
v10 = *(_QWORD *)(*((_QWORD *)this + 1) + 8LL) - v11;
v3 = v11 + *((_QWORD *)this + 3);
*((_QWORD *)this + 3) = v3;
Memory = (google::protobuf::internal::SerialArena::Block *)google::protobuf::internal::AllocateMemory(
a3,
*(const google::protobuf::internal::AllocationPolicy **)(*((_QWORD *)this + 1) + 8LL),
a2,
v3);
v9 = v4;
std::operator&(0LL, 0xFFFFLL);
v13 = *((_QWORD *)this + 4);
std::operator&(0LL, 0xFFFFLL);
*((_QWORD *)this + 4) = v9 + v13;
google::protobuf::internal::ThreadSafeArenaStats::RecordAllocateStats(*((_QWORD *)this + 7), a2, v9, v10);
google::protobuf::internal::SerialArena::Block::Block(
Memory,
*((google::protobuf::internal::SerialArena::Block **)this + 1),
v9);
*((_QWORD *)this + 1) = Memory;
*((_QWORD *)this + 5) = google::protobuf::internal::SerialArena::Block::Pointer(
*((google::protobuf::internal::SerialArena::Block **)this + 1),
0x18uLL);
v5 = google::protobuf::internal::SerialArena::Block::Pointer(
*((google::protobuf::internal::SerialArena::Block **)this + 1),
*(_QWORD *)(*((_QWORD *)this + 1) + 8LL));
result = this;
*((_QWORD *)this + 6) = v5;
return result;
}
| |||
29,233 | google::protobuf::internal::SerialArena::AllocateNewBlock(unsigned long, google::protobuf::internal::AllocationPolicy const*) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/arena.cc | void SerialArena::AllocateNewBlock(size_t n, const AllocationPolicy* policy) {
// Sync limit to block
head_->start = reinterpret_cast<CleanupNode*>(limit_);
// Record how much used in this block.
size_t used = ptr_ - head_->Pointer(kBlockHeaderSize);
size_t wasted = head_->size - used;
space_used_ += used;
// TODO(sbenza): Evaluate if pushing unused space into the cached blocks is a
// win. In preliminary testing showed increased memory savings as expected,
// but with a CPU regression. The regression might have been an artifact of
// the microbenchmark.
auto mem = AllocateMemory(policy, head_->size, n);
// We don't want to emit an expensive RMW instruction that requires
// exclusive access to a cacheline. Hence we write it in terms of a
// regular add.
auto relaxed = std::memory_order_relaxed;
space_allocated_.store(space_allocated_.load(relaxed) + mem.size, relaxed);
ThreadSafeArenaStats::RecordAllocateStats(arena_stats_, /*requested=*/n,
/*allocated=*/mem.size, wasted);
head_ = new (mem.ptr) Block{head_, mem.size};
ptr_ = head_->Pointer(kBlockHeaderSize);
limit_ = head_->Pointer(head_->size);
#ifdef ADDRESS_SANITIZER
ASAN_POISON_MEMORY_REGION(ptr_, limit_ - ptr_);
#endif // ADDRESS_SANITIZER
} | O3 | cpp | google::protobuf::internal::SerialArena::AllocateNewBlock(unsigned long, google::protobuf::internal::AllocationPolicy const*):
pushq %rbx
movq %rdx, %rax
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x8(%rdi), %rcx
movq 0x30(%rdi), %rsi
movq %rsi, 0x10(%rcx)
movq 0x18(%rdi), %rdi
movq 0x28(%rbx), %r8
subq %rcx, %r8
movq 0x8(%rcx), %rsi
leaq (%r8,%rdi), %rcx
addq $-0x18, %rcx
movq %rcx, 0x18(%rbx)
movq %rax, %rdi
callq 0x778fc
addq %rdx, 0x20(%rbx)
movq 0x8(%rbx), %rcx
movq %rcx, (%rax)
movq %rdx, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%rbx)
leaq 0x18(%rax), %rcx
movq %rcx, 0x28(%rbx)
addq %rdx, %rax
movq %rax, 0x30(%rbx)
popq %rbx
retq
nop
| _ZN6google8protobuf8internal11SerialArena16AllocateNewBlockEmPKNS1_16AllocationPolicyE:
push rbx
mov rax, rdx
mov rdx, rsi
mov rbx, rdi
mov rcx, [rdi+8]
mov rsi, [rdi+30h]
mov [rcx+10h], rsi
mov rdi, [rdi+18h]
mov r8, [rbx+28h]
sub r8, rcx
mov rsi, [rcx+8]
lea rcx, [r8+rdi]
add rcx, 0FFFFFFFFFFFFFFE8h
mov [rbx+18h], rcx
mov rdi, rax
call _ZN6google8protobuf8internalL14AllocateMemoryEPKNS1_16AllocationPolicyEmm; google::protobuf::internal::AllocateMemory(google::protobuf::internal::AllocationPolicy const*,ulong,ulong)
add [rbx+20h], rdx
mov rcx, [rbx+8]
mov [rax], rcx
mov [rax+8], rdx
mov qword ptr [rax+10h], 0
mov [rbx+8], rax
lea rcx, [rax+18h]
mov [rbx+28h], rcx
add rax, rdx
mov [rbx+30h], rax
pop rbx
retn
| AllocateNewBlock:
PUSH RBX
MOV RAX,RDX
MOV RDX,RSI
MOV RBX,RDI
MOV RCX,qword ptr [RDI + 0x8]
MOV RSI,qword ptr [RDI + 0x30]
MOV qword ptr [RCX + 0x10],RSI
MOV RDI,qword ptr [RDI + 0x18]
MOV R8,qword ptr [RBX + 0x28]
SUB R8,RCX
MOV RSI,qword ptr [RCX + 0x8]
LEA RCX,[R8 + RDI*0x1]
ADD RCX,-0x18
MOV qword ptr [RBX + 0x18],RCX
MOV RDI,RAX
CALL 0x001778fc
ADD qword ptr [RBX + 0x20],RDX
MOV RCX,qword ptr [RBX + 0x8]
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],RDX
MOV qword ptr [RAX + 0x10],0x0
MOV qword ptr [RBX + 0x8],RAX
LEA RCX,[RAX + 0x18]
MOV qword ptr [RBX + 0x28],RCX
ADD RAX,RDX
MOV qword ptr [RBX + 0x30],RAX
POP RBX
RET
|
/* google::protobuf::internal::SerialArena::AllocateNewBlock(unsigned long,
google::protobuf::internal::AllocationPolicy const*) */
void __thiscall
google::protobuf::internal::SerialArena::AllocateNewBlock
(SerialArena *this,ulong param_1,AllocationPolicy *param_2)
{
ulong uVar1;
int8 *puVar2;
long lVar3;
int1 auVar4 [16];
lVar3 = *(long *)(this + 8);
*(int8 *)(lVar3 + 0x10) = *(int8 *)(this + 0x30);
uVar1 = *(ulong *)(lVar3 + 8);
*(long *)(this + 0x18) = (*(long *)(this + 0x28) - lVar3) + *(long *)(this + 0x18) + -0x18;
auVar4 = AllocateMemory(param_2,uVar1,param_1);
lVar3 = auVar4._8_8_;
puVar2 = auVar4._0_8_;
*(long *)(this + 0x20) = *(long *)(this + 0x20) + lVar3;
*puVar2 = *(int8 *)(this + 8);
puVar2[1] = lVar3;
puVar2[2] = 0;
*(int8 **)(this + 8) = puVar2;
*(int8 **)(this + 0x28) = puVar2 + 3;
*(long *)(this + 0x30) = (long)puVar2 + lVar3;
return;
}
| ||
29,234 | copy_key | eloqsql/storage/myisam/mi_test2.c | static void copy_key(MI_INFO *info,uint inx,uchar *rec,uchar *key_buff)
{
HA_KEYSEG *keyseg;
for (keyseg=info->s->keyinfo[inx].seg ; keyseg->type ; keyseg++)
{
memcpy(key_buff,rec+keyseg->start,(size_t) keyseg->length);
key_buff+=keyseg->length;
}
return;
} | O3 | c | copy_key:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %eax
imulq $0x70, %rax, %rax
movq 0x28(%rdi,%rax), %r15
cmpb $0x0, 0x18(%r15)
je 0x2d4e8
movq %rcx, %rbx
movq %rdx, %r14
addq $0x8, %r15
movl (%r15), %esi
addq %r14, %rsi
movzwl 0xc(%r15), %edx
movq %rbx, %rdi
callq 0x282c0
movzwl 0xc(%r15), %eax
addq %rax, %rbx
cmpb $0x0, 0x30(%r15)
leaq 0x20(%r15), %r15
jne 0x2d4c2
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| copy_key:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov eax, esi
imul rax, 70h ; 'p'
mov r15, [rdi+rax+28h]
cmp byte ptr [r15+18h], 0
jz short loc_2D4E8
mov rbx, rcx
mov r14, rdx
add r15, 8
loc_2D4C2:
mov esi, [r15]
add rsi, r14
movzx edx, word ptr [r15+0Ch]
mov rdi, rbx
call _memcpy
movzx eax, word ptr [r15+0Ch]
add rbx, rax
cmp byte ptr [r15+30h], 0
lea r15, [r15+20h]
jnz short loc_2D4C2
loc_2D4E8:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long copy_key(long long a1, unsigned int a2, long long a3, long long a4)
{
long long result; // rax
long long v5; // r15
unsigned int *v8; // r15
bool v9; // zf
result = 112LL * a2;
v5 = *(_QWORD *)(a1 + result + 40);
if ( *(_BYTE *)(v5 + 24) )
{
v8 = (unsigned int *)(v5 + 8);
do
{
memcpy(a4, a3 + *v8, *((unsigned __int16 *)v8 + 6));
result = *((unsigned __int16 *)v8 + 6);
a4 += result;
v9 = *((_BYTE *)v8 + 48) == 0;
v8 += 8;
}
while ( !v9 );
}
return result;
}
| copy_key:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EAX,ESI
IMUL RAX,RAX,0x70
MOV R15,qword ptr [RDI + RAX*0x1 + 0x28]
CMP byte ptr [R15 + 0x18],0x0
JZ 0x0012d4e8
MOV RBX,RCX
MOV R14,RDX
ADD R15,0x8
LAB_0012d4c2:
MOV ESI,dword ptr [R15]
ADD RSI,R14
MOVZX EDX,word ptr [R15 + 0xc]
MOV RDI,RBX
CALL 0x001282c0
MOVZX EAX,word ptr [R15 + 0xc]
ADD RBX,RAX
CMP byte ptr [R15 + 0x30],0x0
LEA R15,[R15 + 0x20]
JNZ 0x0012d4c2
LAB_0012d4e8:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void copy_key(long param_1,ulong param_2,long param_3,void *param_4)
{
uint *puVar1;
long lVar2;
uint *puVar3;
lVar2 = *(long *)(param_1 + 0x28 + (param_2 & 0xffffffff) * 0x70);
if (*(char *)(lVar2 + 0x18) != '\0') {
puVar3 = (uint *)(lVar2 + 8);
do {
memcpy(param_4,(void *)((ulong)*puVar3 + param_3),(ulong)(ushort)puVar3[3]);
param_4 = (void *)((long)param_4 + (ulong)(ushort)puVar3[3]);
puVar1 = puVar3 + 0xc;
puVar3 = puVar3 + 8;
} while ((char)*puVar1 != '\0');
}
return;
}
| |
29,235 | parts_get_int | navaro[P]qoraal-tictactoe/build_O3/_deps/qoraal_engine-src/src/parts/parts.c | int32_t
parts_get_int(PENGINE_T instance, uint32_t parm, uint32_t flags, int32_t min, int32_t max)
{
int32_t value = 0 ;
#if defined CFG_ENGINE_REGISTRY_ENABLE
if (flags & PART_ACTION_FLAG_INDEXED) {
const char * str = engine_get_string (instance, parm, 0) ;
if (str) {
registry_int32_get (str, &value) ;
}
}
else
#endif
if (flags & PART_ACTION_FLAG_VARIABLE) {
value = parm ;
}
else {
value = (int16_t) parm ;
}
if ((int32_t)value > max) value = max ;
else if ((int32_t)value < min) value = min ;
return (int32_t)value ;
} | O3 | c | parts_get_int:
pushq %rbp
movq %rsp, %rbp
testb $0x10, %dl
movswl %si, %edx
cmovnel %esi, %edx
movl %ecx, %eax
cmpl %ecx, %edx
cmovgl %edx, %eax
cmpl %r8d, %edx
cmovgl %r8d, %eax
popq %rbp
retq
nop
| parts_get_int:
push rbp
mov rbp, rsp
test dl, 10h
movsx edx, si
cmovnz edx, esi
mov eax, ecx
cmp edx, ecx
cmovg eax, edx
cmp edx, r8d
cmovg eax, r8d
pop rbp
retn
| long long parts_get_int(long long a1, int a2, char a3, unsigned int a4, unsigned int a5)
{
bool v5; // zf
signed int v6; // edx
long long result; // rax
v5 = (a3 & 0x10) == 0;
v6 = (__int16)a2;
if ( !v5 )
v6 = a2;
result = a4;
if ( v6 > (int)a4 )
result = (unsigned int)v6;
if ( v6 > (int)a5 )
return a5;
return result;
}
| parts_get_int:
PUSH RBP
MOV RBP,RSP
TEST DL,0x10
MOVSX EDX,SI
CMOVNZ EDX,ESI
MOV EAX,ECX
CMP EDX,ECX
CMOVG EAX,EDX
CMP EDX,R8D
CMOVG EAX,R8D
POP RBP
RET
|
int parts_get_int(int8 param_1,int param_2,ulong param_3,int param_4,int param_5)
{
int iVar1;
iVar1 = (int)(short)param_2;
if ((param_3 & 0x10) != 0) {
iVar1 = param_2;
}
if (param_4 < iVar1) {
param_4 = iVar1;
}
if (param_5 < iVar1) {
param_4 = param_5;
}
return param_4;
}
| |
29,236 | parse_prefixed_json_tool_call_array(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long) | llama.cpp/common/chat.cpp | static common_chat_msg parse_prefixed_json_tool_call_array(const std::string& input, const std::string & prefix, size_t rstrip_prefix = 0) {
auto content_end = input.find(prefix);
size_t tc_start = std::string::npos;
common_chat_msg result;
result.role = "assistant";
if (content_end == std::string::npos) {
result.content = input;
} else {
tc_start = content_end + prefix.size() - rstrip_prefix;
result.content = input.substr(0, content_end);
auto tool_calls = json::parse(input.substr(tc_start));
for (const auto & tool_call : tool_calls) {
result.tool_calls.emplace_back(process_tool_call(tool_call));
}
}
return result;
} | O3 | cpp | parse_prefixed_json_tool_call_array(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbp
movq (%rdx), %rsi
movq 0x8(%rdx), %rcx
xorl %ebx, %ebx
movq %r14, %rdi
xorl %edx, %edx
callq 0x23790
movq %rax, %r15
leaq 0x10(%rbp), %rax
movq %rax, (%rbp)
movq %rbx, 0x8(%rbp)
movb %bl, 0x10(%rbp)
leaq 0x30(%rbp), %rax
movq %rax, 0x20(%rbp)
movq %rbx, 0x28(%rbp)
movb %bl, 0x30(%rbp)
leaq 0x80(%rbp), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbp)
movups %xmm0, 0x50(%rbp)
movups %xmm0, 0x60(%rbp)
movq %rax, 0x70(%rbp)
movq %rbx, 0x78(%rbp)
movb %bl, 0x80(%rbp)
leaq 0xa0(%rbp), %rax
movq %rax, 0x90(%rbp)
movq %rbx, 0x98(%rbp)
movb %bl, 0xa0(%rbp)
leaq 0xc0(%rbp), %rax
movq %rax, 0xb0(%rbp)
movq %rbx, 0xb8(%rbp)
movb %bl, 0xc0(%rbp)
movq %rbp, %rbx
leaq 0x75826(%rip), %rcx # 0x1462f2
movl $0x9, %r8d
movq %rbp, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x23b30
leaq 0x20(%rbx), %rbp
cmpq $-0x1, %r15
je 0xd0cb3
movq %rbx, 0x8(%rsp)
movq 0x8(%r13), %rbx
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0x24710
subq %r12, %r15
addq %rbx, %r15
leaq 0x10(%rsp), %r12
movq %rbp, %rdi
movq %r12, %rsi
callq 0x23ba0
movq (%r12), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xd0b38
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x231f0
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq $-0x1, %rcx
callq 0x24710
xorps %xmm0, %xmm0
leaq 0x80(%rsp), %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
leaq 0x70(%rsp), %r12
leaq 0x10(%rsp), %rsi
movq %r12, %rdi
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0xdbe36
movq 0x90(%rsp), %rax
testq %rax, %rax
je 0xd0b9a
leaq 0x80(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xd0bb6
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x231f0
leaq 0xc8(%rsp), %r14
movq %r12, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
movabsq $-0x8000000000000000, %rbx # imm = 0x8000000000000000
movq %rbx, 0x18(%r14)
movq %r14, %rdi
callq 0xaf6e6
leaq 0xa8(%rsp), %r15
movq %r12, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15)
movq %rbx, 0x18(%r15)
movq %r15, %rdi
callq 0xafa38
movq 0x8(%rsp), %rax
leaq 0x58(%rax), %r12
leaq 0x60(%rsp), %rbp
leaq 0x40(%rsp), %rbx
leaq 0x10(%rsp), %r13
movq %r14, %rdi
movq %r15, %rsi
callq 0xaf758
testb %al, %al
jne 0xd0c9a
movq %r14, %rdi
callq 0xdb564
movq %r13, %rdi
movq %rax, %rsi
callq 0xd0d67
movq %r12, %rdi
movq %r13, %rsi
callq 0xf42c6
movq 0x50(%rsp), %rdi
cmpq %rbp, %rdi
je 0xd0c5a
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x231f0
movq 0x30(%rsp), %rdi
cmpq %rbx, %rdi
je 0xd0c71
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x231f0
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xd0c8d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x231f0
movq %r14, %rdi
callq 0xaec90
jmp 0xd0c16
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xaa5c4
movq %rbx, %rdi
callq 0xaecde
jmp 0xd0cbe
movq %rbp, %rdi
movq %r14, %rsi
callq 0x249b0
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd0d12
movq %rax, %r14
movq 0x90(%rsp), %rax
testq %rax, %rax
je 0xd0cf4
leaq 0x80(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xd0d55
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x231f0
jmp 0xd0d55
movq %rax, %rdi
callq 0x2c93b
jmp 0xd0d23
jmp 0xd0d23
movq %rbx, 0x8(%rsp)
movq %rax, %r14
jmp 0xd0d55
jmp 0xd0d3b
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0xd5f4c
jmp 0xd0d3e
jmp 0xd0d3b
movq %rax, %r14
leaq 0x70(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0xaa5c4
movq %r15, %rdi
callq 0xaecde
movq 0x8(%rsp), %rdi
callq 0xd6416
movq %r14, %rdi
callq 0x23ee0
| _ZL35parse_prefixed_json_tool_call_arrayRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_m:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0E8h
mov r12, rcx
mov r13, rdx
mov r14, rsi
mov rbp, rdi
mov rsi, [rdx]
mov rcx, [rdx+8]
xor ebx, ebx
mov rdi, r14
xor edx, edx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEPKcmm; std::string::find(char const*,ulong,ulong)
mov r15, rax
lea rax, [rbp+10h]
mov [rbp+0], rax
mov [rbp+8], rbx
mov [rbp+10h], bl
lea rax, [rbp+30h]
mov [rbp+20h], rax
mov [rbp+28h], rbx
mov [rbp+30h], bl
lea rax, [rbp+80h]
xorps xmm0, xmm0
movups xmmword ptr [rbp+40h], xmm0
movups xmmword ptr [rbp+50h], xmm0
movups xmmword ptr [rbp+60h], xmm0
mov [rbp+70h], rax
mov [rbp+78h], rbx
mov [rbp+80h], bl
lea rax, [rbp+0A0h]
mov [rbp+90h], rax
mov [rbp+98h], rbx
mov [rbp+0A0h], bl
lea rax, [rbp+0C0h]
mov [rbp+0B0h], rax
mov [rbp+0B8h], rbx
mov [rbp+0C0h], bl
mov rbx, rbp
lea rcx, aYouAreAHelpful+12h; "assistant"
mov r8d, 9
mov rdi, rbp
xor esi, esi
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
lea rbp, [rbx+20h]
cmp r15, 0FFFFFFFFFFFFFFFFh
jz loc_D0CB3
mov [rsp+118h+var_110], rbx
mov rbx, [r13+8]
lea rdi, [rsp+118h+var_108]
mov rsi, r14
xor edx, edx
mov rcx, r15
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
sub r15, r12
add r15, rbx
lea r12, [rsp+118h+var_108]
mov rdi, rbp
mov rsi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [r12]; void *
lea rax, [rsp+118h+var_F8]
cmp rdi, rax
jz short loc_D0B38
mov rsi, [rsp+118h+var_F8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_D0B38:
lea rdi, [rsp+118h+var_108]
mov rsi, r14
mov rdx, r15
mov rcx, 0FFFFFFFFFFFFFFFFh
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
xorps xmm0, xmm0
lea rdx, [rsp+118h+var_98]
movaps xmmword ptr [rdx+10h], xmm0
movaps xmmword ptr [rdx], xmm0
lea r12, [rsp+118h+var_A8]
lea rsi, [rsp+118h+var_108]
mov rdi, r12
mov ecx, 1
xor r8d, r8d
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5parseIS9_EESD_OT_St8functionIFbiNS0_6detail13parse_event_tERSD_EEbb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::parse<std::string>(std::string &&,std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&)>,bool,bool)
mov rax, [rsp+118h+var_88]
test rax, rax
jz short loc_D0B9A
lea rdi, [rsp+118h+var_98]
mov rsi, rdi
mov edx, 3
call rax
loc_D0B9A:
mov rdi, [rsp+118h+var_108]; void *
lea rax, [rsp+118h+var_F8]
cmp rdi, rax
jz short loc_D0BB6
mov rsi, [rsp+118h+var_F8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_D0BB6:
lea r14, [rsp+118h+var_50]
mov [r14], r12
xorps xmm0, xmm0
movups xmmword ptr [r14+8], xmm0
mov rbx, 8000000000000000h
mov [r14+18h], rbx
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE9set_beginEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::set_begin(void)
lea r15, [rsp+118h+var_70]
mov [r15], r12
xorps xmm0, xmm0
movups xmmword ptr [r15+8], xmm0
mov [r15+18h], rbx
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE7set_endEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::set_end(void)
mov rax, [rsp+118h+var_110]
lea r12, [rax+58h]
lea rbp, [rsp+118h+var_B8]
lea rbx, [rsp+118h+var_D8]
lea r13, [rsp+118h+var_108]
loc_D0C16:
mov rdi, r14
mov rsi, r15
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISG_TnNSt9enable_ifIXoosr3std7is_sameIT_SG_EE5valuesr3std7is_sameISJ_NS2_IKSF_EEEE5valueEDnE4typeELDn0EEEbRKSJ_
test al, al
jnz short loc_D0C9A
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEdeEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::operator*(void)
mov rdi, r13
mov rsi, rax
call _ZL17process_tool_callRKN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEE; process_tool_call(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&)
mov rdi, r12
mov rsi, r13
call _ZNSt6vectorI21common_chat_tool_callSaIS0_EE12emplace_backIJS0_EEERS0_DpOT_; std::vector<common_chat_tool_call>::emplace_back<common_chat_tool_call>(common_chat_tool_call &&)
mov rdi, [rsp+118h+var_C8]; void *
cmp rdi, rbp
jz short loc_D0C5A
mov rsi, [rsp+118h+var_B8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_D0C5A:
mov rdi, [rsp+118h+var_E8]; void *
cmp rdi, rbx
jz short loc_D0C71
mov rsi, [rsp+118h+var_D8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_D0C71:
mov rdi, [rsp+118h+var_108]; void *
lea rax, [rsp+118h+var_F8]
cmp rdi, rax
jz short loc_D0C8D
mov rsi, [rsp+118h+var_F8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_D0C8D:
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEppEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::operator++(void)
jmp loc_D0C16
loc_D0C9A:
lea rbx, [rsp+118h+var_A8]
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp short loc_D0CBE
loc_D0CB3:
mov rdi, rbp
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_assignERKS4_; std::string::_M_assign(std::string const&)
loc_D0CBE:
add rsp, 0E8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_D0D12
mov r14, rax
mov rax, [rsp+118h+var_88]
test rax, rax
jz short loc_D0CF4
lea rdi, [rsp+118h+var_98]
mov rsi, rdi
mov edx, 3
call rax
loc_D0CF4:
mov rdi, [rsp+118h+var_108]; void *
lea rax, [rsp+118h+var_F8]
cmp rdi, rax
jz short loc_D0D55
mov rsi, [rsp+118h+var_F8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_D0D55
loc_D0D12:
mov rdi, rax
call __clang_call_terminate
jmp short loc_D0D23
jmp short loc_D0D23
mov [rsp+118h+var_110], rbx
loc_D0D23:
mov r14, rax
jmp short loc_D0D55
jmp short loc_D0D3B
mov r14, rax
lea rdi, [rsp+118h+var_108]; this
call _ZN21common_chat_tool_callD2Ev; common_chat_tool_call::~common_chat_tool_call()
jmp short loc_D0D3E
jmp short $+2
loc_D0D3B:
mov r14, rax
loc_D0D3E:
lea r15, [rsp+118h+var_A8]
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_D0D55:
mov rdi, [rsp+118h+var_110]; this
call _ZN15common_chat_msgD2Ev; common_chat_msg::~common_chat_msg()
mov rdi, r14
call __Unwind_Resume
| long long parse_prefixed_json_tool_call_array(long long a1, long long a2, _QWORD *a3, long long a4)
{
long long v6; // r15
long long v7; // rbx
long long v8; // r15
long long v9; // rax
void *v11[2]; // [rsp+10h] [rbp-108h] BYREF
_QWORD v12[2]; // [rsp+20h] [rbp-F8h] BYREF
void *v13; // [rsp+30h] [rbp-E8h]
long long v14; // [rsp+40h] [rbp-D8h] BYREF
void *v15; // [rsp+50h] [rbp-C8h]
long long v16; // [rsp+60h] [rbp-B8h] BYREF
char v17[16]; // [rsp+70h] [rbp-A8h] BYREF
__int128 v18; // [rsp+80h] [rbp-98h] BYREF
__int128 v19; // [rsp+90h] [rbp-88h]
char *v20; // [rsp+A8h] [rbp-70h] BYREF
__int128 v21; // [rsp+B0h] [rbp-68h]
unsigned long long v22; // [rsp+C0h] [rbp-58h]
char *v23; // [rsp+C8h] [rbp-50h] BYREF
__int128 v24; // [rsp+D0h] [rbp-48h]
unsigned long long v25; // [rsp+E0h] [rbp-38h]
v6 = std::string::find(a2, *a3, 0LL, a3[1]);
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
*(_QWORD *)(a1 + 32) = a1 + 48;
*(_QWORD *)(a1 + 40) = 0LL;
*(_BYTE *)(a1 + 48) = 0;
*(_OWORD *)(a1 + 64) = 0LL;
*(_OWORD *)(a1 + 80) = 0LL;
*(_OWORD *)(a1 + 96) = 0LL;
*(_QWORD *)(a1 + 112) = a1 + 128;
*(_QWORD *)(a1 + 120) = 0LL;
*(_BYTE *)(a1 + 128) = 0;
*(_QWORD *)(a1 + 144) = a1 + 160;
*(_QWORD *)(a1 + 152) = 0LL;
*(_BYTE *)(a1 + 160) = 0;
*(_QWORD *)(a1 + 176) = a1 + 192;
*(_QWORD *)(a1 + 184) = 0LL;
*(_BYTE *)(a1 + 192) = 0;
std::string::_M_replace(a1, 0LL, 0LL, "assistant", 9LL);
if ( v6 == -1 )
return std::string::_M_assign(a1 + 32, a2);
v7 = a3[1];
std::string::substr(v11, a2, 0LL, v6);
v8 = v7 + v6 - a4;
std::string::operator=(a1 + 32, v11);
if ( v11[0] != v12 )
operator delete(v11[0], v12[0] + 1LL);
std::string::substr(v11, a2, v8, -1LL);
v19 = 0LL;
v18 = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::parse<std::string>(
v17,
v11,
&v18,
1LL,
0LL);
if ( (_QWORD)v19 )
((void ( *)(__int128 *, __int128 *, long long))v19)(&v18, &v18, 3LL);
if ( v11[0] != v12 )
operator delete(v11[0], v12[0] + 1LL);
v23 = v17;
v24 = 0LL;
v25 = 0x8000000000000000LL;
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>>::set_begin((unsigned __int8 **)&v23);
v20 = v17;
v21 = 0LL;
v22 = 0x8000000000000000LL;
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>>::set_end((unsigned __int8 **)&v20);
while ( !(unsigned __int8)ZNK8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISG_TnNSt9enable_ifIXoosr3std7is_sameIT_SG_EE5valuesr3std7is_sameISJ_NS2_IKSF_EEEE5valueEDnE4typeELDn0EEEbRKSJ_(
&v23,
&v20) )
{
v9 = 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*(&v23);
process_tool_call(v11, v9);
std::vector<common_chat_tool_call>::emplace_back<common_chat_tool_call>(a1 + 88, v11);
if ( v15 != &v16 )
operator delete(v15, v16 + 1);
if ( v13 != &v14 )
operator delete(v13, v14 + 1);
if ( v11[0] != v12 )
operator delete(v11[0], v12[0] + 1LL);
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++((unsigned __int8 **)&v23);
}
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v17);
return nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v17);
}
| parse_prefixed_json_tool_call_array:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xe8
MOV R12,RCX
MOV R13,RDX
MOV R14,RSI
MOV RBP,RDI
MOV RSI,qword ptr [RDX]
MOV RCX,qword ptr [RDX + 0x8]
XOR EBX,EBX
MOV RDI,R14
XOR EDX,EDX
CALL 0x00123790
MOV R15,RAX
LEA RAX,[RBP + 0x10]
MOV qword ptr [RBP],RAX
MOV qword ptr [RBP + 0x8],RBX
MOV byte ptr [RBP + 0x10],BL
LEA RAX,[RBP + 0x30]
MOV qword ptr [RBP + 0x20],RAX
MOV qword ptr [RBP + 0x28],RBX
MOV byte ptr [RBP + 0x30],BL
LEA RAX,[RBP + 0x80]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBP + 0x40],XMM0
MOVUPS xmmword ptr [RBP + 0x50],XMM0
MOVUPS xmmword ptr [RBP + 0x60],XMM0
MOV qword ptr [RBP + 0x70],RAX
MOV qword ptr [RBP + 0x78],RBX
MOV byte ptr [RBP + 0x80],BL
LEA RAX,[RBP + 0xa0]
MOV qword ptr [RBP + 0x90],RAX
MOV qword ptr [RBP + 0x98],RBX
MOV byte ptr [RBP + 0xa0],BL
LEA RAX,[RBP + 0xc0]
MOV qword ptr [RBP + 0xb0],RAX
MOV qword ptr [RBP + 0xb8],RBX
MOV byte ptr [RBP + 0xc0],BL
MOV RBX,RBP
LAB_001d0ac5:
LEA RCX,[0x2462f2]
MOV R8D,0x9
MOV RDI,RBP
XOR ESI,ESI
XOR EDX,EDX
CALL 0x00123b30
LEA RBP,[RBX + 0x20]
CMP R15,-0x1
JZ 0x001d0cb3
MOV qword ptr [RSP + 0x8],RBX
MOV RBX,qword ptr [R13 + 0x8]
LAB_001d0af5:
LEA RDI,[RSP + 0x10]
MOV RSI,R14
XOR EDX,EDX
MOV RCX,R15
CALL 0x00124710
SUB R15,R12
ADD R15,RBX
LEA R12,[RSP + 0x10]
MOV RDI,RBP
MOV RSI,R12
CALL 0x00123ba0
MOV RDI,qword ptr [R12]
LEA RAX,[RSP + 0x20]
CMP RDI,RAX
JZ 0x001d0b38
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
CALL 0x001231f0
LAB_001d0b38:
LEA RDI,[RSP + 0x10]
MOV RSI,R14
MOV RDX,R15
MOV RCX,-0x1
CALL 0x00124710
XORPS XMM0,XMM0
LEA RDX,[RSP + 0x80]
MOVAPS xmmword ptr [RDX + 0x10],XMM0
MOVAPS xmmword ptr [RDX],XMM0
LAB_001d0b61:
LEA R12,[RSP + 0x70]
LEA RSI,[RSP + 0x10]
MOV RDI,R12
MOV ECX,0x1
XOR R8D,R8D
CALL 0x001dbe36
MOV RAX,qword ptr [RSP + 0x90]
TEST RAX,RAX
JZ 0x001d0b9a
LAB_001d0b88:
LEA RDI,[RSP + 0x80]
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_001d0b9a:
MOV RDI,qword ptr [RSP + 0x10]
LEA RAX,[RSP + 0x20]
CMP RDI,RAX
JZ 0x001d0bb6
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
CALL 0x001231f0
LAB_001d0bb6:
LEA R14,[RSP + 0xc8]
MOV qword ptr [R14],R12
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x8],XMM0
MOV RBX,-0x8000000000000000
MOV qword ptr [R14 + 0x18],RBX
MOV RDI,R14
CALL 0x001af6e6
LEA R15,[RSP + 0xa8]
MOV qword ptr [R15],R12
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R15 + 0x8],XMM0
MOV qword ptr [R15 + 0x18],RBX
MOV RDI,R15
CALL 0x001afa38
MOV RAX,qword ptr [RSP + 0x8]
LEA R12,[RAX + 0x58]
LEA RBP,[RSP + 0x60]
LEA RBX,[RSP + 0x40]
LEA R13,[RSP + 0x10]
LAB_001d0c16:
MOV RDI,R14
MOV RSI,R15
CALL 0x001af758
TEST AL,AL
JNZ 0x001d0c9a
LAB_001d0c25:
MOV RDI,R14
CALL 0x001db564
LAB_001d0c2d:
MOV RDI,R13
MOV RSI,RAX
CALL 0x001d0d67
LAB_001d0c38:
MOV RDI,R12
MOV RSI,R13
CALL 0x001f42c6
MOV RDI,qword ptr [RSP + 0x50]
CMP RDI,RBP
JZ 0x001d0c5a
MOV RSI,qword ptr [RSP + 0x60]
INC RSI
CALL 0x001231f0
LAB_001d0c5a:
MOV RDI,qword ptr [RSP + 0x30]
CMP RDI,RBX
JZ 0x001d0c71
MOV RSI,qword ptr [RSP + 0x40]
INC RSI
CALL 0x001231f0
LAB_001d0c71:
MOV RDI,qword ptr [RSP + 0x10]
LEA RAX,[RSP + 0x20]
CMP RDI,RAX
JZ 0x001d0c8d
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
CALL 0x001231f0
LAB_001d0c8d:
MOV RDI,R14
CALL 0x001aec90
JMP 0x001d0c16
LAB_001d0c9a:
LEA RBX,[RSP + 0x70]
MOV RDI,RBX
XOR ESI,ESI
CALL 0x001aa5c4
MOV RDI,RBX
CALL 0x001aecde
JMP 0x001d0cbe
LAB_001d0cb3:
MOV RDI,RBP
MOV RSI,R14
CALL 0x001249b0
LAB_001d0cbe:
ADD RSP,0xe8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* parse_prefixed_json_tool_call_array(std::__cxx11::string const&, std::__cxx11::string const&,
unsigned long) */
void parse_prefixed_json_tool_call_array(string *param_1,string *param_2,ulong param_3)
{
char cVar1;
long lVar2;
long *local_108 [2];
long local_f8 [2];
long *local_e8;
long local_d8 [2];
long *local_c8;
long local_b8 [2];
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_a8 [16];
int8 local_98;
int8 uStack_90;
code *local_88;
int8 uStack_80;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*local_70;
int8 local_68;
int8 uStack_60;
int8 local_58;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*local_50;
int8 local_48;
int8 uStack_40;
int8 local_38;
lVar2 = std::__cxx11::string::find((char *)param_2,*(ulong *)param_3,0);
*(string **)param_1 = param_1 + 0x10;
*(int8 *)(param_1 + 8) = 0;
param_1[0x10] = (string)0x0;
*(string **)(param_1 + 0x20) = param_1 + 0x30;
*(int8 *)(param_1 + 0x28) = 0;
param_1[0x30] = (string)0x0;
*(int8 *)(param_1 + 0x40) = 0;
*(int8 *)(param_1 + 0x48) = 0;
*(int8 *)(param_1 + 0x50) = 0;
*(int8 *)(param_1 + 0x58) = 0;
*(int8 *)(param_1 + 0x60) = 0;
*(int8 *)(param_1 + 0x68) = 0;
*(string **)(param_1 + 0x70) = param_1 + 0x80;
*(int8 *)(param_1 + 0x78) = 0;
param_1[0x80] = (string)0x0;
*(string **)(param_1 + 0x90) = param_1 + 0xa0;
*(int8 *)(param_1 + 0x98) = 0;
param_1[0xa0] = (string)0x0;
*(string **)(param_1 + 0xb0) = param_1 + 0xc0;
*(int8 *)(param_1 + 0xb8) = 0;
param_1[0xc0] = (string)0x0;
/* try { // try from 001d0ac5 to 001d0add has its CatchHandler @ 001d0d1e */
std::__cxx11::string::_M_replace((ulong)param_1,0,(char *)0x0,0x2462f2);
if (lVar2 == -1) {
/* try { // try from 001d0cb3 to 001d0cbd has its CatchHandler @ 001d0d1e */
std::__cxx11::string::_M_assign(param_1 + 0x20);
}
else {
/* try { // try from 001d0af5 to 001d0b06 has its CatchHandler @ 001d0d1c */
std::__cxx11::string::substr((ulong)local_108,(ulong)param_2);
std::__cxx11::string::operator=(param_1 + 0x20,(string *)local_108);
if (local_108[0] != local_f8) {
operator_delete(local_108[0],local_f8[0] + 1);
}
/* try { // try from 001d0b38 to 001d0b4e has its CatchHandler @ 001d0d1a */
std::__cxx11::string::substr((ulong)local_108,(ulong)param_2);
local_88 = (code *)0x0;
uStack_80 = 0;
local_98 = 0;
uStack_90 = 0;
/* try { // try from 001d0b61 to 001d0b7a has its CatchHandler @ 001d0cd2 */
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::parse<std::__cxx11::string>(local_a8,local_108,&local_98,1,0);
if (local_88 != (code *)0x0) {
/* try { // try from 001d0b88 to 001d0b99 has its CatchHandler @ 001d0cd0 */
(*local_88)(&local_98,&local_98,3);
}
if (local_108[0] != local_f8) {
operator_delete(local_108[0],local_f8[0] + 1);
}
local_48 = 0;
uStack_40 = 0;
local_38 = 0x8000000000000000;
local_50 = local_a8;
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>>
::set_begin((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>>
*)&local_50);
local_68 = 0;
uStack_60 = 0;
local_58 = 0x8000000000000000;
local_70 = local_a8;
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>>
::set_end((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>>
*)&local_70);
while( true ) {
/* try { // try from 001d0c16 to 001d0c20 has its CatchHandler @ 001d0d3b */
cVar1 = _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISG_TnNSt9enable_ifIXoosr3std7is_sameIT_SG_EE5valuesr3std7is_sameISJ_NS2_IKSF_EEEE5valueEDnE4typeELDn0EEEbRKSJ_
((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>>
*)&local_50,
(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>>
*)&local_70);
if (cVar1 != '\0') break;
/* try { // try from 001d0c25 to 001d0c2c has its CatchHandler @ 001d0d39 */
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>>
*)&local_50);
/* try { // try from 001d0c2d to 001d0c37 has its CatchHandler @ 001d0d28 */
process_tool_call((basic_json *)local_108);
/* try { // try from 001d0c38 to 001d0c42 has its CatchHandler @ 001d0d2a */
std::vector<common_chat_tool_call,std::allocator<common_chat_tool_call>>::
emplace_back<common_chat_tool_call>
((vector<common_chat_tool_call,std::allocator<common_chat_tool_call>> *)
(param_1 + 0x58),(common_chat_tool_call *)local_108);
if (local_c8 != local_b8) {
operator_delete(local_c8,local_b8[0] + 1);
}
if (local_e8 != local_d8) {
operator_delete(local_e8,local_d8[0] + 1);
}
if (local_108[0] != local_f8) {
operator_delete(local_108[0],local_f8[0] + 1);
}
/* try { // try from 001d0c8d to 001d0c94 has its CatchHandler @ 001d0d3b */
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>>
*)&local_50);
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81((data *)local_a8,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)local_a8);
}
return;
}
| |
29,237 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::json_value::json_value(nlohmann::json_abi_v3_11_3::detail::value_t) | monkey531[P]llama/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;
}
}
} | O1 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::json_value::json_value(nlohmann::json_abi_v3_11_3::detail::value_t):
pushq %rbx
movq %rdi, %rbx
cmpl $0x8, %esi
ja 0x58759
movl %esi, %eax
leaq 0x91c70(%rip), %rcx # 0xea3c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x0, (%rbx)
jmp 0x587b1
movl $0x20, %edi
jmp 0x58773
movb $0x0, (%rbx)
jmp 0x587b1
movl $0x18, %edi
callq 0x1b8a0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
jmp 0x587ae
leaq 0x9719d(%rip), %rdi # 0xef92c
callq 0x587b4
jmp 0x587ae
movl $0x28, %edi
callq 0x1b8a0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movb $0x0, 0x20(%rax)
movq %rax, (%rbx)
popq %rbx
retq
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10json_valueC2ENS0_6detail7value_tE:
push rbx
mov rbx, rdi
cmp esi, 8; switch 9 cases
ja short def_58757; jumptable 0000000000058757 default case, cases 0,5-7
mov eax, esi
lea rcx, jpt_58757
movsxd rax, ds:(jpt_58757 - 0EA3C0h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
def_58757:
mov qword ptr [rbx], 0; jumptable 0000000000058757 default case, cases 0,5-7
jmp short loc_587B1
loc_58762:
mov edi, 20h ; ' '; jumptable 0000000000058757 case 1
jmp short loc_58773
loc_58769:
mov byte ptr [rbx], 0; jumptable 0000000000058757 case 4
jmp short loc_587B1
loc_5876E:
mov edi, 18h; jumptable 0000000000058757 case 2
loc_58773:
call __Znwm; operator new(ulong)
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
mov qword ptr [rax+10h], 0
jmp short loc_587AE
loc_58788:
lea rdi, aErrorWhileHand_0+34h; jumptable 0000000000058757 case 3
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createIS9_JRA1_KcEEEPT_DpOT0_; 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>::create<std::string,char const(&)[1]>(char const(&)[1] &&)
jmp short loc_587AE
loc_58796:
mov edi, 28h ; '('; jumptable 0000000000058757 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_587AE:
mov [rbx], rax
loc_587B1:
pop rbx
retn
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::json_value::json_value(
_BYTE *a1,
unsigned int a2)
{
long long result; // rax
unsigned long long v4; // rdi
result = a2;
switch ( a2 )
{
case 1u:
v4 = 32LL;
goto LABEL_6;
case 2u:
v4 = 24LL;
LABEL_6:
result = operator new(v4);
*(_OWORD *)result = 0LL;
*(_QWORD *)(result + 16) = 0LL;
goto LABEL_9;
case 3u:
result = 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>::create<std::string,char const(&)[1]>("");
goto LABEL_9;
case 4u:
*a1 = 0;
return result;
case 8u:
result = operator new(0x28uLL);
*(_OWORD *)result = 0LL;
*(_OWORD *)(result + 16) = 0LL;
*(_BYTE *)(result + 32) = 0;
LABEL_9:
*(_QWORD *)a1 = result;
break;
default:
*(_QWORD *)a1 = 0LL;
break;
}
return result;
}
| json_value:
PUSH RBX
MOV RBX,RDI
CMP ESI,0x8
JA 0x00158759
MOV EAX,ESI
LEA RCX,[0x1ea3c0]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
MOV qword ptr [RBX],0x0
JMP 0x001587b1
caseD_1:
MOV EDI,0x20
JMP 0x00158773
caseD_4:
MOV byte ptr [RBX],0x0
JMP 0x001587b1
caseD_2:
MOV EDI,0x18
LAB_00158773:
CALL 0x0011b8a0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOV qword ptr [RAX + 0x10],0x0
JMP 0x001587ae
caseD_3:
LEA RDI,[0x1ef92c]
CALL 0x001587b4
JMP 0x001587ae
caseD_8:
MOV EDI,0x28
CALL 0x0011b8a0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOVUPS xmmword ptr [RAX + 0x10],XMM0
MOV byte ptr [RAX + 0x20],0x0
LAB_001587ae:
MOV qword ptr [RBX],RAX
LAB_001587b1:
POP RBX
RET
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::json_value::json_value(nlohmann::json_abi_v3_11_3::detail::value_t) */
void __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::json_value::json_value(json_value *this,int4 param_2)
{
string *psVar1;
ulong uVar2;
switch(param_2) {
default:
*(int8 *)this = 0;
return;
case 1:
uVar2 = 0x20;
break;
case 2:
uVar2 = 0x18;
break;
case 3:
psVar1 = create<std::__cxx11::string,char_const(&)[1]>("");
goto LAB_001587ae;
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;
goto LAB_001587ae;
}
psVar1 = (string *)operator_new(uVar2);
*(int8 *)psVar1 = 0;
*(int8 *)(psVar1 + 8) = 0;
*(int8 *)(psVar1 + 0x10) = 0;
LAB_001587ae:
*(string **)this = psVar1;
return;
}
| |
29,238 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::json_value::json_value(nlohmann::json_abi_v3_11_3::detail::value_t) | monkey531[P]llama/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<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::json_value::json_value(nlohmann::json_abi_v3_11_3::detail::value_t):
pushq %rbx
movq %rdi, %rbx
cmpl $0x8, %esi
ja 0x5916f
movl %esi, %eax
leaq 0x8f25a(%rip), %rcx # 0xe83c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x0, (%rbx)
jmp 0x591c7
movl $0x20, %edi
jmp 0x59189
movb $0x0, (%rbx)
jmp 0x591c7
movl $0x18, %edi
callq 0x1b8a0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
jmp 0x591c4
leaq 0x94787(%rip), %rdi # 0xed92c
callq 0x591ca
jmp 0x591c4
movl $0x28, %edi
callq 0x1b8a0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movb $0x0, 0x20(%rax)
movq %rax, (%rbx)
popq %rbx
retq
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10json_valueC2ENS0_6detail7value_tE:
push rbx
mov rbx, rdi
cmp esi, 8; switch 9 cases
ja short def_5916D; jumptable 000000000005916D default case, cases 0,5-7
mov eax, esi
lea rcx, jpt_5916D
movsxd rax, ds:(jpt_5916D - 0E83C0h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
def_5916D:
mov qword ptr [rbx], 0; jumptable 000000000005916D default case, cases 0,5-7
jmp short loc_591C7
loc_59178:
mov edi, 20h ; ' '; jumptable 000000000005916D case 1
jmp short loc_59189
loc_5917F:
mov byte ptr [rbx], 0; jumptable 000000000005916D case 4
jmp short loc_591C7
loc_59184:
mov edi, 18h; jumptable 000000000005916D case 2
loc_59189:
call __Znwm; operator new(ulong)
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
mov qword ptr [rax+10h], 0
jmp short loc_591C4
loc_5919E:
lea rdi, aErrorWhileHand_0+34h; jumptable 000000000005916D case 3
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createIS9_JRA1_KcEEEPT_DpOT0_; 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>::create<std::string,char const(&)[1]>(char const(&)[1] &&)
jmp short loc_591C4
loc_591AC:
mov edi, 28h ; '('; jumptable 000000000005916D 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_591C4:
mov [rbx], rax
loc_591C7:
pop rbx
retn
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::json_value::json_value(
_BYTE *a1,
unsigned int a2)
{
long long result; // rax
unsigned long long v4; // rdi
result = a2;
switch ( a2 )
{
case 1u:
v4 = 32LL;
goto LABEL_6;
case 2u:
v4 = 24LL;
LABEL_6:
result = operator new(v4);
*(_OWORD *)result = 0LL;
*(_QWORD *)(result + 16) = 0LL;
goto LABEL_9;
case 3u:
result = 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>::create<std::string,char const(&)[1]>("");
goto LABEL_9;
case 4u:
*a1 = 0;
return result;
case 8u:
result = operator new(0x28uLL);
*(_OWORD *)result = 0LL;
*(_OWORD *)(result + 16) = 0LL;
*(_BYTE *)(result + 32) = 0;
LABEL_9:
*(_QWORD *)a1 = result;
break;
default:
*(_QWORD *)a1 = 0LL;
break;
}
return result;
}
| json_value:
PUSH RBX
MOV RBX,RDI
CMP ESI,0x8
JA 0x0015916f
MOV EAX,ESI
LEA RCX,[0x1e83c0]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
MOV qword ptr [RBX],0x0
JMP 0x001591c7
caseD_1:
MOV EDI,0x20
JMP 0x00159189
caseD_4:
MOV byte ptr [RBX],0x0
JMP 0x001591c7
caseD_2:
MOV EDI,0x18
LAB_00159189:
CALL 0x0011b8a0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOV qword ptr [RAX + 0x10],0x0
JMP 0x001591c4
caseD_3:
LEA RDI,[0x1ed92c]
CALL 0x001591ca
JMP 0x001591c4
caseD_8:
MOV EDI,0x28
CALL 0x0011b8a0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOVUPS xmmword ptr [RAX + 0x10],XMM0
MOV byte ptr [RAX + 0x20],0x0
LAB_001591c4:
MOV qword ptr [RBX],RAX
LAB_001591c7:
POP RBX
RET
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::json_value::json_value(nlohmann::json_abi_v3_11_3::detail::value_t) */
void __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::json_value::json_value(json_value *this,int4 param_2)
{
string *psVar1;
ulong uVar2;
switch(param_2) {
default:
*(int8 *)this = 0;
return;
case 1:
uVar2 = 0x20;
break;
case 2:
uVar2 = 0x18;
break;
case 3:
psVar1 = create<std::__cxx11::string,char_const(&)[1]>("");
goto LAB_001591c4;
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;
goto LAB_001591c4;
}
psVar1 = (string *)operator_new(uVar2);
*(int8 *)psVar1 = 0;
*(int8 *)(psVar1 + 8) = 0;
*(int8 *)(psVar1 + 0x10) = 0;
LAB_001591c4:
*(string **)this = psVar1;
return;
}
| |
29,239 | store_constraints(THD*, TABLE*, st_mysql_const_lex_string const*, st_mysql_const_lex_string const*, char const*, unsigned long, char const*, unsigned long) | eloqsql/sql/sql_show.cc | static bool
store_constraints(THD *thd, TABLE *table, const LEX_CSTRING *db_name,
const LEX_CSTRING *table_name, const char *key_name,
size_t key_len, const char *con_type, size_t con_len)
{
CHARSET_INFO *cs= system_charset_info;
restore_record(table, s->default_values);
table->field[0]->store(STRING_WITH_LEN("def"), cs);
table->field[1]->store(db_name->str, db_name->length, cs);
table->field[2]->store(key_name, key_len, cs);
table->field[3]->store(db_name->str, db_name->length, cs);
table->field[4]->store(table_name->str, table_name->length, cs);
table->field[5]->store(con_type, con_len, cs);
return schema_table_store_record(thd, table);
} | O0 | cpp | store_constraints(THD*, TABLE*, st_mysql_const_lex_string const*, st_mysql_const_lex_string const*, char const*, unsigned long, char const*, unsigned long):
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq 0xf594e9(%rip), %rax # 0x15bfb78
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x248(%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x328(%rax), %rdx
callq 0x4331a0
movq -0x10(%rbp), %rax
movq 0xb0(%rax), %rax
movq (%rax), %rdi
movq -0x38(%rbp), %rcx
movq (%rdi), %rax
leaq 0x717ff3(%rip), %rsi # 0xd7e6ce
movl $0x3, %edx
callq *0x60(%rax)
movq -0x10(%rbp), %rax
movq 0xb0(%rax), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x38(%rbp), %rcx
movq (%rdi), %rax
callq *0x60(%rax)
movq -0x10(%rbp), %rax
movq 0xb0(%rax), %rax
movq 0x10(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq (%rdi), %rax
callq *0x60(%rax)
movq -0x10(%rbp), %rax
movq 0xb0(%rax), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x38(%rbp), %rcx
movq (%rdi), %rax
callq *0x60(%rax)
movq -0x10(%rbp), %rax
movq 0xb0(%rax), %rax
movq 0x20(%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x38(%rbp), %rcx
movq (%rdi), %rax
callq *0x60(%rax)
movq -0x10(%rbp), %rax
movq 0xb0(%rax), %rax
movq 0x28(%rax), %rdi
movq 0x10(%rbp), %rsi
movq 0x18(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq (%rdi), %rax
callq *0x60(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6525b0
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZL17store_constraintsP3THDP5TABLEPK25st_mysql_const_lex_stringS5_PKcmS7_m:
push rbp
mov rbp, rsp
sub rsp, 40h
mov rax, [rbp+arg_8]
mov rax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
lea rax, system_charset_info
mov rax, [rax]
mov [rbp+var_38], rax
mov rax, [rbp+var_10]
mov rdi, [rax+50h]
mov rax, [rbp+var_10]
mov rax, [rax]
mov rsi, [rax+248h]
mov rax, [rbp+var_10]
mov rax, [rax]
mov rdx, [rax+328h]
call _memcpy
mov rax, [rbp+var_10]
mov rax, [rax+0B0h]
mov rdi, [rax]
mov rcx, [rbp+var_38]
mov rax, [rdi]
lea rsi, aDef; "def"
mov edx, 3
call qword ptr [rax+60h]
mov rax, [rbp+var_10]
mov rax, [rax+0B0h]
mov rdi, [rax+8]
mov rax, [rbp+var_18]
mov rsi, [rax]
mov rax, [rbp+var_18]
mov rdx, [rax+8]
mov rcx, [rbp+var_38]
mov rax, [rdi]
call qword ptr [rax+60h]
mov rax, [rbp+var_10]
mov rax, [rax+0B0h]
mov rdi, [rax+10h]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_30]
mov rcx, [rbp+var_38]
mov rax, [rdi]
call qword ptr [rax+60h]
mov rax, [rbp+var_10]
mov rax, [rax+0B0h]
mov rdi, [rax+18h]
mov rax, [rbp+var_18]
mov rsi, [rax]
mov rax, [rbp+var_18]
mov rdx, [rax+8]
mov rcx, [rbp+var_38]
mov rax, [rdi]
call qword ptr [rax+60h]
mov rax, [rbp+var_10]
mov rax, [rax+0B0h]
mov rdi, [rax+20h]
mov rax, [rbp+var_20]
mov rsi, [rax]
mov rax, [rbp+var_20]
mov rdx, [rax+8]
mov rcx, [rbp+var_38]
mov rax, [rdi]
call qword ptr [rax+60h]
mov rax, [rbp+var_10]
mov rax, [rax+0B0h]
mov rdi, [rax+28h]
mov rsi, [rbp+arg_0]
mov rdx, [rbp+arg_8]
mov rcx, [rbp+var_38]
mov rax, [rdi]
call qword ptr [rax+60h]
mov rdi, [rbp+var_8]; THD *
mov rsi, [rbp+var_10]; TABLE *
call _Z25schema_table_store_recordP3THDP5TABLE; schema_table_store_record(THD *,TABLE *)
and al, 1
add rsp, 40h
pop rbp
retn
| bool store_constraints(
THD *a1,
TABLE *a2,
_QWORD *a3,
_QWORD *a4,
long long a5,
long long a6,
long long a7,
long long a8)
{
long long v9; // [rsp+8h] [rbp-38h]
v9 = system_charset_info;
memcpy(*((_QWORD *)a2 + 10), *(_QWORD *)(*(_QWORD *)a2 + 584LL), *(_QWORD *)(*(_QWORD *)a2 + 808LL));
(*(void ( **)(_QWORD, const char *, long long, long long))(***((_QWORD ***)a2 + 22) + 96LL))(
**((_QWORD **)a2 + 22),
"def",
3LL,
v9);
(*(void ( **)(_QWORD, _QWORD, _QWORD, long long))(**(_QWORD **)(*((_QWORD *)a2 + 22) + 8LL) + 96LL))(
*(_QWORD *)(*((_QWORD *)a2 + 22) + 8LL),
*a3,
a3[1],
v9);
(*(void ( **)(_QWORD, long long, long long, long long))(**(_QWORD **)(*((_QWORD *)a2 + 22) + 16LL) + 96LL))(
*(_QWORD *)(*((_QWORD *)a2 + 22) + 16LL),
a5,
a6,
v9);
(*(void ( **)(_QWORD, _QWORD, _QWORD, long long))(**(_QWORD **)(*((_QWORD *)a2 + 22) + 24LL) + 96LL))(
*(_QWORD *)(*((_QWORD *)a2 + 22) + 24LL),
*a3,
a3[1],
v9);
(*(void ( **)(_QWORD, _QWORD, _QWORD, long long))(**(_QWORD **)(*((_QWORD *)a2 + 22) + 32LL) + 96LL))(
*(_QWORD *)(*((_QWORD *)a2 + 22) + 32LL),
*a4,
a4[1],
v9);
(*(void ( **)(_QWORD, long long, long long, long long))(**(_QWORD **)(*((_QWORD *)a2 + 22) + 40LL) + 96LL))(
*(_QWORD *)(*((_QWORD *)a2 + 22) + 40LL),
a7,
a8,
v9);
return schema_table_store_record(a1, a2);
}
| dbname_cache_t:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RDI
LEA RAX,[0x16c3654]
MOV ESI,dword ptr [RAX]
LEA RAX,[0x16bfb90]
MOV RDX,qword ptr [RAX]
LEA RCX,[0xd1ae80]
MOV RAX,RSP
MOV qword ptr [RAX + 0x8],RCX
LEA RCX,[0x666700]
MOV qword ptr [RAX],RCX
MOV dword ptr [RAX + 0x10],0x0
XOR EAX,EAX
MOV R8D,EAX
MOV ECX,0xa
MOV R9D,0x8
CALL 0x00666730
MOV RSI,qword ptr [RBP + -0x20]
ADD RSI,0x70
MOV EDI,dword ptr [0x016c5db8]
LAB_006666c9:
CALL 0x00660ac0
LAB_006666ce:
JMP 0x006666d0
LAB_006666d0:
ADD RSP,0x40
POP RBP
RET
|
/* dbname_cache_t::dbname_cache_t() */
void __thiscall dbname_cache_t::dbname_cache_t(dbname_cache_t *this)
{
Hash_set<st_mysql_lex_string>::Hash_set
((Hash_set<st_mysql_lex_string> *)this,key_memory_dbnames_cache,table_alias_charset,10,0
,8,get_key,my_free,0);
/* try { // try from 006666c9 to 006666cd has its CatchHandler @ 006666d6 */
inline_mysql_rwlock_init(key_rwlock_LOCK_dbnames,(st_mysql_rwlock *)(this + 0x70));
return;
}
| |
29,240 | testing::internal::UnitTestImpl::AddTestInfo(void (*)(), void (*)(), testing::TestInfo*) | AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest-internal-inl.h | void AddTestInfo(internal::SetUpTestSuiteFunc set_up_tc,
internal::TearDownTestSuiteFunc tear_down_tc,
TestInfo* test_info) {
#if GTEST_HAS_FILE_SYSTEM
// In order to support thread-safe death tests, we need to
// remember the original working directory when the test program
// was first invoked. We cannot do this in RUN_ALL_TESTS(), as
// the user may have changed the current directory before calling
// RUN_ALL_TESTS(). Therefore we capture the current directory in
// AddTestInfo(), which is called to register a TEST or TEST_F
// before main() is reached.
if (original_working_dir_.IsEmpty()) {
original_working_dir_ = FilePath::GetCurrentDir();
GTEST_CHECK_(!original_working_dir_.IsEmpty())
<< "Failed to get the current working directory.";
}
#endif // GTEST_HAS_FILE_SYSTEM
GetTestSuite(test_info->test_suite_name_, test_info->type_param(),
set_up_tc, tear_down_tc)
->AddTestInfo(test_info);
} | O0 | c | testing::internal::UnitTestImpl::AddTestInfo(void (*)(), void (*)(), testing::TestInfo*):
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x10, %rdi
callq 0x465d0
testb $0x1, %al
jne 0x4b334
jmp 0x4b3f9
leaq 0x38(%rsp), %rdi
callq 0x18d80
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
leaq 0x38(%rsp), %rsi
callq 0x48390
leaq 0x38(%rsp), %rdi
callq 0x465c0
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
callq 0x465d0
xorb $-0x1, %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x16140
testb $0x1, %al
jne 0x4b37c
jmp 0x4b37e
jmp 0x4b3f7
leaq 0x2ad48(%rip), %rdx # 0x760cd
leaq 0x34(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x3, %esi
movl $0x2b0, %ecx # imm = 0x2B0
callq 0x1b8d0
movq 0x8(%rsp), %rdi
callq 0x107d0
movq %rax, %rdi
leaq 0x2ad88(%rip), %rsi # 0x7613a
callq 0xb460
movq %rax, 0x10(%rsp)
jmp 0x4b3be
movq 0x10(%rsp), %rdi
leaq 0x2ada4(%rip), %rsi # 0x7616e
callq 0xb460
jmp 0x4b3d1
leaq 0x34(%rsp), %rdi
callq 0x1ba40
jmp 0x4b3f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x34(%rsp), %rdi
callq 0x1ba40
jmp 0x4b439
jmp 0x4b3f9
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
movq 0x58(%rsp), %rdi
callq 0x4cbe0
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
movq %rax, %rdx
movq 0x68(%rsp), %rcx
movq 0x60(%rsp), %r8
callq 0x3d3d0
movq %rax, %rdi
movq 0x58(%rsp), %rsi
callq 0x29f20
addq $0x78, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xb910
nopw %cs:(%rax,%rax)
nopl (%rax)
| _ZN7testing8internal12UnitTestImpl11AddTestInfoEPFvvES3_PNS_8TestInfoE:
sub rsp, 78h
mov qword ptr [rsp+78h+var_8], rdi
mov [rsp+78h+var_10], rsi
mov [rsp+78h+var_18], rdx
mov [rsp+78h+var_20], rcx
mov rdi, qword ptr [rsp+78h+var_8]
mov qword ptr [rsp+78h+var_60], rdi; int
add rdi, 10h; this
call _ZNK7testing8internal8FilePath7IsEmptyEv; testing::internal::FilePath::IsEmpty(void)
test al, 1
jnz short loc_4B334
jmp loc_4B3F9
loc_4B334:
lea rdi, [rsp+78h+var_40]; this
call _ZN7testing8internal8FilePath13GetCurrentDirEv; testing::internal::FilePath::GetCurrentDir(void)
mov rdi, qword ptr [rsp+78h+var_60]
add rdi, 10h
lea rsi, [rsp+78h+var_40]; bool
call _ZN7testing8internal8FilePathaSEOS1_; testing::internal::FilePath::operator=(testing::internal::FilePath&&)
lea rdi, [rsp+78h+var_40]; this
call _ZN7testing8internal8FilePathD2Ev; testing::internal::FilePath::~FilePath()
mov rdi, qword ptr [rsp+78h+var_60]
add rdi, 10h; this
call _ZNK7testing8internal8FilePath7IsEmptyEv; testing::internal::FilePath::IsEmpty(void)
xor al, 0FFh
movzx edi, al
and edi, 1; this
call _ZN7testing8internal6IsTrueEb; testing::internal::IsTrue(bool)
test al, 1
jnz short loc_4B37C
jmp short loc_4B37E
loc_4B37C:
jmp short loc_4B3F7
loc_4B37E:
lea rdx, aWorkspaceLlm4b_5; "/workspace/llm4binary/github2025/AlayaL"...
lea rdi, [rsp+78h+var_44]; int
mov [rsp+78h+var_70], rdi; int
mov esi, 3
mov ecx, 2B0h
call _ZN7testing8internal8GTestLogC2ENS0_16GTestLogSeverityEPKci; testing::internal::GTestLog::GTestLog(testing::internal::GTestLogSeverity,char const*,int)
mov rdi, [rsp+78h+var_70]; this
call _ZN7testing8internal8GTestLog9GetStreamEv; testing::internal::GTestLog::GetStream(void)
mov rdi, rax
lea rsi, aConditionOrigi; "Condition !original_working_dir_.IsEmpt"...
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rsp+78h+var_68], rax
jmp short $+2
loc_4B3BE:
mov rdi, [rsp+78h+var_68]
lea rsi, aFailedToGetThe; "Failed to get the current working direc"...
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short $+2
loc_4B3D1:
lea rdi, [rsp+78h+var_44]; this
call _ZN7testing8internal8GTestLogD2Ev; testing::internal::GTestLog::~GTestLog()
jmp short loc_4B3F7
mov rcx, rax
mov eax, edx
mov [rsp+arg_20], rcx
mov [rsp+arg_1C], eax
lea rdi, [rsp+arg_2C]; this
call _ZN7testing8internal8GTestLogD2Ev; testing::internal::GTestLog::~GTestLog()
jmp short loc_4B439
loc_4B3F7:
jmp short $+2
loc_4B3F9:
mov rax, [rsp+78h+var_20]
mov [rsp+78h+var_78], rax
mov rdi, [rsp+78h+var_20]; this
call _ZNK7testing8TestInfo10type_paramEv; testing::TestInfo::type_param(void)
mov rdi, qword ptr [rsp+78h+var_60]
mov rsi, [rsp+78h+var_78]
mov rdx, rax
mov rcx, [rsp+78h+var_10]
mov r8, [rsp+78h+var_18]
call _ZN7testing8internal12UnitTestImpl12GetTestSuiteERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPKcPFvvESD_; testing::internal::UnitTestImpl::GetTestSuite(std::string const&,char const*,void (*)(void),void (*)(void))
mov rdi, rax; this
mov rsi, [rsp+78h+var_20]; testing::TestInfo *
call _ZN7testing9TestSuite11AddTestInfoEPNS_8TestInfoE; testing::TestSuite::AddTestInfo(testing::TestInfo *)
add rsp, 78h
retn
loc_4B439:
mov rdi, [rsp+arg_20]
call __Unwind_Resume
| long long testing::internal::UnitTestImpl::AddTestInfo(
testing::internal::UnitTestImpl *this,
void (*a2)(void),
void (*a3)(void),
testing::TestInfo *a4)
{
bool IsEmpty; // al
void *Stream; // rax
long long v6; // rax
testing::TestSuite *TestSuite; // rax
testing::TestInfo *v9; // [rsp+0h] [rbp-78h]
long long v10; // [rsp+10h] [rbp-68h]
int v11; // [rsp+34h] [rbp-44h] BYREF
_QWORD v12[4]; // [rsp+38h] [rbp-40h] BYREF
testing::TestInfo *v13; // [rsp+58h] [rbp-20h]
void (*v14)(void); // [rsp+60h] [rbp-18h]
void (*v15)(void); // [rsp+68h] [rbp-10h]
int v16[2]; // [rsp+70h] [rbp-8h]
*(_QWORD *)v16 = this;
v15 = a2;
v14 = a3;
v13 = a4;
if ( testing::internal::FilePath::IsEmpty((testing::internal::UnitTestImpl *)((char *)this + 16)) )
{
testing::internal::FilePath::GetCurrentDir((testing::internal::FilePath *)v12);
testing::internal::FilePath::operator=((_QWORD *)this + 2, v12);
testing::internal::FilePath::~FilePath((testing::internal::FilePath *)v12);
IsEmpty = testing::internal::FilePath::IsEmpty((testing::internal::UnitTestImpl *)((char *)this + 16));
if ( (testing::internal::IsTrue((testing::internal *)!IsEmpty) & 1) == 0 )
{
testing::internal::GTestLog::GTestLog(
(testing::internal::GTestLog *)&v11,
3,
(long long)"/workspace/llm4binary/github2025/AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest-internal-inl.h",
688);
Stream = testing::internal::GTestLog::GetStream((testing::internal::GTestLog *)&v11);
v10 = std::operator<<<std::char_traits<char>>(Stream, "Condition !original_working_dir_.IsEmpty() failed. ");
std::operator<<<std::char_traits<char>>(v10, "Failed to get the current working directory.");
testing::internal::GTestLog::~GTestLog((testing::internal::GTestLog *)&v11);
}
}
v9 = v13;
v6 = testing::TestInfo::type_param(v13);
TestSuite = (testing::TestSuite *)testing::internal::UnitTestImpl::GetTestSuite(
(long long)this,
(long long)v9,
v6,
(long long)v15,
(long long)v14);
return testing::TestSuite::AddTestInfo(TestSuite, v13);
}
| AddTestInfo:
SUB RSP,0x78
MOV qword ptr [RSP + 0x70],RDI
MOV qword ptr [RSP + 0x68],RSI
MOV qword ptr [RSP + 0x60],RDX
MOV qword ptr [RSP + 0x58],RCX
MOV RDI,qword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0x18],RDI
ADD RDI,0x10
CALL 0x001465d0
TEST AL,0x1
JNZ 0x0014b334
JMP 0x0014b3f9
LAB_0014b334:
LEA RDI,[RSP + 0x38]
CALL 0x00118d80
MOV RDI,qword ptr [RSP + 0x18]
ADD RDI,0x10
LEA RSI,[RSP + 0x38]
CALL 0x00148390
LEA RDI,[RSP + 0x38]
CALL 0x001465c0
MOV RDI,qword ptr [RSP + 0x18]
ADD RDI,0x10
CALL 0x001465d0
XOR AL,0xff
MOVZX EDI,AL
AND EDI,0x1
CALL 0x00116140
TEST AL,0x1
JNZ 0x0014b37c
JMP 0x0014b37e
LAB_0014b37c:
JMP 0x0014b3f7
LAB_0014b37e:
LEA RDX,[0x1760cd]
LEA RDI,[RSP + 0x34]
MOV qword ptr [RSP + 0x8],RDI
MOV ESI,0x3
MOV ECX,0x2b0
CALL 0x0011b8d0
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x001107d0
MOV RDI,RAX
LAB_0014b3ab:
LEA RSI,[0x17613a]
CALL 0x0010b460
MOV qword ptr [RSP + 0x10],RAX
JMP 0x0014b3be
LAB_0014b3be:
MOV RDI,qword ptr [RSP + 0x10]
LEA RSI,[0x17616e]
CALL 0x0010b460
LAB_0014b3cf:
JMP 0x0014b3d1
LAB_0014b3d1:
LEA RDI,[RSP + 0x34]
CALL 0x0011ba40
JMP 0x0014b3f7
LAB_0014b3f7:
JMP 0x0014b3f9
LAB_0014b3f9:
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x0014cbe0
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP]
MOV RDX,RAX
MOV RCX,qword ptr [RSP + 0x68]
MOV R8,qword ptr [RSP + 0x60]
CALL 0x0013d3d0
MOV RDI,RAX
MOV RSI,qword ptr [RSP + 0x58]
CALL 0x00129f20
ADD RSP,0x78
RET
|
/* testing::internal::UnitTestImpl::AddTestInfo(void (*)(), void (*)(), testing::TestInfo*) */
void __thiscall
testing::internal::UnitTestImpl::AddTestInfo
(UnitTestImpl *this,_func_void *param_1,_func_void *param_2,TestInfo *param_3)
{
TestInfo *pTVar1;
byte bVar2;
ulong uVar3;
ostream *poVar4;
char *pcVar5;
TestSuite *this_00;
GTestLog local_44 [4];
FilePath local_40 [32];
TestInfo *local_20;
_func_void *local_18;
_func_void *local_10;
UnitTestImpl *local_8;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
local_8 = this;
uVar3 = FilePath::IsEmpty((FilePath *)(this + 0x10));
if ((uVar3 & 1) != 0) {
FilePath::GetCurrentDir(local_40);
FilePath::operator=((FilePath *)(this + 0x10),local_40);
FilePath::~FilePath(local_40);
bVar2 = FilePath::IsEmpty((FilePath *)(this + 0x10));
uVar3 = IsTrue((bool)((bVar2 ^ 0xff) & 1));
if ((uVar3 & 1) == 0) {
GTestLog::GTestLog(local_44,3,
"/workspace/llm4binary/github2025/AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest-internal-inl.h"
,0x2b0);
poVar4 = (ostream *)GTestLog::GetStream();
/* try { // try from 0014b3ab to 0014b3ce has its CatchHandler @ 0014b3dd */
poVar4 = std::operator<<(poVar4,"Condition !original_working_dir_.IsEmpty() failed. ");
std::operator<<(poVar4,"Failed to get the current working directory.");
GTestLog::~GTestLog(local_44);
}
}
pTVar1 = local_20;
pcVar5 = (char *)TestInfo::type_param(local_20);
this_00 = (TestSuite *)GetTestSuite(this,(string *)pTVar1,pcVar5,local_10,local_18);
TestSuite::AddTestInfo(this_00,local_20);
return;
}
| |
29,241 | fmt::v10::format_system_error(fmt::v10::detail::buffer<char>&, int, char const*) | AlayaLite/build_O0/_deps/spdlog-src/include/spdlog/fmt/bundled/format-inl.h | FMT_FUNC void format_system_error(detail::buffer<char>& out, int error_code,
const char* message) noexcept {
FMT_TRY {
auto ec = std::error_code(error_code, std::generic_category());
write(std::back_inserter(out), std::system_error(ec, message).what());
return;
} | O0 | c | fmt::v10::format_system_error(fmt::v10::detail::buffer<char>&, int, char const*):
subq $0xd8, %rsp
movq %rdi, 0xc0(%rsp)
movl %esi, 0xbc(%rsp)
movq %rdx, 0xb0(%rsp)
movl 0xbc(%rsp), %eax
movl %eax, 0x2c(%rsp)
callq 0x16330
movl 0x2c(%rsp), %esi
movq %rax, %rdx
leaq 0xa0(%rsp), %rdi
callq 0x8bdd0
movq 0xc0(%rsp), %rdi
callq 0x91260
movq %rax, 0x30(%rsp)
jmp 0x8fb06
movq 0x30(%rsp), %rax
movq %rax, 0x98(%rsp)
movups 0xa0(%rsp), %xmm0
movaps %xmm0, 0x50(%rsp)
movq 0xb0(%rsp), %rcx
movl 0x50(%rsp), %esi
movq 0x58(%rsp), %rdx
leaq 0x68(%rsp), %rdi
callq 0x91290
jmp 0x8fb3d
leaq 0x68(%rsp), %rdi
callq 0x16a20
movq %rax, %rsi
movq 0x98(%rsp), %rdi
callq 0x911d0
movq %rax, 0x20(%rsp)
jmp 0x8fb5e
movq 0x20(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x16ed8
jmp 0x8fc3f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x8fbab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x16ed8
movq 0x90(%rsp), %rdi
callq 0x16280
callq 0x16c20
jmp 0x8fbbf
jmp 0x8fbc1
movq 0xc0(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0xbc(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0xb0(%rsp), %rax
leaq 0x38(%rsp), %rcx
movq %rcx, 0xd0(%rsp)
movq %rax, 0xc8(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0xc8(%rsp), %rcx
movq %rcx, (%rax)
movq 0xc8(%rsp), %rdi
callq 0x16290
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movl 0x14(%rsp), %esi
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rdx
movq 0x40(%rsp), %rcx
callq 0x8ed40
addq $0xd8, %rsp
retq
movq %rax, %rdi
callq 0x1eac0
nop
| _ZN3fmt3v1019format_system_errorERNS0_6detail6bufferIcEEiPKc:
sub rsp, 0D8h
mov [rsp+0D8h+var_18], rdi
mov [rsp+0D8h+var_1C], esi
mov [rsp+0D8h+var_28], rdx
mov eax, [rsp+0D8h+var_1C]
mov [rsp+0D8h+var_AC], eax
call __ZNSt3_V216generic_categoryEv; std::_V2::generic_category(void)
mov esi, [rsp+0D8h+var_AC]
mov rdx, rax
lea rdi, [rsp+0D8h+var_38]
call _ZNSt10error_codeC2EiRKNSt3_V214error_categoryE; std::error_code::error_code(int,std::_V2::error_category const&)
mov rdi, [rsp+0D8h+var_18]
call _ZSt13back_inserterIN3fmt3v106detail6bufferIcEEESt20back_insert_iteratorIT_ERS6_; std::back_inserter<fmt::v10::detail::buffer<char>>(fmt::v10::detail::buffer<char>&)
mov [rsp+0D8h+var_A8], rax
jmp short $+2
loc_8FB06:
mov rax, [rsp+0D8h+var_A8]
mov [rsp+0D8h+var_40], rax
movups xmm0, [rsp+0D8h+var_38]
movaps [rsp+0D8h+var_88], xmm0
mov rcx, [rsp+0D8h+var_28]
mov esi, dword ptr [rsp+0D8h+var_88]
mov rdx, qword ptr [rsp+0D8h+var_88+8]
lea rdi, [rsp+0D8h+var_70]
call _ZNSt12system_errorC2ESt10error_codePKc; std::system_error::system_error(std::error_code,char const*)
jmp short $+2
loc_8FB3D:
lea rdi, [rsp+0D8h+var_70]; this
call __ZNKSt13runtime_error4whatEv; std::runtime_error::what(void)
mov rsi, rax
mov rdi, [rsp+0D8h+var_40]
call _ZN3fmt3v106detail5writeIcSt20back_insert_iteratorINS1_6bufferIcEEEEET0_S7_PKT_; fmt::v10::detail::write<char,std::back_insert_iterator<fmt::v10::detail::buffer<char>>>(std::back_insert_iterator<fmt::v10::detail::buffer<char>>,char const*)
mov [rsp+0D8h+var_B8], rax
jmp short $+2
loc_8FB5E:
mov rax, [rsp+0D8h+var_B8]
mov [rsp+0D8h+var_90], rax
lea rdi, [rsp+0D8h+var_70]; this
call _ZNSt12system_errorD1Ev; std::system_error::~system_error()
jmp loc_8FC3F
mov rcx, rax
mov eax, edx
mov [rsp+0D8h+var_48], rcx
mov [rsp+0D8h+var_4C], eax
jmp short loc_8FBAB
mov rcx, rax
mov eax, edx
mov [rsp+0D8h+var_48], rcx
mov [rsp+0D8h+var_4C], eax
lea rdi, [rsp+0D8h+var_70]; this
call _ZNSt12system_errorD1Ev; std::system_error::~system_error()
loc_8FBAB:
mov rdi, [rsp+0D8h+var_48]; void *
call ___cxa_begin_catch
call ___cxa_end_catch
jmp short $+2
loc_8FBBF:
jmp short $+2
loc_8FBC1:
mov rax, [rsp+0D8h+var_18]
mov [rsp+0D8h+var_D0], rax
mov eax, [rsp+0D8h+var_1C]
mov [rsp+0D8h+var_C4], eax
mov rax, [rsp+0D8h+var_28]
lea rcx, [rsp+0D8h+var_A0]
mov [rsp+0D8h+var_8], rcx
mov [rsp+0D8h+var_10], rax
mov rax, [rsp+0D8h+var_8]
mov [rsp+0D8h+var_C0], rax
mov rcx, [rsp+0D8h+var_10]
mov [rax], rcx
mov rdi, [rsp+0D8h+var_10]
call _strlen
mov rcx, rax
mov rax, [rsp+0D8h+var_C0]
mov [rax+8], rcx
mov esi, [rsp+0D8h+var_C4]
mov rdi, [rsp+0D8h+var_D0]
mov rdx, [rsp+0D8h+var_A0]
mov rcx, [rsp+0D8h+var_98]
call _ZN3fmt3v106detail17format_error_codeERNS1_6bufferIcEEiNS0_17basic_string_viewIcEE; fmt::v10::detail::format_error_code(fmt::v10::detail::buffer<char> &,int,fmt::v10::basic_string_view<char>)
loc_8FC3F:
add rsp, 0D8h
retn
mov rdi, rax
call __clang_call_terminate
| void fmt::v10::format_system_error(std::_V2 *a1, int a2, long long a3)
{
long long v3; // rax
long long v4; // rsi
_BYTE v5[36]; // [rsp+68h] [rbp-70h] BYREF
long long v6; // [rsp+98h] [rbp-40h]
unsigned int v7; // [rsp+A0h] [rbp-38h] BYREF
long long v8; // [rsp+A8h] [rbp-30h]
long long v9; // [rsp+B0h] [rbp-28h]
int v10; // [rsp+BCh] [rbp-1Ch]
std::_V2 *v11; // [rsp+C0h] [rbp-18h]
v11 = a1;
v10 = a2;
v9 = a3;
v3 = std::_V2::generic_category(a1);
std::error_code::error_code((long long)&v7, a2, v3);
v6 = std::back_inserter<fmt::v10::detail::buffer<char>>(v11);
std::system_error::system_error(v5, v7, v8, v9);
v4 = std::runtime_error::what((std::runtime_error *)v5);
fmt::v10::detail::write<char,std::back_insert_iterator<fmt::v10::detail::buffer<char>>>(v6, v4);
std::system_error::~system_error((std::system_error *)v5);
}
| format_system_error:
SUB RSP,0xd8
MOV qword ptr [RSP + 0xc0],RDI
MOV dword ptr [RSP + 0xbc],ESI
MOV qword ptr [RSP + 0xb0],RDX
MOV EAX,dword ptr [RSP + 0xbc]
MOV dword ptr [RSP + 0x2c],EAX
CALL 0x00116330
MOV ESI,dword ptr [RSP + 0x2c]
MOV RDX,RAX
LEA RDI,[RSP + 0xa0]
CALL 0x0018bdd0
MOV RDI,qword ptr [RSP + 0xc0]
LAB_0018fafa:
CALL 0x00191260
MOV qword ptr [RSP + 0x30],RAX
JMP 0x0018fb06
LAB_0018fb06:
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x98],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0xa0]
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOV RCX,qword ptr [RSP + 0xb0]
MOV ESI,dword ptr [RSP + 0x50]
MOV RDX,qword ptr [RSP + 0x58]
LEA RDI,[RSP + 0x68]
CALL 0x00191290
JMP 0x0018fb3d
LAB_0018fb3d:
LEA RDI,[RSP + 0x68]
CALL 0x00116a20
MOV RSI,RAX
MOV RDI,qword ptr [RSP + 0x98]
LAB_0018fb52:
CALL 0x001911d0
LAB_0018fb57:
MOV qword ptr [RSP + 0x20],RAX
JMP 0x0018fb5e
LAB_0018fb5e:
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x48],RAX
LEA RDI,[RSP + 0x68]
CALL 0x00116ed8
JMP 0x0018fc3f
LAB_0018fc3f:
ADD RSP,0xd8
RET
|
/* fmt::v10::format_system_error(fmt::v10::detail::buffer<char>&, int, char const*) */
void fmt::v10::format_system_error(buffer *param_1,int param_2,char *param_3)
{
error_category *peVar1;
int8 uVar2;
system_error local_70 [48];
int8 local_40;
int4 local_38 [2];
int4 uStack_30;
int4 uStack_2c;
char *local_28;
int local_1c;
buffer *local_18;
local_28 = param_3;
local_1c = param_2;
local_18 = param_1;
peVar1 = (error_category *)std::_V2::generic_category();
std::error_code::error_code((error_code *)local_38,param_2,peVar1);
/* try { // try from 0018fafa to 0018fb3a has its CatchHandler @ 0018fb77 */
local_40 = std::back_inserter<fmt::v10::detail::buffer<char>>(local_18);
std::system_error::system_error(local_70,local_38[0],CONCAT44(uStack_2c,uStack_30),local_28);
uVar2 = std::runtime_error::what();
/* try { // try from 0018fb52 to 0018fb56 has its CatchHandler @ 0018fb8d */
detail::write<char,std::back_insert_iterator<fmt::v10::detail::buffer<char>>>(local_40,uVar2);
std::system_error::~system_error(local_70);
return;
}
| |
29,242 | 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>::push_back(std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>> const&) | monkey531[P]llama/common/json.hpp | void push_back(const typename object_t::value_type& val)
{
// push_back only works for null objects or objects
if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
{
JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
}
// transform null object into an object
if (is_null())
{
m_data.m_type = value_t::object;
m_data.m_value = value_t::object;
assert_invariant();
}
// add element to object
auto res = m_data.m_value.object->insert(val);
set_parent(res.first->second);
} | O2 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::push_back(std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>> const&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
testl %eax, %eax
jne 0x81251
movb $0x1, (%r14)
callq 0x2b266
movq %rax, 0x8(%r14)
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x2b16e
jmp 0x81256
cmpl $0x1, %eax
jne 0x8126a
movq 0x8(%r14), %rdi
movq %rbx, %rsi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x813e0
pushq $0x20
popq %rdi
callq 0x213a0
movq %rax, %rbx
movq %r14, %rdi
callq 0x30c70
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x1cee7(%rip), %rsi # 0x9e173
leaq 0x10(%rsp), %rdi
callq 0x4772a
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x134, %esi # imm = 0x134
movq %r14, %rcx
callq 0x30b24
xorl %ebp, %ebp
leaq 0x58c99(%rip), %rsi # 0xd9f50
leaq -0x53ab2(%rip), %rdx # 0x2d80c
movq %rbx, %rdi
callq 0x21b70
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x21dc8
testb %bpl, %bpl
jne 0x812dd
jmp 0x812e5
movq %rax, %r14
movq %rbx, %rdi
callq 0x21530
movq %r14, %rdi
callq 0x21be0
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9push_backERKSt4pairIKS9_SD_E:
push rbp; char
push r14; int
push rbx; int
sub rsp, 30h
mov rbx, rsi
mov r14, rdi
movzx eax, byte ptr [rdi]
test eax, eax
jnz short loc_81251
mov byte ptr [r14], 1
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createINS2_IS9_SD_St4lessIvESaISt4pairIKS9_SD_EEEEJEEEPT_DpOT0_; 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>::create<nlohmann::json_abi_v3_11_3::ordered_map<std::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>,std::less<void>,std::allocator<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>>>>>()
mov [r14+8], rax
push 1
pop rsi
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
jmp short loc_81256
loc_81251:
cmp eax, 1
jnz short loc_8126A
loc_81256:
mov rdi, [r14+8]
mov rsi, rbx
add rsp, 30h
pop rbx
pop r14
pop rbp
jmp _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE6insertERKSI_; nlohmann::json_abi_v3_11_3::ordered_map<std::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>,std::less<void>,std::allocator<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>>>>::insert(std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const&)
loc_8126A:
push 20h ; ' '
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aCannotUsePushB; "cannot use push_back() with "
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA29_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(char const(&)[29],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 134h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rdi, [rsp+48h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_812DD
jmp short loc_812E5
mov r14, rax
loc_812DD:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_812E5:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::push_back(
long long a1,
long long a2)
{
nlohmann::json_abi_v3_11_3::detail::type_error *exception; // rbx
const char *v4; // [rsp+8h] [rbp-40h] BYREF
_BYTE v5[56]; // [rsp+10h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 )
{
if ( *(_BYTE *)a1 != 1 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::type_error *)__cxa_allocate_exception(0x20uLL);
v4 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(
(long long)v5,
(long long)"cannot use push_back() with ",
&v4);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
308,
(long long)v5);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
}
else
{
*(_BYTE *)a1 = 1;
*(_QWORD *)(a1 + 8) = 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>::create<nlohmann::json_abi_v3_11_3::ordered_map<std::string,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::less<void>,std::allocator<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>>>>>();
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)a1);
}
return nlohmann::json_abi_v3_11_3::ordered_map<std::string,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::less<void>,std::allocator<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>>>>::insert(
*(_QWORD *)(a1 + 8),
a2);
}
| push_back:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV RBX,RSI
MOV R14,RDI
MOVZX EAX,byte ptr [RDI]
TEST EAX,EAX
JNZ 0x00181251
MOV byte ptr [R14],0x1
CALL 0x0012b266
MOV qword ptr [R14 + 0x8],RAX
PUSH 0x1
POP RSI
MOV RDI,R14
CALL 0x0012b16e
JMP 0x00181256
LAB_00181251:
CMP EAX,0x1
JNZ 0x0018126a
LAB_00181256:
MOV RDI,qword ptr [R14 + 0x8]
MOV RSI,RBX
ADD RSP,0x30
POP RBX
POP R14
POP RBP
JMP 0x001813e0
LAB_0018126a:
PUSH 0x20
POP RDI
CALL 0x001213a0
MOV RBX,RAX
MOV RDI,R14
CALL 0x00130c70
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_00181285:
LEA RSI,[0x19e173]
LEA RDI,[RSP + 0x10]
CALL 0x0014772a
MOV BPL,0x1
LAB_00181299:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x134
MOV RCX,R14
CALL 0x00130b24
XOR EBP,EBP
LEA RSI,[0x1d9f50]
LEA RDX,[0x12d80c]
MOV RDI,RBX
CALL 0x00121b70
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::push_back(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> > const&) */
void __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::push_back(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,pair *param_1)
{
ordered_map *poVar1;
int8 uVar2;
char *local_40;
detail local_38 [32];
if (*this == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0) {
*this = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x1;
poVar1 = create<nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<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>>>>>
();
*(ordered_map **)(this + 8) = poVar1;
assert_invariant(SUB81(this,0));
}
else if (*this != (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x1) {
uVar2 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name(this);
/* try { // try from 00181285 to 00181295 has its CatchHandler @ 001812da */
detail::concat<std::__cxx11::string,char_const(&)[29],char_const*>
(local_38,"cannot use push_back() with ",&local_40);
/* try { // try from 00181299 to 001812c5 has its CatchHandler @ 001812c6 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar2,0x134,local_38,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar2,&detail::type_error::typeinfo,detail::exception::~exception);
}
ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<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>>>>
::insert(*(ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<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>>>>
**)(this + 8),param_1);
return;
}
| |
29,243 | mark_blocks_free | eloqsql/mysys/my_alloc.c | static inline void mark_blocks_free(MEM_ROOT* root)
{
reg1 USED_MEM *next;
reg2 USED_MEM **last;
/* iterate through (partially) free blocks, mark them free */
last= &root->free;
for (next= root->free; next; next= *(last= &next->next))
{
next->left= next->size - ALIGN_SIZE(sizeof(USED_MEM));
TRASH_MEM(next);
}
/* Combine the free and the used list */
*last= next=root->used;
/* now go through the used blocks and mark them free */
for (; next; next= next->next)
{
next->left= next->size - ALIGN_SIZE(sizeof(USED_MEM));
TRASH_MEM(next);
}
/* Now everything is set; Indicate that nothing is used anymore */
root->used= 0;
root->first_block_usage= 0;
root->block_num= 4;
} | O0 | c | mark_blocks_free:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6adaf
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
subq $0x18, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x6ad98
jmp 0x6ad9a
jmp 0x6ad9c
jmp 0x6ad9e
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x6ad7b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x10(%rbp)
je 0x6adf2
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
subq $0x18, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x6addf
jmp 0x6ade1
jmp 0x6ade3
jmp 0x6ade5
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x6adc2
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x8(%rbp), %rax
movl $0x4, 0x28(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
| mark_blocks_free:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_10], rax
loc_6AD7B:
cmp [rbp+var_10], 0
jz short loc_6ADAF
mov rax, [rbp+var_10]
mov rcx, [rax+10h]
sub rcx, 18h
mov rax, [rbp+var_10]
mov [rax+8], rcx
jmp short $+2
loc_6AD98:
jmp short $+2
loc_6AD9A:
jmp short $+2
loc_6AD9C:
jmp short $+2
loc_6AD9E:
mov rax, [rbp+var_10]
mov [rbp+var_18], rax
mov rax, [rax]
mov [rbp+var_10], rax
jmp short loc_6AD7B
loc_6ADAF:
mov rax, [rbp+var_8]
mov rcx, [rax+8]
mov [rbp+var_10], rcx
mov rax, [rbp+var_18]
mov [rax], rcx
loc_6ADC2:
cmp [rbp+var_10], 0
jz short loc_6ADF2
mov rax, [rbp+var_10]
mov rcx, [rax+10h]
sub rcx, 18h
mov rax, [rbp+var_10]
mov [rax+8], rcx
jmp short $+2
loc_6ADDF:
jmp short $+2
loc_6ADE1:
jmp short $+2
loc_6ADE3:
jmp short $+2
loc_6ADE5:
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_10], rax
jmp short loc_6ADC2
loc_6ADF2:
mov rax, [rbp+var_8]
mov qword ptr [rax+8], 0
mov rax, [rbp+var_8]
mov dword ptr [rax+2Ch], 0
mov rax, [rbp+var_8]
mov dword ptr [rax+28h], 4
pop rbp
retn
| long long mark_blocks_free(long long a1)
{
long long result; // rax
_QWORD *v2; // [rsp+0h] [rbp-18h]
_QWORD *i; // [rsp+8h] [rbp-10h]
_QWORD *v4; // [rsp+8h] [rbp-10h]
v2 = (_QWORD *)a1;
for ( i = *(_QWORD **)a1; i; i = (_QWORD *)*i )
{
i[1] = i[2] - 24LL;
v2 = i;
}
v4 = *(_QWORD **)(a1 + 8);
*v2 = v4;
while ( v4 )
{
v4[1] = v4[2] - 24LL;
v4 = (_QWORD *)*v4;
}
*(_QWORD *)(a1 + 8) = 0LL;
*(_DWORD *)(a1 + 44) = 0;
result = a1;
*(_DWORD *)(a1 + 40) = 4;
return result;
}
| mark_blocks_free:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
LAB_0016ad7b:
CMP qword ptr [RBP + -0x10],0x0
JZ 0x0016adaf
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x10]
SUB RCX,0x18
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x0016ad98
LAB_0016ad98:
JMP 0x0016ad9a
LAB_0016ad9a:
JMP 0x0016ad9c
LAB_0016ad9c:
JMP 0x0016ad9e
LAB_0016ad9e:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x0016ad7b
LAB_0016adaf:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x10],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
LAB_0016adc2:
CMP qword ptr [RBP + -0x10],0x0
JZ 0x0016adf2
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x10]
SUB RCX,0x18
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x0016addf
LAB_0016addf:
JMP 0x0016ade1
LAB_0016ade1:
JMP 0x0016ade3
LAB_0016ade3:
JMP 0x0016ade5
LAB_0016ade5:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x0016adc2
LAB_0016adf2:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x8],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x2c],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x28],0x4
POP RBP
RET
|
void mark_blocks_free(int8 *param_1)
{
int8 *local_20;
int8 *local_18;
local_20 = param_1;
for (local_18 = (int8 *)*param_1; local_18 != (int8 *)0x0;
local_18 = (int8 *)*local_18) {
local_18[1] = local_18[2] + -0x18;
local_20 = local_18;
}
local_18 = (int8 *)param_1[1];
*local_20 = local_18;
for (; local_18 != (int8 *)0x0; local_18 = (int8 *)*local_18) {
local_18[1] = local_18[2] + -0x18;
}
param_1[1] = 0;
*(int4 *)((long)param_1 + 0x2c) = 0;
*(int4 *)(param_1 + 5) = 4;
return;
}
| |
29,244 | 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>::set_parents() | monkey531[P]llama/common/json.hpp | void set_parents()
{
#if JSON_DIAGNOSTICS
switch (m_data.m_type)
{
case value_t::array:
{
for (auto& element : *m_data.m_value.array)
{
element.m_parent = this;
}
break;
}
case value_t::object:
{
for (auto& element : *m_data.m_value.object)
{
element.second.m_parent = this;
}
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:
break;
}
#endif
} | O0 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::set_parents():
movq %rdi, -0x8(%rsp)
retq
nopw %cs:(%rax,%rax)
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE11set_parentsEv:
mov [rsp+var_8], rdi
retn
| void 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>::set_parents()
{
;
}
| set_parents:
MOV qword ptr [RSP + -0x8],RDI
RET
|
/* 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>::set_parents() */
void 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>
::set_parents(void)
{
return;
}
| |
29,245 | common_log_main() | monkey531[P]llama/common/log.cpp | struct common_log * common_log_main() {
static struct common_log log;
return &log;
} | O1 | cpp | common_log_main():
pushq %rbx
movb 0x624c6(%rip), %al # 0x130518
testb %al, %al
je 0xce05f
leaq 0x623eb(%rip), %rax # 0x130448
popq %rbx
retq
leaq 0x624b2(%rip), %rdi # 0x130518
callq 0x1c010
testl %eax, %eax
je 0xce056
leaq 0x623d2(%rip), %rdi # 0x130448
movl $0x100, %esi # imm = 0x100
callq 0xce746
leaq 0x10b(%rip), %rdi # 0xce192
leaq 0x623ba(%rip), %rsi # 0x130448
leaq 0x61843(%rip), %rdx # 0x12f8d8
callq 0x1b7b0
leaq 0x62477(%rip), %rdi # 0x130518
callq 0x1b5b0
jmp 0xce056
movq %rax, %rbx
leaq 0x62466(%rip), %rdi # 0x130518
callq 0x1b5a0
movq %rbx, %rdi
callq 0x1bfb0
| _Z15common_log_mainv:
push rbx
mov al, cs:_ZGVZ15common_log_mainvE3log; `guard variable for'common_log_main(void)::log
test al, al
jz short loc_CE05F
loc_CE056:
lea rax, _ZZ15common_log_mainvE3log; common_log_main(void)::log
pop rbx
retn
loc_CE05F:
lea rdi, _ZGVZ15common_log_mainvE3log; __guard *
call ___cxa_guard_acquire
test eax, eax
jz short loc_CE056
lea rdi, _ZZ15common_log_mainvE3log; this
mov esi, 100h; unsigned __int64
call _ZN10common_logC2Em; common_log::common_log(ulong)
lea rdi, _ZN10common_logD2Ev; lpfunc
lea rsi, _ZZ15common_log_mainvE3log; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZ15common_log_mainvE3log; __guard *
call ___cxa_guard_release
jmp short loc_CE056
mov rbx, rax
lea rdi, _ZGVZ15common_log_mainvE3log; __guard *
call ___cxa_guard_abort
mov rdi, rbx
call __Unwind_Resume
| void *common_log_main(void)
{
if ( !(_BYTE)`guard variable for'common_log_main(void)::log
&& __cxa_guard_acquire(&`guard variable for'common_log_main(void)::log) )
{
common_log::common_log((common_log *)&common_log_main(void)::log, 0x100uLL);
__cxa_atexit(common_log::~common_log, &common_log_main(void)::log, &_dso_handle);
__cxa_guard_release(&`guard variable for'common_log_main(void)::log);
}
return &common_log_main(void)::log;
}
| common_log_main:
PUSH RBX
MOV AL,byte ptr [0x00230518]
TEST AL,AL
JZ 0x001ce05f
LAB_001ce056:
LEA RAX,[0x230448]
POP RBX
RET
LAB_001ce05f:
LEA RDI,[0x230518]
CALL 0x0011c010
TEST EAX,EAX
JZ 0x001ce056
LAB_001ce06f:
LEA RDI,[0x230448]
MOV ESI,0x100
CALL 0x001ce746
LAB_001ce080:
LEA RDI,[0x1ce192]
LEA RSI,[0x230448]
LEA RDX,[0x22f8d8]
CALL 0x0011b7b0
LEA RDI,[0x230518]
CALL 0x0011b5b0
JMP 0x001ce056
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* common_log_main() */
int1 * common_log_main(void)
{
int iVar1;
if (common_log_main()::log == '\0') {
iVar1 = __cxa_guard_acquire(&common_log_main()::log);
if (iVar1 != 0) {
/* try { // try from 001ce06f to 001ce07f has its CatchHandler @ 001ce0a8 */
common_log::common_log((common_log *)common_log_main()::log,0x100);
__cxa_atexit(common_log::~common_log,common_log_main()::log,&__dso_handle);
__cxa_guard_release(&common_log_main()::log);
}
}
return common_log_main()::log;
}
| |
29,246 | common_log_main() | monkey531[P]llama/common/log.cpp | struct common_log * common_log_main() {
static struct common_log log;
return &log;
} | O3 | cpp | common_log_main():
pushq %rbx
movb 0x610aa(%rip), %al # 0x12d518
testb %al, %al
je 0xcc47b
leaq 0x60fcf(%rip), %rax # 0x12d448
popq %rbx
retq
leaq 0x61096(%rip), %rdi # 0x12d518
callq 0x1b010
testl %eax, %eax
je 0xcc472
leaq 0x60fb6(%rip), %rdi # 0x12d448
movl $0x100, %esi # imm = 0x100
callq 0xccb66
leaq 0x10d(%rip), %rdi # 0xcc5b0
leaq 0x60f9e(%rip), %rsi # 0x12d448
leaq 0x60427(%rip), %rdx # 0x12c8d8
callq 0x1a7b0
leaq 0x6105b(%rip), %rdi # 0x12d518
callq 0x1a5b0
jmp 0xcc472
movq %rax, %rbx
leaq 0x6104a(%rip), %rdi # 0x12d518
callq 0x1a5a0
movq %rbx, %rdi
callq 0x1afb0
| _Z15common_log_mainv:
push rbx
mov al, cs:_ZGVZ15common_log_mainvE3log; `guard variable for'common_log_main(void)::log
test al, al
jz short loc_CC47B
loc_CC472:
lea rax, _ZZ15common_log_mainvE3log; common_log_main(void)::log
pop rbx
retn
loc_CC47B:
lea rdi, _ZGVZ15common_log_mainvE3log; __guard *
call ___cxa_guard_acquire
test eax, eax
jz short loc_CC472
lea rdi, _ZZ15common_log_mainvE3log; this
mov esi, 100h; unsigned __int64
call _ZN10common_logC2Em; common_log::common_log(ulong)
lea rdi, _ZN10common_logD2Ev; lpfunc
lea rsi, _ZZ15common_log_mainvE3log; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZ15common_log_mainvE3log; __guard *
call ___cxa_guard_release
jmp short loc_CC472
mov rbx, rax
lea rdi, _ZGVZ15common_log_mainvE3log; __guard *
call ___cxa_guard_abort
mov rdi, rbx
call __Unwind_Resume
| void *common_log_main(void)
{
if ( !(_BYTE)`guard variable for'common_log_main(void)::log
&& __cxa_guard_acquire(&`guard variable for'common_log_main(void)::log) )
{
common_log::common_log((common_log *)&common_log_main(void)::log, 0x100uLL);
__cxa_atexit(common_log::~common_log, &common_log_main(void)::log, &_dso_handle);
__cxa_guard_release(&`guard variable for'common_log_main(void)::log);
}
return &common_log_main(void)::log;
}
| common_log_main:
PUSH RBX
MOV AL,byte ptr [0x0022d518]
TEST AL,AL
JZ 0x001cc47b
LAB_001cc472:
LEA RAX,[0x22d448]
POP RBX
RET
LAB_001cc47b:
LEA RDI,[0x22d518]
CALL 0x0011b010
TEST EAX,EAX
JZ 0x001cc472
LAB_001cc48b:
LEA RDI,[0x22d448]
MOV ESI,0x100
CALL 0x001ccb66
LAB_001cc49c:
LEA RDI,[0x1cc5b0]
LEA RSI,[0x22d448]
LEA RDX,[0x22c8d8]
CALL 0x0011a7b0
LEA RDI,[0x22d518]
CALL 0x0011a5b0
JMP 0x001cc472
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* common_log_main() */
int1 * common_log_main(void)
{
int iVar1;
if (common_log_main()::log == '\0') {
iVar1 = __cxa_guard_acquire(&common_log_main()::log);
if (iVar1 != 0) {
/* try { // try from 001cc48b to 001cc49b has its CatchHandler @ 001cc4c4 */
common_log::common_log((common_log *)common_log_main()::log,0x100);
__cxa_atexit(common_log::~common_log,common_log_main()::log,&__dso_handle);
__cxa_guard_release(&common_log_main()::log);
}
}
return common_log_main()::log;
}
| |
29,247 | mi_dispose | eloqsql/storage/myisam/mi_page.c | int _mi_dispose(register MI_INFO *info, MI_KEYDEF *keyinfo, my_off_t pos,
int level)
{
my_off_t old_link;
uchar buff[8];
DBUG_ENTER("_mi_dispose");
DBUG_PRINT("enter",("pos: %ld", (long) pos));
old_link= info->s->state.key_del[keyinfo->block_size_index];
info->s->state.key_del[keyinfo->block_size_index]= pos;
mi_sizestore(buff,old_link);
info->s->state.changed|= STATE_NOT_SORTED_PAGES;
DBUG_RETURN(key_cache_write(info->s->key_cache,
info->s->kfile, &info->s->dirty_part_map,
pos , level, buff,
sizeof(buff),
(uint) keyinfo->block_length,
(int) (info->lock_type != F_UNLCK)));
} | O0 | c | mi_dispose:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
jmp 0xbe379
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0xa0(%rax), %rax
movq -0x20(%rbp), %rcx
movzwl 0x18(%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0xa0(%rax), %rax
movq -0x20(%rbp), %rcx
movzwl 0x18(%rcx), %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
shrq $0x20, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movb %al, -0xd(%rbp)
movq -0x50(%rbp), %rax
shrq $0x8, %rax
movb %al, -0xe(%rbp)
movq -0x50(%rbp), %rax
shrq $0x10, %rax
movb %al, -0xf(%rbp)
movq -0x50(%rbp), %rax
shrq $0x18, %rax
movb %al, -0x10(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movb %al, -0x9(%rbp)
movq -0x58(%rbp), %rax
shrq $0x8, %rax
movb %al, -0xa(%rbp)
movq -0x58(%rbp), %rax
shrq $0x10, %rax
movb %al, -0xb(%rbp)
movq -0x58(%rbp), %rax
shrq $0x18, %rax
movb %al, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movzbl 0xf0(%rax), %ecx
orl $0x20, %ecx
movb %cl, 0xf0(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x278(%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl 0x350(%rax), %esi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
addq $0x280, %rdx # imm = 0x280
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
leaq -0x10(%rbp), %r9
movq -0x20(%rbp), %rax
movzwl 0xe(%rax), %r10d
movq -0x18(%rbp), %rax
cmpl $0x2, 0x1f4(%rax)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl $0x8, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
callq 0xe4bf0
movl %eax, -0x5c(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xbe4c7
movl -0x5c(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
callq 0x2a270
nopl (%rax)
| _mi_dispose:
push rbp
mov rbp, rsp
sub rsp, 80h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_28], rdx
mov [rbp+var_2C], ecx
jmp short $+2
loc_BE379:
mov rax, [rbp+var_18]
mov rax, [rax]
mov rax, [rax+0A0h]
mov rcx, [rbp+var_20]
movzx ecx, word ptr [rcx+18h]
mov rax, [rax+rcx*8]
mov [rbp+var_38], rax
mov rdx, [rbp+var_28]
mov rax, [rbp+var_18]
mov rax, [rax]
mov rax, [rax+0A0h]
mov rcx, [rbp+var_20]
movzx ecx, word ptr [rcx+18h]
mov [rax+rcx*8], rdx
mov rax, [rbp+var_38]
mov [rbp+var_40], rax
mov rax, [rbp+var_38]
shr rax, 20h
mov [rbp+var_48], rax
mov rax, [rbp+var_48]
mov [rbp+var_50], rax
mov rax, [rbp+var_50]
mov [rbp+var_D], al
mov rax, [rbp+var_50]
shr rax, 8
mov [rbp+var_E], al
mov rax, [rbp+var_50]
shr rax, 10h
mov [rbp+var_F], al
mov rax, [rbp+var_50]
shr rax, 18h
mov [rbp+var_10], al
mov rax, [rbp+var_40]
mov [rbp+var_58], rax
mov rax, [rbp+var_58]
mov [rbp+var_9], al
mov rax, [rbp+var_58]
shr rax, 8
mov [rbp+var_A], al
mov rax, [rbp+var_58]
shr rax, 10h
mov [rbp+var_B], al
mov rax, [rbp+var_58]
shr rax, 18h
mov [rbp+var_C], al
mov rax, [rbp+var_18]
mov rax, [rax]
movzx ecx, byte ptr [rax+0F0h]
or ecx, 20h
mov [rax+0F0h], cl
mov rax, [rbp+var_18]
mov rax, [rax]
mov rdi, [rax+278h]
mov rax, [rbp+var_18]
mov rax, [rax]
mov esi, [rax+350h]
mov rax, [rbp+var_18]
mov rdx, [rax]
add rdx, 280h
mov rcx, [rbp+var_28]
mov r8d, [rbp+var_2C]
lea r9, [rbp+var_10]
mov rax, [rbp+var_20]
movzx r10d, word ptr [rax+0Eh]
mov rax, [rbp+var_18]
cmp dword ptr [rax+1F4h], 2
setnz al
and al, 1
movzx eax, al
mov [rsp+80h+var_80], 8
mov [rsp+80h+var_78], r10d
mov [rsp+80h+var_70], eax
call key_cache_write
mov [rbp+var_5C], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_BE4C7
mov eax, [rbp+var_5C]
add rsp, 80h
pop rbp
retn
loc_BE4C7:
call ___stack_chk_fail
| long long mi_dispose(_DWORD *a1, long long a2, long long a3, int a4)
{
long long v5; // [rsp+48h] [rbp-38h]
_BYTE v6[8]; // [rsp+70h] [rbp-10h] BYREF
unsigned long long v7; // [rsp+78h] [rbp-8h]
v7 = __readfsqword(0x28u);
v5 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 160LL) + 8LL * *(unsigned __int16 *)(a2 + 24));
*(_QWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 160LL) + 8LL * *(unsigned __int16 *)(a2 + 24)) = a3;
v6[2] = BYTE5(v5);
v6[3] = BYTE4(v5);
v6[0] = HIBYTE(v5);
v6[1] = BYTE6(v5);
v6[6] = BYTE1(v5);
v6[7] = v5;
v6[4] = BYTE3(v5);
v6[5] = BYTE2(v5);
*(_BYTE *)(*(_QWORD *)a1 + 240LL) |= 0x20u;
return (unsigned int)key_cache_write(
*(_QWORD *)(*(_QWORD *)a1 + 632LL),
*(_DWORD *)(*(_QWORD *)a1 + 848LL),
*a1 + 640,
a3,
a4,
(unsigned int)v6,
8,
*(unsigned __int16 *)(a2 + 14),
a1[125] != 2);
}
| _mi_dispose:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x2c],ECX
JMP 0x001be379
LAB_001be379:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0xa0]
MOV RCX,qword ptr [RBP + -0x20]
MOVZX ECX,word ptr [RCX + 0x18]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x38],RAX
MOV RDX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0xa0]
MOV RCX,qword ptr [RBP + -0x20]
MOVZX ECX,word ptr [RCX + 0x18]
MOV qword ptr [RAX + RCX*0x8],RDX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x38]
SHR RAX,0x20
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV byte ptr [RBP + -0xd],AL
MOV RAX,qword ptr [RBP + -0x50]
SHR RAX,0x8
MOV byte ptr [RBP + -0xe],AL
MOV RAX,qword ptr [RBP + -0x50]
SHR RAX,0x10
MOV byte ptr [RBP + -0xf],AL
MOV RAX,qword ptr [RBP + -0x50]
SHR RAX,0x18
MOV byte ptr [RBP + -0x10],AL
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x58]
MOV byte ptr [RBP + -0x9],AL
MOV RAX,qword ptr [RBP + -0x58]
SHR RAX,0x8
MOV byte ptr [RBP + -0xa],AL
MOV RAX,qword ptr [RBP + -0x58]
SHR RAX,0x10
MOV byte ptr [RBP + -0xb],AL
MOV RAX,qword ptr [RBP + -0x58]
SHR RAX,0x18
MOV byte ptr [RBP + -0xc],AL
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOVZX ECX,byte ptr [RAX + 0xf0]
OR ECX,0x20
MOV byte ptr [RAX + 0xf0],CL
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + 0x278]
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV ESI,dword ptr [RAX + 0x350]
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RAX]
ADD RDX,0x280
MOV RCX,qword ptr [RBP + -0x28]
MOV R8D,dword ptr [RBP + -0x2c]
LEA R9,[RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x20]
MOVZX R10D,word ptr [RAX + 0xe]
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX + 0x1f4],0x2
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RSP],0x8
MOV dword ptr [RSP + 0x8],R10D
MOV dword ptr [RSP + 0x10],EAX
CALL 0x001e4bf0
MOV dword ptr [RBP + -0x5c],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001be4c7
MOV EAX,dword ptr [RBP + -0x5c]
ADD RSP,0x80
POP RBP
RET
LAB_001be4c7:
CALL 0x0012a270
|
int4 _mi_dispose(long *param_1,long param_2,int8 param_3,int4 param_4)
{
int8 uVar1;
int4 uVar2;
long in_FS_OFFSET;
int1 local_18;
int1 local_17;
int1 local_16;
int1 local_15;
int1 local_14;
int1 local_13;
int1 local_12;
int1 local_11;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar1 = *(int8 *)(*(long *)(*param_1 + 0xa0) + (ulong)*(ushort *)(param_2 + 0x18) * 8);
*(int8 *)(*(long *)(*param_1 + 0xa0) + (ulong)*(ushort *)(param_2 + 0x18) * 8) = param_3;
local_15 = (int1)((ulong)uVar1 >> 0x20);
local_16 = (int1)((ulong)uVar1 >> 0x28);
local_17 = (int1)((ulong)uVar1 >> 0x30);
local_18 = (int1)((ulong)uVar1 >> 0x38);
local_11 = (int1)uVar1;
local_12 = (int1)((ulong)uVar1 >> 8);
local_13 = (int1)((ulong)uVar1 >> 0x10);
local_14 = (int1)((ulong)uVar1 >> 0x18);
*(byte *)(*param_1 + 0xf0) = *(byte *)(*param_1 + 0xf0) | 0x20;
uVar2 = key_cache_write(*(int8 *)(*param_1 + 0x278),*(int4 *)(*param_1 + 0x350),
*param_1 + 0x280,param_3,param_4,&local_18,8,
*(int2 *)(param_2 + 0xe),*(int *)((long)param_1 + 500) != 2);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return uVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
29,248 | my_string_repertoire_8bit | eloqsql/strings/ctype.c | uint
my_string_repertoire_8bit(CHARSET_INFO *cs, const char *str, size_t length)
{
const char *strend;
if ((cs->state & MY_CS_NONASCII) && length > 0)
return MY_REPERTOIRE_UNICODE30;
for (strend= str + length; str < strend; str++)
{
if (((uchar) *str) > 0x7F)
return MY_REPERTOIRE_UNICODE30;
}
return MY_REPERTOIRE_ASCII;
} | O0 | c | my_string_repertoire_8bit:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x2000, %eax # imm = 0x2000
cmpl $0x0, %eax
je 0x6ecf1
cmpq $0x0, -0x20(%rbp)
jbe 0x6ecf1
movl $0x3, -0x4(%rbp)
jmp 0x6ed33
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x6ed2c
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x7f, %eax
jle 0x6ed1c
movl $0x3, -0x4(%rbp)
jmp 0x6ed33
jmp 0x6ed1e
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x6ecfd
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
| my_string_repertoire_8bit:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
mov eax, [rax+0Ch]
and eax, 2000h
cmp eax, 0
jz short loc_6ECF1
cmp [rbp+var_20], 0
jbe short loc_6ECF1
mov [rbp+var_4], 3
jmp short loc_6ED33
loc_6ECF1:
mov rax, [rbp+var_18]
add rax, [rbp+var_20]
mov [rbp+var_28], rax
loc_6ECFD:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_28]
jnb short loc_6ED2C
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
cmp eax, 7Fh
jle short loc_6ED1C
mov [rbp+var_4], 3
jmp short loc_6ED33
loc_6ED1C:
jmp short $+2
loc_6ED1E:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_6ECFD
loc_6ED2C:
mov [rbp+var_4], 1
loc_6ED33:
mov eax, [rbp+var_4]
pop rbp
retn
| long long my_string_repertoire_8bit(long long a1, unsigned __int8 *a2, long long a3)
{
unsigned __int8 *v4; // [rsp+10h] [rbp-18h]
v4 = a2;
if ( (*(_DWORD *)(a1 + 12) & 0x2000) != 0 && a3 )
{
return 3;
}
else
{
while ( v4 < &a2[a3] )
{
if ( *v4 > 0x7Fu )
return 3;
++v4;
}
return 1;
}
}
| my_string_repertoire_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 RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0xc]
AND EAX,0x2000
CMP EAX,0x0
JZ 0x0016ecf1
CMP qword ptr [RBP + -0x20],0x0
JBE 0x0016ecf1
MOV dword ptr [RBP + -0x4],0x3
JMP 0x0016ed33
LAB_0016ecf1:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x28],RAX
LAB_0016ecfd:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x28]
JNC 0x0016ed2c
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x7f
JLE 0x0016ed1c
MOV dword ptr [RBP + -0x4],0x3
JMP 0x0016ed33
LAB_0016ed1c:
JMP 0x0016ed1e
LAB_0016ed1e:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0016ecfd
LAB_0016ed2c:
MOV dword ptr [RBP + -0x4],0x1
LAB_0016ed33:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_string_repertoire_8bit(long param_1,byte *param_2,long param_3)
{
byte *local_20;
int4 local_c;
if (((*(uint *)(param_1 + 0xc) & 0x2000) == 0) || (param_3 == 0)) {
for (local_20 = param_2; local_20 < param_2 + param_3; local_20 = local_20 + 1) {
if (0x7f < *local_20) {
return 3;
}
}
local_c = 1;
}
else {
local_c = 3;
}
return local_c;
}
| |
29,249 | inline_mysql_file_close | eloqsql/include/mysql/psi/mysql_file.h | static inline int
inline_mysql_file_close(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, myf flags)
{
int result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, file, PSI_FILE_CLOSE);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_close_wait)(locker, src_file, src_line);
result= my_close(file, flags);
PSI_FILE_CALL(end_file_close_wait)(locker, result);
return result;
}
#endif
result= my_close(file, flags);
return result;
} | O0 | c | inline_mysql_file_close:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq 0x1e27a8(%rip), %rax # 0x2c00b8
movq (%rax), %rax
movq 0x158(%rax), %rax
movl -0x18(%rbp), %esi
leaq -0x78(%rbp), %rdi
movl $0x4, %edx
callq *%rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xdd99b
leaq 0x1e2765(%rip), %rax # 0x2c00b8
movq (%rax), %rax
movq 0x220(%rax), %rax
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq *%rax
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0xf4500
movl %eax, -0x24(%rbp)
leaq 0x1e2738(%rip), %rax # 0x2c00b8
movq (%rax), %rax
movq 0x228(%rax), %rax
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
callq *%rax
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xdd9b0
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0xf4500
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
| inline_mysql_file_close_8:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_20], rcx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+158h]
mov esi, [rbp+var_18]
lea rdi, [rbp+var_78]
mov edx, 4
call rax
mov [rbp+var_30], rax
cmp [rbp+var_30], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_DD99B
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+220h]
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_10]
mov edx, [rbp+var_14]
call rax
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
call my_close
mov [rbp+var_24], eax
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+228h]
mov rdi, [rbp+var_30]
mov esi, [rbp+var_24]
call rax
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
jmp short loc_DD9B0
loc_DD99B:
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
call my_close
mov [rbp+var_24], eax
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
loc_DD9B0:
mov eax, [rbp+var_4]
add rsp, 80h
pop rbp
retn
| long long inline_mysql_file_close_8(long long a1, unsigned int a2, unsigned int a3, long long a4)
{
_BYTE v5[72]; // [rsp+8h] [rbp-78h] BYREF
long long v6; // [rsp+50h] [rbp-30h]
unsigned int v7; // [rsp+5Ch] [rbp-24h]
long long v8; // [rsp+60h] [rbp-20h]
unsigned int v9; // [rsp+68h] [rbp-18h]
unsigned int v10; // [rsp+6Ch] [rbp-14h]
long long v11; // [rsp+70h] [rbp-10h]
v11 = a1;
v10 = a2;
v9 = a3;
v8 = a4;
v6 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v5, a3, 4LL);
if ( v6 )
{
((void ( *)(long long, long long, _QWORD))PSI_server[68])(v6, v11, v10);
v7 = my_close(v9, v8);
((void ( *)(long long, _QWORD))PSI_server[69])(v6, v7);
}
else
{
return (unsigned int)my_close(v9, v8);
}
return v7;
}
| inline_mysql_file_close:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV qword ptr [RBP + -0x20],RCX
LEA RAX,[0x3c00b8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x158]
MOV ESI,dword ptr [RBP + -0x18]
LEA RDI,[RBP + -0x78]
MOV EDX,0x4
CALL RAX
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x30],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001dd99b
LEA RAX,[0x3c00b8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x220]
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x14]
CALL RAX
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x001f4500
MOV dword ptr [RBP + -0x24],EAX
LEA RAX,[0x3c00b8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x228]
MOV RDI,qword ptr [RBP + -0x30]
MOV ESI,dword ptr [RBP + -0x24]
CALL RAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001dd9b0
LAB_001dd99b:
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x001f4500
MOV dword ptr [RBP + -0x24],EAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
LAB_001dd9b0:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x80
POP RBP
RET
|
int4
inline_mysql_file_close(int8 param_1,int4 param_2,int4 param_3,int8 param_4)
{
int1 local_80 [72];
long local_38;
int4 local_2c;
int8 local_28;
int4 local_20;
int4 local_1c;
int8 local_18;
int4 local_c;
local_28 = param_4;
local_20 = param_3;
local_1c = param_2;
local_18 = param_1;
local_38 = (**(code **)(PSI_server + 0x158))(local_80,param_3,4);
if (local_38 == 0) {
local_c = my_close(local_20,local_28);
}
else {
(**(code **)(PSI_server + 0x220))(local_38,local_18,local_1c);
local_2c = my_close(local_20,local_28);
(**(code **)(PSI_server + 0x228))(local_38,local_2c);
local_c = local_2c;
}
return local_c;
}
| |
29,250 | ma_read_rnd_mempack_record | eloqsql/storage/maria/ma_packrec.c | static int _ma_read_rnd_mempack_record(MARIA_HA *info,
uchar *buf,
register MARIA_RECORD_POS filepos,
my_bool skip_deleted_blocks
__attribute__((unused)))
{
MARIA_BLOCK_INFO block_info;
MARIA_SHARE *share= info->s;
uchar *pos,*start;
DBUG_ENTER("_ma_read_rnd_mempack_record");
if (filepos >= share->state.state.data_file_length)
{
my_errno=HA_ERR_END_OF_FILE;
goto err;
}
if (!(pos= (uchar*) _ma_mempack_get_block_info(info, &info->bit_buff,
&block_info,
&info->rec_buff,
&info->rec_buff_size,
(uchar*)
(start= share->file_map +
filepos))))
goto err;
#ifndef DBUG_OFF
if (block_info.rec_len > info->s->max_pack_length)
{
_ma_set_fatal_error(info, HA_ERR_WRONG_IN_RECORD);
goto err;
}
#endif
info->packed_length=block_info.rec_len;
info->cur_row.lastpos= filepos;
info->cur_row.nextpos= filepos+(uint) (pos-start)+block_info.rec_len;
info->update|= HA_STATE_AKTIV | HA_STATE_KEY_CHANGED;
DBUG_RETURN (_ma_pack_rec_unpack(info, &info->bit_buff, buf,
pos, block_info.rec_len));
err:
DBUG_RETURN(my_errno);
} | O3 | c | ma_read_rnd_mempack_record:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq (%rdi), %rdi
cmpq %rdx, 0x40(%rdi)
jbe 0x3a6a5
movq %rdx, %r15
movq %rsi, %rbx
leaq 0x290(%r14), %r12
leaq 0x3a0(%r14), %rcx
leaq 0x460(%r14), %r8
movq 0x5f0(%rdi), %r13
addq %rdx, %r13
leaq -0x88(%rbp), %rdx
movq %r12, %rsi
movq %r13, %r9
callq 0x3bfb5
testq %rax, %rax
je 0x3a6b0
movq -0x70(%rbp), %r8
movq %r8, 0x450(%r14)
movq %r15, 0x98(%r14)
movl %eax, %ecx
subl %r13d, %ecx
addq %r8, %r15
addq %rcx, %r15
movq %r15, 0xa0(%r14)
orb $-0x7e, 0x624(%r14)
movq %fs:0x28, %rcx
cmpq -0x30(%rbp), %rcx
jne 0x3a6d5
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %rax, %rcx
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3a115
callq 0xa1b22
movl $0x89, (%rax)
callq 0xa1b22
movl (%rax), %eax
movq %fs:0x28, %rcx
cmpq -0x30(%rbp), %rcx
jne 0x3a6d5
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x29270
| _ma_read_rnd_mempack_record:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r14, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov rdi, [rdi]
cmp [rdi+40h], rdx
jbe loc_3A6A5
mov r15, rdx
mov rbx, rsi
lea r12, [r14+290h]
lea rcx, [r14+3A0h]
lea r8, [r14+460h]
mov r13, [rdi+5F0h]
add r13, rdx
lea rdx, [rbp+var_88]
mov rsi, r12
mov r9, r13
call _ma_mempack_get_block_info
test rax, rax
jz short loc_3A6B0
mov r8, [rbp+var_70]
mov [r14+450h], r8
mov [r14+98h], r15
mov ecx, eax
sub ecx, r13d
add r15, r8
add r15, rcx
mov [r14+0A0h], r15
or byte ptr [r14+624h], 82h
mov rcx, fs:28h
cmp rcx, [rbp+var_30]
jnz short loc_3A6D5
mov rdi, r14
mov rsi, r12
mov rdx, rbx
mov rcx, rax
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _ma_pack_rec_unpack
loc_3A6A5:
call _my_thread_var
mov dword ptr [rax], 89h
loc_3A6B0:
call _my_thread_var
mov eax, [rax]
mov rcx, fs:28h
cmp rcx, [rbp+var_30]
jnz short loc_3A6D5
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3A6D5:
call ___stack_chk_fail
| long long ma_read_rnd_mempack_record(long long *a1, long long a2, unsigned long long a3, long long a4, long long a5)
{
long long v6; // rdi
long long v8; // rbx
unsigned long long v9; // r13
long long block_info; // rax
long long v11; // rdx
long long v12; // rcx
long long v13; // r8
int v14; // r9d
long long v15; // r8
_BYTE v17[24]; // [rsp+8h] [rbp-88h] BYREF
long long v18; // [rsp+20h] [rbp-70h]
unsigned long long v19; // [rsp+60h] [rbp-30h]
v19 = __readfsqword(0x28u);
v6 = *a1;
if ( *(_QWORD *)(v6 + 64) <= a3 )
{
*(_DWORD *)my_thread_var(v6, a2, a3, a4, a5) = 137;
}
else
{
v8 = a2;
v9 = a3 + *(_QWORD *)(v6 + 1520);
a2 = (long long)(a1 + 82);
block_info = ma_mempack_get_block_info(v6, a1 + 82, v17, a1 + 116, a1 + 140, v9);
if ( block_info )
{
v15 = v18;
a1[138] = v18;
a1[19] = a3;
a1[20] = (unsigned int)(block_info - v9) + v15 + a3;
*((_BYTE *)a1 + 1572) |= 0x82u;
return ma_pack_rec_unpack(a1, (long long)(a1 + 82), v8, block_info, v15, v14);
}
}
return *(unsigned int *)my_thread_var(v6, a2, v11, v12, v13);
}
| _ma_read_rnd_mempack_record:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RDI]
CMP qword ptr [RDI + 0x40],RDX
JBE 0x0013a6a5
MOV R15,RDX
MOV RBX,RSI
LEA R12,[R14 + 0x290]
LEA RCX,[R14 + 0x3a0]
LEA R8,[R14 + 0x460]
MOV R13,qword ptr [RDI + 0x5f0]
ADD R13,RDX
LEA RDX,[RBP + -0x88]
MOV RSI,R12
MOV R9,R13
CALL 0x0013bfb5
TEST RAX,RAX
JZ 0x0013a6b0
MOV R8,qword ptr [RBP + -0x70]
MOV qword ptr [R14 + 0x450],R8
MOV qword ptr [R14 + 0x98],R15
MOV ECX,EAX
SUB ECX,R13D
ADD R15,R8
ADD R15,RCX
MOV qword ptr [R14 + 0xa0],R15
OR byte ptr [R14 + 0x624],0x82
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x30]
JNZ 0x0013a6d5
MOV RDI,R14
MOV RSI,R12
MOV RDX,RBX
MOV RCX,RAX
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0013a115
LAB_0013a6a5:
CALL 0x001a1b22
MOV dword ptr [RAX],0x89
LAB_0013a6b0:
CALL 0x001a1b22
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x30]
JNZ 0x0013a6d5
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013a6d5:
CALL 0x00129270
|
ulong _ma_read_rnd_mempack_record(long *param_1,int8 param_2,ulong param_3)
{
long lVar1;
ulong uVar2;
int4 *puVar3;
uint *puVar4;
long lVar5;
long in_FS_OFFSET;
int1 local_90 [24];
long local_78;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
lVar1 = *param_1;
if (param_3 < *(ulong *)(lVar1 + 0x40)) {
lVar5 = *(long *)(lVar1 + 0x5f0) + param_3;
lVar1 = _ma_mempack_get_block_info
(lVar1,param_1 + 0x52,local_90,param_1 + 0x74,param_1 + 0x8c,lVar5);
if (lVar1 != 0) {
param_1[0x8a] = local_78;
param_1[0x13] = param_3;
param_1[0x14] = param_3 + local_78 + (ulong)(uint)((int)lVar1 - (int)lVar5);
*(byte *)((long)param_1 + 0x624) = *(byte *)((long)param_1 + 0x624) | 0x82;
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
uVar2 = _ma_pack_rec_unpack(param_1,param_1 + 0x52,param_2,lVar1);
return uVar2;
}
goto LAB_0013a6d5;
}
}
else {
puVar3 = (int4 *)_my_thread_var();
*puVar3 = 0x89;
}
puVar4 = (uint *)_my_thread_var();
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return (ulong)*puVar4;
}
LAB_0013a6d5:
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
29,251 | ma_log_del_prefix | eloqsql/storage/maria/ma_write.c | static my_bool _ma_log_del_prefix(MARIA_PAGE *ma_page,
uint org_length, uint new_length,
const uchar *key_pos, uint key_length,
int move_length)
{
LSN lsn;
uchar log_data[FILEID_STORE_SIZE + PAGE_STORE_SIZE + 2 + 2 + 12 + 7];
uchar *log_pos;
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 4];
uint offset= (uint) (key_pos - ma_page->buff);
uint diff_length= org_length + move_length - new_length;
uint translog_parts, extra_length;
MARIA_HA *info= ma_page->info;
my_off_t page= ma_page->pos / info->s->block_size;
DBUG_ENTER("_ma_log_del_prefix");
DBUG_PRINT("enter", ("page: %lu org_length: %u new_length: %u",
(ulong) page, org_length, new_length));
DBUG_ASSERT((int) diff_length > 0);
DBUG_ASSERT(ma_page->org_size == org_length);
DBUG_ASSERT(ma_page->size == new_length);
log_pos= log_data + FILEID_STORE_SIZE;
page_store(log_pos, page);
log_pos+= PAGE_STORE_SIZE;
translog_parts= 1;
extra_length= 0;
#ifdef EXTRA_DEBUG_KEY_CHANGES
*log_pos++= KEY_OP_DEBUG;
*log_pos++= KEY_OP_DEBUG_LOG_DEL_PREFIX;
#endif
/* Store keypage_flag */
*log_pos++= KEY_OP_SET_PAGEFLAG;
*log_pos++= _ma_get_keypage_flag(info->s, ma_page->buff);
if (offset < diff_length + info->s->keypage_header)
{
/*
Key is not anymore on page. Move data down, but take into account that
the original page had grown with 'move_length bytes'
*/
DBUG_ASSERT(offset + key_length <= diff_length + info->s->keypage_header);
log_pos[0]= KEY_OP_DEL_PREFIX;
int2store(log_pos+1, diff_length - move_length);
log_pos+= 3;
}
else
{
/*
Correct position to key, as data before key has been delete and key
has thus been moved down
*/
offset-= diff_length;
key_pos-= diff_length;
/* Move data down */
log_pos[0]= KEY_OP_DEL_PREFIX;
int2store(log_pos+1, diff_length);
log_pos+= 3;
log_pos[0]= KEY_OP_OFFSET;
int2store(log_pos+1, offset);
log_pos+= 3;
if (move_length)
{
log_pos[0]= KEY_OP_SHIFT;
int2store(log_pos+1, move_length);
log_pos+= 3;
}
log_pos[0]= KEY_OP_CHANGE;
int2store(log_pos+1, key_length);
log_pos+= 3;
log_array[TRANSLOG_INTERNAL_PARTS + 1].str= key_pos;
log_array[TRANSLOG_INTERNAL_PARTS + 1].length= key_length;
translog_parts= 2;
extra_length= key_length;
}
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= log_data;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= (uint) (log_pos -
log_data);
_ma_log_key_changes(ma_page,
log_array + TRANSLOG_INTERNAL_PARTS + translog_parts,
log_pos, &extra_length, &translog_parts);
/* Remember new page length for future log entires for same page */
ma_page->org_size= ma_page->size;
DBUG_RETURN(translog_write_record(&lsn, LOGREC_REDO_INDEX,
info->trn, info,
(translog_size_t)
log_array[TRANSLOG_INTERNAL_PARTS +
0].length + extra_length,
TRANSLOG_INTERNAL_PARTS + translog_parts,
log_array, log_data, NULL));
} | O3 | c | ma_log_del_prefix:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rcx, %r10
movq %fs:0x28, %rax
movq %rax, -0x28(%rbp)
movq (%rdi), %rcx
movq 0x10(%rdi), %r14
movl %r10d, %r11d
subl %r14d, %r11d
subl %edx, %esi
leal (%rsi,%r9), %ebx
movq 0x18(%rdi), %rax
movq (%rcx), %r15
movl 0x7bc(%r15), %r12d
xorl %edx, %edx
divq %r12
movl %eax, -0x4e(%rbp)
shrq $0x20, %rax
movb %al, -0x4a(%rbp)
movb $0xa, -0x49(%rbp)
movl 0x744(%r15), %eax
leal -0x3(%rax), %edx
movb (%r14,%rdx), %dl
movb %dl, -0x48(%rbp)
addl %ebx, %eax
cmpl %r11d, %eax
jbe 0x5880e
leaq -0x44(%rbp), %rax
movb $0x5, -0x3(%rax)
movw %si, -0x2(%rax)
movl $0x3, %r9d
xorl %r8d, %r8d
jmp 0x58862
subl %ebx, %r11d
movl %ebx, %eax
subq %rax, %r10
movb $0x5, -0x47(%rbp)
movw %bx, -0x46(%rbp)
movb $0x1, -0x44(%rbp)
movw %r11w, -0x43(%rbp)
testl %r9d, %r9d
je 0x5883b
leaq -0x3e(%rbp), %rax
movb $0x2, -0x3(%rax)
movw %r9w, -0x2(%rax)
jmp 0x5883f
leaq -0x41(%rbp), %rax
movb $0x3, (%rax)
movw %r8w, 0x1(%rax)
addq $0x3, %rax
movq %r10, -0x90(%rbp)
movl %r8d, %edx
movq %rdx, -0x88(%rbp)
movl $0x4, %r9d
leaq -0x50(%rbp), %r10
leaq -0xc0(%rbp), %r11
movq %r10, 0x20(%r11)
subq %r10, %rax
movl %eax, %edx
movq %rdx, 0x28(%r11)
movl 0x20(%rdi), %edx
movl %edx, 0x24(%rdi)
movq 0x8(%rcx), %rdx
addl %eax, %r8d
subq $0x8, %rsp
leaq -0x58(%rbp), %rdi
movl $0xc, %esi
pushq $0x0
pushq %r10
pushq %r11
callq 0x29c44
addq $0x20, %rsp
movq %fs:0x28, %rcx
cmpq -0x28(%rbp), %rcx
jne 0x588c2
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x29250
nop
| _ma_log_del_prefix:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 0A0h
mov r10, rcx
mov rax, fs:28h
mov [rbp+var_28], rax
mov rcx, [rdi]
mov r14, [rdi+10h]
mov r11d, r10d
sub r11d, r14d
sub esi, edx
lea ebx, [rsi+r9]
mov rax, [rdi+18h]
mov r15, [rcx]
mov r12d, [r15+7BCh]
xor edx, edx
div r12
mov [rbp+var_4E], eax
shr rax, 20h
mov [rbp+var_4A], al
mov [rbp+var_49], 0Ah
mov eax, [r15+744h]
lea edx, [rax-3]
mov dl, [r14+rdx]
mov [rbp+var_48], dl
add eax, ebx
cmp eax, r11d
jbe short loc_5880E
lea rax, [rbp+var_44]
mov byte ptr [rax-3], 5
mov [rax-2], si
mov r9d, 3
xor r8d, r8d
jmp short loc_58862
loc_5880E:
sub r11d, ebx
mov eax, ebx
sub r10, rax
mov [rbp+var_47], 5
mov [rbp+var_46], bx
mov [rbp+var_44], 1
mov [rbp+var_43], r11w
test r9d, r9d
jz short loc_5883B
lea rax, [rbp+var_3E]
mov byte ptr [rax-3], 2
mov [rax-2], r9w
jmp short loc_5883F
loc_5883B:
lea rax, [rbp+var_41]
loc_5883F:
mov byte ptr [rax], 3
mov [rax+1], r8w
add rax, 3
mov [rbp+var_90], r10
mov edx, r8d
mov [rbp+var_88], rdx
mov r9d, 4
loc_58862:
lea r10, [rbp+var_50]
lea r11, [rbp+var_C0]
mov [r11+20h], r10
sub rax, r10
mov edx, eax
mov [r11+28h], rdx
mov edx, [rdi+20h]
mov [rdi+24h], edx
mov rdx, [rcx+8]
add r8d, eax
sub rsp, 8
lea rdi, [rbp+var_58]
mov esi, 0Ch
push 0
push r10
push r11
call translog_write_record
add rsp, 20h
mov rcx, fs:28h
cmp rcx, [rbp+var_28]
jnz short loc_588C2
add rsp, 0A0h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_588C2:
call ___stack_chk_fail
| long long ma_log_del_prefix(long long **a1, int a2, int a3, long long a4, unsigned int a5, int a6)
{
long long *v7; // rcx
long long *v8; // r14
__int16 v9; // r11
int v10; // esi
unsigned int v11; // ebx
long long v12; // r15
unsigned long long v13; // rax
char *v14; // rax
int v15; // r9d
long long v16; // r10
char *v17; // rax
signed long long v18; // rax
__int128 v20; // [rsp+0h] [rbp-C0h] BYREF
__int16 *v21; // [rsp+20h] [rbp-A0h]
long long v22; // [rsp+28h] [rbp-98h]
long long v23; // [rsp+30h] [rbp-90h]
long long v24; // [rsp+38h] [rbp-88h]
_BYTE v25[8]; // [rsp+68h] [rbp-58h] BYREF
__int16 v26; // [rsp+70h] [rbp-50h] BYREF
int v27; // [rsp+72h] [rbp-4Eh]
char v28; // [rsp+76h] [rbp-4Ah]
char v29; // [rsp+77h] [rbp-49h]
char v30; // [rsp+78h] [rbp-48h]
char v31; // [rsp+79h] [rbp-47h]
__int16 v32; // [rsp+7Ah] [rbp-46h]
char v33; // [rsp+7Ch] [rbp-44h] BYREF
__int16 v34; // [rsp+7Dh] [rbp-43h]
char v35; // [rsp+7Fh] [rbp-41h] BYREF
__int16 v36; // [rsp+80h] [rbp-40h]
char v37; // [rsp+82h] [rbp-3Eh] BYREF
unsigned long long v38; // [rsp+98h] [rbp-28h]
v38 = __readfsqword(0x28u);
v7 = *a1;
v8 = a1[2];
v9 = a4 - (_WORD)v8;
v10 = a2 - a3;
v11 = v10 + a6;
v12 = **a1;
v13 = (unsigned long long)a1[3] / *(unsigned int *)(v12 + 1980);
v27 = v13;
v28 = BYTE4(v13);
v29 = 10;
LODWORD(v13) = *(_DWORD *)(v12 + 1860);
v30 = *((_BYTE *)v8 + (unsigned int)(v13 - 3));
if ( v10 + a6 + (int)v13 <= (unsigned int)(a4 - (_DWORD)v8) )
{
v16 = a4 - v11;
v31 = 5;
v32 = v10 + a6;
v33 = 1;
v34 = v9 - v11;
if ( a6 )
{
v17 = &v37;
v35 = 2;
v36 = a6;
}
else
{
v17 = &v35;
}
*v17 = 3;
*(_WORD *)(v17 + 1) = a5;
v14 = v17 + 3;
v23 = v16;
v24 = a5;
v15 = 4;
}
else
{
v14 = &v33;
v31 = 5;
v32 = v10;
v15 = 3;
a5 = 0;
}
v21 = &v26;
v18 = v14 - (char *)&v26;
v22 = (unsigned int)v18;
*((_DWORD *)a1 + 9) = *((_DWORD *)a1 + 8);
return translog_write_record(
(unsigned long long)v25,
&byte_9[3],
v7[1],
v7,
(unsigned int)v18 + a5,
v15,
&v20,
&v26,
0LL);
}
| _ma_log_del_prefix:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0xa0
MOV R10,RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
MOV RCX,qword ptr [RDI]
MOV R14,qword ptr [RDI + 0x10]
MOV R11D,R10D
SUB R11D,R14D
SUB ESI,EDX
LEA EBX,[RSI + R9*0x1]
MOV RAX,qword ptr [RDI + 0x18]
MOV R15,qword ptr [RCX]
MOV R12D,dword ptr [R15 + 0x7bc]
XOR EDX,EDX
DIV R12
MOV dword ptr [RBP + -0x4e],EAX
SHR RAX,0x20
MOV byte ptr [RBP + -0x4a],AL
MOV byte ptr [RBP + -0x49],0xa
MOV EAX,dword ptr [R15 + 0x744]
LEA EDX,[RAX + -0x3]
MOV DL,byte ptr [R14 + RDX*0x1]
MOV byte ptr [RBP + -0x48],DL
ADD EAX,EBX
CMP EAX,R11D
JBE 0x0015880e
LEA RAX,[RBP + -0x44]
MOV byte ptr [RAX + -0x3],0x5
MOV word ptr [RAX + -0x2],SI
MOV R9D,0x3
XOR R8D,R8D
JMP 0x00158862
LAB_0015880e:
SUB R11D,EBX
MOV EAX,EBX
SUB R10,RAX
MOV byte ptr [RBP + -0x47],0x5
MOV word ptr [RBP + -0x46],BX
MOV byte ptr [RBP + -0x44],0x1
MOV word ptr [RBP + -0x43],R11W
TEST R9D,R9D
JZ 0x0015883b
LEA RAX,[RBP + -0x3e]
MOV byte ptr [RAX + -0x3],0x2
MOV word ptr [RAX + -0x2],R9W
JMP 0x0015883f
LAB_0015883b:
LEA RAX,[RBP + -0x41]
LAB_0015883f:
MOV byte ptr [RAX],0x3
MOV word ptr [RAX + 0x1],R8W
ADD RAX,0x3
MOV qword ptr [RBP + -0x90],R10
MOV EDX,R8D
MOV qword ptr [RBP + -0x88],RDX
MOV R9D,0x4
LAB_00158862:
LEA R10,[RBP + -0x50]
LEA R11,[RBP + -0xc0]
MOV qword ptr [R11 + 0x20],R10
SUB RAX,R10
MOV EDX,EAX
MOV qword ptr [R11 + 0x28],RDX
MOV EDX,dword ptr [RDI + 0x20]
MOV dword ptr [RDI + 0x24],EDX
MOV RDX,qword ptr [RCX + 0x8]
ADD R8D,EAX
SUB RSP,0x8
LEA RDI,[RBP + -0x58]
MOV ESI,0xc
PUSH 0x0
PUSH R10
PUSH R11
CALL 0x00129c44
ADD RSP,0x20
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x28]
JNZ 0x001588c2
ADD RSP,0xa0
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001588c2:
CALL 0x00129250
|
void _ma_log_del_prefix(long *param_1,int param_2,int param_3,long param_4,uint param_5,int param_6)
{
long *plVar1;
int1 auVar2 [16];
int iVar3;
uint uVar4;
int1 *puVar5;
int8 uVar6;
uint uVar7;
long in_FS_OFFSET;
int1 local_c8 [32];
int1 *local_a8;
ulong local_a0;
long local_98;
ulong local_90;
int1 local_60 [8];
int1 local_58 [2];
int4 local_56;
int1 local_52;
int1 local_51;
int1 local_50;
int1 local_4f;
short local_4e;
int1 local_4c;
short local_4b;
int1 local_49;
int2 local_48;
int1 local_46 [22];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
plVar1 = (long *)*param_1;
uVar7 = (int)param_4 - (int)param_1[2];
uVar4 = (param_2 - param_3) + param_6;
auVar2._8_8_ = 0;
auVar2._0_8_ = param_1[3];
auVar2 = auVar2 / ZEXT416(*(uint *)(*plVar1 + 0x7bc));
local_56 = auVar2._0_4_;
local_52 = auVar2[4];
local_51 = 10;
iVar3 = *(int *)(*plVar1 + 0x744);
local_50 = *(int1 *)(param_1[2] + (ulong)(iVar3 - 3));
if (uVar7 < iVar3 + uVar4) {
iVar3 = (int)&local_4c;
local_4e = (short)(param_2 - param_3);
uVar6 = 3;
param_5 = 0;
}
else {
local_4e = (short)uVar4;
local_4b = (short)uVar7 - local_4e;
local_98 = param_4 - (ulong)uVar4;
local_4c = 1;
if (param_6 == 0) {
puVar5 = &local_49;
}
else {
puVar5 = local_46;
local_49 = 2;
local_48 = (int2)param_6;
}
*puVar5 = 3;
*(short *)(puVar5 + 1) = (short)param_5;
iVar3 = (int)puVar5 + 3;
local_90 = (ulong)param_5;
uVar6 = 4;
}
local_4f = 5;
local_a8 = local_58;
uVar4 = iVar3 - (int)local_a8;
local_a0 = (ulong)uVar4;
*(int *)((long)param_1 + 0x24) = (int)param_1[4];
translog_write_record(local_60,0xc,plVar1[1],plVar1,param_5 + uVar4,uVar6,local_c8,local_a8,0);
if (*(long *)(in_FS_OFFSET + 0x28) == local_30) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
29,252 | ma_tls_read_async | eloqsql/libmariadb/libmariadb/secure/openssl.c | ssize_t ma_tls_read_async(MARIADB_PVIO *pvio,
const unsigned char *buffer,
size_t length)
{
int res;
struct mysql_async_context *b= pvio->mysql->options.extension->async_context;
MARIADB_TLS *ctls= pvio->ctls;
for (;;)
{
res= SSL_read((SSL *)ctls->ssl, (void *)buffer, (int)length);
if (ma_tls_async_check_result(res, b, (SSL *)ctls->ssl))
return res;
}
} | O3 | c | ma_tls_read_async:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq 0x38(%rdi), %r13
movq 0x40(%rdi), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %r15
movq 0x10(%r13), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x13070
movl %eax, %r12d
movq 0x10(%r13), %rdx
movl %eax, %edi
movq %r15, %rsi
callq 0x2b046
testb %al, %al
je 0x2b011
movslq %r12d, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| ma_tls_read_async:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdx
mov r14, rsi
mov r13, [rdi+38h]
mov rax, [rdi+40h]
mov rax, [rax+480h]
mov r15, [rax+28h]
loc_2B011:
mov rdi, [r13+10h]
mov rsi, r14
mov edx, ebx
call _SSL_read
mov r12d, eax
mov rdx, [r13+10h]
mov edi, eax
mov rsi, r15
call ma_tls_async_check_result
test al, al
jz short loc_2B011
movsxd rax, r12d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ma_tls_read_async(long long a1, long long a2, unsigned int a3)
{
long long v4; // r13
long long v5; // r15
long long v6; // r12
v4 = *(_QWORD *)(a1 + 56);
v5 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 64) + 1152LL) + 40LL);
do
v6 = (unsigned int)SSL_read(*(_QWORD *)(v4 + 16), a2, a3);
while ( !(unsigned __int8)ma_tls_async_check_result(v6, v5, *(_QWORD *)(v4 + 16)) );
return (int)v6;
}
| ma_tls_read_async:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RSI
MOV R13,qword ptr [RDI + 0x38]
MOV RAX,qword ptr [RDI + 0x40]
MOV RAX,qword ptr [RAX + 0x480]
MOV R15,qword ptr [RAX + 0x28]
LAB_0012b011:
MOV RDI,qword ptr [R13 + 0x10]
MOV RSI,R14
MOV EDX,EBX
CALL 0x00113070
MOV R12D,EAX
MOV RDX,qword ptr [R13 + 0x10]
MOV EDI,EAX
MOV RSI,R15
CALL 0x0012b046
TEST AL,AL
JZ 0x0012b011
MOVSXD RAX,R12D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long ma_tls_read_async(long param_1,void *param_2,int param_3)
{
long lVar1;
int8 uVar2;
char cVar3;
int iVar4;
lVar1 = *(long *)(param_1 + 0x38);
uVar2 = *(int8 *)(*(long *)(*(long *)(param_1 + 0x40) + 0x480) + 0x28);
do {
iVar4 = SSL_read(*(SSL **)(lVar1 + 0x10),param_2,param_3);
cVar3 = ma_tls_async_check_result(iVar4,uVar2,*(int8 *)(lVar1 + 0x10));
} while (cVar3 == '\0');
return (long)iVar4;
}
| |
29,253 | Json::codePointToUTF8[abi:cxx11](unsigned int) | aimrt_mujoco_sim/_deps/jsoncpp-src/src/lib_json/json_tool.h | static inline String codePointToUTF8(unsigned int cp) {
String result;
// based on description from http://en.wikipedia.org/wiki/UTF-8
if (cp <= 0x7f) {
result.resize(1);
result[0] = static_cast<char>(cp);
} else if (cp <= 0x7FF) {
result.resize(2);
result[1] = static_cast<char>(0x80 | (0x3f & cp));
result[0] = static_cast<char>(0xC0 | (0x1f & (cp >> 6)));
} else if (cp <= 0xFFFF) {
result.resize(3);
result[2] = static_cast<char>(0x80 | (0x3f & cp));
result[1] = static_cast<char>(0x80 | (0x3f & (cp >> 6)));
result[0] = static_cast<char>(0xE0 | (0xf & (cp >> 12)));
} else if (cp <= 0x10FFFF) {
result.resize(4);
result[3] = static_cast<char>(0x80 | (0x3f & cp));
result[2] = static_cast<char>(0x80 | (0x3f & (cp >> 6)));
result[1] = static_cast<char>(0x80 | (0x3f & (cp >> 12)));
result[0] = static_cast<char>(0xF0 | (0x7 & (cp >> 18)));
}
return result;
} | O3 | c | Json::codePointToUTF8[abi:cxx11](unsigned int):
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpl $0x7f, %esi
ja 0x6f1e2
movl $0x1, %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x1e5b0
movq (%r14), %rax
jmp 0x6f2a6
cmpl $0x7ff, %ebx # imm = 0x7FF
ja 0x6f215
movl $0x2, %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x1e5b0
movq (%r14), %rax
movl %ebx, %ecx
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x1(%rax)
movq (%r14), %rax
shrl $0x6, %ebx
orb $-0x40, %bl
jmp 0x6f2a6
cmpl $0xffff, %ebx # imm = 0xFFFF
ja 0x6f256
movl $0x3, %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x1e5b0
movq (%r14), %rax
movl %ebx, %ecx
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x2(%rax)
movq (%r14), %rax
movl %ebx, %ecx
shrl $0x6, %ecx
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x1(%rax)
movq (%r14), %rax
shrl $0xc, %ebx
orb $-0x20, %bl
jmp 0x6f2a6
cmpl $0x10ffff, %ebx # imm = 0x10FFFF
ja 0x6f2a8
movl $0x4, %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x1e5b0
movq (%r14), %rax
movl %ebx, %ecx
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x3(%rax)
movq (%r14), %rax
movl %ebx, %ecx
shrl $0x6, %ecx
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x2(%rax)
movq (%r14), %rax
movl %ebx, %ecx
shrl $0xc, %ecx
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x1(%rax)
movq (%r14), %rax
shrl $0x12, %ebx
orb $-0x10, %bl
movb %bl, (%rax)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x6f2be
callq 0x1f0e0
movq %rbx, %rdi
callq 0x1ffd0
| _ZN4JsonL15codePointToUTF8B5cxx11Ej:
push r15
push r14
push rbx
mov ebx, esi
mov r14, rdi
lea r15, [rdi+10h]
mov [rdi], r15
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
cmp esi, 7Fh
ja short loc_6F1E2
mov esi, 1
mov rdi, r14
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6resizeEmc; std::string::resize(ulong,char)
mov rax, [r14]
jmp loc_6F2A6
loc_6F1E2:
cmp ebx, 7FFh
ja short loc_6F215
mov esi, 2
mov rdi, r14
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6resizeEmc; std::string::resize(ulong,char)
mov rax, [r14]
mov ecx, ebx
and cl, 3Fh
or cl, 80h
mov [rax+1], cl
mov rax, [r14]
shr ebx, 6
or bl, 0C0h
jmp loc_6F2A6
loc_6F215:
cmp ebx, 0FFFFh
ja short loc_6F256
mov esi, 3
mov rdi, r14
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6resizeEmc; std::string::resize(ulong,char)
mov rax, [r14]
mov ecx, ebx
and cl, 3Fh
or cl, 80h
mov [rax+2], cl
mov rax, [r14]
mov ecx, ebx
shr ecx, 6
and cl, 3Fh
or cl, 80h
mov [rax+1], cl
mov rax, [r14]
shr ebx, 0Ch
or bl, 0E0h
jmp short loc_6F2A6
loc_6F256:
cmp ebx, 10FFFFh
ja short loc_6F2A8
mov esi, 4
mov rdi, r14
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6resizeEmc; std::string::resize(ulong,char)
mov rax, [r14]
mov ecx, ebx
and cl, 3Fh
or cl, 80h
mov [rax+3], cl
mov rax, [r14]
mov ecx, ebx
shr ecx, 6
and cl, 3Fh
or cl, 80h
mov [rax+2], cl
mov rax, [r14]
mov ecx, ebx
shr ecx, 0Ch
and cl, 3Fh
or cl, 80h
mov [rax+1], cl
mov rax, [r14]
shr ebx, 12h
or bl, 0F0h
loc_6F2A6:
mov [rax], bl
loc_6F2A8:
pop rbx
pop r14
pop r15
retn
mov rbx, rax
mov rdi, [r14]; void *
cmp rdi, r15
jz short loc_6F2BE
call __ZdlPv; operator delete(void *)
loc_6F2BE:
mov rdi, rbx
call __Unwind_Resume
| void Json::codePointToUTF8[abi:cxx11](long long a1, unsigned int a2)
{
char v2; // bl
_BYTE *v3; // rax
v2 = a2;
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
if ( a2 > 0x7F )
{
if ( a2 > 0x7FF )
{
if ( a2 > 0xFFFF )
{
if ( a2 > 0x10FFFF )
return;
std::string::resize(a1, 4LL, 0LL);
*(_BYTE *)(*(_QWORD *)a1 + 3LL) = a2 & 0x3F | 0x80;
*(_BYTE *)(*(_QWORD *)a1 + 2LL) = (a2 >> 6) & 0x3F | 0x80;
*(_BYTE *)(*(_QWORD *)a1 + 1LL) = (a2 >> 12) & 0x3F | 0x80;
v3 = *(_BYTE **)a1;
v2 = (a2 >> 18) | 0xF0;
}
else
{
std::string::resize(a1, 3LL, 0LL);
*(_BYTE *)(*(_QWORD *)a1 + 2LL) = a2 & 0x3F | 0x80;
*(_BYTE *)(*(_QWORD *)a1 + 1LL) = (a2 >> 6) & 0x3F | 0x80;
v3 = *(_BYTE **)a1;
v2 = (a2 >> 12) | 0xE0;
}
}
else
{
std::string::resize(a1, 2LL, 0LL);
*(_BYTE *)(*(_QWORD *)a1 + 1LL) = a2 & 0x3F | 0x80;
v3 = *(_BYTE **)a1;
v2 = (a2 >> 6) | 0xC0;
}
}
else
{
std::string::resize(a1, 1LL, 0LL);
v3 = *(_BYTE **)a1;
}
*v3 = v2;
}
| codePointToUTF8[abi:cxx11]:
PUSH R15
PUSH R14
PUSH RBX
MOV EBX,ESI
MOV R14,RDI
LEA R15,[RDI + 0x10]
MOV qword ptr [RDI],R15
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
CMP ESI,0x7f
JA 0x0016f1e2
LAB_0016f1cb:
MOV ESI,0x1
MOV RDI,R14
XOR EDX,EDX
CALL 0x0011e5b0
MOV RAX,qword ptr [R14]
JMP 0x0016f2a6
LAB_0016f1e2:
CMP EBX,0x7ff
JA 0x0016f215
MOV ESI,0x2
MOV RDI,R14
XOR EDX,EDX
CALL 0x0011e5b0
MOV RAX,qword ptr [R14]
MOV ECX,EBX
AND CL,0x3f
OR CL,0x80
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [R14]
SHR EBX,0x6
OR BL,0xc0
JMP 0x0016f2a6
LAB_0016f215:
CMP EBX,0xffff
JA 0x0016f256
MOV ESI,0x3
MOV RDI,R14
XOR EDX,EDX
CALL 0x0011e5b0
MOV RAX,qword ptr [R14]
MOV ECX,EBX
AND CL,0x3f
OR CL,0x80
MOV byte ptr [RAX + 0x2],CL
MOV RAX,qword ptr [R14]
MOV ECX,EBX
SHR ECX,0x6
AND CL,0x3f
OR CL,0x80
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [R14]
SHR EBX,0xc
OR BL,0xe0
JMP 0x0016f2a6
LAB_0016f256:
CMP EBX,0x10ffff
JA 0x0016f2a8
MOV ESI,0x4
MOV RDI,R14
XOR EDX,EDX
CALL 0x0011e5b0
LAB_0016f26d:
MOV RAX,qword ptr [R14]
MOV ECX,EBX
AND CL,0x3f
OR CL,0x80
MOV byte ptr [RAX + 0x3],CL
MOV RAX,qword ptr [R14]
MOV ECX,EBX
SHR ECX,0x6
AND CL,0x3f
OR CL,0x80
MOV byte ptr [RAX + 0x2],CL
MOV RAX,qword ptr [R14]
MOV ECX,EBX
SHR ECX,0xc
AND CL,0x3f
OR CL,0x80
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [R14]
SHR EBX,0x12
OR BL,0xf0
LAB_0016f2a6:
MOV byte ptr [RAX],BL
LAB_0016f2a8:
POP RBX
POP R14
POP R15
RET
|
/* Json::codePointToUTF8[abi:cxx11](unsigned int) */
void __thiscall Json::codePointToUTF8_abi_cxx11_(Json *this,uint param_1)
{
int1 *puVar1;
byte bVar2;
*(Json **)this = this + 0x10;
*(int8 *)(this + 8) = 0;
this[0x10] = (Json)0x0;
if (param_1 < 0x80) {
/* try { // try from 0016f1cb to 0016f26c has its CatchHandler @ 0016f2ae */
std::__cxx11::string::resize((string *)this,1,'\0');
puVar1 = *(int1 **)this;
}
else {
bVar2 = (byte)param_1;
if (param_1 < 0x800) {
std::__cxx11::string::resize((string *)this,2,'\0');
*(byte *)(*(long *)this + 1) = bVar2 & 0x3f | 0x80;
puVar1 = *(int1 **)this;
param_1 = (uint)(byte)((byte)(param_1 >> 6) | 0xc0);
}
else if (param_1 < 0x10000) {
std::__cxx11::string::resize((string *)this,3,'\0');
*(byte *)(*(long *)this + 2) = bVar2 & 0x3f | 0x80;
*(byte *)(*(long *)this + 1) = (byte)(param_1 >> 6) & 0x3f | 0x80;
puVar1 = *(int1 **)this;
param_1 = (uint)(byte)((byte)(param_1 >> 0xc) | 0xe0);
}
else {
if (0x10ffff < param_1) {
return;
}
std::__cxx11::string::resize((string *)this,4,'\0');
*(byte *)(*(long *)this + 3) = bVar2 & 0x3f | 0x80;
*(byte *)(*(long *)this + 2) = (byte)(param_1 >> 6) & 0x3f | 0x80;
*(byte *)(*(long *)this + 1) = (byte)(param_1 >> 0xc) & 0x3f | 0x80;
puVar1 = *(int1 **)this;
param_1 = (uint)(byte)((byte)(param_1 >> 0x12) | 0xf0);
}
}
*puVar1 = (char)param_1;
return;
}
| |
29,254 | ulight::(anonymous namespace)::Parser::expect(bool (*)(char32_t)) | ulight/src/main/cpp/mmml.cpp | [[nodiscard]]
bool expect(bool predicate(char32_t))
{
if (eof()) {
return false;
}
const auto [code_point, length] = peek_code_point();
if (!predicate(code_point)) {
return false;
}
m_pos += std::size_t(length);
return true;
} | O0 | cpp | ulight::(anonymous namespace)::Parser::expect(bool (*)(char32_t)):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x15780
testb $0x1, %al
jne 0x16473
jmp 0x16479
movb $0x0, -0x1(%rbp)
jmp 0x164ad
movq -0x28(%rbp), %rdi
callq 0x164c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %edi
callq *%rax
testb $0x1, %al
jne 0x16499
movb $0x0, -0x1(%rbp)
jmp 0x164ad
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ZN6ulight12_GLOBAL__N_16Parser6expectEPFbDiE:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rdi, [rbp+var_10]; this
mov [rbp+var_28], rdi
call _ZNK6ulight12_GLOBAL__N_16Parser3eofEv; ulight::`anonymous namespace'::Parser::eof(void)
test al, 1
jnz short loc_16473
jmp short loc_16479
loc_16473:
mov [rbp+var_1], 0
jmp short loc_164AD
loc_16479:
mov rdi, [rbp+var_28]; this
call _ZNK6ulight12_GLOBAL__N_16Parser15peek_code_pointEv; ulight::`anonymous namespace'::Parser::peek_code_point(void)
mov [rbp+var_20], rax
mov rax, [rbp+var_18]
mov edi, dword ptr [rbp+var_20]
call rax
test al, 1
jnz short loc_16499
mov [rbp+var_1], 0
jmp short loc_164AD
loc_16499:
mov rax, [rbp+var_28]
movsxd rcx, dword ptr [rbp+var_20+4]
add rcx, [rax+18h]
mov [rax+18h], rcx
mov [rbp+var_1], 1
loc_164AD:
mov al, [rbp+var_1]
and al, 1
add rsp, 30h
pop rbp
retn
| char ulight::`anonymous namespace'::Parser::expect(
ulight::_anonymous_namespace_::Parser *a1,
long long ( *a2)(_QWORD))
{
long long v3; // [rsp+10h] [rbp-20h]
if ( ulight::`anonymous namespace'::Parser::eof(a1) )
return 0;
v3 = ulight::`anonymous namespace'::Parser::peek_code_point(a1);
if ( (a2((unsigned int)v3) & 1) == 0 )
return 0;
*((_QWORD *)a1 + 3) += SHIDWORD(v3);
return 1;
}
| expect:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RDI,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RDI
CALL 0x00115780
TEST AL,0x1
JNZ 0x00116473
JMP 0x00116479
LAB_00116473:
MOV byte ptr [RBP + -0x1],0x0
JMP 0x001164ad
LAB_00116479:
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x001164c0
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EDI,dword ptr [RBP + -0x20]
CALL RAX
TEST AL,0x1
JNZ 0x00116499
MOV byte ptr [RBP + -0x1],0x0
JMP 0x001164ad
LAB_00116499:
MOV RAX,qword ptr [RBP + -0x28]
MOVSXD RCX,dword ptr [RBP + -0x1c]
ADD RCX,qword ptr [RAX + 0x18]
MOV qword ptr [RAX + 0x18],RCX
MOV byte ptr [RBP + -0x1],0x1
LAB_001164ad:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0x30
POP RBP
RET
|
/* ulight::(anonymous namespace)::Parser::expect(bool (*)(char32_t)) */
int1 __thiscall
ulight::(anonymous_namespace)::Parser::expect(Parser *this,_func_bool_wchar32 *param_1)
{
bool bVar1;
ulong uVar2;
int8 uVar3;
int iStack_24;
int1 local_9;
uVar2 = eof(this);
if ((uVar2 & 1) == 0) {
uVar3 = peek_code_point(this);
bVar1 = (*param_1)((wchar32)uVar3);
if (bVar1) {
iStack_24 = (int)((ulong)uVar3 >> 0x20);
*(long *)(this + 0x18) = (long)iStack_24 + *(long *)(this + 0x18);
local_9 = 1;
}
else {
local_9 = 0;
}
}
else {
local_9 = 0;
}
return local_9;
}
| |
29,255 | common_detokenize[abi:cxx11](llama_vocab const*, std::vector<int, std::allocator<int>> const&, bool) | llama.cpp/common/common.cpp | std::string common_detokenize(const struct llama_vocab * vocab, const std::vector<llama_token> & tokens, bool special) {
std::string text;
text.resize(std::max(text.capacity(), tokens.size()));
int32_t n_chars = llama_detokenize(vocab, tokens.data(), (int32_t)tokens.size(), &text[0], (int32_t)text.size(), false, special);
if (n_chars < 0) {
text.resize(-n_chars);
n_chars = llama_detokenize(vocab, tokens.data(), (int32_t)tokens.size(), &text[0], (int32_t)text.size(), false, special);
GGML_ASSERT(n_chars <= (int32_t)text.size()); // whitespace trimming is performed after per-token detokenization
}
text.resize(n_chars);
// NOTE: the original tokenizer decodes bytes after collecting the pieces.
return text;
} | O3 | cpp | common_detokenize[abi:cxx11](llama_vocab const*, std::vector<int, std::allocator<int>> const&, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rdx), %rax
subq (%rdx), %rax
sarq $0x2, %rax
cmpq $0x10, %rax
movl $0xf, %esi
cmovaeq %rax, %rsi
xorl %edx, %edx
callq 0x1c840
movq (%r15), %rsi
movq 0x8(%r15), %rdx
subq %rsi, %rdx
shrq $0x2, %rdx
movq (%rbx), %rcx
movl 0x8(%rbx), %r8d
movzbl %bpl, %ebp
movl %ebp, (%rsp)
movq %r14, %rdi
xorl %r9d, %r9d
callq 0x1cc70
testl %eax, %eax
jns 0xb03da
negl %eax
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x1c840
movq (%r15), %rsi
movq 0x8(%r15), %rdx
subq %rsi, %rdx
shrq $0x2, %rdx
movq (%rbx), %rcx
movl 0x8(%rbx), %r8d
movl %ebp, (%rsp)
movq %r14, %rdi
xorl %r9d, %r9d
callq 0x1cc70
cmpl 0x8(%rbx), %eax
jg 0xb03f7
movslq %eax, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1c840
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20813(%rip), %rdi # 0xd0c11
leaq 0x17c8b(%rip), %rdx # 0xc8090
leaq 0x20e46(%rip), %rcx # 0xd1252
movl $0x505, %esi # imm = 0x505
xorl %eax, %eax
callq 0x1ca40
jmp 0xb041a
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0xb0431
movq (%r12), %rsi
incq %rsi
callq 0x1c110
movq %r14, %rdi
callq 0x1c7d0
| _Z17common_detokenizeB5cxx11PK11llama_vocabRKSt6vectorIiSaIiEEb:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov ebp, ecx
mov r15, rdx
mov r14, rsi
mov rbx, rdi
lea r12, [rdi+10h]
mov [rdi], r12
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rax, [rdx+8]
sub rax, [rdx]
sar rax, 2
cmp rax, 10h
mov esi, 0Fh
cmovnb rsi, rax
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6resizeEmc; std::string::resize(ulong,char)
mov rsi, [r15]
mov rdx, [r15+8]
sub rdx, rsi
shr rdx, 2
mov rcx, [rbx]
mov r8d, [rbx+8]
movzx ebp, bpl
mov [rsp+38h+var_38], ebp
mov rdi, r14
xor r9d, r9d
call _llama_detokenize
test eax, eax
jns short loc_B03DA
neg eax
mov rdi, rbx
mov rsi, rax
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6resizeEmc; std::string::resize(ulong,char)
mov rsi, [r15]
mov rdx, [r15+8]
sub rdx, rsi
shr rdx, 2
mov rcx, [rbx]
mov r8d, [rbx+8]
mov [rsp+38h+var_38], ebp
mov rdi, r14
xor r9d, r9d
call _llama_detokenize
cmp eax, [rbx+8]
jg short loc_B03F7
loc_B03DA:
movsxd rsi, eax
mov rdi, rbx
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6resizeEmc; std::string::resize(ulong,char)
mov rax, rbx
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_B03F7:
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aNCharsInt32TTe; "n_chars <= (int32_t)text.size()"
mov esi, 505h
xor eax, eax
call _ggml_abort
jmp short $+2
loc_B041A:
mov r14, rax
mov rdi, [rbx]; void *
cmp rdi, r12
jz short loc_B0431
mov rsi, [r12]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_B0431:
mov rdi, r14
call __Unwind_Resume
| _QWORD * common_detokenize[abi:cxx11](_QWORD *a1, long long a2, _QWORD *a3, unsigned __int8 a4)
{
_QWORD *v7; // r12
long long v8; // rsi
int v9; // eax
long long v11; // r14
v7 = a1 + 2;
*a1 = a1 + 2;
a1[1] = 0LL;
*((_BYTE *)a1 + 16) = 0;
v8 = 15LL;
if ( (unsigned long long)((long long)(a3[1] - *a3) >> 2) >= 0x10 )
v8 = (long long)(a3[1] - *a3) >> 2;
std::string::resize(a1, v8, 0LL);
v9 = llama_detokenize(a2, *a3, (a3[1] - *a3) >> 2, *a1, *((unsigned int *)a1 + 2), 0LL, a4);
if ( v9 < 0 )
{
std::string::resize(a1, (unsigned int)-v9, 0LL);
v9 = llama_detokenize(a2, *a3, (a3[1] - *a3) >> 2, *a1, *((unsigned int *)a1 + 2), 0LL, a4);
if ( v9 > *((_DWORD *)a1 + 2) )
{
v11 = ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/common.cpp",
1285LL,
"GGML_ASSERT(%s) failed",
"n_chars <= (int32_t)text.size()");
if ( (_QWORD *)*a1 != v7 )
operator delete((void *)*a1, *v7 + 1LL);
_Unwind_Resume(v11);
}
}
std::string::resize(a1, v9, 0LL);
return a1;
}
| common_detokenize[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV EBP,ECX
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
LEA R12,[RDI + 0x10]
MOV qword ptr [RDI],R12
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
MOV RAX,qword ptr [RDX + 0x8]
SUB RAX,qword ptr [RDX]
SAR RAX,0x2
CMP RAX,0x10
MOV ESI,0xf
CMOVNC RSI,RAX
LAB_001b0371:
XOR EDX,EDX
CALL 0x0011c840
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
SUB RDX,RSI
SHR RDX,0x2
MOV RCX,qword ptr [RBX]
MOV R8D,dword ptr [RBX + 0x8]
LAB_001b038d:
MOVZX EBP,BPL
MOV dword ptr [RSP],EBP
MOV RDI,R14
XOR R9D,R9D
CALL 0x0011cc70
TEST EAX,EAX
JNS 0x001b03da
NEG EAX
MOV RDI,RBX
MOV RSI,RAX
XOR EDX,EDX
CALL 0x0011c840
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
SUB RDX,RSI
SHR RDX,0x2
MOV RCX,qword ptr [RBX]
MOV R8D,dword ptr [RBX + 0x8]
MOV dword ptr [RSP],EBP
MOV RDI,R14
XOR R9D,R9D
CALL 0x0011cc70
CMP EAX,dword ptr [RBX + 0x8]
JG 0x001b03f7
LAB_001b03da:
MOVSXD RSI,EAX
MOV RDI,RBX
XOR EDX,EDX
CALL 0x0011c840
MOV RAX,RBX
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001b03f7:
LEA RDI,[0x1d0c11]
LEA RDX,[0x1c8090]
LEA RCX,[0x1d1252]
MOV ESI,0x505
XOR EAX,EAX
CALL 0x0011ca40
|
/* common_detokenize[abi:cxx11](llama_vocab const*, std::vector<int, std::allocator<int> > const&,
bool) */
llama_vocab * common_detokenize_abi_cxx11_(llama_vocab *param_1,vector *param_2,bool param_3)
{
int iVar1;
ulong uVar2;
int1 in_CL;
int7 in_register_00000011;
long *plVar3;
ulong uVar4;
plVar3 = (long *)CONCAT71(in_register_00000011,param_3);
*(llama_vocab **)param_1 = param_1 + 0x10;
*(int8 *)(param_1 + 8) = 0;
param_1[0x10] = (llama_vocab)0x0;
uVar2 = plVar3[1] - *plVar3 >> 2;
uVar4 = 0xf;
if (0xf < uVar2) {
uVar4 = uVar2;
}
/* try { // try from 001b0371 to 001b0377 has its CatchHandler @ 001b0418 */
std::__cxx11::string::resize((ulong)param_1,(char)uVar4);
/* try { // try from 001b038d to 001b0417 has its CatchHandler @ 001b041a */
iVar1 = llama_detokenize(param_2,*plVar3,(ulong)(plVar3[1] - *plVar3) >> 2,*(int8 *)param_1,
*(int4 *)(param_1 + 8),0,in_CL);
if (iVar1 < 0) {
std::__cxx11::string::resize((ulong)param_1,-(char)iVar1);
iVar1 = llama_detokenize(param_2,*plVar3,(ulong)(plVar3[1] - *plVar3) >> 2,
*(int8 *)param_1,*(int4 *)(param_1 + 8),0,in_CL);
if (*(int *)(param_1 + 8) < iVar1) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/common.cpp",0x505,
"GGML_ASSERT(%s) failed","n_chars <= (int32_t)text.size()");
}
}
std::__cxx11::string::resize((ulong)param_1,(char)iVar1);
return param_1;
}
| |
29,256 | mi_pack_rec_unpack | eloqsql/storage/myisam/mi_packrec.c | int _mi_pack_rec_unpack(register MI_INFO *info, MI_BIT_BUFF *bit_buff,
register uchar *to, uchar *from, ulong reclength)
{
uchar *end_field;
reg3 MI_COLUMNDEF *end;
MI_COLUMNDEF *current_field;
MYISAM_SHARE *share=info->s;
DBUG_ENTER("_mi_pack_rec_unpack");
init_bit_buffer(bit_buff, (uchar*) from, reclength);
for (current_field=share->rec, end=current_field+share->base.fields ;
current_field < end ;
current_field++,to=end_field)
{
end_field=to+current_field->length;
(*current_field->unpack)(current_field, bit_buff, (uchar*) to,
(uchar*) end_field);
}
if (!bit_buff->error &&
bit_buff->pos - bit_buff->bits / 8 == bit_buff->end)
DBUG_RETURN(0);
info->update&= ~HA_STATE_AKTIV;
DBUG_RETURN(my_errno=HA_ERR_WRONG_IN_RECORD);
} | O3 | c | mi_pack_rec_unpack:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq %rcx, 0x8(%rsi)
movl %r8d, %esi
addq %rcx, %rsi
movq %rsi, 0x10(%r14)
movl $0x0, 0x28(%r14)
movq $0x0, (%r14)
movq 0x168(%rax), %rcx
testq %rcx, %rcx
jle 0x81ca5
movq 0x230(%rax), %r15
leaq (%rcx,%rcx,2), %r13
shlq $0x4, %r13
addq %r15, %r13
movzwl 0x4(%r15), %r12d
addq %rdx, %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rcx
callq *0x10(%r15)
addq $0x30, %r15
movq %r12, %rdx
cmpq %r13, %r15
jb 0x81c7d
cmpl $0x0, 0x28(%r14)
jne 0x81cb9
movq 0x8(%r14), %rax
movl 0x4(%r14), %ecx
shrl $0x3, %ecx
subq %rcx, %rax
cmpq 0x10(%r14), %rax
je 0x81cd2
andb $-0x3, 0x1d0(%rbx)
callq 0xa1b22
movl $0x7f, (%rax)
movl $0x7f, %eax
jmp 0x81cd4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _mi_pack_rec_unpack:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov rax, [rdi]
mov [rsi+8], rcx
mov esi, r8d
add rsi, rcx
mov [r14+10h], rsi
mov dword ptr [r14+28h], 0
mov qword ptr [r14], 0
mov rcx, [rax+168h]
test rcx, rcx
jle short loc_81CA5
mov r15, [rax+230h]
lea r13, [rcx+rcx*2]
shl r13, 4
add r13, r15
loc_81C7D:
movzx r12d, word ptr [r15+4]
add r12, rdx
mov rdi, r15
mov rsi, r14
mov rcx, r12
call qword ptr [r15+10h]
add r15, 30h ; '0'
mov rdx, r12
cmp r15, r13
jb short loc_81C7D
cmp dword ptr [r14+28h], 0
jnz short loc_81CB9
loc_81CA5:
mov rax, [r14+8]
mov ecx, [r14+4]
shr ecx, 3
sub rax, rcx
cmp rax, [r14+10h]
jz short loc_81CD2
loc_81CB9:
and byte ptr [rbx+1D0h], 0FDh
call _my_thread_var
mov dword ptr [rax], 7Fh
mov eax, 7Fh
jmp short loc_81CD4
loc_81CD2:
xor eax, eax
loc_81CD4:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long mi_pack_rec_unpack(_QWORD *a1, long long a2, long long a3, long long a4, unsigned int a5)
{
_QWORD *v6; // rbx
long long v7; // rax
const char *v8; // rsi
long long v9; // rcx
unsigned long long v10; // r15
unsigned long long v11; // r13
long long v12; // r12
v6 = a1;
v7 = *a1;
*(_QWORD *)(a2 + 8) = a4;
v8 = (const char *)(a4 + a5);
*(_QWORD *)(a2 + 16) = v8;
*(_DWORD *)(a2 + 40) = 0;
*(_QWORD *)a2 = 0LL;
v9 = *(_QWORD *)(v7 + 360);
if ( v9 <= 0 )
goto LABEL_5;
v10 = *(_QWORD *)(v7 + 560);
v11 = v10 + 48 * v9;
do
{
v12 = a3 + *(unsigned __int16 *)(v10 + 4);
a1 = (_QWORD *)v10;
v8 = (const char *)a2;
(*(void ( **)(unsigned long long, long long, long long, long long))(v10 + 16))(v10, a2, a3, v12);
v10 += 48LL;
a3 = v12;
}
while ( v10 < v11 );
if ( !*(_DWORD *)(a2 + 40) )
{
LABEL_5:
if ( *(_QWORD *)(a2 + 8) - (*(_DWORD *)(a2 + 4) >> 3) == *(_QWORD *)(a2 + 16) )
return 0LL;
}
*((_BYTE *)v6 + 464) &= ~2u;
*(_DWORD *)my_thread_var(a1, v8, a3) = 127;
return 127LL;
}
| _mi_pack_rec_unpack:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RDI]
MOV qword ptr [RSI + 0x8],RCX
MOV ESI,R8D
ADD RSI,RCX
MOV qword ptr [R14 + 0x10],RSI
MOV dword ptr [R14 + 0x28],0x0
MOV qword ptr [R14],0x0
MOV RCX,qword ptr [RAX + 0x168]
TEST RCX,RCX
JLE 0x00181ca5
MOV R15,qword ptr [RAX + 0x230]
LEA R13,[RCX + RCX*0x2]
SHL R13,0x4
ADD R13,R15
LAB_00181c7d:
MOVZX R12D,word ptr [R15 + 0x4]
ADD R12,RDX
MOV RDI,R15
MOV RSI,R14
MOV RCX,R12
CALL qword ptr [R15 + 0x10]
ADD R15,0x30
MOV RDX,R12
CMP R15,R13
JC 0x00181c7d
CMP dword ptr [R14 + 0x28],0x0
JNZ 0x00181cb9
LAB_00181ca5:
MOV RAX,qword ptr [R14 + 0x8]
MOV ECX,dword ptr [R14 + 0x4]
SHR ECX,0x3
SUB RAX,RCX
CMP RAX,qword ptr [R14 + 0x10]
JZ 0x00181cd2
LAB_00181cb9:
AND byte ptr [RBX + 0x1d0],0xfd
CALL 0x001a1b22
MOV dword ptr [RAX],0x7f
MOV EAX,0x7f
JMP 0x00181cd4
LAB_00181cd2:
XOR EAX,EAX
LAB_00181cd4:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
_mi_pack_rec_unpack(long *param_1,int8 *param_2,long param_3,long param_4,uint param_5)
{
long lVar1;
int4 *puVar2;
long lVar3;
ulong uVar4;
ulong uVar5;
lVar3 = *param_1;
param_2[1] = param_4;
param_2[2] = (ulong)param_5 + param_4;
*(int4 *)(param_2 + 5) = 0;
*param_2 = 0;
lVar1 = *(long *)(lVar3 + 0x168);
if (0 < lVar1) {
uVar5 = *(ulong *)(lVar3 + 0x230);
uVar4 = lVar1 * 0x30 + uVar5;
do {
lVar3 = (ulong)*(ushort *)(uVar5 + 4) + param_3;
(**(code **)(uVar5 + 0x10))(uVar5,param_2,param_3,lVar3);
uVar5 = uVar5 + 0x30;
param_3 = lVar3;
} while (uVar5 < uVar4);
if (*(int *)(param_2 + 5) != 0) goto LAB_00181cb9;
}
if (param_2[1] - (ulong)(*(uint *)((long)param_2 + 4) >> 3) == param_2[2]) {
return 0;
}
LAB_00181cb9:
*(byte *)(param_1 + 0x3a) = *(byte *)(param_1 + 0x3a) & 0xfd;
puVar2 = (int4 *)_my_thread_var();
*puVar2 = 0x7f;
return 0x7f;
}
| |
29,257 | ecp_use_curve25519 | msxemulator/build_O0/_deps/pico_sdk-src/lib/mbedtls/library/ecp_curves.c | static int ecp_use_curve25519(mbedtls_ecp_group *grp)
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
/* Actually ( A + 2 ) / 4 */
MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&grp->A, curve25519_a24));
/* P = 2^255 - 19 */
MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&grp->P, 1));
MBEDTLS_MPI_CHK(mbedtls_mpi_shift_l(&grp->P, 255));
MBEDTLS_MPI_CHK(mbedtls_mpi_sub_int(&grp->P, &grp->P, 19));
grp->pbits = mbedtls_mpi_bitlen(&grp->P);
/* N = 2^252 + 27742317777372353535851937790883648493 */
MBEDTLS_MPI_CHK(mbedtls_mpi_read_binary(&grp->N,
curve25519_part_of_n, sizeof(curve25519_part_of_n)));
MBEDTLS_MPI_CHK(mbedtls_mpi_set_bit(&grp->N, 252, 1));
/* Y intentionally not set, since we use x/z coordinates.
* This is used as a marker to identify Montgomery curves! */
MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&grp->G.X, 9));
MBEDTLS_MPI_CHK(mbedtls_mpi_lset(&grp->G.Z, 1));
mbedtls_mpi_free(&grp->G.Y);
/* Actually, the required msb for private keys */
grp->nbits = 254;
cleanup:
if (ret != 0) {
mbedtls_ecp_group_free(grp);
}
return ret;
} | O0 | c | ecp_use_curve25519:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0xffffff92, 0xc(%rsp) # imm = 0xFFFFFF92
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
movl $0x1db42, %esi # imm = 0x1DB42
callq 0x11e360
movl %eax, 0xc(%rsp)
cmpl $0x0, %eax
je 0x132ca2
jmp 0x132dfa
jmp 0x132ca4
jmp 0x132ca6
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0x11e360
movl %eax, 0xc(%rsp)
cmpl $0x0, %eax
je 0x132cc7
jmp 0x132dfa
jmp 0x132cc9
jmp 0x132ccb
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movl $0xff, %esi
callq 0x11fa00
movl %eax, 0xc(%rsp)
cmpl $0x0, %eax
je 0x132cec
jmp 0x132dfa
jmp 0x132cee
jmp 0x132cf0
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movq 0x10(%rsp), %rsi
addq $0x8, %rsi
movl $0x13, %edx
callq 0x120900
movl %eax, 0xc(%rsp)
cmpl $0x0, %eax
je 0x132d1a
jmp 0x132dfa
jmp 0x132d1c
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x11e650
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0xb0(%rax)
movq 0x10(%rsp), %rdi
addq $0x98, %rdi
leaq 0x45df4(%rip), %rsi # 0x178b40
movl $0x10, %edx
callq 0x11f5d0
movl %eax, 0xc(%rsp)
cmpl $0x0, %eax
je 0x132d64
jmp 0x132dfa
jmp 0x132d66
jmp 0x132d68
movq 0x10(%rsp), %rdi
addq $0x98, %rdi
movl $0xfc, %esi
movl $0x1, %edx
callq 0x11e490
movl %eax, 0xc(%rsp)
cmpl $0x0, %eax
je 0x132d8e
jmp 0x132dfa
jmp 0x132d90
jmp 0x132d92
movq 0x10(%rsp), %rdi
addq $0x50, %rdi
movl $0x9, %esi
callq 0x11e360
movl %eax, 0xc(%rsp)
cmpl $0x0, %eax
je 0x132db0
jmp 0x132dfa
jmp 0x132db2
jmp 0x132db4
movq 0x10(%rsp), %rdi
addq $0x50, %rdi
addq $0x30, %rdi
movl $0x1, %esi
callq 0x11e360
movl %eax, 0xc(%rsp)
cmpl $0x0, %eax
je 0x132dd6
jmp 0x132dfa
jmp 0x132dd8
movq 0x10(%rsp), %rdi
addq $0x50, %rdi
addq $0x18, %rdi
callq 0x11dec0
movq 0x10(%rsp), %rax
movq $0xfe, 0xb8(%rax)
cmpl $0x0, 0xc(%rsp)
je 0x132e0b
movq 0x10(%rsp), %rdi
callq 0x128ee0
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| ecp_use_curve25519:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov [rsp+18h+var_C], 0FFFFFF92h
mov rdi, [rsp+18h+var_8]
add rdi, 20h ; ' '
mov esi, 1DB42h
call mbedtls_mpi_lset
mov [rsp+18h+var_C], eax
cmp eax, 0
jz short loc_132CA2
jmp loc_132DFA
loc_132CA2:
jmp short $+2
loc_132CA4:
jmp short $+2
loc_132CA6:
mov rdi, [rsp+18h+var_8]
add rdi, 8
mov esi, 1
call mbedtls_mpi_lset
mov [rsp+18h+var_C], eax
cmp eax, 0
jz short loc_132CC7
jmp loc_132DFA
loc_132CC7:
jmp short $+2
loc_132CC9:
jmp short $+2
loc_132CCB:
mov rdi, [rsp+18h+var_8]
add rdi, 8
mov esi, 0FFh
call mbedtls_mpi_shift_l
mov [rsp+18h+var_C], eax
cmp eax, 0
jz short loc_132CEC
jmp loc_132DFA
loc_132CEC:
jmp short $+2
loc_132CEE:
jmp short $+2
loc_132CF0:
mov rdi, [rsp+18h+var_8]
add rdi, 8
mov rsi, [rsp+18h+var_8]
add rsi, 8
mov edx, 13h
call mbedtls_mpi_sub_int
mov [rsp+18h+var_C], eax
cmp eax, 0
jz short loc_132D1A
jmp loc_132DFA
loc_132D1A:
jmp short $+2
loc_132D1C:
mov rdi, [rsp+18h+var_8]
add rdi, 8
call mbedtls_mpi_bitlen
mov rcx, rax
mov rax, [rsp+18h+var_8]
mov [rax+0B0h], rcx
mov rdi, [rsp+18h+var_8]
add rdi, 98h
lea rsi, curve25519_part_of_n
mov edx, 10h
call mbedtls_mpi_read_binary
mov [rsp+18h+var_C], eax
cmp eax, 0
jz short loc_132D64
jmp loc_132DFA
loc_132D64:
jmp short $+2
loc_132D66:
jmp short $+2
loc_132D68:
mov rdi, [rsp+18h+var_8]
add rdi, 98h
mov esi, 0FCh
mov edx, 1
call mbedtls_mpi_set_bit
mov [rsp+18h+var_C], eax
cmp eax, 0
jz short loc_132D8E
jmp short loc_132DFA
loc_132D8E:
jmp short $+2
loc_132D90:
jmp short $+2
loc_132D92:
mov rdi, [rsp+18h+var_8]
add rdi, 50h ; 'P'
mov esi, 9
call mbedtls_mpi_lset
mov [rsp+18h+var_C], eax
cmp eax, 0
jz short loc_132DB0
jmp short loc_132DFA
loc_132DB0:
jmp short $+2
loc_132DB2:
jmp short $+2
loc_132DB4:
mov rdi, [rsp+18h+var_8]
add rdi, 50h ; 'P'
add rdi, 30h ; '0'
mov esi, 1
call mbedtls_mpi_lset
mov [rsp+18h+var_C], eax
cmp eax, 0
jz short loc_132DD6
jmp short loc_132DFA
loc_132DD6:
jmp short $+2
loc_132DD8:
mov rdi, [rsp+18h+var_8]
add rdi, 50h ; 'P'
add rdi, 18h
call mbedtls_mpi_free
mov rax, [rsp+18h+var_8]
mov qword ptr [rax+0B8h], 0FEh
loc_132DFA:
cmp [rsp+18h+var_C], 0
jz short loc_132E0B
mov rdi, [rsp+18h+var_8]
call mbedtls_ecp_group_free
loc_132E0B:
mov eax, [rsp+18h+var_C]
add rsp, 18h
retn
| long long ecp_use_curve25519(long long a1)
{
unsigned int binary; // [rsp+Ch] [rbp-Ch]
binary = mbedtls_mpi_lset(a1 + 32, 121666LL);
if ( !binary )
{
binary = mbedtls_mpi_lset(a1 + 8, 1LL);
if ( !binary )
{
binary = mbedtls_mpi_shift_l(a1 + 8, 0xFFuLL);
if ( !binary )
{
binary = mbedtls_mpi_sub_int((int *)(a1 + 8), (int *)(a1 + 8), 19LL);
if ( !binary )
{
*(_QWORD *)(a1 + 176) = mbedtls_mpi_bitlen(a1 + 8);
binary = mbedtls_mpi_read_binary(a1 + 152, (long long)&curve25519_part_of_n, 0x10uLL);
if ( !binary )
{
binary = mbedtls_mpi_set_bit(a1 + 152, 0xFCuLL, 1u);
if ( !binary )
{
binary = mbedtls_mpi_lset(a1 + 80, 9LL);
if ( !binary )
{
binary = mbedtls_mpi_lset(a1 + 128, 1LL);
if ( !binary )
{
mbedtls_mpi_free(a1 + 104);
*(_QWORD *)(a1 + 184) = 254LL;
}
}
}
}
}
}
}
}
if ( binary )
mbedtls_ecp_group_free(a1);
return binary;
}
| operator():
SUB RSP,0x158
MOV qword ptr [RSP + 0x28],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x30],RAX
MOV qword ptr [RSP + 0x150],RDI
MOV qword ptr [RSP + 0x148],RSI
MOV qword ptr [RSP + 0x140],RDX
MOV qword ptr [RSP + 0x138],RCX
MOV RAX,qword ptr [RSP + 0x148]
MOV qword ptr [RSP + 0x38],RAX
MOV RDI,qword ptr [RSP + 0x138]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x0010f640
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2d
JNZ 0x00132dea
MOV RAX,qword ptr [RSP + 0x38]
MOV RAX,qword ptr [RAX]
MOV byte ptr [RAX],0x1
MOV byte ptr [RSP + 0xeb],0x1
MOV EDI,0x28
CALL 0x0010f300
MOV qword ptr [RSP + 0x20],RAX
MOV RDI,qword ptr [RSP + 0x140]
CALL 0x0015a2f0
MOV RDI,RAX
CALL 0x0015a300
MOV RDX,RAX
LAB_00132d08:
LEA RSI,[0x26fe9d]
LEA RDI,[RSP + 0xf8]
CALL 0x00157f50
JMP 0x00132d1e
LAB_00132d1e:
LEA RDX,[0x2716cb]
LEA RDI,[RSP + 0x118]
LEA RSI,[RSP + 0xf8]
CALL 0x00157950
JMP 0x00132d3c
LAB_00132d3c:
MOV RDI,qword ptr [RSP + 0x20]
LEA RSI,[RSP + 0x118]
CALL 0x0015a310
JMP 0x00132d50
LAB_00132d50:
MOV RDI,qword ptr [RSP + 0x20]
MOV byte ptr [RSP + 0xeb],0x0
LEA RSI,[0x2dd160]
LEA RDX,[0x15a360]
CALL 0x0010f9a0
LAB_00132dea:
MOV RDI,qword ptr [RSP + 0x140]
CALL 0x0015a2f0
MOV RSI,RAX
MOV RAX,qword ptr [RSI]
MOV RAX,qword ptr [RAX + 0x48]
LEA RDI,[RSP + 0xd0]
MOV qword ptr [RSP + 0x10],RDI
CALL RAX
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x00184f20
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0xc0],RAX
CALL 0x00184f50
MOV qword ptr [RSP + 0xb8],RAX
MOV RAX,qword ptr [RSP + 0x138]
MOV qword ptr [RSP + 0xb0],RAX
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0xb8]
MOV RDX,qword ptr [RSP + 0xb0]
LAB_00132e5c:
CALL 0x0014f420
LAB_00132e61:
MOV qword ptr [RSP + 0x18],RAX
JMP 0x00132e68
LAB_00132e68:
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0xc8],RAX
LEA RDI,[RSP + 0xd0]
CALL 0x00184f50
MOV qword ptr [RSP + 0xa8],RAX
LEA RDI,[RSP + 0xc8]
LEA RSI,[RSP + 0xa8]
CALL 0x00187c00
TEST AL,0x1
JNZ 0x00132ea8
JMP 0x0013301c
LAB_00132ea8:
MOV RSI,qword ptr [RSP + 0x140]
LEA RDI,[0x2e9bf0]
CALL 0x00185030
MOV RAX,qword ptr [RSP + 0x38]
MOV RCX,qword ptr [RAX + 0x8]
MOV byte ptr [RCX],0x1
MOV RAX,qword ptr [RAX]
MOV byte ptr [RAX],0x1
MOV byte ptr [RSP + 0x47],0x1
MOV EDI,0x28
CALL 0x0010f300
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x140]
CALL 0x0015a2f0
MOV RDI,RAX
CALL 0x0015a300
MOV RDX,RAX
LAB_00132efa:
LEA RSI,[0x2716f0]
LEA RDI,[RSP + 0x48]
CALL 0x00157f50
JMP 0x00132f0d
LAB_00132f0d:
LEA RDX,[0x2716f9]
LEA RDI,[RSP + 0x68]
LEA RSI,[RSP + 0x48]
CALL 0x00157950
JMP 0x00132f25
LAB_00132f25:
MOV RDX,qword ptr [RSP + 0x138]
LAB_00132f2d:
LEA RDI,[RSP + 0x88]
LEA RSI,[RSP + 0x68]
CALL 0x001795d0
JMP 0x00132f41
LAB_00132f41:
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[RSP + 0x88]
CALL 0x0015a310
JMP 0x00132f55
LAB_00132f55:
MOV RDI,qword ptr [RSP + 0x8]
MOV byte ptr [RSP + 0x47],0x0
LEA RSI,[0x2dd160]
LEA RDX,[0x15a360]
CALL 0x0010f9a0
LAB_0013301c:
LEA RDI,[RSP + 0xc8]
CALL 0x00184fc0
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,RAX
CALL 0x00183380
LEA RDI,[RSP + 0xd0]
CALL 0x00159580
MOV RAX,qword ptr [RSP + 0x30]
ADD RSP,0x158
RET
|
/* parse(int, char**)::$_2::TEMPNAMEPLACEHOLDERVALUE(std::shared_ptr<cmd>&, std::__cxx11::string
const&) const */
shared_ptr * parse(int,char**)::$_2::operator()(shared_ptr *param_1,string *param_2)
{
bool bVar1;
char *pcVar2;
parse_error *ppVar3;
cmd *pcVar4;
long *plVar5;
shared_ptr *psVar6;
ulong in_RCX;
__shared_ptr_access<cmd,(__gnu_cxx::_Lock_policy)2,false,false> *in_RDX;
char local_110 [32];
string local_f0 [32];
string local_d0 [32];
int8 local_b0;
ulong local_a8;
int8 local_a0;
int8 local_98;
int8 local_90;
vector<std::shared_ptr<cmd>,std::allocator<std::shared_ptr<cmd>>> local_88 [27];
int1 local_6d;
char local_60 [32];
string local_40 [32];
ulong local_20;
__shared_ptr_access<cmd,(__gnu_cxx::_Lock_policy)2,false,false> *local_18;
string *local_10;
shared_ptr *local_8;
local_20 = in_RCX;
local_18 = in_RDX;
local_10 = param_2;
local_8 = param_1;
pcVar2 = (char *)std::__cxx11::string::operator[](in_RCX);
if (*pcVar2 == '-') {
**(int1 **)param_2 = 1;
local_6d = 1;
ppVar3 = (parse_error *)__cxa_allocate_exception(0x28);
pcVar4 = (cmd *)std::__shared_ptr_access<cmd,(__gnu_cxx::_Lock_policy)2,false,false>::operator->
(local_18);
cmd::name_abi_cxx11_(pcVar4);
/* try { // try from 00132d08 to 00132d1b has its CatchHandler @ 00132d75 */
std::operator+(local_60,(string *)"Expected ");
/* try { // try from 00132d1e to 00132d39 has its CatchHandler @ 00132d8b */
std::operator+(local_40,local_60);
/* try { // try from 00132d3c to 00132d6f has its CatchHandler @ 00132da1 */
cli::parse_error::parse_error(ppVar3,local_40);
local_6d = 0;
/* WARNING: Subroutine does not return */
__cxa_throw(ppVar3,&cli::parse_error::typeinfo,cli::parse_error::~parse_error);
}
plVar5 = (long *)std::__shared_ptr_access<cmd,(__gnu_cxx::_Lock_policy)2,false,false>::operator->
(local_18);
(**(code **)(*plVar5 + 0x48))();
local_98 = std::vector<std::shared_ptr<cmd>,std::allocator<std::shared_ptr<cmd>>>::begin(local_88)
;
local_a0 = std::vector<std::shared_ptr<cmd>,std::allocator<std::shared_ptr<cmd>>>::end(local_88);
local_a8 = local_20;
/* try { // try from 00132e5c to 00132e60 has its CatchHandler @ 00132f77 */
local_90 = std::operator()(local_98,local_a0,local_20);
local_b0 = std::vector<std::shared_ptr<cmd>,std::allocator<std::shared_ptr<cmd>>>::end(local_88);
bVar1 = __gnu_cxx::operator==((__normal_iterator *)&local_90,(__normal_iterator *)&local_b0);
if (!bVar1) {
psVar6 = (shared_ptr *)
__gnu_cxx::
__normal_iterator<std::shared_ptr<cmd>*,std::vector<std::shared_ptr<cmd>,std::allocator<std::shared_ptr<cmd>>>>
::operator*((__normal_iterator<std::shared_ptr<cmd>*,std::vector<std::shared_ptr<cmd>,std::allocator<std::shared_ptr<cmd>>>>
*)&local_90);
std::shared_ptr<cmd>::shared_ptr((shared_ptr<cmd> *)param_1,psVar6);
std::vector<std::shared_ptr<cmd>,std::allocator<std::shared_ptr<cmd>>>::~vector(local_88);
return param_1;
}
std::shared_ptr<cmd>::operator=((shared_ptr<cmd> *)selected_cmd,(shared_ptr *)local_18);
**(int1 **)(param_2 + 8) = 1;
**(int1 **)param_2 = 1;
ppVar3 = (parse_error *)__cxa_allocate_exception(0x28);
pcVar4 = (cmd *)std::__shared_ptr_access<cmd,(__gnu_cxx::_Lock_policy)2,false,false>::operator->
(local_18);
cmd::name_abi_cxx11_(pcVar4);
/* try { // try from 00132efa to 00132f0a has its CatchHandler @ 00132f90 */
std::operator+(local_110,(string *)"Unknown ");
/* try { // try from 00132f0d to 00132f22 has its CatchHandler @ 00132fa6 */
std::operator+(local_f0,local_110);
/* try { // try from 00132f2d to 00132f3e has its CatchHandler @ 00132fbc */
std::operator+(local_d0,local_f0);
/* try { // try from 00132f41 to 00132f71 has its CatchHandler @ 00132fd2 */
cli::parse_error::parse_error(ppVar3,local_d0);
/* WARNING: Subroutine does not return */
__cxa_throw(ppVar3,&cli::parse_error::typeinfo,cli::parse_error::~parse_error);
}
| |
29,258 | my_collation_get_by_name | eloqsql/mysys/charset.c | CHARSET_INFO *
my_collation_get_by_name(MY_CHARSET_LOADER *loader,
const char *name, myf flags)
{
uint cs_number;
CHARSET_INFO *cs;
my_pthread_once(&charsets_initialized, init_available_charsets);
cs_number= get_collation_number(name,flags);
my_charset_loader_init_mysys(loader);
cs= cs_number ? get_internal_charset(loader, cs_number, flags) : NULL;
if (!cs && (flags & MY_WME))
{
char index_file[FN_REFLEN + sizeof(MY_CHARSET_INDEX)];
strmov(get_charsets_dir(index_file),MY_CHARSET_INDEX);
my_error(EE_UNKNOWN_COLLATION, MYF(ME_BELL), name, index_file);
}
return cs;
} | O3 | c | my_collation_get_by_name:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %fs:0x28, %rax
movq %rax, -0x20(%rbp)
leaq 0x360577(%rip), %rdi # 0x3ae810
leaq -0x7e1(%rip), %rsi # 0x4dabf
callq 0x28330
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4da13
movb $0x0, (%r15)
leaq -0xfc9(%rip), %rcx # 0x4d2f2
movq %rcx, 0x80(%r15)
leaq -0xfc8(%rip), %rcx # 0x4d301
movq %rcx, 0x88(%r15)
leaq -0xfbb(%rip), %rcx # 0x4d31c
movq %rcx, 0x90(%r15)
leaq 0xc30d(%rip), %rcx # 0x5a5f2
movq %rcx, 0x98(%r15)
leaq 0x2e173d(%rip), %rcx # 0x32fa30
movq (%rcx), %rcx
movq %rcx, 0xa0(%r15)
leaq -0xfca(%rip), %rcx # 0x4d33a
movq %rcx, 0xa8(%r15)
testl %eax, %eax
je 0x4e321
movq %r15, %rdi
movl %eax, %esi
movq %r14, %rdx
callq 0x4df4e
movq %rax, %r15
jmp 0x4e324
xorl %r15d, %r15d
testq %r15, %r15
setne %al
testb $0x10, %r14b
sete %cl
orb %al, %cl
jne 0x4e36e
leaq -0x230(%rbp), %r14
movq %r14, %rdi
callq 0x4d87f
movabsq $0x6d782e7865646e49, %rcx # imm = 0x6D782E7865646E49
movq %rcx, (%rax)
movw $0x6c, 0x8(%rax)
movl $0x4, %esi
movl $0x1c, %edi
movq %rbx, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x588af
movq %fs:0x28, %rax
cmpq -0x20(%rbp), %rax
jne 0x4e38e
movq %r15, %rax
addq $0x218, %rsp # imm = 0x218
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x283d0
| my_collation_get_by_name:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 218h
mov r14, rdx
mov rbx, rsi
mov r15, rdi
mov rax, fs:28h
mov [rbp+var_20], rax
lea rdi, charsets_initialized
lea rsi, init_available_charsets
call _pthread_once
mov rdi, rbx
mov rsi, r14
call get_collation_number
mov byte ptr [r15], 0
lea rcx, my_once_alloc_c
mov [r15+80h], rcx
lea rcx, my_malloc_c
mov [r15+88h], rcx
lea rcx, my_realloc_c
mov [r15+90h], rcx
lea rcx, my_free
mov [r15+98h], rcx
lea rcx, my_charset_error_reporter
mov rcx, [rcx]
mov [r15+0A0h], rcx
lea rcx, add_collation
mov [r15+0A8h], rcx
test eax, eax
jz short loc_4E321
mov rdi, r15
mov esi, eax
mov rdx, r14
call get_internal_charset
mov r15, rax
jmp short loc_4E324
loc_4E321:
xor r15d, r15d
loc_4E324:
test r15, r15
setnz al
test r14b, 10h
setz cl
or cl, al
jnz short loc_4E36E
lea r14, [rbp+var_230]
mov rdi, r14
call get_charsets_dir
mov rcx, 6D782E7865646E49h
mov [rax], rcx
mov word ptr [rax+8], 6Ch ; 'l'
mov esi, 4
mov edi, 1Ch
mov rdx, rbx
mov rcx, r14
xor eax, eax
call my_error
loc_4E36E:
mov rax, fs:28h
cmp rax, [rbp+var_20]
jnz short loc_4E38E
mov rax, r15
add rsp, 218h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_4E38E:
call ___stack_chk_fail
| long long my_collation_get_by_name(long long a1, long long a2, long long a3)
{
unsigned int collation_number; // eax
long long internal_charset; // r15
int v6; // r8d
int v7; // r9d
_BYTE v9[528]; // [rsp+0h] [rbp-230h] BYREF
unsigned long long v10; // [rsp+210h] [rbp-20h]
v10 = __readfsqword(0x28u);
pthread_once(&charsets_initialized, init_available_charsets);
collation_number = get_collation_number(a2, a3);
*(_BYTE *)a1 = 0;
*(_QWORD *)(a1 + 128) = my_once_alloc_c;
*(_QWORD *)(a1 + 136) = my_malloc_c;
*(_QWORD *)(a1 + 144) = my_realloc_c;
*(_QWORD *)(a1 + 152) = my_free;
*(_QWORD *)(a1 + 160) = my_charset_error_reporter;
*(_QWORD *)(a1 + 168) = add_collation;
if ( collation_number )
internal_charset = get_internal_charset(a1, collation_number, a3);
else
internal_charset = 0LL;
if ( internal_charset == 0 && (a3 & 0x10) != 0 )
{
strcpy((char *)get_charsets_dir((long long)v9), "Index.xml");
my_error(28, 4, a2, (unsigned int)v9, v6, v7);
}
return internal_charset;
}
| my_collation_get_by_name:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x218
MOV R14,RDX
MOV RBX,RSI
MOV R15,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x20],RAX
LEA RDI,[0x4ae810]
LEA RSI,[0x14dabf]
CALL 0x00128330
MOV RDI,RBX
MOV RSI,R14
CALL 0x0014da13
MOV byte ptr [R15],0x0
LEA RCX,[0x14d2f2]
MOV qword ptr [R15 + 0x80],RCX
LEA RCX,[0x14d301]
MOV qword ptr [R15 + 0x88],RCX
LEA RCX,[0x14d31c]
MOV qword ptr [R15 + 0x90],RCX
LEA RCX,[0x15a5f2]
MOV qword ptr [R15 + 0x98],RCX
LEA RCX,[0x42fa30]
MOV RCX,qword ptr [RCX]
MOV qword ptr [R15 + 0xa0],RCX
LEA RCX,[0x14d33a]
MOV qword ptr [R15 + 0xa8],RCX
TEST EAX,EAX
JZ 0x0014e321
MOV RDI,R15
MOV ESI,EAX
MOV RDX,R14
CALL 0x0014df4e
MOV R15,RAX
JMP 0x0014e324
LAB_0014e321:
XOR R15D,R15D
LAB_0014e324:
TEST R15,R15
SETNZ AL
TEST R14B,0x10
SETZ CL
OR CL,AL
JNZ 0x0014e36e
LEA R14,[RBP + -0x230]
MOV RDI,R14
CALL 0x0014d87f
MOV RCX,0x6d782e7865646e49
MOV qword ptr [RAX],RCX
MOV word ptr [RAX + 0x8],0x6c
MOV ESI,0x4
MOV EDI,0x1c
MOV RDX,RBX
MOV RCX,R14
XOR EAX,EAX
CALL 0x001588af
LAB_0014e36e:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x0014e38e
MOV RAX,R15
ADD RSP,0x218
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0014e38e:
CALL 0x001283d0
|
long my_collation_get_by_name(int1 *param_1,int8 param_2,ulong param_3)
{
int iVar1;
long lVar2;
int8 *puVar3;
long in_FS_OFFSET;
int1 local_238 [528];
long local_28;
local_28 = *(long *)(in_FS_OFFSET + 0x28);
pthread_once(&charsets_initialized,init_available_charsets);
iVar1 = get_collation_number(param_2,param_3);
*param_1 = 0;
*(code **)(param_1 + 0x80) = my_once_alloc_c;
*(code **)(param_1 + 0x88) = my_malloc_c;
*(code **)(param_1 + 0x90) = my_realloc_c;
*(code **)(param_1 + 0x98) = my_free;
*(int **)(param_1 + 0xa0) = my_charset_error_reporter;
*(code **)(param_1 + 0xa8) = add_collation;
if (iVar1 == 0) {
lVar2 = 0;
}
else {
lVar2 = get_internal_charset(param_1,iVar1,param_3);
}
if ((param_3 & 0x10) != 0 && lVar2 == 0) {
puVar3 = (int8 *)get_charsets_dir(local_238);
*puVar3 = 0x6d782e7865646e49;
*(int2 *)(puVar3 + 1) = 0x6c;
my_error(0x1c,4,param_2,local_238);
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_28) {
return lVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
29,259 | my_uca_coll_init_utf8mb4 | eloqsql/strings/ctype-uca.c | static my_bool
my_uca_coll_init_utf8mb4(struct charset_info_st *cs, MY_CHARSET_LOADER *loader)
{
if (my_coll_init_uca(cs, loader))
return TRUE;
if (my_uca_collation_can_optimize_no_contractions(cs))
my_uca_handler_map(cs, &my_uca_package_utf8mb4,
&my_uca_package_no_contractions_utf8mb4);
return FALSE;
} | O0 | c | my_uca_coll_init_utf8mb4:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7ea70
cmpb $0x0, %al
je 0x812e7
movb $0x1, -0x1(%rbp)
jmp 0x8130f
movq -0x10(%rbp), %rdi
callq 0x8aa60
cmpb $0x0, %al
je 0x8130b
movq -0x10(%rbp), %rdi
leaq 0x286681(%rip), %rsi # 0x307980
leaq 0x28669a(%rip), %rdx # 0x3079a0
callq 0x8aac0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| my_uca_coll_init_utf8mb4:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call my_coll_init_uca
cmp al, 0
jz short loc_812E7
mov [rbp+var_1], 1
jmp short loc_8130F
loc_812E7:
mov rdi, [rbp+var_10]
call my_uca_collation_can_optimize_no_contractions
cmp al, 0
jz short loc_8130B
mov rdi, [rbp+var_10]
lea rsi, my_uca_package_utf8mb4
lea rdx, my_uca_package_no_contractions_utf8mb4
call my_uca_handler_map
loc_8130B:
mov [rbp+var_1], 0
loc_8130F:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
| char my_uca_coll_init_utf8mb4(long long a1, long long a2)
{
if ( (unsigned __int8)my_coll_init_uca(a1, a2) )
return 1;
if ( (unsigned __int8)my_uca_collation_can_optimize_no_contractions(a1) )
my_uca_handler_map(a1, my_uca_package_utf8mb4, my_uca_package_no_contractions_utf8mb4);
return 0;
}
| my_uca_coll_init_utf8mb4:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0017ea70
CMP AL,0x0
JZ 0x001812e7
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0018130f
LAB_001812e7:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0018aa60
CMP AL,0x0
JZ 0x0018130b
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x407980]
LEA RDX,[0x4079a0]
CALL 0x0018aac0
LAB_0018130b:
MOV byte ptr [RBP + -0x1],0x0
LAB_0018130f:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int1 my_uca_coll_init_utf8mb4(int8 param_1,int8 param_2)
{
char cVar1;
int1 local_9;
cVar1 = my_coll_init_uca(param_1,param_2);
if (cVar1 == '\0') {
cVar1 = my_uca_collation_can_optimize_no_contractions(param_1);
if (cVar1 != '\0') {
my_uca_handler_map(param_1,my_uca_package_utf8mb4,my_uca_package_no_contractions_utf8mb4);
}
local_9 = 0;
}
else {
local_9 = 1;
}
return local_9;
}
| |
29,260 | nglog::base::SetLogger(nglog::LogSeverity, nglog::base::Logger*) | ng-log[P]ng-log/src/logging.cc | void base::SetLogger(LogSeverity severity, base::Logger* logger) {
std::lock_guard<std::mutex> l{log_mutex};
LogDestination::log_destination(severity)->SetLoggerImpl(logger);
} | O1 | cpp | nglog::base::SetLogger(nglog::LogSeverity, nglog::base::Logger*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x3aa52(%rip), %rdi # 0x562b8
callq 0x89e0
testl %eax, %eax
jne 0x1b904
movl %ebp, %eax
leaq 0x2b984(%rip), %rcx # 0x47200
leaq (%rcx,%rax,8), %r14
cmpq $0x0, (%r14)
jne 0x1b8bf
movl $0xd0, %edi
callq 0xa980
movq %rax, %r15
movq %rax, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x19e80
leaq 0x8(%rsp), %r12
movq $0x0, (%r12)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2215e
movq %r12, %rdi
callq 0x20eb0
movq (%r14), %r14
movq 0xc8(%r14), %rdi
cmpq %rbx, %rdi
je 0x1b8eb
testq %rdi, %rdi
sete %al
cmpq %r14, %rdi
sete %cl
orb %al, %cl
jne 0x1b8e4
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, 0xc8(%r14)
leaq 0x3a9c6(%rip), %rdi # 0x562b8
callq 0x8490
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x83f0
movq %rax, %rbx
movl $0xd0, %esi
movq %r15, %rdi
callq 0xa9cc
jmp 0x1b920
movq %rax, %rbx
leaq 0x3a991(%rip), %rdi # 0x562b8
callq 0x8490
movq %rbx, %rdi
callq 0x8bb0
| _ZN5nglog4base9SetLoggerENS_11LogSeverityEPNS0_6LoggerE:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov rbx, rsi
mov ebp, edi
lea rdi, _ZN5nglogL9log_mutexE; nglog::log_mutex
call _pthread_mutex_lock
test eax, eax
jnz loc_1B904
mov eax, ebp
lea rcx, _ZN5nglog14LogDestination17log_destinations_E; nglog::LogDestination::log_destinations_
lea r14, [rcx+rax*8]
cmp qword ptr [r14], 0
jnz short loc_1B8BF
mov edi, 0D0h; unsigned __int64
call _Znwm; operator new(ulong)
mov r15, rax
mov rdi, rax
mov esi, ebp
xor edx, edx
call _ZN5nglog14LogDestinationC2ENS_11LogSeverityEPKc; nglog::LogDestination::LogDestination(nglog::LogSeverity,char const*)
lea r12, [rsp+38h+var_30]
mov qword ptr [r12], 0
mov rdi, r14
mov rsi, r15
call _ZNSt15__uniq_ptr_implIN5nglog14LogDestinationESt14default_deleteIS1_EE5resetEPS1_; std::__uniq_ptr_impl<nglog::LogDestination,std::default_delete<nglog::LogDestination>>::reset(nglog::LogDestination*)
mov rdi, r12
call _ZNSt10unique_ptrIN5nglog14LogDestinationESt14default_deleteIS1_EED2Ev; std::unique_ptr<nglog::LogDestination>::~unique_ptr()
loc_1B8BF:
mov r14, [r14]
mov rdi, [r14+0C8h]
cmp rdi, rbx
jz short loc_1B8EB
test rdi, rdi
setz al
cmp rdi, r14
setz cl
or cl, al
jnz short loc_1B8E4
mov rax, [rdi]
call qword ptr [rax+8]
loc_1B8E4:
mov [r14+0C8h], rbx
loc_1B8EB:
lea rdi, _ZN5nglogL9log_mutexE; nglog::log_mutex
call _pthread_mutex_unlock
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_1B904:
mov edi, eax; int
call __ZSt20__throw_system_errori; std::__throw_system_error(int)
mov rbx, rax
mov esi, 0D0h; unsigned __int64
mov rdi, r15; void *
call _ZdlPvm; operator delete(void *,ulong)
jmp short loc_1B920
mov rbx, rax
loc_1B920:
lea rdi, _ZN5nglogL9log_mutexE; nglog::log_mutex
call _pthread_mutex_unlock
mov rdi, rbx
call __Unwind_Resume
| long long nglog::base::SetLogger(unsigned int a1, long long a2)
{
int v2; // eax
long long *v3; // r14
long long v4; // r15
long long v5; // r14
long long v6; // rdi
_QWORD v8[6]; // [rsp+8h] [rbp-30h] BYREF
v2 = pthread_mutex_lock(&nglog::log_mutex);
if ( v2 )
std::__throw_system_error(v2);
v3 = (long long *)((char *)&nglog::LogDestination::log_destinations_ + 8 * a1);
if ( !*v3 )
{
v4 = operator new(208LL);
nglog::LogDestination::LogDestination(v4, a1, 0LL);
v8[0] = 0LL;
std::__uniq_ptr_impl<nglog::LogDestination,std::default_delete<nglog::LogDestination>>::reset(
(char *)&nglog::LogDestination::log_destinations_ + 8 * a1,
v4);
std::unique_ptr<nglog::LogDestination>::~unique_ptr(v8);
}
v5 = *v3;
v6 = *(_QWORD *)(v5 + 200);
if ( v6 != a2 )
{
if ( v6 != 0 && v6 != v5 )
(*(void ( **)(long long))(*(_QWORD *)v6 + 8LL))(v6);
*(_QWORD *)(v5 + 200) = a2;
}
return pthread_mutex_unlock(&nglog::log_mutex);
}
| SetLogger:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV RBX,RSI
MOV EBP,EDI
LEA RDI,[0x1562b8]
CALL 0x001089e0
TEST EAX,EAX
JNZ 0x0011b904
MOV EAX,EBP
LEA RCX,[0x147200]
LEA R14,[RCX + RAX*0x8]
CMP qword ptr [R14],0x0
JNZ 0x0011b8bf
LAB_0011b886:
MOV EDI,0xd0
CALL 0x0010a980
LAB_0011b890:
MOV R15,RAX
MOV RDI,RAX
MOV ESI,EBP
XOR EDX,EDX
CALL 0x00119e80
LAB_0011b89f:
LEA R12,[RSP + 0x8]
MOV qword ptr [R12],0x0
MOV RDI,R14
MOV RSI,R15
CALL 0x0012215e
MOV RDI,R12
CALL 0x00120eb0
LAB_0011b8bf:
MOV R14,qword ptr [R14]
MOV RDI,qword ptr [R14 + 0xc8]
CMP RDI,RBX
JZ 0x0011b8eb
TEST RDI,RDI
SETZ AL
CMP RDI,R14
SETZ CL
OR CL,AL
JNZ 0x0011b8e4
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0011b8e4:
MOV qword ptr [R14 + 0xc8],RBX
LAB_0011b8eb:
LEA RDI,[0x1562b8]
CALL 0x00108490
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0011b904:
MOV EDI,EAX
CALL 0x001083f0
|
/* nglog::base::SetLogger(nglog::LogSeverity, nglog::base::Logger*) */
void nglog::base::SetLogger(uint param_1,long *param_2)
{
__uniq_ptr_impl<nglog::LogDestination,std::default_delete<nglog::LogDestination>> *this;
long *plVar1;
long *plVar2;
int iVar3;
LogDestination *pLVar4;
int8 local_30;
iVar3 = pthread_mutex_lock((pthread_mutex_t *)log_mutex);
if (iVar3 == 0) {
this = (__uniq_ptr_impl<nglog::LogDestination,std::default_delete<nglog::LogDestination>> *)
(&LogDestination::log_destinations_ + param_1);
if (*(long *)this == 0) {
/* try { // try from 0011b886 to 0011b88f has its CatchHandler @ 0011b91d */
pLVar4 = (LogDestination *)operator_new(0xd0);
/* try { // try from 0011b890 to 0011b89e has its CatchHandler @ 0011b90b */
LogDestination::LogDestination(pLVar4,param_1,0);
local_30 = 0;
std::__uniq_ptr_impl<nglog::LogDestination,std::default_delete<nglog::LogDestination>>::reset
(this,pLVar4);
std::unique_ptr<nglog::LogDestination,std::default_delete<nglog::LogDestination>>::~unique_ptr
((unique_ptr<nglog::LogDestination,std::default_delete<nglog::LogDestination>> *)
&local_30);
}
plVar1 = *(long **)this;
plVar2 = (long *)plVar1[0x19];
if (plVar2 != param_2) {
if (plVar2 != plVar1 && plVar2 != (long *)0x0) {
(**(code **)(*plVar2 + 8))();
}
plVar1[0x19] = (long)param_2;
}
pthread_mutex_unlock((pthread_mutex_t *)log_mutex);
return;
}
/* WARNING: Subroutine does not return */
std::__throw_system_error(iVar3);
}
| |
29,261 | nglog::base::SetLogger(nglog::LogSeverity, nglog::base::Logger*) | ng-log[P]ng-log/src/logging.cc | void base::SetLogger(LogSeverity severity, base::Logger* logger) {
std::lock_guard<std::mutex> l{log_mutex};
LogDestination::log_destination(severity)->SetLoggerImpl(logger);
} | O3 | cpp | nglog::base::SetLogger(nglog::LogSeverity, nglog::base::Logger*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x3a95a(%rip), %rdi # 0x552b8
callq 0x89e0
testl %eax, %eax
jne 0x1aa00
movl %ebp, %r15d
leaq 0x2b88b(%rip), %r12 # 0x46200
movq (%r12,%r15,8), %r14
testq %r14, %r14
jne 0x1a9be
movl $0xd0, %edi
callq 0xa850
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18f7c
leaq (%r12,%r15,8), %r15
leaq 0x8(%rsp), %r12
movq $0x0, (%r12)
movq %r15, %rdi
movq %r14, %rsi
callq 0x2110e
movq %r12, %rdi
callq 0x1fe8c
movq (%r15), %r14
movq 0xc8(%r14), %rdi
cmpq %rbx, %rdi
je 0x1a9e7
testq %rdi, %rdi
sete %al
cmpq %r14, %rdi
sete %cl
orb %al, %cl
jne 0x1a9e0
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, 0xc8(%r14)
leaq 0x3a8ca(%rip), %rdi # 0x552b8
callq 0x8490
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x83f0
movq %rax, %rbx
movl $0xd0, %esi
movq %r14, %rdi
callq 0xa89c
jmp 0x1aa1c
movq %rax, %rbx
leaq 0x3a895(%rip), %rdi # 0x552b8
callq 0x8490
movq %rbx, %rdi
callq 0x8bb0
| _ZN5nglog4base9SetLoggerENS_11LogSeverityEPNS0_6LoggerE:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov rbx, rsi
mov ebp, edi
lea rdi, _ZN5nglogL9log_mutexE; nglog::log_mutex
call _pthread_mutex_lock
test eax, eax
jnz loc_1AA00
mov r15d, ebp
lea r12, _ZN5nglog14LogDestination17log_destinations_E; nglog::LogDestination::log_destinations_
mov r14, [r12+r15*8]
test r14, r14
jnz short loc_1A9BE
mov edi, 0D0h; unsigned __int64
call _Znwm; operator new(ulong)
mov r14, rax
mov rdi, rax
mov esi, ebp
xor edx, edx
call _ZN5nglog14LogDestinationC2ENS_11LogSeverityEPKc; nglog::LogDestination::LogDestination(nglog::LogSeverity,char const*)
lea r15, [r12+r15*8]
lea r12, [rsp+38h+var_30]
mov qword ptr [r12], 0
mov rdi, r15
mov rsi, r14
call _ZNSt15__uniq_ptr_implIN5nglog14LogDestinationESt14default_deleteIS1_EE5resetEPS1_; std::__uniq_ptr_impl<nglog::LogDestination,std::default_delete<nglog::LogDestination>>::reset(nglog::LogDestination*)
mov rdi, r12
call _ZNSt10unique_ptrIN5nglog14LogDestinationESt14default_deleteIS1_EED2Ev; std::unique_ptr<nglog::LogDestination>::~unique_ptr()
mov r14, [r15]
loc_1A9BE:
mov rdi, [r14+0C8h]
cmp rdi, rbx
jz short loc_1A9E7
test rdi, rdi
setz al
cmp rdi, r14
setz cl
or cl, al
jnz short loc_1A9E0
mov rax, [rdi]
call qword ptr [rax+8]
loc_1A9E0:
mov [r14+0C8h], rbx
loc_1A9E7:
lea rdi, _ZN5nglogL9log_mutexE; nglog::log_mutex
call _pthread_mutex_unlock
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_1AA00:
mov edi, eax; int
call __ZSt20__throw_system_errori; std::__throw_system_error(int)
mov rbx, rax
mov esi, 0D0h; unsigned __int64
mov rdi, r14; void *
call _ZdlPvm; operator delete(void *,ulong)
jmp short loc_1AA1C
mov rbx, rax
loc_1AA1C:
lea rdi, _ZN5nglogL9log_mutexE; nglog::log_mutex
call _pthread_mutex_unlock
mov rdi, rbx
call __Unwind_Resume
| long long nglog::base::SetLogger(int a1, long long a2)
{
int v2; // eax
long long v3; // r14
long long v4; // r14
long long v5; // rdi
_QWORD v7[6]; // [rsp+8h] [rbp-30h] BYREF
v2 = pthread_mutex_lock(&nglog::log_mutex);
if ( v2 )
std::__throw_system_error(v2);
v3 = nglog::LogDestination::log_destinations_[a1];
if ( !v3 )
{
v4 = operator new(208LL);
nglog::LogDestination::LogDestination(v4, a1, 0LL);
v7[0] = 0LL;
std::__uniq_ptr_impl<nglog::LogDestination,std::default_delete<nglog::LogDestination>>::reset(
&nglog::LogDestination::log_destinations_[a1],
v4);
std::unique_ptr<nglog::LogDestination>::~unique_ptr(v7);
v3 = nglog::LogDestination::log_destinations_[a1];
}
v5 = *(_QWORD *)(v3 + 200);
if ( v5 != a2 )
{
if ( v5 != 0 && v5 != v3 )
(*(void ( **)(long long))(*(_QWORD *)v5 + 8LL))(v5);
*(_QWORD *)(v3 + 200) = a2;
}
return pthread_mutex_unlock(&nglog::log_mutex);
}
| SetLogger:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV RBX,RSI
MOV EBP,EDI
LEA RDI,[0x1552b8]
CALL 0x001089e0
TEST EAX,EAX
JNZ 0x0011aa00
MOV R15D,EBP
LEA R12,[0x146200]
MOV R14,qword ptr [R12 + R15*0x8]
TEST R14,R14
JNZ 0x0011a9be
LAB_0011a97e:
MOV EDI,0xd0
CALL 0x0010a850
LAB_0011a988:
MOV R14,RAX
MOV RDI,RAX
MOV ESI,EBP
XOR EDX,EDX
CALL 0x00118f7c
LAB_0011a997:
LEA R15,[R12 + R15*0x8]
LEA R12,[RSP + 0x8]
MOV qword ptr [R12],0x0
MOV RDI,R15
MOV RSI,R14
CALL 0x0012110e
MOV RDI,R12
CALL 0x0011fe8c
MOV R14,qword ptr [R15]
LAB_0011a9be:
MOV RDI,qword ptr [R14 + 0xc8]
CMP RDI,RBX
JZ 0x0011a9e7
TEST RDI,RDI
SETZ AL
CMP RDI,R14
SETZ CL
OR CL,AL
JNZ 0x0011a9e0
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0011a9e0:
MOV qword ptr [R14 + 0xc8],RBX
LAB_0011a9e7:
LEA RDI,[0x1552b8]
CALL 0x00108490
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0011aa00:
MOV EDI,EAX
CALL 0x001083f0
|
/* nglog::base::SetLogger(nglog::LogSeverity, nglog::base::Logger*) */
void nglog::base::SetLogger(uint param_1,long *param_2)
{
long *plVar1;
int iVar2;
LogDestination *pLVar3;
long *plVar4;
int8 local_30;
iVar2 = pthread_mutex_lock((pthread_mutex_t *)log_mutex);
if (iVar2 == 0) {
plVar4 = (long *)(&LogDestination::log_destinations_)[param_1];
if (plVar4 == (long *)0x0) {
/* try { // try from 0011a97e to 0011a987 has its CatchHandler @ 0011aa19 */
pLVar3 = (LogDestination *)operator_new(0xd0);
/* try { // try from 0011a988 to 0011a996 has its CatchHandler @ 0011aa07 */
LogDestination::LogDestination(pLVar3,param_1,0);
local_30 = 0;
std::__uniq_ptr_impl<nglog::LogDestination,std::default_delete<nglog::LogDestination>>::reset
((__uniq_ptr_impl<nglog::LogDestination,std::default_delete<nglog::LogDestination>>
*)(&LogDestination::log_destinations_ + param_1),pLVar3);
std::unique_ptr<nglog::LogDestination,std::default_delete<nglog::LogDestination>>::~unique_ptr
((unique_ptr<nglog::LogDestination,std::default_delete<nglog::LogDestination>> *)
&local_30);
plVar4 = *(long **)(&LogDestination::log_destinations_ + param_1);
}
plVar1 = (long *)plVar4[0x19];
if (plVar1 != param_2) {
if (plVar1 != plVar4 && plVar1 != (long *)0x0) {
(**(code **)(*plVar1 + 8))();
}
plVar4[0x19] = (long)param_2;
}
pthread_mutex_unlock((pthread_mutex_t *)log_mutex);
return;
}
/* WARNING: Subroutine does not return */
std::__throw_system_error(iVar2);
}
| |
29,262 | protocol::encode(protocol::RequestChunk const&, unsigned int) | untodesu[P]voxelius/game/shared/protocol.cc | ENetPacket *protocol::encode(const protocol::RequestChunk &packet, enet_uint32 flags)
{
write_buffer.reset();
write_buffer.write_UI16(protocol::RequestChunk::ID);
write_buffer.write_I32(packet.cpos.x);
write_buffer.write_I32(packet.cpos.y);
write_buffer.write_I32(packet.cpos.z);
return write_buffer.to_packet(flags);
} | O0 | cpp | protocol::encode(protocol::RequestChunk const&, unsigned int):
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x214442(%rip), %rdi # 0x2d1998
callq 0xf28f0
leaq 0x214436(%rip), %rdi # 0x2d1998
movl $0xf, %esi
callq 0xf2940
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
leaq 0x21441e(%rip), %rdi # 0x2d1998
callq 0xbef30
movq -0x8(%rbp), %rax
movl 0x14(%rax), %esi
leaq 0x21440b(%rip), %rdi # 0x2d1998
callq 0xbef30
movq -0x8(%rbp), %rax
movl 0x18(%rax), %esi
leaq 0x2143f8(%rip), %rdi # 0x2d1998
callq 0xbef30
movl -0xc(%rbp), %esi
leaq 0x2143e9(%rip), %rdi # 0x2d1998
callq 0xf2d50
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _ZN8protocol6encodeERKNS_12RequestChunkEj:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
lea rdi, _ZL12write_buffer; this
call _ZN11WriteBuffer5resetEv; WriteBuffer::reset(void)
lea rdi, _ZL12write_buffer; this
mov esi, 0Fh; unsigned __int16
call _ZN11WriteBuffer10write_UI16Et; WriteBuffer::write_UI16(ushort)
mov rax, [rbp+var_8]
mov esi, [rax+10h]; int
lea rdi, _ZL12write_buffer; this
call _ZN11WriteBuffer9write_I32Ei; WriteBuffer::write_I32(int)
mov rax, [rbp+var_8]
mov esi, [rax+14h]; int
lea rdi, _ZL12write_buffer; this
call _ZN11WriteBuffer9write_I32Ei; WriteBuffer::write_I32(int)
mov rax, [rbp+var_8]
mov esi, [rax+18h]; int
lea rdi, _ZL12write_buffer; this
call _ZN11WriteBuffer9write_I32Ei; WriteBuffer::write_I32(int)
mov esi, [rbp+var_C]; unsigned int
lea rdi, _ZL12write_buffer; this
call _ZNK11WriteBuffer9to_packetEj; WriteBuffer::to_packet(uint)
add rsp, 10h
pop rbp
retn
| long long protocol::encode(protocol *this, const protocol::RequestChunk *a2)
{
WriteBuffer::reset((WriteBuffer *)&write_buffer);
WriteBuffer::write_UI16((WriteBuffer *)&write_buffer, 0xFu);
WriteBuffer::write_I32((WriteBuffer *)&write_buffer, *((_DWORD *)this + 4));
WriteBuffer::write_I32((WriteBuffer *)&write_buffer, *((_DWORD *)this + 5));
WriteBuffer::write_I32((WriteBuffer *)&write_buffer, *((_DWORD *)this + 6));
return WriteBuffer::to_packet((WriteBuffer *)&write_buffer, (unsigned int)a2);
}
| encode:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
LEA RDI,[0x3d1998]
CALL 0x001f28f0
LEA RDI,[0x3d1998]
MOV ESI,0xf
CALL 0x001f2940
MOV RAX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RAX + 0x10]
LEA RDI,[0x3d1998]
CALL 0x001bef30
MOV RAX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RAX + 0x14]
LEA RDI,[0x3d1998]
CALL 0x001bef30
MOV RAX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RAX + 0x18]
LEA RDI,[0x3d1998]
CALL 0x001bef30
MOV ESI,dword ptr [RBP + -0xc]
LEA RDI,[0x3d1998]
CALL 0x001f2d50
ADD RSP,0x10
POP RBP
RET
|
/* protocol::encode(protocol::RequestChunk const&, unsigned int) */
void protocol::encode(RequestChunk *param_1,uint param_2)
{
WriteBuffer::reset((WriteBuffer *)write_buffer);
WriteBuffer::write_UI16((WriteBuffer *)write_buffer,0xf);
WriteBuffer::write_I32((WriteBuffer *)write_buffer,*(int *)(param_1 + 0x10));
WriteBuffer::write_I32((WriteBuffer *)write_buffer,*(int *)(param_1 + 0x14));
WriteBuffer::write_I32((WriteBuffer *)write_buffer,*(int *)(param_1 + 0x18));
WriteBuffer::to_packet((WriteBuffer *)write_buffer,param_2);
return;
}
| |
29,263 | protocol::encode(protocol::RequestChunk const&, unsigned int) | untodesu[P]voxelius/game/shared/protocol.cc | ENetPacket *protocol::encode(const protocol::RequestChunk &packet, enet_uint32 flags)
{
write_buffer.reset();
write_buffer.write_UI16(protocol::RequestChunk::ID);
write_buffer.write_I32(packet.cpos.x);
write_buffer.write_I32(packet.cpos.y);
write_buffer.write_I32(packet.cpos.z);
return write_buffer.to_packet(flags);
} | O3 | cpp | protocol::encode(protocol::RequestChunk const&, unsigned int):
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0xc66df(%rip), %r15 # 0x1090d8
movq %r15, %rdi
callq 0x4ee24
movq %r15, %rdi
movl $0xf, %esi
callq 0x4ee4c
movl 0x10(%r14), %esi
movq %r15, %rdi
callq 0x4ee82
movl 0x14(%r14), %esi
movq %r15, %rdi
callq 0x4ee82
movl 0x18(%r14), %esi
movq %r15, %rdi
callq 0x4ee82
movq %r15, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x4f05c
| _ZN8protocol6encodeERKNS_12RequestChunkEj:
push r15
push r14
push rbx
mov ebx, esi
mov r14, rdi
lea r15, _ZL12write_buffer; write_buffer
mov rdi, r15; this
call _ZN11WriteBuffer5resetEv; WriteBuffer::reset(void)
mov rdi, r15; this
mov esi, 0Fh; unsigned __int16
call _ZN11WriteBuffer10write_UI16Et; WriteBuffer::write_UI16(ushort)
mov esi, [r14+10h]; unsigned int
mov rdi, r15; this
call _ZN11WriteBuffer10write_UI32Ej; WriteBuffer::write_UI32(uint)
mov esi, [r14+14h]; unsigned int
mov rdi, r15; this
call _ZN11WriteBuffer10write_UI32Ej; WriteBuffer::write_UI32(uint)
mov esi, [r14+18h]; unsigned int
mov rdi, r15; this
call _ZN11WriteBuffer10write_UI32Ej; WriteBuffer::write_UI32(uint)
mov rdi, r15; this
mov esi, ebx; unsigned int
pop rbx
pop r14
pop r15
jmp _ZNK11WriteBuffer9to_packetEj; WriteBuffer::to_packet(uint)
| long long protocol::encode(protocol *this, const protocol::RequestChunk *a2)
{
WriteBuffer::reset((WriteBuffer *)&write_buffer);
WriteBuffer::write_UI16((WriteBuffer *)&write_buffer, 0xFu);
WriteBuffer::write_UI32((WriteBuffer *)&write_buffer, *((_DWORD *)this + 4));
WriteBuffer::write_UI32((WriteBuffer *)&write_buffer, *((_DWORD *)this + 5));
WriteBuffer::write_UI32((WriteBuffer *)&write_buffer, *((_DWORD *)this + 6));
return WriteBuffer::to_packet((WriteBuffer *)&write_buffer, (unsigned int)a2);
}
| encode:
PUSH R15
PUSH R14
PUSH RBX
MOV EBX,ESI
MOV R14,RDI
LEA R15,[0x2090d8]
MOV RDI,R15
CALL 0x0014ee24
MOV RDI,R15
MOV ESI,0xf
CALL 0x0014ee4c
MOV ESI,dword ptr [R14 + 0x10]
MOV RDI,R15
CALL 0x0014ee82
MOV ESI,dword ptr [R14 + 0x14]
MOV RDI,R15
CALL 0x0014ee82
MOV ESI,dword ptr [R14 + 0x18]
MOV RDI,R15
CALL 0x0014ee82
MOV RDI,R15
MOV ESI,EBX
POP RBX
POP R14
POP R15
JMP 0x0014f05c
|
/* protocol::encode(protocol::RequestChunk const&, unsigned int) */
void protocol::encode(RequestChunk *param_1,uint param_2)
{
WriteBuffer::reset((WriteBuffer *)write_buffer);
WriteBuffer::write_UI16(0x90d8);
WriteBuffer::write_UI32(0x2090d8);
WriteBuffer::write_UI32(0x2090d8);
WriteBuffer::write_UI32(0x2090d8);
WriteBuffer::to_packet((WriteBuffer *)write_buffer,param_2);
return;
}
| |
29,264 | str2int | eloqsql/strings/str2int.c | char *str2int(register const char *src, register int radix, long int lower,
long int upper, long int *val)
{
int sign; /* is number negative (+1) or positive (-1) */
int n; /* number of digits yet to be converted */
long limit; /* "largest" possible valid input */
long scale; /* the amount to multiply next digit by */
long sofar; /* the running value */
register int d; /* (negative of) next digit */
char *start;
int digits[32]; /* Room for numbers */
/* Make sure *val is sensible in case of error */
*val = 0;
/* Check that the radix is in the range 2..36 */
#ifndef DBUG_OFF
if (radix < 2 || radix > 36) {
errno=EDOM;
return NullS;
}
#endif
/* The basic problem is: how do we handle the conversion of
a number without resorting to machine-specific code to
check for overflow? Obviously, we have to ensure that
no calculation can overflow. We are guaranteed that the
"lower" and "upper" arguments are valid machine integers.
On sign-and-magnitude, twos-complement, and ones-complement
machines all, if +|n| is representable, so is -|n|, but on
twos complement machines the converse is not true. So the
"maximum" representable number has a negative representative.
Limit is set to MY_MIN(-|lower|,-|upper|); this is the "largest"
number we are concerned with. */
/* Calculate Limit using Scale as a scratch variable */
if ((limit = lower) > 0) limit = -limit;
if ((scale = upper) > 0) scale = -scale;
if (scale < limit) limit = scale;
/* Skip leading spaces and check for a sign.
Note: because on a 2s complement machine MinLong is a valid
integer but |MinLong| is not, we have to keep the current
converted value (and the scale!) as *negative* numbers,
so the sign is the opposite of what you might expect.
*/
while (my_isspace(&my_charset_latin1,*src)) src++;
sign = -1;
if (*src == '+') src++; else
if (*src == '-') src++, sign = 1;
/* Skip leading zeros so that we never compute a power of radix
in scale that we won't have a need for. Otherwise sticking
enough 0s in front of a number could cause the multiplication
to overflow when it neededn't.
*/
start=(char*) src;
while (*src == '0') src++;
/* Move over the remaining digits. We have to convert from left
to left in order to avoid overflow. Answer is after last digit.
*/
for (n = 0; (digits[n]=char_val(*src)) < radix && n < 20; n++,src++) ;
/* Check that there is at least one digit */
if (start == src) {
errno=EDOM;
return NullS;
}
/* The invariant we want to maintain is that src is just
to the right of n digits, we've converted k digits to
sofar, scale = -radix**k, and scale < sofar < 0. Now
if the final number is to be within the original
Limit, we must have (to the left)*scale+sofar >= Limit,
or (to the left)*scale >= Limit-sofar, i.e. the digits
to the left of src must form an integer <= (Limit-sofar)/(scale).
In particular, this is true of the next digit. In our
incremental calculation of Limit,
IT IS VITAL that (-|N|)/(-|D|) = |N|/|D|
*/
for (sofar = 0, scale = -1; --n >= 1;)
{
if ((long) -(d=digits[n]) < limit) {
errno=ERANGE;
return NullS;
}
limit = (limit+d)/radix, sofar += d*scale; scale *= radix;
}
if (n == 0)
{
if ((long) -(d=digits[n]) < limit) /* get last digit */
{
errno=ERANGE;
return NullS;
}
sofar+=d*scale;
}
/* Now it might still happen that sofar = -32768 or its equivalent,
so we can't just multiply by the sign and check that the result
is in the range lower..upper. All of this caution is a right
pain in the neck. If only there were a standard routine which
says generate thus and such a signal on integer overflow...
But not enough machines can do it *SIGH*.
*/
if (sign < 0)
{
if (sofar < -LONG_MAX || (sofar= -sofar) > upper)
{
errno=ERANGE;
return NullS;
}
}
else if (sofar < lower)
{
errno=ERANGE;
return NullS;
}
*val = sofar;
errno=0; /* indicate that all went well */
return (char*) src;
} | O3 | c | str2int:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdx, %r9
movq $0x0, (%r8)
movq %rdx, %rax
negq %rax
cmovsq %rdx, %rax
movq %rcx, %rdx
negq %rdx
cmovnsq %rcx, %rdx
leaq 0x2d164d(%rip), %r10 # 0x363db0
movq 0x40(%r10), %r11
movzbl (%rdi), %r10d
incq %rdi
testb $0x8, 0x1(%r11,%r10)
jne 0x92767
negq %rax
cmpq %rax, %rdx
cmovlq %rdx, %rax
cmpl $0x2b, %r10d
je 0x92794
cmpl $0x2d, %r10d
jne 0x92791
xorl %r10d, %r10d
jmp 0x92797
decq %rdi
movb $0x1, %r10b
leaq -0x1(%rdi), %rbx
movb 0x1(%rbx), %r14b
incq %rbx
cmpb $0x30, %r14b
je 0x9279b
xorl %r11d, %r11d
xorl %edx, %edx
leal -0x30(%r14), %r15d
cmpb $0x9, %r15b
ja 0x927bd
movzbl %r15b, %r15d
jmp 0x927e9
leal -0x41(%r14), %r15d
cmpb $0x19, %r15b
ja 0x927d1
movzbl %r14b, %r15d
addl $-0x37, %r15d
jmp 0x927e9
leal -0x61(%r14), %r12d
movl $0x7f, %r15d
cmpb $0x19, %r12b
ja 0x927e9
movzbl %r14b, %r15d
addl $-0x57, %r15d
movl %r15d, -0xa0(%rbp,%rdx,4)
cmpl %esi, %r15d
jge 0x9280b
cmpq $0x13, %rdx
ja 0x9280b
incq %rdx
movb 0x1(%rbx), %r14b
incq %rbx
incl %r11d
jmp 0x927ad
cmpq %rdi, %rbx
je 0x92853
cmpq $0x2, %rdx
jb 0x9285b
movslq %esi, %r14
movq $-0x1, %rdi
xorl %esi, %esi
decl %r11d
movslq -0xa0(%rbp,%r11,4), %r15
movq %r15, %rdx
negq %rdx
cmpq %rdx, %rax
jg 0x92896
addq %r15, %rax
cqto
idivq %r14
imulq %rdi, %r15
addq %r15, %rsi
imulq %r14, %rdi
cmpl $0x1, %r11d
jg 0x92822
jmp 0x92868
movl $0x21, %r14d
jmp 0x9289c
xorl %esi, %esi
decl %edx
jne 0x92881
movq $-0x1, %rdi
movslq -0xa0(%rbp), %rdx
movq %rdx, %r11
negq %r11
cmpq %r11, %rax
jg 0x92896
imulq %rdx, %rdi
addq %rdi, %rsi
testb %r10b, %r10b
je 0x928b9
negq %rsi
seto %al
cmpq %rcx, %rsi
setg %cl
orb %al, %cl
je 0x928be
movl $0x22, %r14d
xorl %ebx, %ebx
callq 0x36a30
movl %r14d, (%rax)
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpq %r9, %rsi
jl 0x92896
movq %rsi, (%r8)
xorl %r14d, %r14d
jmp 0x9289e
nop
| str2int:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 80h
mov r9, rdx
mov qword ptr [r8], 0
mov rax, rdx
neg rax
cmovs rax, rdx
mov rdx, rcx
neg rdx
cmovns rdx, rcx
lea r10, my_charset_latin1
mov r11, [r10+40h]
loc_92767:
movzx r10d, byte ptr [rdi]
inc rdi
test byte ptr [r11+r10+1], 8
jnz short loc_92767
neg rax
cmp rdx, rax
cmovl rax, rdx
cmp r10d, 2Bh ; '+'
jz short loc_92794
cmp r10d, 2Dh ; '-'
jnz short loc_92791
xor r10d, r10d
jmp short loc_92797
loc_92791:
dec rdi
loc_92794:
mov r10b, 1
loc_92797:
lea rbx, [rdi-1]
loc_9279B:
mov r14b, [rbx+1]
inc rbx
cmp r14b, 30h ; '0'
jz short loc_9279B
xor r11d, r11d
xor edx, edx
loc_927AD:
lea r15d, [r14-30h]
cmp r15b, 9
ja short loc_927BD
movzx r15d, r15b
jmp short loc_927E9
loc_927BD:
lea r15d, [r14-41h]
cmp r15b, 19h
ja short loc_927D1
movzx r15d, r14b
add r15d, 0FFFFFFC9h
jmp short loc_927E9
loc_927D1:
lea r12d, [r14-61h]
mov r15d, 7Fh
cmp r12b, 19h
ja short loc_927E9
movzx r15d, r14b
add r15d, 0FFFFFFA9h
loc_927E9:
mov [rbp+rdx*4+var_A0], r15d
cmp r15d, esi
jge short loc_9280B
cmp rdx, 13h
ja short loc_9280B
inc rdx
mov r14b, [rbx+1]
inc rbx
inc r11d
jmp short loc_927AD
loc_9280B:
cmp rbx, rdi
jz short loc_92853
cmp rdx, 2
jb short loc_9285B
movsxd r14, esi
mov rdi, 0FFFFFFFFFFFFFFFFh
xor esi, esi
loc_92822:
dec r11d
movsxd r15, [rbp+r11*4+var_A0]
mov rdx, r15
neg rdx
cmp rax, rdx
jg short loc_92896
add rax, r15
cqo
idiv r14
imul r15, rdi
add rsi, r15
imul rdi, r14
cmp r11d, 1
jg short loc_92822
jmp short loc_92868
loc_92853:
mov r14d, 21h ; '!'
jmp short loc_9289C
loc_9285B:
xor esi, esi
dec edx
jnz short loc_92881
mov rdi, 0FFFFFFFFFFFFFFFFh
loc_92868:
movsxd rdx, [rbp+var_A0]
mov r11, rdx
neg r11
cmp rax, r11
jg short loc_92896
imul rdi, rdx
add rsi, rdi
loc_92881:
test r10b, r10b
jz short loc_928B9
neg rsi
seto al
cmp rsi, rcx
setnle cl
or cl, al
jz short loc_928BE
loc_92896:
mov r14d, 22h ; '"'
loc_9289C:
xor ebx, ebx
loc_9289E:
call ___errno_location
mov [rax], r14d
mov rax, rbx
add rsp, 80h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_928B9:
cmp rsi, r9
jl short loc_92896
loc_928BE:
mov [r8], rsi
xor r14d, r14d
jmp short loc_9289E
| long long str2int(long long a1, int a2, long long a3, long long a4, long long *a5)
{
long long v6; // rax
long long v7; // rdx
long long v8; // r10
long long v9; // rax
char v10; // r10
long long v11; // rbx
unsigned __int8 v12; // r14
long long v13; // r11
unsigned long long i; // rdx
int v15; // r15d
long long v16; // r14
long long v17; // rsi
long long v18; // r15
int v19; // r14d
_DWORD v21[40]; // [rsp+0h] [rbp-A0h]
*a5 = 0LL;
v6 = -a3;
if ( a3 > 0 )
v6 = a3;
v7 = -a4;
if ( a4 <= 0 )
v7 = a4;
do
v8 = *(unsigned __int8 *)a1++;
while ( (*(_BYTE *)(*(_QWORD *)&my_charset_latin1[16] + v8 + 1) & 8) != 0 );
v9 = -v6;
if ( v7 < v9 )
v9 = v7;
if ( (_DWORD)v8 != 43 )
{
if ( (_DWORD)v8 == 45 )
{
v10 = 0;
goto LABEL_13;
}
--a1;
}
v10 = 1;
LABEL_13:
v11 = a1 - 1;
do
v12 = *(_BYTE *)++v11;
while ( v12 == 48 );
LODWORD(v13) = 0;
for ( i = 0LL; ; ++i )
{
LOBYTE(v15) = v12 - 48;
if ( (unsigned __int8)(v12 - 48) > 9u )
{
if ( (unsigned __int8)(v12 - 65) > 0x19u )
{
v15 = 127;
if ( (unsigned __int8)(v12 - 97) <= 0x19u )
v15 = v12 - 87;
}
else
{
v15 = v12 - 55;
}
}
else
{
v15 = (unsigned __int8)v15;
}
v21[i] = v15;
if ( v15 >= a2 || i > 0x13 )
break;
v12 = *(_BYTE *)++v11;
LODWORD(v13) = v13 + 1;
}
if ( v11 != a1 )
{
if ( i >= 2 )
{
v16 = a2;
a1 = -1LL;
v17 = 0LL;
while ( 1 )
{
v13 = (unsigned int)(v13 - 1);
v18 = (int)v21[v13];
if ( v9 > -v18 )
goto LABEL_38;
v9 = (v18 + v9) / v16;
v17 += a1 * v18;
a1 *= v16;
if ( (int)v13 <= 1 )
goto LABEL_34;
}
}
v17 = 0LL;
if ( (_DWORD)i == 1 )
{
a1 = -1LL;
LABEL_34:
if ( v9 > -(long long)v21[0] )
goto LABEL_38;
a1 *= v21[0];
v17 += a1;
}
if ( v10 )
{
v17 = -v17;
if ( __OFSUB__(v17, 1LL) || v17 > a4 )
{
LABEL_38:
v19 = 34;
goto LABEL_39;
}
}
else if ( v17 < a3 )
{
goto LABEL_38;
}
*a5 = v17;
v19 = 0;
goto LABEL_40;
}
v19 = 33;
LABEL_39:
v11 = 0LL;
LABEL_40:
*(_DWORD *)__errno_location(a1) = v19;
return v11;
}
| str2int:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x80
MOV R9,RDX
MOV qword ptr [R8],0x0
MOV RAX,RDX
NEG RAX
CMOVS RAX,RDX
MOV RDX,RCX
NEG RDX
CMOVNS RDX,RCX
LEA R10,[0x463db0]
MOV R11,qword ptr [R10 + 0x40]
LAB_00192767:
MOVZX R10D,byte ptr [RDI]
INC RDI
TEST byte ptr [R11 + R10*0x1 + 0x1],0x8
JNZ 0x00192767
NEG RAX
CMP RDX,RAX
CMOVL RAX,RDX
CMP R10D,0x2b
JZ 0x00192794
CMP R10D,0x2d
JNZ 0x00192791
XOR R10D,R10D
JMP 0x00192797
LAB_00192791:
DEC RDI
LAB_00192794:
MOV R10B,0x1
LAB_00192797:
LEA RBX,[RDI + -0x1]
LAB_0019279b:
MOV R14B,byte ptr [RBX + 0x1]
INC RBX
CMP R14B,0x30
JZ 0x0019279b
XOR R11D,R11D
XOR EDX,EDX
LAB_001927ad:
LEA R15D,[R14 + -0x30]
CMP R15B,0x9
JA 0x001927bd
MOVZX R15D,R15B
JMP 0x001927e9
LAB_001927bd:
LEA R15D,[R14 + -0x41]
CMP R15B,0x19
JA 0x001927d1
MOVZX R15D,R14B
ADD R15D,-0x37
JMP 0x001927e9
LAB_001927d1:
LEA R12D,[R14 + -0x61]
MOV R15D,0x7f
CMP R12B,0x19
JA 0x001927e9
MOVZX R15D,R14B
ADD R15D,-0x57
LAB_001927e9:
MOV dword ptr [RBP + RDX*0x4 + -0xa0],R15D
CMP R15D,ESI
JGE 0x0019280b
CMP RDX,0x13
JA 0x0019280b
INC RDX
MOV R14B,byte ptr [RBX + 0x1]
INC RBX
INC R11D
JMP 0x001927ad
LAB_0019280b:
CMP RBX,RDI
JZ 0x00192853
CMP RDX,0x2
JC 0x0019285b
MOVSXD R14,ESI
MOV RDI,-0x1
XOR ESI,ESI
LAB_00192822:
DEC R11D
MOVSXD R15,dword ptr [RBP + R11*0x4 + -0xa0]
MOV RDX,R15
NEG RDX
CMP RAX,RDX
JG 0x00192896
ADD RAX,R15
CQO
IDIV R14
IMUL R15,RDI
ADD RSI,R15
IMUL RDI,R14
CMP R11D,0x1
JG 0x00192822
JMP 0x00192868
LAB_00192853:
MOV R14D,0x21
JMP 0x0019289c
LAB_0019285b:
XOR ESI,ESI
DEC EDX
JNZ 0x00192881
MOV RDI,-0x1
LAB_00192868:
MOVSXD RDX,dword ptr [RBP + -0xa0]
MOV R11,RDX
NEG R11
CMP RAX,R11
JG 0x00192896
IMUL RDI,RDX
ADD RSI,RDI
LAB_00192881:
TEST R10B,R10B
JZ 0x001928b9
NEG RSI
SETO AL
CMP RSI,RCX
SETG CL
OR CL,AL
JZ 0x001928be
LAB_00192896:
MOV R14D,0x22
LAB_0019289c:
XOR EBX,EBX
LAB_0019289e:
CALL 0x00136a30
MOV dword ptr [RAX],R14D
MOV RAX,RBX
ADD RSP,0x80
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001928b9:
CMP RSI,R9
JL 0x00192896
LAB_001928be:
MOV qword ptr [R8],RSI
XOR R14D,R14D
JMP 0x0019289e
|
byte * str2int(byte *param_1,int param_2,long param_3,long param_4,long *param_5)
{
long lVar1;
int *piVar2;
ulong uVar3;
byte *pbVar4;
long lVar5;
byte *pbVar6;
long lVar7;
ulong uVar8;
byte bVar9;
int iVar10;
uint uVar11;
long lVar12;
bool bVar13;
uint local_a8 [32];
*param_5 = 0;
lVar5 = -param_3;
if (0 < param_3) {
lVar5 = param_3;
}
lVar7 = -param_4;
if (param_4 < 1) {
lVar7 = param_4;
}
do {
pbVar4 = param_1;
bVar9 = *pbVar4;
param_1 = pbVar4 + 1;
} while ((PTR_ctype_latin1_00463df0[(ulong)bVar9 + 1] & 8) != 0);
lVar1 = -lVar5;
if (SBORROW8(lVar7,-lVar5) != lVar7 + lVar5 < 0) {
lVar1 = lVar7;
}
pbVar6 = param_1;
if ((bVar9 == 0x2b) || (pbVar6 = pbVar4, bVar9 != 0x2d)) {
bVar13 = true;
}
else {
bVar13 = false;
pbVar6 = param_1;
}
pbVar4 = pbVar6 + -1;
do {
bVar9 = pbVar4[1];
pbVar4 = pbVar4 + 1;
} while (bVar9 == 0x30);
uVar8 = 0;
uVar3 = 0;
while( true ) {
if ((byte)(bVar9 - 0x30) < 10) {
uVar11 = (uint)(byte)(bVar9 - 0x30);
}
else if ((byte)(bVar9 + 0xbf) < 0x1a) {
uVar11 = bVar9 - 0x37;
}
else {
uVar11 = 0x7f;
if ((byte)(bVar9 + 0x9f) < 0x1a) {
uVar11 = bVar9 - 0x57;
}
}
local_a8[uVar3] = uVar11;
if ((param_2 <= (int)uVar11) || (0x13 < uVar3)) break;
uVar3 = uVar3 + 1;
bVar9 = pbVar4[1];
pbVar4 = pbVar4 + 1;
uVar8 = (ulong)((int)uVar8 + 1);
}
if (pbVar4 == pbVar6) {
iVar10 = 0x21;
}
else {
if (uVar3 < 2) {
lVar5 = 0;
if ((int)uVar3 == 1) {
lVar7 = -1;
goto LAB_00192868;
}
LAB_00192881:
if (bVar13) {
lVar7 = -lVar5;
bVar13 = -param_4 == lVar5;
lVar5 = lVar7;
if (bVar13 || lVar7 < param_4) {
LAB_001928be:
*param_5 = lVar5;
iVar10 = 0;
goto LAB_0019289e;
}
}
else if (param_3 <= lVar5) goto LAB_001928be;
}
else {
lVar7 = -1;
lVar5 = 0;
do {
uVar11 = (int)uVar8 - 1;
uVar8 = (ulong)uVar11;
lVar12 = (long)(int)local_a8[uVar8];
if (lVar1 != -lVar12 && SBORROW8(lVar1,-lVar12) == lVar1 + lVar12 < 0) goto LAB_00192896;
lVar1 = (lVar1 + lVar12) / (long)param_2;
lVar5 = lVar5 + lVar12 * lVar7;
lVar7 = lVar7 * param_2;
} while (1 < (int)uVar11);
LAB_00192868:
lVar12 = (long)(int)local_a8[0];
if (lVar1 == -lVar12 || SBORROW8(lVar1,-lVar12) != lVar1 + lVar12 < 0) {
lVar5 = lVar5 + lVar7 * lVar12;
goto LAB_00192881;
}
}
LAB_00192896:
iVar10 = 0x22;
}
pbVar4 = (byte *)0x0;
LAB_0019289e:
piVar2 = __errno_location();
*piVar2 = iVar10;
return pbVar4;
}
| |
29,265 | read_next_extent | eloqsql/storage/maria/ma_blockrec.c | static uchar *read_next_extent(MARIA_HA *info, MARIA_EXTENT_CURSOR *extent,
uchar **end_of_data)
{
MARIA_SHARE *share= info->s;
uchar *buff, *data;
MARIA_PINNED_PAGE page_link;
enum pagecache_page_lock lock;
DBUG_ENTER("read_next_extent");
if (!extent->page_count)
{
uint page_count;
if (!--extent->extent_count)
goto crashed;
extent->extent+= ROW_EXTENT_SIZE;
extent->page= page_korr(extent->extent);
page_count= (uint2korr(extent->extent+ROW_EXTENT_PAGE_SIZE) &
~START_EXTENT_BIT);
if (!page_count)
goto crashed;
extent->tail= page_count & TAIL_BIT;
if (extent->tail)
extent->tail_row_nr= page_count & ~TAIL_BIT;
else
extent->page_count= page_count;
DBUG_PRINT("info",("New extent. Page: %lu page_count: %u tail_flag: %d",
(ulong) extent->page, extent->page_count,
extent->tail != 0));
}
extent->first_extent= 0;
lock= PAGECACHE_LOCK_LEFT_UNLOCKED;
if (extent->tail)
lock= extent->lock_for_tail_pages;
buff= pagecache_read(share->pagecache,
&info->dfile, extent->page, 0,
info->buff, share->page_type,
lock, &page_link.link);
if (lock != PAGECACHE_LOCK_LEFT_UNLOCKED)
{
/* Read during UNDO */
page_link.unlock= PAGECACHE_LOCK_WRITE_UNLOCK;
page_link.changed= buff != 0;
push_dynamic(&info->pinned_pages, (void*) &page_link);
}
if (!buff)
{
/* check if we tried to read over end of file (ie: bad data in record) */
if ((extent->page + 1) * share->block_size >
share->state.state.data_file_length)
goto crashed;
DBUG_RETURN(0);
}
if (!extent->tail)
{
/* Full data page */
if ((buff[PAGE_TYPE_OFFSET] & PAGE_TYPE_MASK) != BLOB_PAGE)
goto crashed;
extent->page++; /* point to next page */
extent->page_count--;
*end_of_data= buff + share->block_size - PAGE_SUFFIX_SIZE;
info->cur_row.full_page_count++; /* For maria_chk */
DBUG_RETURN(extent->data_start= buff + FULL_PAGE_HEADER_SIZE(share));
}
/* Found tail */
if ((buff[PAGE_TYPE_OFFSET] & PAGE_TYPE_MASK) != TAIL_PAGE)
goto crashed;
*(extent->tail_positions++)= ma_recordpos(extent->page,
extent->tail_row_nr);
info->cur_row.tail_count++; /* For maria_chk */
if (!(data= get_record_position(share, buff,
extent->tail_row_nr,
end_of_data)))
goto crashed;
extent->data_start= data;
extent->page_count= 0; /* No more data in extent */
DBUG_RETURN(data);
crashed:
DBUG_ASSERT(!maria_assert_if_crashed_table);
_ma_set_fatal_error(info, HA_ERR_WRONG_IN_RECORD);
DBUG_PRINT("error", ("wrong extent information"));
DBUG_RETURN(0);
} | O0 | c | read_next_extent:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x79693
movq -0x18(%rbp), %rcx
movl 0x28(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x28(%rcx)
cmpl $0x0, %eax
jne 0x79614
jmp 0x798a6
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x7, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x7b3c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movzwl 0x5(%rax), %eax
andl $0xffffbfff, %eax # imm = 0xFFFFBFFF
movl %eax, -0x58(%rbp)
cmpl $0x0, -0x58(%rbp)
jne 0x79657
jmp 0x798a6
movl -0x58(%rbp), %ecx
andl $0x8000, %ecx # imm = 0x8000
movq -0x18(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
je 0x79683
movl -0x58(%rbp), %ecx
andl $0xffff7fff, %ecx # imm = 0xFFFF7FFF
movq -0x18(%rbp), %rax
movl %ecx, 0x30(%rax)
jmp 0x7968d
movl -0x58(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x20(%rax)
jmp 0x7968f
jmp 0x79691
jmp 0x79693
movq -0x18(%rbp), %rax
movb $0x0, 0x34(%rax)
movl $0x0, -0x54(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
je 0x796b6
movq -0x18(%rbp), %rax
movl 0x24(%rax), %eax
movl %eax, -0x54(%rbp)
movq -0x28(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x470, %rsi # imm = 0x470
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x378(%rax), %r8
movq -0x28(%rbp), %rax
movl 0x7d4(%rax), %r9d
movl -0x54(%rbp), %r10d
leaq -0x50(%rbp), %rax
xorl %ecx, %ecx
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x2ecf0
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x54(%rbp)
je 0x79737
movl $0x6, -0x48(%rbp)
cmpq $0x0, -0x30(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x40(%rbp)
movq -0x10(%rbp), %rdi
addq $0x2e8, %rdi # imm = 0x2E8
leaq -0x50(%rbp), %rsi
callq 0xdbcc0
cmpq $0x0, -0x30(%rbp)
jne 0x79776
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
addq $0x1, %rax
movq -0x28(%rbp), %rcx
movl 0x7bc(%rcx), %ecx
imulq %rcx, %rax
movq -0x28(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jbe 0x79767
jmp 0x798a6
jmp 0x79769
movq $0x0, -0x8(%rbp)
jmp 0x798c4
movq -0x18(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jne 0x7980c
movq -0x30(%rbp), %rax
movzbl 0x7(%rax), %eax
andl $0x7, %eax
cmpl $0x3, %eax
je 0x79799
jmp 0x798a6
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movl 0x20(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x20(%rax)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movl 0x7bc(%rax), %eax
addq %rax, %rcx
addq $-0x4, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl 0x130(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x130(%rax)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movl 0xc18(%rcx), %ecx
addl $0x8, %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq -0x18(%rbp), %rcx
movq %rax, 0x8(%rcx)
movq %rax, -0x8(%rbp)
jmp 0x798c4
movq -0x30(%rbp), %rax
movzbl 0x7(%rax), %eax
andl $0x7, %eax
cmpl $0x2, %eax
je 0x79821
jmp 0x798a6
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x30(%rax), %esi
callq 0x7a7b0
movq %rax, %rcx
movq -0x18(%rbp), %rdx
movq 0x10(%rdx), %rax
movq %rax, %rsi
addq $0x8, %rsi
movq %rsi, 0x10(%rdx)
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl 0x134(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x134(%rax)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0x30(%rax), %edx
movq -0x20(%rbp), %rcx
callq 0x799f0
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x79885
jmp 0x798a6
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x798c4
jmp 0x798a8
jmp 0x798aa
movq -0x10(%rbp), %rdi
movl $0x7f, %esi
callq 0x34c30
jmp 0x798ba
jmp 0x798bc
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nop
| read_next_extent:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
cmp dword ptr [rax+20h], 0
jnz loc_79693
mov rcx, [rbp+var_18]
mov eax, [rcx+28h]
add eax, 0FFFFFFFFh
mov [rcx+28h], eax
cmp eax, 0
jnz short loc_79614
jmp loc_798A6
loc_79614:
mov rax, [rbp+var_18]
mov rcx, [rax]
add rcx, 7
mov [rax], rcx
mov rax, [rbp+var_18]
mov rdi, [rax]
call uint5korr_1
mov rcx, rax
mov rax, [rbp+var_18]
mov [rax+18h], rcx
mov rax, [rbp+var_18]
mov rax, [rax]
movzx eax, word ptr [rax+5]
and eax, 0FFFFBFFFh
mov [rbp+var_58], eax
cmp [rbp+var_58], 0
jnz short loc_79657
jmp loc_798A6
loc_79657:
mov ecx, [rbp+var_58]
and ecx, 8000h
mov rax, [rbp+var_18]
mov [rax+2Ch], ecx
mov rax, [rbp+var_18]
cmp dword ptr [rax+2Ch], 0
jz short loc_79683
mov ecx, [rbp+var_58]
and ecx, 0FFFF7FFFh
mov rax, [rbp+var_18]
mov [rax+30h], ecx
jmp short loc_7968D
loc_79683:
mov ecx, [rbp+var_58]
mov rax, [rbp+var_18]
mov [rax+20h], ecx
loc_7968D:
jmp short $+2
loc_7968F:
jmp short $+2
loc_79691:
jmp short $+2
loc_79693:
mov rax, [rbp+var_18]
mov byte ptr [rax+34h], 0
mov [rbp+var_54], 0
mov rax, [rbp+var_18]
cmp dword ptr [rax+2Ch], 0
jz short loc_796B6
mov rax, [rbp+var_18]
mov eax, [rax+24h]
mov [rbp+var_54], eax
loc_796B6:
mov rax, [rbp+var_28]
mov rdi, [rax+600h]
mov rsi, [rbp+var_10]
add rsi, 470h
mov rax, [rbp+var_18]
mov rdx, [rax+18h]
mov rax, [rbp+var_10]
mov r8, [rax+378h]
mov rax, [rbp+var_28]
mov r9d, [rax+7D4h]
mov r10d, [rbp+var_54]
lea rax, [rbp+var_50]
xor ecx, ecx
mov [rsp+70h+var_70], r10d
mov [rsp+70h+var_68], rax
call pagecache_read
mov [rbp+var_30], rax
cmp [rbp+var_54], 0
jz short loc_79737
mov [rbp+var_48], 6
cmp [rbp+var_30], 0
setnz al
and al, 1
movzx eax, al
mov [rbp+var_40], al
mov rdi, [rbp+var_10]
add rdi, 2E8h
lea rsi, [rbp+var_50]
call insert_dynamic
loc_79737:
cmp [rbp+var_30], 0
jnz short loc_79776
mov rax, [rbp+var_18]
mov rax, [rax+18h]
add rax, 1
mov rcx, [rbp+var_28]
mov ecx, [rcx+7BCh]
imul rax, rcx
mov rcx, [rbp+var_28]
cmp rax, [rcx+40h]
jbe short loc_79767
jmp loc_798A6
loc_79767:
jmp short $+2
loc_79769:
mov [rbp+var_8], 0
jmp loc_798C4
loc_79776:
mov rax, [rbp+var_18]
cmp dword ptr [rax+2Ch], 0
jnz loc_7980C
mov rax, [rbp+var_30]
movzx eax, byte ptr [rax+7]
and eax, 7
cmp eax, 3
jz short loc_79799
jmp loc_798A6
loc_79799:
mov rax, [rbp+var_18]
mov rcx, [rax+18h]
add rcx, 1
mov [rax+18h], rcx
mov rax, [rbp+var_18]
mov ecx, [rax+20h]
add ecx, 0FFFFFFFFh
mov [rax+20h], ecx
mov rcx, [rbp+var_30]
mov rax, [rbp+var_28]
mov eax, [rax+7BCh]
add rcx, rax
add rcx, 0FFFFFFFFFFFFFFFCh
mov rax, [rbp+var_20]
mov [rax], rcx
mov rax, [rbp+var_10]
mov ecx, [rax+130h]
add ecx, 1
mov [rax+130h], ecx
mov rax, [rbp+var_30]
mov rcx, [rbp+var_28]
mov ecx, [rcx+0C18h]
add ecx, 8
mov ecx, ecx
add rax, rcx
mov rcx, [rbp+var_18]
mov [rcx+8], rax
mov [rbp+var_8], rax
jmp loc_798C4
loc_7980C:
mov rax, [rbp+var_30]
movzx eax, byte ptr [rax+7]
and eax, 7
cmp eax, 2
jz short loc_79821
jmp loc_798A6
loc_79821:
mov rax, [rbp+var_18]
mov rdi, [rax+18h]
mov rax, [rbp+var_18]
mov esi, [rax+30h]
call ma_recordpos
mov rcx, rax
mov rdx, [rbp+var_18]
mov rax, [rdx+10h]
mov rsi, rax
add rsi, 8
mov [rdx+10h], rsi
mov [rax], rcx
mov rax, [rbp+var_10]
mov ecx, [rax+134h]
add ecx, 1
mov [rax+134h], ecx
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_30]
mov rax, [rbp+var_18]
mov edx, [rax+30h]
mov rcx, [rbp+var_20]
call get_record_position
mov [rbp+var_38], rax
cmp rax, 0
jnz short loc_79885
jmp short loc_798A6
loc_79885:
mov rcx, [rbp+var_38]
mov rax, [rbp+var_18]
mov [rax+8], rcx
mov rax, [rbp+var_18]
mov dword ptr [rax+20h], 0
mov rax, [rbp+var_38]
mov [rbp+var_8], rax
jmp short loc_798C4
loc_798A6:
jmp short $+2
loc_798A8:
jmp short $+2
loc_798AA:
mov rdi, [rbp+var_10]
mov esi, 7Fh
call _ma_set_fatal_error
jmp short $+2
loc_798BA:
jmp short $+2
loc_798BC:
mov [rbp+var_8], 0
loc_798C4:
mov rax, [rbp+var_8]
add rsp, 70h
pop rbp
retn
| long long read_next_extent(_DWORD *a1, long long a2, long long a3, long long a4, long long a5, int a6)
{
long long v6; // rcx
int v7; // eax
long long v8; // rax
long long v9; // rcx
long long *v10; // rax
int v12; // [rsp+18h] [rbp-58h]
unsigned int v13; // [rsp+1Ch] [rbp-54h]
char v14[8]; // [rsp+20h] [rbp-50h] BYREF
int v15; // [rsp+28h] [rbp-48h]
bool v16; // [rsp+30h] [rbp-40h]
long long record_position; // [rsp+38h] [rbp-38h]
long long v18; // [rsp+40h] [rbp-30h]
long long v19; // [rsp+48h] [rbp-28h]
_QWORD *v20; // [rsp+50h] [rbp-20h]
long long v21; // [rsp+58h] [rbp-18h]
_DWORD *v22; // [rsp+60h] [rbp-10h]
v22 = a1;
v21 = a2;
v20 = (_QWORD *)a3;
v19 = *(_QWORD *)a1;
if ( !*(_DWORD *)(a2 + 32) )
{
v6 = v21;
v7 = *(_DWORD *)(v21 + 40) - 1;
*(_DWORD *)(v21 + 40) = v7;
if ( !v7 )
goto LABEL_20;
*(_QWORD *)v21 += 7LL;
v6 = uint5korr_1(*(_QWORD *)v21);
*(_QWORD *)(v21 + 24) = v6;
v12 = *(_WORD *)(*(_QWORD *)v21 + 5LL) & 0xBFFF;
if ( (*(_WORD *)(*(_QWORD *)v21 + 5LL) & 0xBFFF) == 0 )
goto LABEL_20;
*(_DWORD *)(v21 + 44) = *(_WORD *)(*(_QWORD *)v21 + 5LL) & 0x8000;
if ( *(_DWORD *)(v21 + 44) )
*(_DWORD *)(v21 + 48) = v12 & 0xFFFF7FFF;
else
*(_DWORD *)(v21 + 32) = v12;
}
*(_BYTE *)(v21 + 52) = 0;
v13 = 0;
if ( *(_DWORD *)(v21 + 44) )
v13 = *(_DWORD *)(v21 + 36);
v18 = pagecache_read(
*(_QWORD **)(v19 + 1536),
(long long)(v22 + 284),
*(_QWORD *)(v21 + 24),
0,
*((_QWORD *)v22 + 111),
*(_DWORD *)(v19 + 2004),
v13,
v14);
if ( v13 )
{
v15 = 6;
v16 = v18 != 0;
insert_dynamic(v22 + 186, v14);
}
if ( v18 )
{
if ( *(_DWORD *)(v21 + 44) )
{
if ( (*(_BYTE *)(v18 + 7) & 7) == 2 )
{
v9 = ma_recordpos(*(_QWORD *)(v21 + 24), *(unsigned int *)(v21 + 48));
v10 = *(long long **)(v21 + 16);
*(_QWORD *)(v21 + 16) = v10 + 1;
*v10 = v9;
++v22[77];
record_position = get_record_position(v19, v18, *(unsigned int *)(v21 + 48), v20);
if ( record_position )
{
*(_QWORD *)(v21 + 8) = record_position;
*(_DWORD *)(v21 + 32) = 0;
return record_position;
}
}
}
else if ( (*(_BYTE *)(v18 + 7) & 7) == 3 )
{
++*(_QWORD *)(v21 + 24);
--*(_DWORD *)(v21 + 32);
*v20 = *(unsigned int *)(v19 + 1980) + v18 - 4;
++v22[76];
v8 = (unsigned int)(*(_DWORD *)(v19 + 3096) + 8) + v18;
*(_QWORD *)(v21 + 8) = v8;
return v8;
}
LABEL_20:
ma_set_fatal_error(v22, 127, a3, v6, a5, a6);
return 0LL;
}
v6 = v19;
if ( (unsigned long long)*(unsigned int *)(v19 + 1980) * (*(_QWORD *)(v21 + 24) + 1LL) > *(_QWORD *)(v19 + 64) )
goto LABEL_20;
return 0LL;
}
| read_next_extent:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX + 0x20],0x0
JNZ 0x00179693
MOV RCX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RCX + 0x28]
ADD EAX,-0x1
MOV dword ptr [RCX + 0x28],EAX
CMP EAX,0x0
JNZ 0x00179614
JMP 0x001798a6
LAB_00179614:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX]
ADD RCX,0x7
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX]
CALL 0x0017b3c0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOVZX EAX,word ptr [RAX + 0x5]
AND EAX,0xffffbfff
MOV dword ptr [RBP + -0x58],EAX
CMP dword ptr [RBP + -0x58],0x0
JNZ 0x00179657
JMP 0x001798a6
LAB_00179657:
MOV ECX,dword ptr [RBP + -0x58]
AND ECX,0x8000
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x2c],ECX
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX + 0x2c],0x0
JZ 0x00179683
MOV ECX,dword ptr [RBP + -0x58]
AND ECX,0xffff7fff
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x30],ECX
JMP 0x0017968d
LAB_00179683:
MOV ECX,dword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x20],ECX
LAB_0017968d:
JMP 0x0017968f
LAB_0017968f:
JMP 0x00179691
LAB_00179691:
JMP 0x00179693
LAB_00179693:
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x34],0x0
MOV dword ptr [RBP + -0x54],0x0
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX + 0x2c],0x0
JZ 0x001796b6
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x24]
MOV dword ptr [RBP + -0x54],EAX
LAB_001796b6:
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RAX + 0x600]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x470
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV R8,qword ptr [RAX + 0x378]
MOV RAX,qword ptr [RBP + -0x28]
MOV R9D,dword ptr [RAX + 0x7d4]
MOV R10D,dword ptr [RBP + -0x54]
LEA RAX,[RBP + -0x50]
XOR ECX,ECX
MOV dword ptr [RSP],R10D
MOV qword ptr [RSP + 0x8],RAX
CALL 0x0012ecf0
MOV qword ptr [RBP + -0x30],RAX
CMP dword ptr [RBP + -0x54],0x0
JZ 0x00179737
MOV dword ptr [RBP + -0x48],0x6
CMP qword ptr [RBP + -0x30],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x40],AL
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x2e8
LEA RSI,[RBP + -0x50]
CALL 0x001dbcc0
LAB_00179737:
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x00179776
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x18]
ADD RAX,0x1
MOV RCX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RCX + 0x7bc]
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RCX + 0x40]
JBE 0x00179767
JMP 0x001798a6
LAB_00179767:
JMP 0x00179769
LAB_00179769:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001798c4
LAB_00179776:
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX + 0x2c],0x0
JNZ 0x0017980c
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX + 0x7]
AND EAX,0x7
CMP EAX,0x3
JZ 0x00179799
JMP 0x001798a6
LAB_00179799:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX + 0x18]
ADD RCX,0x1
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RAX + 0x20]
ADD ECX,-0x1
MOV dword ptr [RAX + 0x20],ECX
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX + 0x7bc]
ADD RCX,RAX
ADD RCX,-0x4
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x130]
ADD ECX,0x1
MOV dword ptr [RAX + 0x130],ECX
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RCX + 0xc18]
ADD ECX,0x8
MOV ECX,ECX
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x18]
MOV qword ptr [RCX + 0x8],RAX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001798c4
LAB_0017980c:
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX + 0x7]
AND EAX,0x7
CMP EAX,0x2
JZ 0x00179821
JMP 0x001798a6
LAB_00179821:
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x18]
MOV ESI,dword ptr [RAX + 0x30]
CALL 0x0017a7b0
MOV RCX,RAX
MOV RDX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RDX + 0x10]
MOV RSI,RAX
ADD RSI,0x8
MOV qword ptr [RDX + 0x10],RSI
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x134]
ADD ECX,0x1
MOV dword ptr [RAX + 0x134],ECX
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RAX + 0x30]
MOV RCX,qword ptr [RBP + -0x20]
CALL 0x001799f0
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JNZ 0x00179885
JMP 0x001798a6
LAB_00179885:
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x20],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001798c4
LAB_001798a6:
JMP 0x001798a8
LAB_001798a8:
JMP 0x001798aa
LAB_001798aa:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x7f
CALL 0x00134c30
JMP 0x001798ba
LAB_001798ba:
JMP 0x001798bc
LAB_001798bc:
MOV qword ptr [RBP + -0x8],0x0
LAB_001798c4:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x70
POP RBP
RET
|
long read_next_extent(long *param_1,long *param_2,long *param_3)
{
int8 *puVar1;
int iVar2;
uint uVar3;
long lVar4;
ulong uVar5;
int8 uVar6;
int local_5c;
int1 local_58 [8];
int4 local_50;
int1 local_48;
int8 local_40;
long local_38;
long local_30;
long *local_28;
long *local_20;
long *local_18;
local_30 = *param_1;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
if ((int)param_2[4] == 0) {
iVar2 = (int)param_2[5] + -1;
*(int *)(param_2 + 5) = iVar2;
if (iVar2 == 0) goto LAB_001798a6;
*param_2 = *param_2 + 7;
lVar4 = uint5korr(*param_2);
local_20[3] = lVar4;
uVar3 = (uint)*(ushort *)(*local_20 + 5);
if ((*(ushort *)(*local_20 + 5) & 0xbfff) == 0) goto LAB_001798a6;
*(uint *)((long)local_20 + 0x2c) = uVar3 & 0x8000;
if (*(int *)((long)local_20 + 0x2c) == 0) {
*(uint *)(local_20 + 4) = uVar3 & 0xffffbfff;
}
else {
*(uint *)(local_20 + 6) = uVar3 & 0xffff3fff;
}
}
*(int1 *)((long)local_20 + 0x34) = 0;
local_5c = 0;
if (*(int *)((long)local_20 + 0x2c) != 0) {
local_5c = *(int *)((long)local_20 + 0x24);
}
local_38 = pagecache_read(*(int8 *)(local_30 + 0x600),local_18 + 0x8e,local_20[3],0,
local_18[0x6f],*(int4 *)(local_30 + 0x7d4),local_5c,local_58);
if (local_5c != 0) {
local_50 = 6;
local_48 = local_38 != 0;
insert_dynamic(local_18 + 0x5d,local_58);
}
if (local_38 == 0) {
uVar5 = (local_20[3] + 1) * (ulong)*(uint *)(local_30 + 0x7bc);
if (uVar5 < *(ulong *)(local_30 + 0x40) || uVar5 - *(ulong *)(local_30 + 0x40) == 0) {
return 0;
}
}
else if (*(int *)((long)local_20 + 0x2c) == 0) {
if ((*(byte *)(local_38 + 7) & 7) == 3) {
local_20[3] = local_20[3] + 1;
*(int *)(local_20 + 4) = (int)local_20[4] + -1;
*local_28 = local_38 + (ulong)*(uint *)(local_30 + 0x7bc) + -4;
*(int *)(local_18 + 0x26) = (int)local_18[0x26] + 1;
local_38 = local_38 + (ulong)(*(int *)(local_30 + 0xc18) + 8);
local_20[1] = local_38;
return local_38;
}
}
else if ((*(byte *)(local_38 + 7) & 7) == 2) {
uVar6 = ma_recordpos(local_20[3],(int)local_20[6]);
puVar1 = (int8 *)local_20[2];
local_20[2] = (long)(puVar1 + 1);
*puVar1 = uVar6;
*(int *)((long)local_18 + 0x134) = *(int *)((long)local_18 + 0x134) + 1;
lVar4 = get_record_position(local_30,local_38,(int)local_20[6],local_28);
if (lVar4 != 0) {
local_20[1] = lVar4;
*(int4 *)(local_20 + 4) = 0;
return lVar4;
}
local_40 = 0;
}
LAB_001798a6:
_ma_set_fatal_error(local_18,0x7f);
return 0;
}
| |
29,266 | my_strnxfrm_simple | eloqsql/strings/ctype-simple.c | size_t my_strnxfrm_simple(CHARSET_INFO * cs,
uchar *dst, size_t dstlen, uint nweights,
const uchar *src, size_t srclen, uint flags)
{
uchar *d0= dst;
dst= d0 + my_strnxfrm_simple_internal(cs, dst, dstlen, &nweights,
src, srclen);
return my_strxfrm_pad_desc_and_reverse(cs, d0, dst, d0 + dstlen,
nweights, flags, 0);
} | O0 | c | my_strnxfrm_simple:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
leaq -0x1c(%rbp), %rcx
callq 0x52fc0
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x38(%rbp), %rcx
addq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %r8d
movl 0x10(%rbp), %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x53160
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
| my_strnxfrm_simple:
push rbp
mov rbp, rsp
sub rsp, 50h
mov eax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_10]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov [rbp+var_40], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov r8, [rbp+var_28]
mov r9, [rbp+var_30]
lea rcx, [rbp+var_1C]
call my_strnxfrm_simple_internal
mov rcx, rax
mov rax, [rbp+var_40]
add rax, rcx
mov [rbp+var_10], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_38]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_38]
add rcx, [rbp+var_18]
mov r8d, [rbp+var_1C]
mov r9d, [rbp+arg_0]
xor eax, eax
mov [rsp+50h+var_50], 0
call my_strxfrm_pad_desc_and_reverse
add rsp, 50h
pop rbp
retn
| long long my_strnxfrm_simple(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
unsigned int a4,
unsigned __int8 *a5,
unsigned long long a6,
int a7)
{
_BYTE *v7; // rax
unsigned int v9; // [rsp+34h] [rbp-1Ch] BYREF
unsigned long long v10; // [rsp+38h] [rbp-18h]
unsigned __int8 *v11; // [rsp+40h] [rbp-10h]
long long v12; // [rsp+48h] [rbp-8h]
v12 = a1;
v11 = a2;
v10 = a3;
v9 = a4;
v7 = my_strnxfrm_simple_internal(a1, a2, a3, &v9, a5, a6);
v11 = &a2[(_QWORD)v7];
return my_strxfrm_pad_desc_and_reverse(v12, (_DWORD)a2, (int)v7 + (int)a2, (int)v10 + (int)a2, v9, a7, 0);
}
| my_strnxfrm_simple:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV R8,qword ptr [RBP + -0x28]
MOV R9,qword ptr [RBP + -0x30]
LEA RCX,[RBP + -0x1c]
CALL 0x00152fc0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x38]
ADD RCX,qword ptr [RBP + -0x18]
MOV R8D,dword ptr [RBP + -0x1c]
MOV R9D,dword ptr [RBP + 0x10]
XOR EAX,EAX
MOV dword ptr [RSP],0x0
CALL 0x00153160
ADD RSP,0x50
POP RBP
RET
|
void my_strnxfrm_simple(int8 param_1,long param_2,long param_3,int4 param_4,
int8 param_5,int8 param_6,int4 param_7)
{
int4 local_24;
long local_20;
long local_18;
int8 local_10;
local_24 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
local_18 = my_strnxfrm_simple_internal(param_1,param_2,param_3,&local_24,param_5,param_6);
local_18 = param_2 + local_18;
my_strxfrm_pad_desc_and_reverse(local_10,param_2,local_18,param_2 + local_20,local_24,param_7,0);
return;
}
| |
29,267 | yoyo::Logger::getLogDirName[abi:cxx11]() const | isyoCode[P]yoyologger/test/./../src/logger.hpp | explicit Message(LOGLEVEL level, std::string str, LocationInfo&& tLoc)
: _levle(level),
_sMsg(std::move(str)),
_ProduceTime(std::chrono::system_clock::now()),
_loction(std::move(tLoc)) {} | O2 | cpp | yoyo::Logger::getLogDirName[abi:cxx11]() const:
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rsi, %r14
movq %rdi, %rbx
movb $0x0, (%rax)
addq $0x300, %rsi # imm = 0x300
leaq 0x8(%rsp), %rdi
callq 0x4fb0
leaq 0x23bf(%rip), %rsi # 0x7287
movq %rax, %rdi
callq 0x4898
addq $0x2e0, %r14 # imm = 0x2E0
movq %rax, %rdi
movq %r14, %rsi
callq 0x4fb0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4fc0
leaq 0x8(%rsp), %rdi
callq 0x3a22
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3a22
movq %rbx, %rdi
callq 0x33e0
nop
| _ZNK4yoyo6Logger13getLogDirNameB5cxx11Ev:
push r14
push rbx
sub rsp, 28h
lea rax, [rsp+38h+var_20]
mov [rax-10h], rax
and qword ptr [rax-8], 0
mov r14, rsi
mov rbx, rdi
mov byte ptr [rax], 0
add rsi, 300h
lea rdi, [rsp+38h+var_30]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendERKS4_; std::string::append(std::string const&)
lea rsi, asc_7287; "/"
mov rdi, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
add r14, 2E0h
mov rdi, rax
mov rsi, r14
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendERKS4_; std::string::append(std::string const&)
mov rdi, rbx
mov rsi, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
lea rdi, [rsp+38h+var_30]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rax, rbx
add rsp, 28h
pop rbx
pop r14
retn
mov rbx, rax
lea rdi, [rsp+arg_0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
call __Unwind_Resume
| long long yoyo::Logger::getLogDirName[abi:cxx11](long long a1, long long a2)
{
long long v2; // rax
long long v3; // rax
long long v4; // rax
_QWORD v6[2]; // [rsp+8h] [rbp-30h] BYREF
char v7; // [rsp+18h] [rbp-20h] BYREF
v6[0] = &v7;
v6[1] = 0LL;
v7 = 0;
v2 = std::string::append(v6, a2 + 768);
v3 = std::string::append(v2, (long long)"/");
v4 = std::string::append(v3, a2 + 736);
std::string::basic_string(a1, v4);
std::string::~string(v6);
return a1;
}
| getLogDirName[abi:cxx11]:
PUSH R14
PUSH RBX
SUB RSP,0x28
LEA RAX,[RSP + 0x18]
MOV qword ptr [RAX + -0x10],RAX
AND qword ptr [RAX + -0x8],0x0
MOV R14,RSI
MOV RBX,RDI
MOV byte ptr [RAX],0x0
ADD RSI,0x300
LAB_00104eb7:
LEA RDI,[RSP + 0x8]
CALL 0x00104fb0
LEA RSI,[0x107287]
MOV RDI,RAX
CALL 0x00104898
ADD R14,0x2e0
MOV RDI,RAX
MOV RSI,R14
CALL 0x00104fb0
MOV RDI,RBX
MOV RSI,RAX
CALL 0x00104fc0
LAB_00104eed:
LEA RDI,[RSP + 0x8]
CALL 0x00103a22
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R14
RET
|
/* yoyo::Logger::getLogDirName[abi:cxx11]() const */
void yoyo::Logger::getLogDirName_abi_cxx11_(void)
{
string *psVar1;
long in_RSI;
string *in_RDI;
int1 *local_30;
int8 local_28;
int1 local_20 [16];
local_30 = local_20;
local_28 = 0;
local_20[0] = 0;
/* try { // try from 00104eb7 to 00104eec has its CatchHandler @ 00104f02 */
psVar1 = (string *)std::__cxx11::string::append((string *)&local_30,(string *)(in_RSI + 0x300));
psVar1 = (string *)std::__cxx11::string::append(psVar1,"/");
psVar1 = (string *)std::__cxx11::string::append(psVar1,(string *)(in_RSI + 0x2e0));
std::__cxx11::string::string(in_RDI,psVar1);
std::__cxx11::string::~string((string *)&local_30);
return;
}
| |
29,268 | js_math_sign | bluesky950520[P]quickjs/quickjs.c | static double js_math_sign(double a)
{
if (isnan(a) || a == 0.0)
return a;
if (a < 0)
return -1;
else
return 1;
} | O2 | c | js_math_sign:
xorpd %xmm1, %xmm1
xorl %eax, %eax
ucomisd %xmm0, %xmm1
seta %cl
ucomisd %xmm1, %xmm0
je 0x6d7a6
movb %cl, %al
leaq 0x1b25f(%rip), %rcx # 0x88a00
movsd (%rcx,%rax,8), %xmm0
retq
| js_math_sign:
xorpd xmm1, xmm1
xor eax, eax
ucomisd xmm1, xmm0
setnbe cl
ucomisd xmm0, xmm1
jz short locret_6D7A6
mov al, cl
lea rcx, unk_88A00
movsd xmm0, qword ptr [rcx+rax*8]
locret_6D7A6:
retn
| double js_math_sign(double result)
{
long long v1; // rax
v1 = 0LL;
if ( result != 0.0 )
{
LOBYTE(v1) = result < 0.0;
return dbl_88A00[v1];
}
return result;
}
| js_math_sign:
XORPD XMM1,XMM1
XOR EAX,EAX
UCOMISD XMM1,XMM0
SETA CL
UCOMISD XMM0,XMM1
JZ 0x0016d7a6
MOV AL,CL
LEA RCX,[0x188a00]
MOVSD XMM0,qword ptr [RCX + RAX*0x8]
LAB_0016d7a6:
RET
|
bool js_math_sign(double param_1)
{
return param_1 != 0.0 && param_1 < 0.0;
}
| |
29,269 | void nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, int, 0>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, int&) | llama.cpp/common/json.hpp | inline void from_json(const BasicJsonType& j, ArithmeticType& val)
{
switch (static_cast<value_t>(j))
{
case value_t::number_unsigned:
{
val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
break;
}
case value_t::number_integer:
{
val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
break;
}
case value_t::number_float:
{
val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
break;
}
case value_t::boolean:
{
val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
break;
}
case value_t::null:
case value_t::object:
case value_t::array:
case value_t::string:
case value_t::binary:
case value_t::discarded:
default:
JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j));
}
} | O3 | cpp | void nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, int, 0>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, int&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
movzbl (%rdi), %eax
addl $-0x4, %eax
cmpl $0x3, %eax
ja 0xc0ae5
leaq 0x5e4ee(%rip), %rcx # 0x11efac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x8(%r14), %eax
jmp 0xc0ada
movzbl 0x8(%r14), %eax
jmp 0xc0ada
cvttsd2si 0x8(%r14), %eax
movl %eax, (%rsi)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x20650
movq %rax, %rbx
movq %r14, %rdi
callq 0x8aa3c
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x5f4f8(%rip), %rsi # 0x120001
leaq 0x10(%rsp), %rdi
callq 0x8041a
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x12e, %esi # imm = 0x12E
movq %r14, %rcx
callq 0xbc464
xorl %ebp, %ebp
leaq 0xa050c(%rip), %rsi # 0x161040
leaq -0x4a1dd(%rip), %rdx # 0x7695e
movq %rbx, %rdi
callq 0x20a50
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc0b61
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x20180
testb %bpl, %bpl
jne 0xc0b6b
jmp 0xc0b73
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f00
movq %r14, %rdi
callq 0x20af0
nop
| _ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEiTnNSt9enable_ifIXaaaaaaaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_17number_unsigned_tEEE5valuentsr3std7is_sameISH_NSI_16number_integer_tEEE5valuentsr3std7is_sameISH_NSI_14number_float_tEEE5valuentsr3std7is_sameISH_NSI_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_:
push rbp; void *
push r14; int
push rbx; __int64
sub rsp, 30h
mov r14, rdi
movzx eax, byte ptr [rdi]
add eax, 0FFFFFFFCh; switch 4 cases
cmp eax, 3
ja short def_C0AC5; jumptable 00000000000C0AC5 default case
lea rcx, jpt_C0AC5
movsxd rax, ds:(jpt_C0AC5 - 11EFACh)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_C0AC7:
mov eax, [r14+8]; jumptable 00000000000C0AC5 cases 5,6
jmp short loc_C0ADA
loc_C0ACD:
movzx eax, byte ptr [r14+8]; jumptable 00000000000C0AC5 case 4
jmp short loc_C0ADA
loc_C0AD4:
cvttsd2si eax, qword ptr [r14+8]; jumptable 00000000000C0AC5 case 7
loc_C0ADA:
mov [rsi], eax
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
def_C0AC5:
mov edi, 20h ; ' '; jumptable 00000000000C0AC5 default case
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aTypeMustBeNumb; "type must be number, but is "
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA29_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(char const(&)[29],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 12Eh; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_C0B61
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C0B61:
test bpl, bpl
jnz short loc_C0B6B
jmp short loc_C0B73
mov r14, rax
loc_C0B6B:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_C0B73:
mov rdi, r14
call __Unwind_Resume
| long long ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEiTnNSt9enable_ifIXaaaaaaaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_17number_unsigned_tEEE5valuentsr3std7is_sameISH_NSI_16number_integer_tEEE5valuentsr3std7is_sameISH_NSI_14number_float_tEEE5valuentsr3std7is_sameISH_NSI_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_(
unsigned __int8 *a1,
_DWORD *a2)
{
long long result; // rax
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
const char *v4; // [rsp+8h] [rbp-40h] BYREF
_QWORD v5[2]; // [rsp+10h] [rbp-38h] BYREF
switch ( *a1 )
{
case 4u:
result = a1[8];
break;
case 5u:
case 6u:
result = *((unsigned int *)a1 + 2);
break;
case 7u:
result = (unsigned int)(int)*((double *)a1 + 1);
break;
default:
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v4 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name(a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(
(long long)v5,
(long long)"type must be number, but is ",
&v4);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
exception,
302,
v5);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
*a2 = result;
return result;
}
| _ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEiTnNSt9enable_ifIXaaaaaaaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_17number_unsigned_tEEE5valuentsr3std7is_sameISH_NSI_16number_integer_tEEE5valuentsr3std7is_sameISH_NSI_14number_float_tEEE5valuentsr3std7is_sameISH_NSI_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RDI
MOVZX EAX,byte ptr [RDI]
ADD EAX,-0x4
CMP EAX,0x3
JA 0x001c0ae5
LEA RCX,[0x21efac]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_5:
MOV EAX,dword ptr [R14 + 0x8]
JMP 0x001c0ada
caseD_4:
MOVZX EAX,byte ptr [R14 + 0x8]
JMP 0x001c0ada
caseD_7:
CVTTSD2SI EAX,qword ptr [R14 + 0x8]
LAB_001c0ada:
MOV dword ptr [RSI],EAX
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
default:
MOV EDI,0x20
CALL 0x00120650
MOV RBX,RAX
MOV RDI,R14
CALL 0x0018aa3c
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_001c0b02:
LEA RSI,[0x220001]
LEA RDI,[RSP + 0x10]
CALL 0x0018041a
MOV BPL,0x1
LAB_001c0b16:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x12e
MOV RCX,R14
CALL 0x001bc464
XOR EBP,EBP
LEA RSI,[0x261040]
LEA RDX,[0x17695e]
MOV RDI,RBX
CALL 0x00120a50
|
void _ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEiTnNSt9enable_ifIXaaaaaaaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_17number_unsigned_tEEE5valuentsr3std7is_sameISH_NSI_16number_integer_tEEE5valuentsr3std7is_sameISH_NSI_14number_float_tEEE5valuentsr3std7is_sameISH_NSI_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*param_1,uint *param_2)
{
uint uVar1;
int8 uVar2;
char *local_40;
detail local_38 [32];
switch(*param_1) {
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x4:
uVar1 = (uint)(byte)param_1[8];
break;
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x5:
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x6:
uVar1 = *(uint *)(param_1 + 8);
break;
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x7:
uVar1 = (uint)*(double *)(param_1 + 8);
break;
default:
uVar2 = __cxa_allocate_exception(0x20);
local_40 = (char *)nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::type_name(param_1);
/* try { // try from 001c0b02 to 001c0b12 has its CatchHandler @ 001c0b68 */
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[29],char_const*>
(local_38,"type must be number, but is ",&local_40);
/* try { // try from 001c0b16 to 001c0b42 has its CatchHandler @ 001c0b43 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar2,0x12e,local_38,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar2,&nlohmann::json_abi_v3_11_3::detail::type_error::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
*param_2 = uVar1;
return;
}
| |
29,270 | my_strnxfrm_simple_nopad | eloqsql/strings/ctype-simple.c | size_t my_strnxfrm_simple_nopad(CHARSET_INFO * cs,
uchar *dst, size_t dstlen, uint nweights,
const uchar *src, size_t srclen, uint flags)
{
uchar *d0= dst;
dst= d0 + my_strnxfrm_simple_internal(cs, dst, dstlen, &nweights,
src, srclen);
return my_strxfrm_pad_desc_and_reverse_nopad(cs, d0, dst, d0 + dstlen,
nweights, flags, 0);
} | O0 | c | my_strnxfrm_simple_nopad:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
leaq -0x1c(%rbp), %rcx
callq 0x52510
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x38(%rbp), %rcx
addq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %r8d
movl 0x10(%rbp), %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x52870
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
| my_strnxfrm_simple_nopad:
push rbp
mov rbp, rsp
sub rsp, 50h
mov eax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_10]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov [rbp+var_40], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov r8, [rbp+var_28]
mov r9, [rbp+var_30]
lea rcx, [rbp+var_1C]
call my_strnxfrm_simple_internal
mov rcx, rax
mov rax, [rbp+var_40]
add rax, rcx
mov [rbp+var_10], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_38]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_38]
add rcx, [rbp+var_18]
mov r8d, [rbp+var_1C]
mov r9d, [rbp+arg_0]
xor eax, eax
mov [rsp+50h+var_50], 0
call my_strxfrm_pad_desc_and_reverse_nopad
add rsp, 50h
pop rbp
retn
| long long my_strnxfrm_simple_nopad(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
unsigned int a4,
unsigned __int8 *a5,
unsigned long long a6,
int a7)
{
_BYTE *v7; // rax
unsigned int v9; // [rsp+34h] [rbp-1Ch] BYREF
unsigned long long v10; // [rsp+38h] [rbp-18h]
unsigned __int8 *v11; // [rsp+40h] [rbp-10h]
long long v12; // [rsp+48h] [rbp-8h]
v12 = a1;
v11 = a2;
v10 = a3;
v9 = a4;
v7 = my_strnxfrm_simple_internal(a1, a2, a3, &v9, a5, a6);
v11 = &a2[(_QWORD)v7];
return my_strxfrm_pad_desc_and_reverse_nopad(v12, (_DWORD)a2, (int)v7 + (int)a2, (int)v10 + (int)a2, v9, a7, 0);
}
| my_strnxfrm_simple_nopad:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV R8,qword ptr [RBP + -0x28]
MOV R9,qword ptr [RBP + -0x30]
LEA RCX,[RBP + -0x1c]
CALL 0x00152510
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x38]
ADD RCX,qword ptr [RBP + -0x18]
MOV R8D,dword ptr [RBP + -0x1c]
MOV R9D,dword ptr [RBP + 0x10]
XOR EAX,EAX
MOV dword ptr [RSP],0x0
CALL 0x00152870
ADD RSP,0x50
POP RBP
RET
|
void my_strnxfrm_simple_nopad
(int8 param_1,long param_2,long param_3,int4 param_4,int8 param_5,
int8 param_6,int4 param_7)
{
int4 local_24;
long local_20;
long local_18;
int8 local_10;
local_24 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
local_18 = my_strnxfrm_simple_internal(param_1,param_2,param_3,&local_24,param_5,param_6);
local_18 = param_2 + local_18;
my_strxfrm_pad_desc_and_reverse_nopad
(local_10,param_2,local_18,param_2 + local_20,local_24,param_7,0);
return;
}
| |
29,271 | minja::SequenceNode::SequenceNode(minja::Location const&, std::vector<std::shared_ptr<minja::TemplateNode>, std::allocator<std::shared_ptr<minja::TemplateNode>>>&&) | monkey531[P]llama/common/minja.hpp | TemplateNode(const Location & location) : location_(location) {} | O1 | cpp | minja::SequenceNode::SequenceNode(minja::Location const&, std::vector<std::shared_ptr<minja::TemplateNode>, std::allocator<std::shared_ptr<minja::TemplateNode>>>&&):
leaq 0x77ecb(%rip), %rax # 0xdcfe8
addq $0x10, %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0x6514d
movq 0x78e59(%rip), %rcx # 0xddf98
cmpb $0x0, (%rcx)
je 0x65149
incl 0x8(%rax)
jmp 0x6514d
lock
incl 0x8(%rax)
movq 0x10(%rsi), %rax
movq %rax, 0x18(%rdi)
leaq 0x784dc(%rip), %rax # 0xdd638
addq $0x10, %rax
movq %rax, (%rdi)
movups (%rdx), %xmm0
movups %xmm0, 0x20(%rdi)
movq 0x10(%rdx), %rax
movq %rax, 0x30(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
retq
nop
| _ZN5minja12SequenceNodeC2ERKNS_8LocationEOSt6vectorISt10shared_ptrINS_12TemplateNodeEESaIS7_EE:
lea rax, _ZTVN5minja12TemplateNodeE; `vtable for'minja::TemplateNode
add rax, 10h
mov [rdi], rax
mov rax, [rsi]
mov [rdi+8], rax
mov rax, [rsi+8]
mov [rdi+10h], rax
test rax, rax
jz short loc_6514D
mov rcx, cs:__libc_single_threaded_ptr
cmp byte ptr [rcx], 0
jz short loc_65149
inc dword ptr [rax+8]
jmp short loc_6514D
loc_65149:
lock inc dword ptr [rax+8]
loc_6514D:
mov rax, [rsi+10h]
mov [rdi+18h], rax
lea rax, _ZTVN5minja12SequenceNodeE; `vtable for'minja::SequenceNode
add rax, 10h
mov [rdi], rax
movups xmm0, xmmword ptr [rdx]
movups xmmword ptr [rdi+20h], xmm0
mov rax, [rdx+10h]
mov [rdi+30h], rax
xorps xmm0, xmm0
movups xmmword ptr [rdx], xmm0
mov qword ptr [rdx+10h], 0
retn
| long long minja::SequenceNode::SequenceNode(long long a1, _QWORD *a2, long long a3)
{
long long v3; // rax
long long result; // rax
*(_QWORD *)a1 = &`vtable for'minja::TemplateNode + 2;
*(_QWORD *)(a1 + 8) = *a2;
v3 = a2[1];
*(_QWORD *)(a1 + 16) = v3;
if ( v3 )
{
if ( _libc_single_threaded )
++*(_DWORD *)(v3 + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(v3 + 8));
}
*(_QWORD *)(a1 + 24) = a2[2];
*(_QWORD *)a1 = &`vtable for'minja::SequenceNode + 2;
*(_OWORD *)(a1 + 32) = *(_OWORD *)a3;
result = *(_QWORD *)(a3 + 16);
*(_QWORD *)(a1 + 48) = result;
*(_OWORD *)a3 = 0LL;
*(_QWORD *)(a3 + 16) = 0LL;
return result;
}
| SequenceNode:
LEA RAX,[0x1dcfe8]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RAX,qword ptr [RSI]
MOV qword ptr [RDI + 0x8],RAX
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x10],RAX
TEST RAX,RAX
JZ 0x0016514d
MOV RCX,qword ptr [0x001ddf98]
CMP byte ptr [RCX],0x0
JZ 0x00165149
INC dword ptr [RAX + 0x8]
JMP 0x0016514d
LAB_00165149:
INC.LOCK dword ptr [RAX + 0x8]
LAB_0016514d:
MOV RAX,qword ptr [RSI + 0x10]
MOV qword ptr [RDI + 0x18],RAX
LEA RAX,[0x1dd638]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOVUPS XMM0,xmmword ptr [RDX]
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOV RAX,qword ptr [RDX + 0x10]
MOV qword ptr [RDI + 0x30],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDX],XMM0
MOV qword ptr [RDX + 0x10],0x0
RET
|
/* minja::SequenceNode::SequenceNode(minja::Location const&,
std::vector<std::shared_ptr<minja::TemplateNode>,
std::allocator<std::shared_ptr<minja::TemplateNode> > >&&) */
void __thiscall
minja::SequenceNode::SequenceNode(SequenceNode *this,Location *param_1,vector *param_2)
{
long lVar1;
int8 uVar2;
*(int ***)this = &PTR___cxa_pure_virtual_001dcff8;
*(int8 *)(this + 8) = *(int8 *)param_1;
lVar1 = *(long *)(param_1 + 8);
*(long *)(this + 0x10) = lVar1;
if (lVar1 != 0) {
if (*PTR___libc_single_threaded_001ddf98 == '\0') {
LOCK();
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
UNLOCK();
}
else {
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
}
}
*(int8 *)(this + 0x18) = *(int8 *)(param_1 + 0x10);
*(int ***)this = &PTR_do_render_001dd648;
uVar2 = *(int8 *)(param_2 + 8);
*(int8 *)(this + 0x20) = *(int8 *)param_2;
*(int8 *)(this + 0x28) = uVar2;
*(int8 *)(this + 0x30) = *(int8 *)(param_2 + 0x10);
*(int8 *)param_2 = 0;
*(int8 *)(param_2 + 8) = 0;
*(int8 *)(param_2 + 0x10) = 0;
return;
}
| |
29,272 | minja::SequenceNode::SequenceNode(minja::Location const&, std::vector<std::shared_ptr<minja::TemplateNode>, std::allocator<std::shared_ptr<minja::TemplateNode>>>&&) | monkey531[P]llama/common/minja.hpp | TemplateNode(const Location & location) : location_(location) {} | O3 | cpp | minja::SequenceNode::SequenceNode(minja::Location const&, std::vector<std::shared_ptr<minja::TemplateNode>, std::allocator<std::shared_ptr<minja::TemplateNode>>>&&):
leaq 0x7e477(%rip), %rax # 0xdafe8
addq $0x10, %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0x5cba1
movq 0x7f405(%rip), %rcx # 0xdbf98
cmpb $0x0, (%rcx)
je 0x5cb9d
incl 0x8(%rax)
jmp 0x5cba1
lock
incl 0x8(%rax)
movq 0x10(%rsi), %rax
movq %rax, 0x18(%rdi)
leaq 0x7e3e8(%rip), %rax # 0xdaf98
addq $0x10, %rax
movq %rax, (%rdi)
movups (%rdx), %xmm0
movups %xmm0, 0x20(%rdi)
movq 0x10(%rdx), %rax
movq %rax, 0x30(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
retq
nop
| _ZN5minja6IfNodeC2ERKNS_8LocationEOSt6vectorISt4pairISt10shared_ptrINS_10ExpressionEES6_INS_12TemplateNodeEEESaISB_EE:
lea rax, _ZTVN5minja12TemplateNodeE; `vtable for'minja::TemplateNode
add rax, 10h
mov [rdi], rax
mov rax, [rsi]
mov [rdi+8], rax
mov rax, [rsi+8]
mov [rdi+10h], rax
test rax, rax
jz short loc_5CBA1
mov rcx, cs:__libc_single_threaded_ptr
cmp byte ptr [rcx], 0
jz short loc_5CB9D
inc dword ptr [rax+8]
jmp short loc_5CBA1
loc_5CB9D:
lock inc dword ptr [rax+8]
loc_5CBA1:
mov rax, [rsi+10h]
mov [rdi+18h], rax
lea rax, _ZTVN5minja6IfNodeE; `vtable for'minja::IfNode
add rax, 10h
mov [rdi], rax
movups xmm0, xmmword ptr [rdx]
movups xmmword ptr [rdi+20h], xmm0
mov rax, [rdx+10h]
mov [rdi+30h], rax
xorps xmm0, xmm0
movups xmmword ptr [rdx], xmm0
mov qword ptr [rdx+10h], 0
retn
| long long minja::IfNode::IfNode(long long a1, _QWORD *a2, long long a3)
{
long long v3; // rax
long long result; // rax
*(_QWORD *)a1 = &`vtable for'minja::TemplateNode + 2;
*(_QWORD *)(a1 + 8) = *a2;
v3 = a2[1];
*(_QWORD *)(a1 + 16) = v3;
if ( v3 )
{
if ( _libc_single_threaded )
++*(_DWORD *)(v3 + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(v3 + 8));
}
*(_QWORD *)(a1 + 24) = a2[2];
*(_QWORD *)a1 = &`vtable for'minja::IfNode + 2;
*(_OWORD *)(a1 + 32) = *(_OWORD *)a3;
result = *(_QWORD *)(a3 + 16);
*(_QWORD *)(a1 + 48) = result;
*(_OWORD *)a3 = 0LL;
*(_QWORD *)(a3 + 16) = 0LL;
return result;
}
| IfNode:
LEA RAX,[0x1dafe8]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RAX,qword ptr [RSI]
MOV qword ptr [RDI + 0x8],RAX
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x10],RAX
TEST RAX,RAX
JZ 0x0015cba1
MOV RCX,qword ptr [0x001dbf98]
CMP byte ptr [RCX],0x0
JZ 0x0015cb9d
INC dword ptr [RAX + 0x8]
JMP 0x0015cba1
LAB_0015cb9d:
INC.LOCK dword ptr [RAX + 0x8]
LAB_0015cba1:
MOV RAX,qword ptr [RSI + 0x10]
MOV qword ptr [RDI + 0x18],RAX
LEA RAX,[0x1daf98]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOVUPS XMM0,xmmword ptr [RDX]
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOV RAX,qword ptr [RDX + 0x10]
MOV qword ptr [RDI + 0x30],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDX],XMM0
MOV qword ptr [RDX + 0x10],0x0
RET
|
/* minja::IfNode::IfNode(minja::Location const&,
std::vector<std::pair<std::shared_ptr<minja::Expression>, std::shared_ptr<minja::TemplateNode> >,
std::allocator<std::pair<std::shared_ptr<minja::Expression>, std::shared_ptr<minja::TemplateNode>
> > >&&) */
void __thiscall minja::IfNode::IfNode(IfNode *this,Location *param_1,vector *param_2)
{
long lVar1;
int8 uVar2;
*(int ***)this = &PTR___cxa_pure_virtual_001daff8;
*(int8 *)(this + 8) = *(int8 *)param_1;
lVar1 = *(long *)(param_1 + 8);
*(long *)(this + 0x10) = lVar1;
if (lVar1 != 0) {
if (*PTR___libc_single_threaded_001dbf98 == '\0') {
LOCK();
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
UNLOCK();
}
else {
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
}
}
*(int8 *)(this + 0x18) = *(int8 *)(param_1 + 0x10);
*(int ***)this = &PTR_do_render_001dafa8;
uVar2 = *(int8 *)(param_2 + 8);
*(int8 *)(this + 0x20) = *(int8 *)param_2;
*(int8 *)(this + 0x28) = uVar2;
*(int8 *)(this + 0x30) = *(int8 *)(param_2 + 0x10);
*(int8 *)param_2 = 0;
*(int8 *)(param_2 + 8) = 0;
*(int8 *)(param_2 + 0x10) = 0;
return;
}
| |
29,273 | mysql_stmt_prepare | eloqsql/libmariadb/libmariadb/mariadb_stmt.c | int STDCALL mysql_stmt_prepare(MYSQL_STMT *stmt, const char *query, unsigned long length)
{
MYSQL *mysql= stmt->mysql;
int rc= 1;
my_bool is_multi= 0;
if (!stmt->mysql)
{
SET_CLIENT_STMT_ERROR(stmt, CR_SERVER_LOST, SQLSTATE_UNKNOWN, 0);
return(1);
}
if (length == (unsigned long) -1)
length= (unsigned long)strlen(query);
/* clear flags */
CLEAR_CLIENT_STMT_ERROR(stmt);
CLEAR_CLIENT_ERROR(stmt->mysql);
stmt->upsert_status.affected_rows= mysql->affected_rows= (unsigned long long) ~0;
/* check if we have to clear results */
if (stmt->state > MYSQL_STMT_INITTED)
{
char stmt_id[STMT_ID_LENGTH];
is_multi= (mysql->net.extension->multi_status > COM_MULTI_OFF);
/* We need to semi-close the prepared statement:
reset stmt and free all buffers and close the statement
on server side. Statement handle will get a new stmt_id */
if (!is_multi)
ma_multi_command(mysql, COM_MULTI_ENABLED);
if (mysql_stmt_internal_reset(stmt, 1))
goto fail;
ma_free_root(&stmt->mem_root, MYF(MY_KEEP_PREALLOC));
ma_free_root(&((MADB_STMT_EXTENSION *)stmt->extension)->fields_ma_alloc_root, MYF(0));
stmt->param_count= 0;
stmt->field_count= 0;
stmt->fields= NULL;
stmt->params= NULL;
int4store(stmt_id, stmt->stmt_id);
if (mysql->methods->db_command(mysql, COM_STMT_CLOSE, stmt_id,
sizeof(stmt_id), 1, stmt))
goto fail;
}
if (mysql->methods->db_command(mysql, COM_STMT_PREPARE, query, length, 1, stmt))
goto fail;
if (!is_multi && mysql->net.extension->multi_status == COM_MULTI_ENABLED)
if (ma_multi_command(mysql, COM_MULTI_END))
goto fail;
if (mysql->net.extension->multi_status > COM_MULTI_OFF ||
mysql->options.extension->skip_read_response)
return 0;
if (mysql->methods->db_read_prepare_response &&
mysql->methods->db_read_prepare_response(stmt))
goto fail;
return(0);
fail:
stmt->state= MYSQL_STMT_INITTED;
UPDATE_STMT_ERROR(stmt);
return(rc);
} | O3 | c | mysql_stmt_prepare:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq 0x38(%rdi), %r14
testq %r14, %r14
je 0x210cc
movq %rdx, %r12
movq %rsi, %r15
cmpq $-0x1, %rdx
jne 0x20fc5
movq %r15, %rdi
callq 0x131c0
movq %rax, %r12
xorl %eax, %eax
movl %eax, 0x108(%rbx)
movl $0x30303030, %ecx # imm = 0x30303030
movl %ecx, 0x30d(%rbx)
movw $0x30, %dx
movw %dx, 0x311(%rbx)
movb %al, 0x10c(%rbx)
movl %eax, 0x90(%r14)
movq 0x38(%rbx), %rsi
movw %dx, 0x29b(%rsi)
movl %ecx, 0x297(%rsi)
movq 0x38(%rbx), %rcx
movb %al, 0x97(%rcx)
movq 0x38(%rbx), %rax
movq 0x2a0(%rax), %rax
testq %rax, %rax
je 0x21022
movl $0x0, 0x4(%rax)
movq $-0x1, %rax
movq %rax, 0x338(%r14)
movq %rax, 0xf8(%rbx)
cmpl $0x0, 0x50(%rbx)
je 0x21111
movq 0x2a0(%r14), %rax
cmpl $0x0, (%rax)
sete %r13b
jne 0x2105e
movq %r14, %rdi
movl $0x2, %esi
callq 0x1602d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1fcd4
testb %al, %al
jne 0x2113d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1de3f
movq 0x340(%rbx), %rdi
xorl %esi, %esi
callq 0x1de3f
movq $0x0, 0x70(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rbx)
movl 0x40(%rbx), %eax
leaq -0x34(%rbp), %rdx
movl %eax, (%rdx)
movq 0x4d0(%r14), %rax
movl $0x4, %ecx
movq %r14, %rdi
movl $0x19, %esi
movl $0x1, %r8d
movq %rbx, %r9
callq *0x10(%rax)
testl %eax, %eax
jne 0x2113d
jmp 0x21114
movl $0x7dd, 0x108(%rbx) # imm = 0x7DD
leaq 0x30d(%rbx), %rdi
leaq 0x2797c(%rip), %rax # 0x48a60
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
movb $0x0, 0x312(%rbx)
leaq 0x10c(%rbx), %rdi
leaq 0x2796a(%rip), %rax # 0x48a70
movq 0x68(%rax), %rsi
movl $0x200, %edx # imm = 0x200
jmp 0x2118b
movb $0x1, %r13b
movq 0x4d0(%r14), %rax
movq %r14, %rdi
movl $0x16, %esi
movq %r15, %rdx
movq %r12, %rcx
movl $0x1, %r8d
movq %rbx, %r9
callq *0x10(%rax)
testl %eax, %eax
je 0x211be
leaq 0x30d(%rbx), %rdi
leaq 0x10c(%rbx), %r14
movl $0x0, 0x50(%rbx)
movq 0x38(%rbx), %rsi
movl 0x90(%rsi), %eax
movl %eax, 0x108(%rbx)
addq $0x297, %rsi # imm = 0x297
movl $0x5, %edx
callq 0x13220
movb $0x0, 0x312(%rbx)
movl $0x97, %esi
addq 0x38(%rbx), %rsi
movl $0x200, %edx # imm = 0x200
movq %r14, %rdi
callq 0x13220
movb $0x0, 0x30b(%rbx)
movl $0x1, %r15d
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x21225
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testb %r13b, %r13b
je 0x211e4
movq 0x2a0(%r14), %rax
cmpl $0x2, (%rax)
jne 0x211e4
movq %r14, %rdi
movl $0x4, %esi
callq 0x1602d
testl %eax, %eax
jne 0x2113d
movq 0x2a0(%r14), %rax
xorl %r15d, %r15d
cmpl $0x0, (%rax)
jne 0x2119d
movq 0x480(%r14), %rax
cmpb $0x0, 0x148(%rax)
jne 0x2119d
movq 0x4d0(%r14), %rax
movq 0x40(%rax), %rax
testq %rax, %rax
je 0x2119d
movq %rbx, %rdi
callq *%rax
testb %al, %al
jne 0x2113d
jmp 0x2119d
callq 0x13500
| mysql_stmt_prepare:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov r14, [rdi+38h]
test r14, r14
jz loc_210CC
mov r12, rdx
mov r15, rsi
cmp rdx, 0FFFFFFFFFFFFFFFFh
jnz short loc_20FC5
mov rdi, r15
call _strlen
mov r12, rax
loc_20FC5:
xor eax, eax
mov [rbx+108h], eax
mov ecx, 30303030h
mov [rbx+30Dh], ecx
mov dx, 30h ; '0'
mov [rbx+311h], dx
mov [rbx+10Ch], al
mov [r14+90h], eax
mov rsi, [rbx+38h]
mov [rsi+29Bh], dx
mov [rsi+297h], ecx
mov rcx, [rbx+38h]
mov [rcx+97h], al
mov rax, [rbx+38h]
mov rax, [rax+2A0h]
test rax, rax
jz short loc_21022
mov dword ptr [rax+4], 0
loc_21022:
mov rax, 0FFFFFFFFFFFFFFFFh
mov [r14+338h], rax
mov [rbx+0F8h], rax
cmp dword ptr [rbx+50h], 0
jz loc_21111
mov rax, [r14+2A0h]
cmp dword ptr [rax], 0
setz r13b
jnz short loc_2105E
mov rdi, r14
mov esi, 2
call ma_multi_command
loc_2105E:
mov rdi, rbx
mov esi, 1
call mysql_stmt_internal_reset
test al, al
jnz loc_2113D
mov rdi, rbx
mov esi, 1
call ma_free_root
mov rdi, [rbx+340h]
xor esi, esi
call ma_free_root
mov qword ptr [rbx+70h], 0
xorps xmm0, xmm0
movups xmmword ptr [rbx+58h], xmm0
mov eax, [rbx+40h]
lea rdx, [rbp+var_34]
mov [rdx], eax
mov rax, [r14+4D0h]
mov ecx, 4
mov rdi, r14
mov esi, 19h
mov r8d, 1
mov r9, rbx
call qword ptr [rax+10h]
test eax, eax
jnz short loc_2113D
jmp short loc_21114
loc_210CC:
mov dword ptr [rbx+108h], 7DDh
lea rdi, [rbx+30Dh]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov byte ptr [rbx+312h], 0
lea rdi, [rbx+10Ch]
lea rax, client_errors
mov rsi, [rax+68h]
mov edx, 200h
jmp short loc_2118B
loc_21111:
mov r13b, 1
loc_21114:
mov rax, [r14+4D0h]
mov rdi, r14
mov esi, 16h
mov rdx, r15
mov rcx, r12
mov r8d, 1
mov r9, rbx
call qword ptr [rax+10h]
test eax, eax
jz loc_211BE
loc_2113D:
lea rdi, [rbx+30Dh]
lea r14, [rbx+10Ch]
mov dword ptr [rbx+50h], 0
mov rsi, [rbx+38h]
mov eax, [rsi+90h]
mov [rbx+108h], eax
add rsi, 297h
mov edx, 5
call _strncpy
mov byte ptr [rbx+312h], 0
mov esi, 97h
add rsi, [rbx+38h]
mov edx, 200h
mov rdi, r14
loc_2118B:
call _strncpy
mov byte ptr [rbx+30Bh], 0
mov r15d, 1
loc_2119D:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_21225
mov eax, r15d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_211BE:
test r13b, r13b
jz short loc_211E4
mov rax, [r14+2A0h]
cmp dword ptr [rax], 2
jnz short loc_211E4
mov rdi, r14
mov esi, 4
call ma_multi_command
test eax, eax
jnz loc_2113D
loc_211E4:
mov rax, [r14+2A0h]
xor r15d, r15d
cmp dword ptr [rax], 0
jnz short loc_2119D
mov rax, [r14+480h]
cmp byte ptr [rax+148h], 0
jnz short loc_2119D
mov rax, [r14+4D0h]
mov rax, [rax+40h]
test rax, rax
jz short loc_2119D
mov rdi, rbx
call rax
test al, al
jnz loc_2113D
jmp loc_2119D
loc_21225:
call ___stack_chk_fail
| long long mysql_stmt_prepare(long long a1, long long a2, long long a3)
{
long long v4; // r14
long long v5; // r12
long long v6; // rax
_DWORD *v7; // rax
bool v8; // r13
long long v9; // rdi
char *v10; // rsi
long long v11; // rsi
unsigned int v12; // r15d
unsigned __int8 ( *v14)(long long); // rax
int v15; // [rsp+Ch] [rbp-34h] BYREF
unsigned long long v16; // [rsp+10h] [rbp-30h]
v16 = __readfsqword(0x28u);
v4 = *(_QWORD *)(a1 + 56);
if ( !v4 )
{
*(_DWORD *)(a1 + 264) = 2013;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
v9 = a1 + 268;
v10 = client_errors[13];
LABEL_16:
strncpy(v9, v10, 512LL);
*(_BYTE *)(a1 + 779) = 0;
return 1;
}
v5 = a3;
if ( a3 == -1 )
v5 = strlen(a2);
*(_DWORD *)(a1 + 264) = 0;
strcpy((char *)(a1 + 781), "00000");
*(_BYTE *)(a1 + 268) = 0;
*(_DWORD *)(v4 + 144) = 0;
strcpy((char *)(*(_QWORD *)(a1 + 56) + 663LL), "00000");
*(_BYTE *)(*(_QWORD *)(a1 + 56) + 151LL) = 0;
v6 = *(_QWORD *)(*(_QWORD *)(a1 + 56) + 672LL);
if ( v6 )
*(_DWORD *)(v6 + 4) = 0;
*(_QWORD *)(v4 + 824) = -1LL;
*(_QWORD *)(a1 + 248) = -1LL;
if ( *(_DWORD *)(a1 + 80) )
{
v7 = *(_DWORD **)(v4 + 672);
v8 = *v7 == 0;
if ( !*v7 )
ma_multi_command(v4, 2);
if ( (unsigned __int8)mysql_stmt_internal_reset(a1, 1) )
goto LABEL_15;
ma_free_root(a1, 1);
ma_free_root(*(_QWORD *)(a1 + 832), 0);
*(_QWORD *)(a1 + 112) = 0LL;
*(_OWORD *)(a1 + 88) = 0LL;
v15 = *(_DWORD *)(a1 + 64);
if ( (*(unsigned int ( **)(long long, long long, int *, long long, long long, long long))(*(_QWORD *)(v4 + 1232)
+ 16LL))(
v4,
25LL,
&v15,
4LL,
1LL,
a1) )
{
goto LABEL_15;
}
}
else
{
v8 = 1;
}
if ( (*(unsigned int ( **)(long long, long long, long long, long long, long long, long long))(*(_QWORD *)(v4 + 1232)
+ 16LL))(
v4,
22LL,
a2,
v5,
1LL,
a1)
|| v8 && **(_DWORD **)(v4 + 672) == 2 && (unsigned int)ma_multi_command(v4, 4)
|| (v12 = 0, !**(_DWORD **)(v4 + 672))
&& !*(_BYTE *)(*(_QWORD *)(v4 + 1152) + 328LL)
&& (v14 = *(unsigned __int8 ( **)(long long))(*(_QWORD *)(v4 + 1232) + 64LL)) != 0LL
&& v14(a1) )
{
LABEL_15:
*(_DWORD *)(a1 + 80) = 0;
v11 = *(_QWORD *)(a1 + 56);
*(_DWORD *)(a1 + 264) = *(_DWORD *)(v11 + 144);
strncpy(a1 + 781, v11 + 663, 5LL);
*(_BYTE *)(a1 + 786) = 0;
v10 = (char *)(*(_QWORD *)(a1 + 56) + 151LL);
v9 = a1 + 268;
goto LABEL_16;
}
return v12;
}
| mysql_stmt_prepare:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV R14,qword ptr [RDI + 0x38]
TEST R14,R14
JZ 0x001210cc
MOV R12,RDX
MOV R15,RSI
CMP RDX,-0x1
JNZ 0x00120fc5
MOV RDI,R15
CALL 0x001131c0
MOV R12,RAX
LAB_00120fc5:
XOR EAX,EAX
MOV dword ptr [RBX + 0x108],EAX
MOV ECX,0x30303030
MOV dword ptr [RBX + 0x30d],ECX
MOV DX,0x30
MOV word ptr [RBX + 0x311],DX
MOV byte ptr [RBX + 0x10c],AL
MOV dword ptr [R14 + 0x90],EAX
MOV RSI,qword ptr [RBX + 0x38]
MOV word ptr [RSI + 0x29b],DX
MOV dword ptr [RSI + 0x297],ECX
MOV RCX,qword ptr [RBX + 0x38]
MOV byte ptr [RCX + 0x97],AL
MOV RAX,qword ptr [RBX + 0x38]
MOV RAX,qword ptr [RAX + 0x2a0]
TEST RAX,RAX
JZ 0x00121022
MOV dword ptr [RAX + 0x4],0x0
LAB_00121022:
MOV RAX,-0x1
MOV qword ptr [R14 + 0x338],RAX
MOV qword ptr [RBX + 0xf8],RAX
CMP dword ptr [RBX + 0x50],0x0
JZ 0x00121111
MOV RAX,qword ptr [R14 + 0x2a0]
CMP dword ptr [RAX],0x0
SETZ R13B
JNZ 0x0012105e
MOV RDI,R14
MOV ESI,0x2
CALL 0x0011602d
LAB_0012105e:
MOV RDI,RBX
MOV ESI,0x1
CALL 0x0011fcd4
TEST AL,AL
JNZ 0x0012113d
MOV RDI,RBX
MOV ESI,0x1
CALL 0x0011de3f
MOV RDI,qword ptr [RBX + 0x340]
XOR ESI,ESI
CALL 0x0011de3f
MOV qword ptr [RBX + 0x70],0x0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x58],XMM0
MOV EAX,dword ptr [RBX + 0x40]
LEA RDX,[RBP + -0x34]
MOV dword ptr [RDX],EAX
MOV RAX,qword ptr [R14 + 0x4d0]
MOV ECX,0x4
MOV RDI,R14
MOV ESI,0x19
MOV R8D,0x1
MOV R9,RBX
CALL qword ptr [RAX + 0x10]
TEST EAX,EAX
JNZ 0x0012113d
JMP 0x00121114
LAB_001210cc:
MOV dword ptr [RBX + 0x108],0x7dd
LEA RDI,[RBX + 0x30d]
LEA RAX,[0x148a60]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
MOV byte ptr [RBX + 0x312],0x0
LEA RDI,[RBX + 0x10c]
LEA RAX,[0x148a70]
MOV RSI,qword ptr [RAX + 0x68]
MOV EDX,0x200
JMP 0x0012118b
LAB_00121111:
MOV R13B,0x1
LAB_00121114:
MOV RAX,qword ptr [R14 + 0x4d0]
MOV RDI,R14
MOV ESI,0x16
MOV RDX,R15
MOV RCX,R12
MOV R8D,0x1
MOV R9,RBX
CALL qword ptr [RAX + 0x10]
TEST EAX,EAX
JZ 0x001211be
LAB_0012113d:
LEA RDI,[RBX + 0x30d]
LEA R14,[RBX + 0x10c]
MOV dword ptr [RBX + 0x50],0x0
MOV RSI,qword ptr [RBX + 0x38]
MOV EAX,dword ptr [RSI + 0x90]
MOV dword ptr [RBX + 0x108],EAX
ADD RSI,0x297
MOV EDX,0x5
CALL 0x00113220
MOV byte ptr [RBX + 0x312],0x0
MOV ESI,0x97
ADD RSI,qword ptr [RBX + 0x38]
MOV EDX,0x200
MOV RDI,R14
LAB_0012118b:
CALL 0x00113220
MOV byte ptr [RBX + 0x30b],0x0
MOV R15D,0x1
LAB_0012119d:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00121225
MOV EAX,R15D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001211be:
TEST R13B,R13B
JZ 0x001211e4
MOV RAX,qword ptr [R14 + 0x2a0]
CMP dword ptr [RAX],0x2
JNZ 0x001211e4
MOV RDI,R14
MOV ESI,0x4
CALL 0x0011602d
TEST EAX,EAX
JNZ 0x0012113d
LAB_001211e4:
MOV RAX,qword ptr [R14 + 0x2a0]
XOR R15D,R15D
CMP dword ptr [RAX],0x0
JNZ 0x0012119d
MOV RAX,qword ptr [R14 + 0x480]
CMP byte ptr [RAX + 0x148],0x0
JNZ 0x0012119d
MOV RAX,qword ptr [R14 + 0x4d0]
MOV RAX,qword ptr [RAX + 0x40]
TEST RAX,RAX
JZ 0x0012119d
MOV RDI,RBX
CALL RAX
TEST AL,AL
JNZ 0x0012113d
JMP 0x0012119d
LAB_00121225:
CALL 0x00113500
|
int8 mysql_stmt_prepare(long param_1,char *param_2,size_t param_3)
{
long lVar1;
long lVar2;
code *pcVar3;
char cVar4;
int iVar5;
char *__src;
int8 uVar6;
long in_FS_OFFSET;
bool bVar7;
int4 local_3c;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
lVar1 = *(long *)(param_1 + 0x38);
if (lVar1 == 0) {
*(int4 *)(param_1 + 0x108) = 0x7dd;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
__src = PTR_s_Lost_connection_to_server_during_00148ad8;
}
else {
if (param_3 == 0xffffffffffffffff) {
param_3 = strlen(param_2);
}
*(int4 *)(param_1 + 0x108) = 0;
*(int4 *)(param_1 + 0x30d) = 0x30303030;
*(int2 *)(param_1 + 0x311) = 0x30;
*(int1 *)(param_1 + 0x10c) = 0;
*(int4 *)(lVar1 + 0x90) = 0;
lVar2 = *(long *)(param_1 + 0x38);
*(int2 *)(lVar2 + 0x29b) = 0x30;
*(int4 *)(lVar2 + 0x297) = 0x30303030;
*(int1 *)(*(long *)(param_1 + 0x38) + 0x97) = 0;
lVar2 = *(long *)(*(long *)(param_1 + 0x38) + 0x2a0);
if (lVar2 != 0) {
*(int4 *)(lVar2 + 4) = 0;
}
*(int8 *)(lVar1 + 0x338) = 0xffffffffffffffff;
*(int8 *)(param_1 + 0xf8) = 0xffffffffffffffff;
if (*(int *)(param_1 + 0x50) == 0) {
bVar7 = true;
LAB_00121114:
iVar5 = (**(code **)(*(long *)(lVar1 + 0x4d0) + 0x10))(lVar1,0x16,param_2,param_3,1,param_1);
if ((iVar5 == 0) &&
(((!bVar7 || (**(int **)(lVar1 + 0x2a0) != 2)) ||
(iVar5 = ma_multi_command(lVar1,4), iVar5 == 0)))) {
uVar6 = 0;
if ((((**(int **)(lVar1 + 0x2a0) != 0) ||
(*(char *)(*(long *)(lVar1 + 0x480) + 0x148) != '\0')) ||
(pcVar3 = *(code **)(*(long *)(lVar1 + 0x4d0) + 0x40), pcVar3 == (code *)0x0)) ||
(cVar4 = (*pcVar3)(param_1), uVar6 = 0, cVar4 == '\0')) goto LAB_0012119d;
}
}
else {
bVar7 = **(int **)(lVar1 + 0x2a0) == 0;
if (bVar7) {
ma_multi_command(lVar1,2);
}
cVar4 = mysql_stmt_internal_reset(param_1,1);
if (cVar4 == '\0') {
ma_free_root(param_1,1);
ma_free_root(*(int8 *)(param_1 + 0x340),0);
*(int8 *)(param_1 + 0x70) = 0;
*(int8 *)(param_1 + 0x58) = 0;
*(int8 *)(param_1 + 0x60) = 0;
local_3c = *(int4 *)(param_1 + 0x40);
iVar5 = (**(code **)(*(long *)(lVar1 + 0x4d0) + 0x10))(lVar1,0x19,&local_3c,4,1,param_1);
if (iVar5 == 0) goto LAB_00121114;
}
}
*(int4 *)(param_1 + 0x50) = 0;
*(int4 *)(param_1 + 0x108) = *(int4 *)(*(long *)(param_1 + 0x38) + 0x90);
strncpy((char *)(param_1 + 0x30d),(char *)(*(long *)(param_1 + 0x38) + 0x297),5);
*(int1 *)(param_1 + 0x312) = 0;
__src = (char *)(*(long *)(param_1 + 0x38) + 0x97);
}
strncpy((char *)(param_1 + 0x10c),__src,0x200);
*(int1 *)(param_1 + 0x30b) = 0;
uVar6 = 1;
LAB_0012119d:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar6;
}
| |
29,274 | nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>>::key() const | llama.cpp/common/json.hpp | const string_type& key() const
{
JSON_ASSERT(anchor.m_object != nullptr);
switch (anchor.m_object->type())
{
// use integer array index as key
case value_t::array:
{
if (array_index != array_index_last)
{
int_to_string( array_index_str, array_index );
array_index_last = array_index;
}
return array_index_str;
}
// use key from the object
case value_t::object:
return anchor.key();
// use an empty key for all primitive types
case value_t::null:
case value_t::string:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::binary:
case value_t::discarded:
default:
return empty_str;
}
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>>::key() const:
pushq %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x46282
movq %rdi, %rbx
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x46270
cmpl $0x2, %eax
jne 0x46279
movq 0x20(%rbx), %rsi
cmpq 0x28(%rbx), %rsi
je 0x4626a
leaq 0x30(%rbx), %rdi
callq 0x4abb4
movq 0x20(%rbx), %rax
movq %rax, 0x28(%rbx)
addq $0x30, %rbx
jmp 0x4627d
movq %rbx, %rdi
popq %rbx
jmp 0x4ac76
addq $0x50, %rbx
movq %rbx, %rax
popq %rbx
retq
leaq 0x1a14f(%rip), %rdi # 0x603d8
leaq 0x15b02(%rip), %rdx # 0x5bd92
leaq 0x1aab8(%rip), %rcx # 0x60d4f
movl $0x1491, %esi # imm = 0x1491
xorl %eax, %eax
callq 0x17950
nop
| _ZNK8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEE3keyEv:
push rbx
mov rax, [rdi]
test rax, rax
jz short loc_46282
mov rbx, rdi
movzx eax, byte ptr [rax]
cmp eax, 1
jz short loc_46270
cmp eax, 2
jnz short loc_46279
mov rsi, [rbx+20h]
cmp rsi, [rbx+28h]
jz short loc_4626A
lea rdi, [rbx+30h]
call _ZN8nlohmann16json_abi_v3_11_36detail13int_to_stringINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEvRT_m; nlohmann::json_abi_v3_11_3::detail::int_to_string<std::string>(std::string &,ulong)
mov rax, [rbx+20h]
mov [rbx+28h], rax
loc_4626A:
add rbx, 30h ; '0'
jmp short loc_4627D
loc_46270:
mov rdi, rbx
pop rbx
jmp _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE3keyEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::key(void)
loc_46279:
add rbx, 50h ; 'P'
loc_4627D:
mov rax, rbx
pop rbx
retn
loc_46282:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aAnchorMObjectN; "anchor.m_object != nullptr"
mov esi, 1491h
xor eax, eax
call _ggml_abort
nop
| long long nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>>::key(
unsigned __int8 **a1)
{
int v1; // eax
if ( *a1 )
{
v1 = **a1;
if ( v1 == 1 )
{
return nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::key(a1);
}
else
{
if ( v1 != 2 )
return (long long)(a1 + 10);
if ( a1[4] != a1[5] )
{
nlohmann::json_abi_v3_11_3::detail::int_to_string<std::string>(a1 + 6);
a1[5] = a1[4];
}
return (long long)(a1 + 6);
}
}
else
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
5265LL,
"GGML_ASSERT(%s) failed",
"anchor.m_object != nullptr");
return nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>>::~iteration_proxy_value("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp");
}
}
| key:
PUSH RBX
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x00146282
MOV RBX,RDI
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x1
JZ 0x00146270
CMP EAX,0x2
JNZ 0x00146279
MOV RSI,qword ptr [RBX + 0x20]
CMP RSI,qword ptr [RBX + 0x28]
JZ 0x0014626a
LEA RDI,[RBX + 0x30]
CALL 0x0014abb4
MOV RAX,qword ptr [RBX + 0x20]
MOV qword ptr [RBX + 0x28],RAX
LAB_0014626a:
ADD RBX,0x30
JMP 0x0014627d
LAB_00146270:
MOV RDI,RBX
POP RBX
JMP 0x0014ac76
LAB_00146279:
ADD RBX,0x50
LAB_0014627d:
MOV RAX,RBX
POP RBX
RET
LAB_00146282:
LEA RDI,[0x1603d8]
LEA RDX,[0x15bd92]
LEA RCX,[0x160d4f]
MOV ESI,0x1491
XOR EAX,EAX
CALL 0x00117950
|
/* nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const> >::key() const */
iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
* __thiscall
nlohmann::json_abi_v3_11_3::detail::
iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
::key(iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
*this)
{
char cVar1;
iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
*piVar2;
if (*(char **)this == (char *)0x0) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",0x1491,
"GGML_ASSERT(%s) failed","anchor.m_object != nullptr");
}
cVar1 = **(char **)this;
if (cVar1 != '\x01') {
if (cVar1 == '\x02') {
if (*(ulong *)(this + 0x20) != *(ulong *)(this + 0x28)) {
int_to_string<std::__cxx11::string>((string *)(this + 0x30),*(ulong *)(this + 0x20));
*(int8 *)(this + 0x28) = *(int8 *)(this + 0x20);
}
piVar2 = this + 0x30;
}
else {
piVar2 = this + 0x50;
}
return piVar2;
}
piVar2 = (iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
*)iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::key((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)this);
return piVar2;
}
| |
29,275 | coro::thread_pool::executor(unsigned long) | AlayaLite/build_O3/_deps/libcoro-src/src/thread_pool.cpp | auto thread_pool::executor(std::size_t idx) -> void
{
if (m_opts.on_thread_start_functor != nullptr)
{
m_opts.on_thread_start_functor(idx);
}
// Process until shutdown is requested.
while (!m_shutdown_requested.load(std::memory_order::acquire))
{
std::unique_lock<std::mutex> lk{m_wait_mutex};
m_wait_cv.wait(lk, [&]() { return !m_queue.empty() || m_shutdown_requested.load(std::memory_order::acquire); });
if (m_queue.empty())
{
continue;
}
auto handle = m_queue.front();
m_queue.pop_front();
lk.unlock();
// Release the lock while executing the coroutine.
handle.resume();
m_size.fetch_sub(1, std::memory_order::release);
}
// Process until there are no ready tasks left.
while (m_size.load(std::memory_order::acquire) > 0)
{
std::unique_lock<std::mutex> lk{m_wait_mutex};
// m_size will only drop to zero once all executing coroutines are finished
// but the queue could be empty for threads that finished early.
if (m_queue.empty())
{
break;
}
auto handle = m_queue.front();
m_queue.pop_front();
lk.unlock();
// Release the lock while executing the coroutine.
handle.resume();
m_size.fetch_sub(1, std::memory_order::release);
}
if (m_opts.on_thread_stop_functor != nullptr)
{
m_opts.on_thread_stop_functor(idx);
}
} | O3 | cpp | coro::thread_pool::executor(unsigned long):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
je 0x5ad4
leaq 0x10(%rbx), %rdi
movq %rsp, %rsi
movq %r14, (%rsi)
callq *0x28(%rbx)
movq %r14, 0x10(%rsp)
movb 0x128(%rbx), %al
testb $0x1, %al
jne 0x5b86
leaq 0x68(%rbx), %r14
leaq 0x90(%rbx), %r15
leaq 0xd0(%rbx), %r12
movq %rsp, %r13
movq %r14, (%rsp)
movb $0x0, 0x8(%rsp)
movq %r13, %rdi
callq 0x5454
movb $0x1, 0x8(%rsp)
movq 0xe0(%rbx), %rax
movq 0x100(%rbx), %rcx
cmpq %rax, %rcx
jne 0x5b4a
movb 0x128(%rbx), %al
testb $0x1, %al
jne 0x5b3c
movq %r15, %rdi
movq %r13, %rsi
callq 0x622a
jmp 0x5b12
movq 0xe0(%rbx), %rax
movq 0x100(%rbx), %rcx
cmpq %rax, %rcx
je 0x5b70
movq (%rax), %rbp
movq %r12, %rdi
callq 0x5ed0
movq %r13, %rdi
callq 0x5490
movq %rbp, %rdi
callq *(%rbp)
lock
decq 0x120(%rbx)
movq %r13, %rdi
callq 0x543e
movb 0x128(%rbx), %al
testb $0x1, %al
je 0x5afc
movq 0x120(%rbx), %rax
testq %rax, %rax
je 0x5c06
leaq 0x68(%rbx), %r14
leaq 0xd0(%rbx), %r15
movq %rsp, %r12
movq %r14, (%rsp)
movb $0x0, 0x8(%rsp)
movq %r12, %rdi
callq 0x5454
movb $0x1, 0x8(%rsp)
movq 0xe0(%rbx), %rax
cmpq %rax, 0x100(%rbx)
je 0x5bfe
movq (%rax), %r13
movq %r15, %rdi
callq 0x5ed0
movq %r12, %rdi
callq 0x5490
movq %r13, %rdi
callq *(%r13)
lock
decq 0x120(%rbx)
movq %r12, %rdi
callq 0x543e
movq 0x120(%rbx), %rax
testq %rax, %rax
jne 0x5ba0
jmp 0x5c06
movq %rsp, %rdi
callq 0x543e
cmpq $0x0, 0x40(%rbx)
je 0x5c1f
leaq 0x30(%rbx), %rdi
movq %rsp, %rsi
movq 0x10(%rsp), %rax
movq %rax, (%rsi)
callq *0x48(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5c32
jmp 0x5c32
movq %rax, %rbx
movq %rsp, %rdi
callq 0x543e
movq %rbx, %rdi
callq 0x3430
nop
| _ZN4coro11thread_pool8executorEm:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r14, rsi
mov rbx, rdi
cmp qword ptr [rdi+20h], 0
jz short loc_5AD4
lea rdi, [rbx+10h]
mov rsi, rsp
mov [rsi], r14
call qword ptr [rbx+28h]
loc_5AD4:
mov [rsp+48h+var_38], r14
mov al, [rbx+128h]
test al, 1
jnz loc_5B86
lea r14, [rbx+68h]
lea r15, [rbx+90h]
lea r12, [rbx+0D0h]
mov r13, rsp
loc_5AFC:
mov [rsp+48h+var_48], r14
mov [rsp+48h+var_40], 0
mov rdi, r13
call _ZNSt11unique_lockISt5mutexE4lockEv; std::unique_lock<std::mutex>::lock(void)
mov [rsp+48h+var_40], 1
loc_5B12:
mov rax, [rbx+0E0h]
mov rcx, [rbx+100h]
cmp rcx, rax
jnz short loc_5B4A
mov al, [rbx+128h]
test al, 1
jnz short loc_5B3C
mov rdi, r15
mov rsi, r13
call _ZNSt3_V222condition_variable_any4waitISt11unique_lockISt5mutexEEEvRT_; std::_V2::condition_variable_any::wait<std::unique_lock<std::mutex>>(std::unique_lock<std::mutex> &)
jmp short loc_5B12
loc_5B3C:
mov rax, [rbx+0E0h]
mov rcx, [rbx+100h]
loc_5B4A:
cmp rcx, rax
jz short loc_5B70
mov rbp, [rax]
mov rdi, r12
call _ZNSt5dequeINSt7__n486116coroutine_handleIvEESaIS2_EE9pop_frontEv; std::deque<std::__n4861::coroutine_handle<void>>::pop_front(void)
mov rdi, r13
call _ZNSt11unique_lockISt5mutexE6unlockEv; std::unique_lock<std::mutex>::unlock(void)
mov rdi, rbp
call qword ptr [rbp+0]
lock dec qword ptr [rbx+120h]
loc_5B70:
mov rdi, r13
call _ZNSt11unique_lockISt5mutexED2Ev; std::unique_lock<std::mutex>::~unique_lock()
mov al, [rbx+128h]
test al, 1
jz loc_5AFC
loc_5B86:
mov rax, [rbx+120h]
test rax, rax
jz short loc_5C06
lea r14, [rbx+68h]
lea r15, [rbx+0D0h]
mov r12, rsp
loc_5BA0:
mov [rsp+48h+var_48], r14
mov [rsp+48h+var_40], 0
mov rdi, r12
call _ZNSt11unique_lockISt5mutexE4lockEv; std::unique_lock<std::mutex>::lock(void)
mov [rsp+48h+var_40], 1
mov rax, [rbx+0E0h]
cmp [rbx+100h], rax
jz short loc_5BFE
mov r13, [rax]
mov rdi, r15
call _ZNSt5dequeINSt7__n486116coroutine_handleIvEESaIS2_EE9pop_frontEv; std::deque<std::__n4861::coroutine_handle<void>>::pop_front(void)
mov rdi, r12
call _ZNSt11unique_lockISt5mutexE6unlockEv; std::unique_lock<std::mutex>::unlock(void)
mov rdi, r13
call qword ptr [r13+0]
lock dec qword ptr [rbx+120h]
mov rdi, r12
call _ZNSt11unique_lockISt5mutexED2Ev; std::unique_lock<std::mutex>::~unique_lock()
mov rax, [rbx+120h]
test rax, rax
jnz short loc_5BA0
jmp short loc_5C06
loc_5BFE:
mov rdi, rsp
call _ZNSt11unique_lockISt5mutexED2Ev; std::unique_lock<std::mutex>::~unique_lock()
loc_5C06:
cmp qword ptr [rbx+40h], 0
jz short loc_5C1F
lea rdi, [rbx+30h]
mov rsi, rsp
mov rax, [rsp+48h+var_38]
mov [rsi], rax
call qword ptr [rbx+48h]
loc_5C1F:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_5C32
jmp short $+2
loc_5C32:
mov rbx, rax
mov rdi, rsp
call _ZNSt11unique_lockISt5mutexED2Ev; std::unique_lock<std::mutex>::~unique_lock()
mov rdi, rbx
call __Unwind_Resume
| void ( *** coro::thread_pool::executor(coro::thread_pool *this, long long a2))(_QWORD)
{
int v2; // edx
int v3; // r8d
int v4; // r9d
void ( ***v5)(_QWORD); // rax
void ( ***v6)(_QWORD); // rcx
void ( **v7)(_QWORD); // rbp
void ( ***result)(_QWORD); // rax
void ( **v9)(_QWORD); // r13
long long v10; // [rsp+0h] [rbp-48h] BYREF
char v11; // [rsp+8h] [rbp-40h]
long long v12; // [rsp+10h] [rbp-38h]
if ( *((_QWORD *)this + 4) )
{
v10 = a2;
(*((void ( **)(char *))this + 5))((char *)this + 16);
}
v12 = a2;
while ( (*((_BYTE *)this + 296) & 1) == 0 )
{
v10 = (long long)this + 104;
v11 = 0;
std::unique_lock<std::mutex>::lock(&v10);
v11 = 1;
while ( 1 )
{
v5 = (void ( ***)(_QWORD))*((_QWORD *)this + 28);
v6 = (void ( ***)(_QWORD))*((_QWORD *)this + 32);
if ( v6 != v5 )
break;
if ( (*((_BYTE *)this + 296) & 1) != 0 )
{
v5 = (void ( ***)(_QWORD))*((_QWORD *)this + 28);
v6 = (void ( ***)(_QWORD))*((_QWORD *)this + 32);
break;
}
std::_V2::condition_variable_any::wait<std::unique_lock<std::mutex>>(
(_DWORD)this + 144,
(unsigned int)&v10,
v2,
(_DWORD)v6,
v3,
v4,
v10);
}
if ( v6 != v5 )
{
v7 = *v5;
std::deque<std::__n4861::coroutine_handle<void>>::pop_front((char *)this + 208);
std::unique_lock<std::mutex>::unlock(&v10);
(*v7)(v7);
_InterlockedDecrement64((volatile signed long long *)this + 36);
}
std::unique_lock<std::mutex>::~unique_lock((long long)&v10);
}
result = (void ( ***)(_QWORD))*((_QWORD *)this + 36);
if ( result )
{
while ( 1 )
{
v10 = (long long)this + 104;
v11 = 0;
std::unique_lock<std::mutex>::lock(&v10);
v11 = 1;
result = (void ( ***)(_QWORD))*((_QWORD *)this + 28);
if ( *((void ( ****)(_QWORD))this + 32) == result )
break;
v9 = *result;
std::deque<std::__n4861::coroutine_handle<void>>::pop_front((char *)this + 208);
std::unique_lock<std::mutex>::unlock(&v10);
(*v9)(v9);
_InterlockedDecrement64((volatile signed long long *)this + 36);
std::unique_lock<std::mutex>::~unique_lock((long long)&v10);
result = (void ( ***)(_QWORD))*((_QWORD *)this + 36);
if ( !result )
goto LABEL_17;
}
std::unique_lock<std::mutex>::~unique_lock((long long)&v10);
}
LABEL_17:
if ( *((_QWORD *)this + 8) )
{
v10 = v12;
return (void ( ***)(_QWORD))(*((long long ( **)(char *))this + 9))((char *)this + 48);
}
return result;
}
| executor:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R14,RSI
MOV RBX,RDI
CMP qword ptr [RDI + 0x20],0x0
JZ 0x00105ad4
LEA RDI,[RBX + 0x10]
MOV RSI,RSP
MOV qword ptr [RSI],R14
CALL qword ptr [RBX + 0x28]
LAB_00105ad4:
MOV qword ptr [RSP + 0x10],R14
MOV AL,byte ptr [RBX + 0x128]
TEST AL,0x1
JNZ 0x00105b86
LEA R14,[RBX + 0x68]
LEA R15,[RBX + 0x90]
LEA R12,[RBX + 0xd0]
MOV R13,RSP
LAB_00105afc:
MOV qword ptr [RSP],R14
MOV byte ptr [RSP + 0x8],0x0
MOV RDI,R13
CALL 0x00105454
MOV byte ptr [RSP + 0x8],0x1
LAB_00105b12:
MOV RAX,qword ptr [RBX + 0xe0]
MOV RCX,qword ptr [RBX + 0x100]
CMP RCX,RAX
JNZ 0x00105b4a
MOV AL,byte ptr [RBX + 0x128]
TEST AL,0x1
JNZ 0x00105b3c
LAB_00105b2f:
MOV RDI,R15
MOV RSI,R13
CALL 0x0010622a
JMP 0x00105b12
LAB_00105b3c:
MOV RAX,qword ptr [RBX + 0xe0]
MOV RCX,qword ptr [RBX + 0x100]
LAB_00105b4a:
CMP RCX,RAX
JZ 0x00105b70
MOV RBP,qword ptr [RAX]
MOV RDI,R12
CALL 0x00105ed0
LAB_00105b5a:
MOV RDI,R13
CALL 0x00105490
MOV RDI,RBP
CALL qword ptr [RBP]
LAB_00105b68:
DEC.LOCK qword ptr [RBX + 0x120]
LAB_00105b70:
MOV RDI,R13
CALL 0x0010543e
MOV AL,byte ptr [RBX + 0x128]
TEST AL,0x1
JZ 0x00105afc
LAB_00105b86:
MOV RAX,qword ptr [RBX + 0x120]
TEST RAX,RAX
JZ 0x00105c06
LEA R14,[RBX + 0x68]
LEA R15,[RBX + 0xd0]
MOV R12,RSP
LAB_00105ba0:
MOV qword ptr [RSP],R14
MOV byte ptr [RSP + 0x8],0x0
MOV RDI,R12
CALL 0x00105454
MOV byte ptr [RSP + 0x8],0x1
MOV RAX,qword ptr [RBX + 0xe0]
CMP qword ptr [RBX + 0x100],RAX
JZ 0x00105bfe
MOV R13,qword ptr [RAX]
MOV RDI,R15
CALL 0x00105ed0
LAB_00105bd1:
MOV RDI,R12
CALL 0x00105490
MOV RDI,R13
CALL qword ptr [R13]
LAB_00105be0:
DEC.LOCK qword ptr [RBX + 0x120]
MOV RDI,R12
CALL 0x0010543e
MOV RAX,qword ptr [RBX + 0x120]
TEST RAX,RAX
JNZ 0x00105ba0
JMP 0x00105c06
LAB_00105bfe:
MOV RDI,RSP
CALL 0x0010543e
LAB_00105c06:
CMP qword ptr [RBX + 0x40],0x0
JZ 0x00105c1f
LEA RDI,[RBX + 0x30]
MOV RSI,RSP
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSI],RAX
CALL qword ptr [RBX + 0x48]
LAB_00105c1f:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* coro::thread_pool::executor(unsigned long) */
void __thiscall coro::thread_pool::executor(thread_pool *this,ulong param_1)
{
int8 *puVar1;
int8 *puVar2;
thread_pool *local_48;
int1 local_40;
ulong local_38;
if (*(long *)(this + 0x20) != 0) {
local_48 = (thread_pool *)param_1;
(**(code **)(this + 0x28))(this + 0x10);
}
local_38 = param_1;
if (((byte)this[0x128] & 1) == 0) {
do {
local_40 = 0;
local_48 = this + 0x68;
std::unique_lock<std::mutex>::lock();
local_40 = 1;
while( true ) {
puVar1 = *(int8 **)(this + 0xe0);
puVar2 = *(int8 **)(this + 0x100);
if (puVar2 != puVar1) break;
if (((byte)this[0x128] & 1) != 0) {
puVar1 = *(int8 **)(this + 0xe0);
puVar2 = *(int8 **)(this + 0x100);
break;
}
/* try { // try from 00105b2f to 00105b39 has its CatchHandler @ 00105c32 */
std::_V2::condition_variable_any::wait<std::unique_lock<std::mutex>>
((condition_variable_any *)(this + 0x90),(unique_lock *)&local_48);
}
if (puVar2 != puVar1) {
puVar1 = (int8 *)*puVar1;
std::
deque<std::__n4861::coroutine_handle<void>,std::allocator<std::__n4861::coroutine_handle<void>>>
::pop_front((deque<std::__n4861::coroutine_handle<void>,std::allocator<std::__n4861::coroutine_handle<void>>>
*)(this + 0xd0));
/* try { // try from 00105b5a to 00105b67 has its CatchHandler @ 00105c30 */
std::unique_lock<std::mutex>::unlock();
(*(code *)*puVar1)(puVar1);
LOCK();
*(long *)(this + 0x120) = *(long *)(this + 0x120) + -1;
UNLOCK();
}
std::unique_lock<std::mutex>::~unique_lock((unique_lock<std::mutex> *)&local_48);
} while (((byte)this[0x128] & 1) == 0);
}
if (*(long *)(this + 0x120) != 0) {
do {
local_40 = 0;
local_48 = this + 0x68;
std::unique_lock<std::mutex>::lock();
local_40 = 1;
if (*(int8 **)(this + 0x100) == *(int8 **)(this + 0xe0)) {
std::unique_lock<std::mutex>::~unique_lock((unique_lock<std::mutex> *)&local_48);
break;
}
puVar2 = (int8 *)**(int8 **)(this + 0xe0);
std::
deque<std::__n4861::coroutine_handle<void>,std::allocator<std::__n4861::coroutine_handle<void>>>
::pop_front((deque<std::__n4861::coroutine_handle<void>,std::allocator<std::__n4861::coroutine_handle<void>>>
*)(this + 0xd0));
/* try { // try from 00105bd1 to 00105bdf has its CatchHandler @ 00105c2e */
std::unique_lock<std::mutex>::unlock();
(*(code *)*puVar2)(puVar2);
LOCK();
*(long *)(this + 0x120) = *(long *)(this + 0x120) + -1;
UNLOCK();
std::unique_lock<std::mutex>::~unique_lock((unique_lock<std::mutex> *)&local_48);
} while (*(long *)(this + 0x120) != 0);
}
if (*(long *)(this + 0x40) != 0) {
local_48 = (thread_pool *)local_38;
(**(code **)(this + 0x48))(this + 0x30);
}
return;
}
| |
29,276 | utf8_scan | bluesky950520[P]quickjs/cutils.c | int utf8_scan(const char *buf, size_t buf_len, size_t *plen)
{
const uint8_t *p, *p_end, *p_next;
size_t i, len;
int kind;
uint8_t cbits;
kind = UTF8_PLAIN_ASCII;
cbits = 0;
len = buf_len;
// TODO: handle more than 1 byte at a time
for (i = 0; i < buf_len; i++)
cbits |= buf[i];
if (cbits >= 0x80) {
p = (const uint8_t *)buf;
p_end = p + buf_len;
kind = UTF8_NON_ASCII;
len = 0;
while (p < p_end) {
len++;
if (*p++ >= 0x80) {
/* parse UTF-8 sequence, check for encoding error */
uint32_t c = utf8_decode_len(p - 1, p_end - (p - 1), &p_next);
if (p_next == p)
kind |= UTF8_HAS_ERRORS;
p = p_next;
if (c > 0xFF) {
kind |= UTF8_HAS_16BIT;
if (c > 0xFFFF) {
len++;
kind |= UTF8_HAS_NON_BMP1;
}
}
}
}
}
*plen = len;
return kind;
} | O1 | c | utf8_scan:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
testq %rsi, %rsi
je 0x1b89b
xorl %eax, %eax
xorl %ecx, %ecx
orb (%rdi,%rcx), %al
incq %rcx
cmpq %rcx, %r14
jne 0x1b88c
testb %al, %al
js 0x1b8b1
xorl %ebp, %ebp
movq %r14, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testq %r14, %r14
jle 0x1b91a
movq %r14, %r12
addq %rdi, %r12
movl $0x1, %ebp
xorl %r13d, %r13d
leaq 0x1(%r13), %r14
leaq 0x1(%rdi), %r15
cmpb $0x0, (%rdi)
js 0x1b8d6
movq %r15, %rdi
jmp 0x1b910
movq %r12, %rsi
subq %rdi, %rsi
movq %rsp, %rdx
callq 0x1b837
movq (%rsp), %rdi
movl %ebp, %ecx
orl $0x8, %ecx
cmpq %r15, %rdi
cmovel %ecx, %ebp
cmpl $0x100, %eax # imm = 0x100
jb 0x1b910
cmpl $0x10000, %eax # imm = 0x10000
jb 0x1b90d
addq $0x2, %r13
orl $0x6, %ebp
movq %r13, %r14
jmp 0x1b910
orl $0x2, %ebp
movq %r14, %r13
cmpq %r12, %rdi
jb 0x1b8c4
jmp 0x1b89d
movl $0x1, %ebp
xorl %r14d, %r14d
jmp 0x1b89d
| utf8_scan:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdx
mov r14, rsi
test rsi, rsi
jz short loc_1B89B
xor eax, eax
xor ecx, ecx
loc_1B88C:
or al, [rdi+rcx]
inc rcx
cmp r14, rcx
jnz short loc_1B88C
test al, al
js short loc_1B8B1
loc_1B89B:
xor ebp, ebp
loc_1B89D:
mov [rbx], r14
mov eax, ebp
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1B8B1:
test r14, r14
jle short loc_1B91A
mov r12, r14
add r12, rdi
mov ebp, 1
xor r13d, r13d
loc_1B8C4:
lea r14, [r13+1]
lea r15, [rdi+1]
cmp byte ptr [rdi], 0
js short loc_1B8D6
mov rdi, r15
jmp short loc_1B910
loc_1B8D6:
mov rsi, r12
sub rsi, rdi
mov rdx, rsp
call utf8_decode_len
mov rdi, [rsp+38h+var_38]
mov ecx, ebp
or ecx, 8
cmp rdi, r15
cmovz ebp, ecx
cmp eax, 100h
jb short loc_1B910
cmp eax, 10000h
jb short loc_1B90D
add r13, 2
or ebp, 6
mov r14, r13
jmp short loc_1B910
loc_1B90D:
or ebp, 2
loc_1B910:
mov r13, r14
cmp rdi, r12
jb short loc_1B8C4
jmp short loc_1B89D
loc_1B91A:
mov ebp, 1
xor r14d, r14d
jmp loc_1B89D
| long long utf8_scan(char *a1, long long a2, long long *a3)
{
char *v3; // rax
long long v5; // r14
char v6; // al
long long i; // rcx
unsigned int v8; // ebp
char *v10; // r12
long long v11; // r13
char *v12; // r15
unsigned int v13; // eax
char *v14; // [rsp+0h] [rbp-38h] BYREF
v14 = v3;
v5 = a2;
if ( !a2 )
goto LABEL_5;
v6 = 0;
for ( i = 0LL; i != a2; v6 |= a1[i++] )
;
if ( v6 < 0 )
{
if ( a2 <= 0 )
{
v8 = 1;
v5 = 0LL;
}
else
{
v10 = &a1[a2];
v8 = 1;
v11 = 0LL;
do
{
v5 = v11 + 1;
v12 = a1 + 1;
if ( *a1 < 0 )
{
v13 = utf8_decode_len(a1, v10 - a1, &v14);
a1 = v14;
if ( v14 == v12 )
v8 |= 8u;
if ( v13 >= 0x100 )
{
if ( v13 < 0x10000 )
{
v8 |= 2u;
}
else
{
v8 |= 6u;
v5 = v11 + 2;
}
}
}
else
{
++a1;
}
v11 = v5;
}
while ( a1 < v10 );
}
}
else
{
LABEL_5:
v8 = 0;
}
*a3 = v5;
return v8;
}
| utf8_scan:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RSI
TEST RSI,RSI
JZ 0x0011b89b
XOR EAX,EAX
XOR ECX,ECX
LAB_0011b88c:
OR AL,byte ptr [RDI + RCX*0x1]
INC RCX
CMP R14,RCX
JNZ 0x0011b88c
TEST AL,AL
JS 0x0011b8b1
LAB_0011b89b:
XOR EBP,EBP
LAB_0011b89d:
MOV qword ptr [RBX],R14
MOV EAX,EBP
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0011b8b1:
TEST R14,R14
JLE 0x0011b91a
MOV R12,R14
ADD R12,RDI
MOV EBP,0x1
XOR R13D,R13D
LAB_0011b8c4:
LEA R14,[R13 + 0x1]
LEA R15,[RDI + 0x1]
CMP byte ptr [RDI],0x0
JS 0x0011b8d6
MOV RDI,R15
JMP 0x0011b910
LAB_0011b8d6:
MOV RSI,R12
SUB RSI,RDI
MOV RDX,RSP
CALL 0x0011b837
MOV RDI,qword ptr [RSP]
MOV ECX,EBP
OR ECX,0x8
CMP RDI,R15
CMOVZ EBP,ECX
CMP EAX,0x100
JC 0x0011b910
CMP EAX,0x10000
JC 0x0011b90d
ADD R13,0x2
OR EBP,0x6
MOV R14,R13
JMP 0x0011b910
LAB_0011b90d:
OR EBP,0x2
LAB_0011b910:
MOV R13,R14
CMP RDI,R12
JC 0x0011b8c4
JMP 0x0011b89d
LAB_0011b91a:
MOV EBP,0x1
XOR R14D,R14D
JMP 0x0011b89d
|
uint utf8_scan(char *param_1,long param_2,long *param_3)
{
byte bVar1;
uint uVar2;
char *in_RAX;
long lVar3;
uint uVar4;
char *pcVar5;
char *pcVar6;
char *local_38;
if (param_2 != 0) {
bVar1 = 0;
lVar3 = 0;
do {
bVar1 = bVar1 | param_1[lVar3];
lVar3 = lVar3 + 1;
} while (param_2 != lVar3);
if ((char)bVar1 < '\0') {
if (param_2 < 1) {
uVar4 = 1;
param_2 = 0;
}
else {
pcVar6 = param_1 + param_2;
uVar4 = 1;
param_2 = 0;
local_38 = in_RAX;
do {
lVar3 = param_2 + 1;
pcVar5 = param_1 + 1;
if (*param_1 < '\0') {
uVar2 = utf8_decode_len(param_1,(long)pcVar6 - (long)param_1,&local_38);
if (local_38 == pcVar5) {
uVar4 = uVar4 | 8;
}
pcVar5 = local_38;
if (0xff < uVar2) {
if (uVar2 < 0x10000) {
uVar4 = uVar4 | 2;
}
else {
uVar4 = uVar4 | 6;
lVar3 = param_2 + 2;
}
}
}
param_2 = lVar3;
param_1 = pcVar5;
} while (pcVar5 < pcVar6);
}
goto LAB_0011b89d;
}
}
uVar4 = 0;
LAB_0011b89d:
*param_3 = param_2;
return uVar4;
}
| |
29,277 | utf8_scan | bluesky950520[P]quickjs/cutils.c | int utf8_scan(const char *buf, size_t buf_len, size_t *plen)
{
const uint8_t *p, *p_end, *p_next;
size_t i, len;
int kind;
uint8_t cbits;
kind = UTF8_PLAIN_ASCII;
cbits = 0;
len = buf_len;
// TODO: handle more than 1 byte at a time
for (i = 0; i < buf_len; i++)
cbits |= buf[i];
if (cbits >= 0x80) {
p = (const uint8_t *)buf;
p_end = p + buf_len;
kind = UTF8_NON_ASCII;
len = 0;
while (p < p_end) {
len++;
if (*p++ >= 0x80) {
/* parse UTF-8 sequence, check for encoding error */
uint32_t c = utf8_decode_len(p - 1, p_end - (p - 1), &p_next);
if (p_next == p)
kind |= UTF8_HAS_ERRORS;
p = p_next;
if (c > 0xFF) {
kind |= UTF8_HAS_16BIT;
if (c > 0xFFFF) {
len++;
kind |= UTF8_HAS_NON_BMP1;
}
}
}
}
}
*plen = len;
return kind;
} | O3 | c | utf8_scan:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
testq %rsi, %rsi
je 0x1c1d3
movq %rsi, %r14
xorl %eax, %eax
xorl %ecx, %ecx
orb (%rdi,%rcx), %al
incq %rcx
cmpq %rcx, %r14
jne 0x1c1bd
xorl %ebp, %ebp
testb %al, %al
js 0x1c1da
movq %r14, %r12
jmp 0x1c248
xorl %r12d, %r12d
xorl %ebp, %ebp
jmp 0x1c248
testq %r14, %r14
jle 0x1c240
addq %rdi, %r14
movl $0x1, %ebp
xorl %r13d, %r13d
leaq 0x1(%r13), %r12
leaq 0x1(%rdi), %r15
cmpb $0x0, (%rdi)
js 0x1c1fc
movq %r15, %rdi
jmp 0x1c236
movq %r14, %rsi
subq %rdi, %rsi
movq %rsp, %rdx
callq 0x1c168
movq (%rsp), %rdi
movl %ebp, %ecx
orl $0x8, %ecx
cmpq %r15, %rdi
cmovel %ecx, %ebp
cmpl $0x100, %eax # imm = 0x100
jb 0x1c236
cmpl $0x10000, %eax # imm = 0x10000
jb 0x1c233
addq $0x2, %r13
orl $0x6, %ebp
movq %r13, %r12
jmp 0x1c236
orl $0x2, %ebp
movq %r12, %r13
cmpq %r14, %rdi
jb 0x1c1ea
jmp 0x1c248
movl $0x1, %ebp
xorl %r12d, %r12d
movq %r12, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| utf8_scan:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdx
test rsi, rsi
jz short loc_1C1D3
mov r14, rsi
xor eax, eax
xor ecx, ecx
loc_1C1BD:
or al, [rdi+rcx]
inc rcx
cmp r14, rcx
jnz short loc_1C1BD
xor ebp, ebp
test al, al
js short loc_1C1DA
mov r12, r14
jmp short loc_1C248
loc_1C1D3:
xor r12d, r12d
xor ebp, ebp
jmp short loc_1C248
loc_1C1DA:
test r14, r14
jle short loc_1C240
add r14, rdi
mov ebp, 1
xor r13d, r13d
loc_1C1EA:
lea r12, [r13+1]
lea r15, [rdi+1]
cmp byte ptr [rdi], 0
js short loc_1C1FC
mov rdi, r15
jmp short loc_1C236
loc_1C1FC:
mov rsi, r14
sub rsi, rdi
mov rdx, rsp
call utf8_decode_len
mov rdi, [rsp+38h+var_38]
mov ecx, ebp
or ecx, 8
cmp rdi, r15
cmovz ebp, ecx
cmp eax, 100h
jb short loc_1C236
cmp eax, offset loc_10000
jb short loc_1C233
add r13, 2
or ebp, 6
mov r12, r13
jmp short loc_1C236
loc_1C233:
or ebp, 2
loc_1C236:
mov r13, r12
cmp rdi, r14
jb short loc_1C1EA
jmp short loc_1C248
loc_1C240:
mov ebp, 1
xor r12d, r12d
loc_1C248:
mov [rbx], r12
mov eax, ebp
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long utf8_scan(char *a1, long long a2, long long *a3)
{
char *v3; // rax
char v5; // al
long long i; // rcx
unsigned int v7; // ebp
long long v8; // r12
char *v9; // r14
long long v10; // r13
char *v11; // r15
unsigned int v12; // eax
char *v14; // [rsp+0h] [rbp-38h] BYREF
v14 = v3;
if ( a2 )
{
v5 = 0;
for ( i = 0LL; i != a2; ++i )
v5 |= a1[i];
v7 = 0;
if ( v5 < 0 )
{
if ( a2 <= 0 )
{
v7 = 1;
v8 = 0LL;
}
else
{
v9 = &a1[a2];
v7 = 1;
v10 = 0LL;
do
{
v8 = v10 + 1;
v11 = a1 + 1;
if ( *a1 < 0 )
{
v12 = utf8_decode_len(a1, v9 - a1, &v14);
a1 = v14;
if ( v14 == v11 )
v7 |= 8u;
if ( v12 >= 0x100 )
{
if ( v12 < (unsigned int)&loc_10000 )
{
v7 |= 2u;
}
else
{
v7 |= 6u;
v8 = v10 + 2;
}
}
}
else
{
++a1;
}
v10 = v8;
}
while ( a1 < v9 );
}
}
else
{
v8 = a2;
}
}
else
{
v8 = 0LL;
v7 = 0;
}
*a3 = v8;
return v7;
}
| utf8_scan:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDX
TEST RSI,RSI
JZ 0x0011c1d3
MOV R14,RSI
XOR EAX,EAX
XOR ECX,ECX
LAB_0011c1bd:
OR AL,byte ptr [RDI + RCX*0x1]
INC RCX
CMP R14,RCX
JNZ 0x0011c1bd
XOR EBP,EBP
TEST AL,AL
JS 0x0011c1da
MOV R12,R14
JMP 0x0011c248
LAB_0011c1d3:
XOR R12D,R12D
XOR EBP,EBP
JMP 0x0011c248
LAB_0011c1da:
TEST R14,R14
JLE 0x0011c240
ADD R14,RDI
MOV EBP,0x1
XOR R13D,R13D
LAB_0011c1ea:
LEA R12,[R13 + 0x1]
LEA R15,[RDI + 0x1]
CMP byte ptr [RDI],0x0
JS 0x0011c1fc
MOV RDI,R15
JMP 0x0011c236
LAB_0011c1fc:
MOV RSI,R14
SUB RSI,RDI
MOV RDX,RSP
CALL 0x0011c168
MOV RDI,qword ptr [RSP]
MOV ECX,EBP
OR ECX,0x8
CMP RDI,R15
CMOVZ EBP,ECX
CMP EAX,0x100
JC 0x0011c236
CMP EAX,0x10000
JC 0x0011c233
ADD R13,0x2
OR EBP,0x6
MOV R12,R13
JMP 0x0011c236
LAB_0011c233:
OR EBP,0x2
LAB_0011c236:
MOV R13,R12
CMP RDI,R14
JC 0x0011c1ea
JMP 0x0011c248
LAB_0011c240:
MOV EBP,0x1
XOR R12D,R12D
LAB_0011c248:
MOV qword ptr [RBX],R12
MOV EAX,EBP
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
uint utf8_scan(char *param_1,long param_2,long *param_3)
{
byte bVar1;
uint uVar2;
char *in_RAX;
long lVar3;
uint uVar4;
char *pcVar5;
char *pcVar6;
char *local_38;
if (param_2 == 0) {
param_2 = 0;
uVar4 = 0;
}
else {
bVar1 = 0;
lVar3 = 0;
do {
bVar1 = bVar1 | param_1[lVar3];
lVar3 = lVar3 + 1;
} while (param_2 != lVar3);
uVar4 = 0;
if ((char)bVar1 < '\0') {
if (param_2 < 1) {
uVar4 = 1;
param_2 = 0;
}
else {
pcVar6 = param_1 + param_2;
uVar4 = 1;
lVar3 = 0;
local_38 = in_RAX;
do {
param_2 = lVar3 + 1;
pcVar5 = param_1 + 1;
if (*param_1 < '\0') {
uVar2 = utf8_decode_len(param_1,(long)pcVar6 - (long)param_1,&local_38);
if (local_38 == pcVar5) {
uVar4 = uVar4 | 8;
}
pcVar5 = local_38;
if (0xff < uVar2) {
if (uVar2 < 0x10000) {
uVar4 = uVar4 | 2;
}
else {
param_2 = lVar3 + 2;
uVar4 = uVar4 | 6;
}
}
}
param_1 = pcVar5;
lVar3 = param_2;
} while (pcVar5 < pcVar6);
}
}
}
*param_3 = param_2;
return uVar4;
}
| |
29,278 | ggml_rms_norm_back | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c | struct ggml_tensor * ggml_rms_norm_back(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b,
float eps) {
struct ggml_tensor * result = ggml_dup_tensor(ctx, a);
ggml_set_op_params(result, &eps, sizeof(eps));
result->op = GGML_OP_RMS_NORM_BACK;
result->src[0] = a;
result->src[1] = b;
return result;
} | O1 | c | ggml_rms_norm_back:
pushq %r14
pushq %rbx
pushq %rax
movss %xmm0, 0x4(%rsp)
movq %rdx, %rbx
movq %rsi, %r14
movl (%rsi), %esi
leaq 0x10(%r14), %rcx
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x1b871
testq %rax, %rax
je 0x1cd46
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x54(%rax)
movl $0x18, 0x50(%rax)
movq %r14, 0x98(%rax)
movq %rbx, 0xa0(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x31978(%rip), %rdi # 0x4e6c5
leaq 0x2f86d(%rip), %rdx # 0x4c5c1
leaq 0x31a97(%rip), %rcx # 0x4e7f2
movl $0x70, %esi
xorl %eax, %eax
callq 0x18ce0
| ggml_rms_norm_back:
push r14
push rbx
push rax
movss [rsp+18h+var_14], xmm0
mov rbx, rdx
mov r14, rsi
mov esi, [rsi]
lea rcx, [r14+10h]
mov edx, 4
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
test rax, rax
jz short loc_1CD46
movss xmm0, [rsp+18h+var_14]
movss dword ptr [rax+54h], xmm0
mov dword ptr [rax+50h], 18h
mov [rax+98h], r14
mov [rax+0A0h], rbx
add rsp, 8
pop rbx
pop r14
retn
loc_1CD46:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aTensorNull; "tensor != NULL"
mov esi, 70h ; 'p'
xor eax, eax
call _ggml_abort
| long long ggml_rms_norm_back(long long a1, long long a2, long long a3, double a4)
{
long long result; // rax
int v6; // r8d
int v7; // r9d
result = ggml_new_tensor_impl(a1, *(_DWORD *)a2, 4, (long long *)(a2 + 16), 0LL, 0LL, a4);
if ( !result )
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-impl.h",
112,
(unsigned int)"GGML_ASSERT(%s) failed",
(unsigned int)"tensor != NULL",
v6,
v7);
*(_DWORD *)(result + 84) = LODWORD(a4);
*(_DWORD *)(result + 80) = 24;
*(_QWORD *)(result + 152) = a2;
*(_QWORD *)(result + 160) = a3;
return result;
}
| ggml_rms_norm_back:
PUSH R14
PUSH RBX
PUSH RAX
MOVSS dword ptr [RSP + 0x4],XMM0
MOV RBX,RDX
MOV R14,RSI
MOV ESI,dword ptr [RSI]
LEA RCX,[R14 + 0x10]
MOV EDX,0x4
XOR R8D,R8D
XOR R9D,R9D
CALL 0x0011b871
TEST RAX,RAX
JZ 0x0011cd46
MOVSS XMM0,dword ptr [RSP + 0x4]
MOVSS dword ptr [RAX + 0x54],XMM0
MOV dword ptr [RAX + 0x50],0x18
MOV qword ptr [RAX + 0x98],R14
MOV qword ptr [RAX + 0xa0],RBX
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_0011cd46:
LEA RDI,[0x14e6c5]
LEA RDX,[0x14c5c1]
LEA RCX,[0x14e7f2]
MOV ESI,0x70
XOR EAX,EAX
CALL 0x00118ce0
|
void ggml_rms_norm_back(int4 param_1,int8 param_2,int4 *param_3,int8 param_4
)
{
long lVar1;
lVar1 = ggml_new_tensor_impl(param_2,*param_3,4,param_3 + 4,0,0);
if (lVar1 != 0) {
*(int4 *)(lVar1 + 0x54) = param_1;
*(int4 *)(lVar1 + 0x50) = 0x18;
*(int4 **)(lVar1 + 0x98) = param_3;
*(int8 *)(lVar1 + 0xa0) = param_4;
return;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-impl.h"
,0x70,"GGML_ASSERT(%s) failed","tensor != NULL");
}
| |
29,279 | ggml_rms_norm_back | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c | struct ggml_tensor * ggml_rms_norm_back(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b,
float eps) {
struct ggml_tensor * result = ggml_dup_tensor(ctx, a);
ggml_set_op_params(result, &eps, sizeof(eps));
result->op = GGML_OP_RMS_NORM_BACK;
result->src[0] = a;
result->src[1] = b;
return result;
} | O2 | c | ggml_rms_norm_back:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x4(%rsp), %r15
movss %xmm0, (%r15)
callq 0x1e7a0
movq %rax, %r12
pushq $0x4
popq %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2221d
movl $0x18, 0x50(%r12)
movq %r14, 0x98(%r12)
movq %rbx, 0xa0(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| ggml_rms_norm_back:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rdx
mov r14, rsi
lea r15, [rsp+28h+var_24]
movss dword ptr [r15], xmm0
call _ggml_dup_tensor
mov r12, rax
push 4
pop rdx
mov rdi, rax
mov rsi, r15
call ggml_set_op_params
mov dword ptr [r12+50h], 18h
mov [r12+98h], r14
mov [r12+0A0h], rbx
mov rax, r12
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| long long ggml_rms_norm_back(
long long a1,
unsigned int *a2,
long long a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
long long v12; // r12
long long v13; // rcx
long long v14; // r8
long long v15; // r9
__m128 v16; // xmm4
__m128 v17; // xmm5
__int32 v19[9]; // [rsp+0h] [rbp-24h] BYREF
v19[0] = a4.m128_i32[0];
v12 = ggml_dup_tensor(a1, a2);
ggml_set_op_params(v12, (long long)v19, 4LL, a4, a5, a6, a7, v16, v17, a10, a11, v13, v14, v15);
*(_DWORD *)(v12 + 80) = 24;
*(_QWORD *)(v12 + 152) = a2;
*(_QWORD *)(v12 + 160) = a3;
return v12;
}
| ggml_rms_norm_back:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RSI
LEA R15,[RSP + 0x4]
MOVSS dword ptr [R15],XMM0
CALL 0x0011e7a0
MOV R12,RAX
PUSH 0x4
POP RDX
MOV RDI,RAX
MOV RSI,R15
CALL 0x0012221d
MOV dword ptr [R12 + 0x50],0x18
MOV qword ptr [R12 + 0x98],R14
MOV qword ptr [R12 + 0xa0],RBX
MOV RAX,R12
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
long ggml_rms_norm_back(int8 param_1,int8 param_2,int8 param_3)
{
long lVar1;
int1 local_24 [4];
lVar1 = ggml_dup_tensor();
ggml_set_op_params(lVar1,local_24,4);
*(int4 *)(lVar1 + 0x50) = 0x18;
*(int8 *)(lVar1 + 0x98) = param_2;
*(int8 *)(lVar1 + 0xa0) = param_3;
return lVar1;
}
| |
29,280 | ggml_rms_norm_back | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c | struct ggml_tensor * ggml_rms_norm_back(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b,
float eps) {
struct ggml_tensor * result = ggml_dup_tensor(ctx, a);
ggml_set_op_params(result, &eps, sizeof(eps));
result->op = GGML_OP_RMS_NORM_BACK;
result->src[0] = a;
result->src[1] = b;
return result;
} | O3 | c | ggml_rms_norm_back:
pushq %r14
pushq %rbx
pushq %rax
movss %xmm0, 0x4(%rsp)
movq %rdx, %rbx
movq %rsi, %r14
movl (%rsi), %esi
leaq 0x10(%r14), %rcx
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x1a57f
testq %rax, %rax
je 0x1ba5f
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x54(%rax)
movl $0x18, 0x50(%rax)
movq %r14, 0x98(%rax)
movq %rbx, 0xa0(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x32d03(%rip), %rdi # 0x4e769
leaq 0x30bf8(%rip), %rdx # 0x4c665
leaq 0x32e22(%rip), %rcx # 0x4e896
movl $0x70, %esi
xorl %eax, %eax
callq 0x17cd0
| ggml_rms_norm_back:
push r14
push rbx
push rax
movss [rsp+18h+var_14], xmm0
mov rbx, rdx
mov r14, rsi
mov esi, [rsi]
lea rcx, [r14+10h]
mov edx, 4
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
test rax, rax
jz short loc_1BA5F
movss xmm0, [rsp+18h+var_14]
movss dword ptr [rax+54h], xmm0
mov dword ptr [rax+50h], 18h
mov [rax+98h], r14
mov [rax+0A0h], rbx
add rsp, 8
pop rbx
pop r14
retn
loc_1BA5F:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aTensorNull; "tensor != NULL"
mov esi, 70h ; 'p'
xor eax, eax
call _ggml_abort
| long long ggml_rms_norm_back(long long a1, long long a2, long long a3, double a4)
{
long long result; // rax
int v6; // r8d
int v7; // r9d
result = ggml_new_tensor_impl(a1, *(_DWORD *)a2, 4u, (long long *)(a2 + 16), 0LL, 0LL, a4);
if ( !result )
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-impl.h",
112,
(unsigned int)"GGML_ASSERT(%s) failed",
(unsigned int)"tensor != NULL",
v6,
v7);
*(_DWORD *)(result + 84) = LODWORD(a4);
*(_DWORD *)(result + 80) = 24;
*(_QWORD *)(result + 152) = a2;
*(_QWORD *)(result + 160) = a3;
return result;
}
| ggml_rms_norm_back:
PUSH R14
PUSH RBX
PUSH RAX
MOVSS dword ptr [RSP + 0x4],XMM0
MOV RBX,RDX
MOV R14,RSI
MOV ESI,dword ptr [RSI]
LEA RCX,[R14 + 0x10]
MOV EDX,0x4
XOR R8D,R8D
XOR R9D,R9D
CALL 0x0011a57f
TEST RAX,RAX
JZ 0x0011ba5f
MOVSS XMM0,dword ptr [RSP + 0x4]
MOVSS dword ptr [RAX + 0x54],XMM0
MOV dword ptr [RAX + 0x50],0x18
MOV qword ptr [RAX + 0x98],R14
MOV qword ptr [RAX + 0xa0],RBX
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_0011ba5f:
LEA RDI,[0x14e769]
LEA RDX,[0x14c665]
LEA RCX,[0x14e896]
MOV ESI,0x70
XOR EAX,EAX
CALL 0x00117cd0
|
void ggml_rms_norm_back(int4 param_1,int8 param_2,int4 *param_3,int8 param_4
)
{
long lVar1;
lVar1 = ggml_new_tensor_impl(param_2,*param_3,4,param_3 + 4,0,0);
if (lVar1 != 0) {
*(int4 *)(lVar1 + 0x54) = param_1;
*(int4 *)(lVar1 + 0x50) = 0x18;
*(int4 **)(lVar1 + 0x98) = param_3;
*(int8 *)(lVar1 + 0xa0) = param_4;
return;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-impl.h"
,0x70,"GGML_ASSERT(%s) failed","tensor != NULL");
}
| |
29,281 | js_typed_array_find | bluesky950520[P]quickjs/quickjs.c | static JSValue js_typed_array_find(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int mode)
{
JSValue func, this_arg;
JSValue args[3];
JSValue val, index_val, res;
int len, k, end;
int dir;
val = JS_UNDEFINED;
len = js_typed_array_get_length_unsafe(ctx, this_val);
if (len < 0)
goto exception;
func = argv[0];
if (check_function(ctx, func))
goto exception;
this_arg = JS_UNDEFINED;
if (argc > 1)
this_arg = argv[1];
k = 0;
dir = 1;
end = len;
if (mode == ArrayFindLast || mode == ArrayFindLastIndex) {
k = len - 1;
dir = -1;
end = -1;
}
for(; k != end; k += dir) {
index_val = js_int32(k);
val = JS_GetPropertyValue(ctx, this_val, index_val);
if (JS_IsException(val))
goto exception;
args[0] = val;
args[1] = index_val;
args[2] = this_val;
res = JS_Call(ctx, func, this_arg, 3, args);
if (JS_IsException(res))
goto exception;
if (JS_ToBoolFree(ctx, res)) {
if (mode == ArrayFindIndex || mode == ArrayFindLastIndex) {
JS_FreeValue(ctx, val);
return index_val;
} else {
return val;
}
}
JS_FreeValue(ctx, val);
}
if (mode == ArrayFindIndex || mode == ArrayFindLastIndex)
return js_int32(-1);
else
return JS_UNDEFINED;
exception:
JS_FreeValue(ctx, val);
return JS_EXCEPTION;
} | O1 | c | js_typed_array_find:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %r9d, %r12d
movq %r8, %r15
movl %ecx, %r14d
movq %rdi, %rbx
movq %rsi, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
callq 0x77f2d
movl $0x3, %r13d
testl %eax, %eax
js 0x81344
movl %eax, %ebp
movl %r12d, 0x24(%rsp)
movl %r14d, 0x28(%rsp)
movq (%r15), %r14
movq 0x8(%r15), %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x415b1
testl %eax, %eax
je 0x8137d
xorl %esi, %esi
xorl %eax, %eax
orq %rax, %rsi
movq 0x18(%rbx), %rdi
movq %r13, %rdx
callq 0x1d8c6
movl $0x6, %r13d
xorl %r14d, %r14d
xorl %ecx, %ecx
movl %r14d, %eax
orq %rcx, %rax
movq %r13, %rdx
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, 0x50(%rsp)
movq %r14, 0x58(%rsp)
xorl %r14d, %r14d
cmpl $0x2, 0x28(%rsp)
jl 0x813b4
movq 0x10(%r15), %rax
movq 0x18(%r15), %rcx
movq %rcx, 0x48(%rsp)
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rax, %rcx
movq %rcx, 0x28(%rsp)
movl %eax, %eax
jmp 0x813c9
movl $0x3, %eax
movq %rax, 0x48(%rsp)
xorl %eax, %eax
movq $0x0, 0x28(%rsp)
movq 0x38(%rsp), %r12
movq 0x30(%rsp), %r15
movl 0x24(%rsp), %edi
andl $-0x2, %edi
leal -0x1(%rbp), %r8d
xorl %ecx, %ecx
cmpl $0x2, %edi
movl $0xffffffff, %r9d # imm = 0xFFFFFFFF
cmovnel %ebp, %r9d
setne %dil
cmovel %r8d, %r14d
movl %r9d, 0x44(%rsp)
cmpl %r9d, %r14d
jne 0x8141f
movl 0x24(%rsp), %eax
orl $0x2, %eax
cmpl $0x3, %eax
jne 0x8152e
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
xorl %ecx, %ecx
xorl %r13d, %r13d
jmp 0x81362
movb %dil, %cl
leal -0x1(,%rcx,2), %ecx
movl %ecx, 0x40(%rsp)
orq %rax, 0x28(%rsp)
movl %r14d, %r14d
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x3fe2d
movq %rax, %rbp
movq %rdx, %r13
cmpl $0x6, %r13d
je 0x81517
movq %rbp, 0x70(%rsp)
movq %r13, 0x78(%rsp)
movq %r14, 0x80(%rsp)
movq $0x0, 0x88(%rsp)
movq %r15, 0x90(%rsp)
movq %r12, 0x98(%rsp)
movl $0x0, 0x60(%rsp)
movq $0x3, 0x68(%rsp)
movups 0x60(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x2, 0x18(%rsp)
movq %rbx, %rdi
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x48(%rsp), %r8
movl $0x3, %r9d
callq 0x284ca
cmpl $0x6, %edx
je 0x81517
movq %rbx, %rdi
movq %rax, %rsi
callq 0x22d0d
testl %eax, %eax
jne 0x81539
movq 0x18(%rbx), %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x1d8c6
addl 0x40(%rsp), %r14d
cmpl %r14d, 0x44(%rsp)
movq 0x38(%rsp), %r12
movq 0x30(%rsp), %r15
jne 0x81432
jmp 0x813ff
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
movq %rbp, %rax
andq %rcx, %rax
movl %ebp, %esi
jmp 0x81348
movl $0x3, %r13d
jmp 0x8135d
movl 0x24(%rsp), %eax
orl $0x2, %eax
cmpl $0x3, %eax
jne 0x81559
movq 0x18(%rbx), %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x1d8c6
jmp 0x81415
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %rbp, %rcx
andq %rax, %rcx
movq %rbp, %r14
jmp 0x81362
| js_typed_array_find:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0A8h
mov r12d, r9d
mov r15, r8
mov r14d, ecx
mov rbx, rdi
mov [rsp+0D8h+var_A8], rsi
mov [rsp+0D8h+var_A0], rdx
call js_typed_array_get_length_unsafe
mov r13d, 3
test eax, eax
js short loc_81344
mov ebp, eax
mov [rsp+0D8h+var_B4], r12d
mov dword ptr [rsp+0D8h+var_B0], r14d
mov r14, [r15]
mov r12, [r15+8]
mov rdi, rbx
mov rsi, r14
mov rdx, r12
call check_function
test eax, eax
jz short loc_8137D
loc_81344:
xor esi, esi
xor eax, eax
loc_81348:
or rsi, rax
mov rdi, [rbx+18h]
mov rdx, r13
call JS_FreeValueRT
mov r13d, 6
loc_8135D:
xor r14d, r14d
xor ecx, ecx
loc_81362:
mov eax, r14d
or rax, rcx
mov rdx, r13
add rsp, 0A8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_8137D:
mov [rsp+0D8h+var_88], r12
mov [rsp+0D8h+var_80], r14
xor r14d, r14d
cmp dword ptr [rsp+0D8h+var_B0], 2
jl short loc_813B4
mov rax, [r15+10h]
mov rcx, [r15+18h]
mov [rsp+0D8h+var_90], rcx
mov rcx, 0FFFFFFFF00000000h
and rcx, rax
mov [rsp+0D8h+var_B0], rcx
mov eax, eax
jmp short loc_813C9
loc_813B4:
mov eax, 3
mov [rsp+0D8h+var_90], rax
xor eax, eax
mov [rsp+0D8h+var_B0], 0
loc_813C9:
mov r12, [rsp+0D8h+var_A0]
mov r15, [rsp+0D8h+var_A8]
mov edi, [rsp+0D8h+var_B4]
and edi, 0FFFFFFFEh
lea r8d, [rbp-1]
xor ecx, ecx
cmp edi, 2
mov r9d, 0FFFFFFFFh
cmovnz r9d, ebp
setnz dil
cmovz r14d, r8d
mov [rsp+0D8h+var_94], r9d
cmp r14d, r9d
jnz short loc_8141F
loc_813FF:
mov eax, [rsp+0D8h+var_B4]
or eax, 2
cmp eax, 3
jnz loc_8152E
mov r14d, 0FFFFFFFFh
loc_81415:
xor ecx, ecx
xor r13d, r13d
jmp loc_81362
loc_8141F:
mov cl, dil
lea ecx, ds:0FFFFFFFFFFFFFFFFh[rcx*2]
mov [rsp+0D8h+var_98], ecx
or [rsp+0D8h+var_B0], rax
loc_81432:
mov r14d, r14d
mov rdi, rbx
mov rsi, r15
mov rdx, r12
mov rcx, r14
xor r8d, r8d
call JS_GetPropertyValue
mov rbp, rax
mov r13, rdx
cmp r13d, 6
jz loc_81517
mov [rsp+0D8h+var_68], rbp
mov [rsp+0D8h+var_60], r13
mov [rsp+0D8h+var_58], r14
mov [rsp+0D8h+var_50], 0
mov [rsp+0D8h+var_48], r15
mov [rsp+0D8h+var_40], r12
mov dword ptr [rsp+0D8h+var_78], 0
mov qword ptr [rsp+0D8h+var_78+8], 3
movups xmm0, [rsp+0D8h+var_78]
movups [rsp+0D8h+var_D8], xmm0
lea rax, [rsp+0D8h+var_68]
mov [rsp+0D8h+var_C8], rax
mov [rsp+0D8h+var_C0], 2
mov rdi, rbx
mov rsi, [rsp+0D8h+var_80]
mov rdx, [rsp+0D8h+var_88]
mov rcx, [rsp+0D8h+var_B0]
mov r8, [rsp+0D8h+var_90]
mov r9d, 3
call JS_CallInternal
cmp edx, 6
jz short loc_81517
mov rdi, rbx
mov rsi, rax
call JS_ToBoolFree
test eax, eax
jnz short loc_81539
mov rdi, [rbx+18h]
mov rsi, rbp
mov rdx, r13
call JS_FreeValueRT
add r14d, [rsp+0D8h+var_98]
cmp [rsp+0D8h+var_94], r14d
mov r12, [rsp+0D8h+var_A0]
mov r15, [rsp+0D8h+var_A8]
jnz loc_81432
jmp loc_813FF
loc_81517:
mov rcx, 0FFFFFFFF00000000h
mov rax, rbp
and rax, rcx
mov esi, ebp
jmp loc_81348
loc_8152E:
mov r13d, 3
jmp loc_8135D
loc_81539:
mov eax, [rsp+0D8h+var_B4]
or eax, 2
cmp eax, 3
jnz short loc_81559
mov rdi, [rbx+18h]
mov rsi, rbp
mov rdx, r13
call JS_FreeValueRT
jmp loc_81415
loc_81559:
mov rax, 0FFFFFFFF00000000h
mov rcx, rbp
and rcx, rax
mov r14, rbp
jmp loc_81362
| unsigned long long js_typed_array_find(
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)
{
int v14; // r12d
int v16; // r14d
int length_unsafe; // eax
double v18; // xmm4_8
double v19; // xmm5_8
long long v20; // r13
int v21; // ebp
long long v22; // r14
long long v23; // r12
double v24; // xmm4_8
double v25; // xmm5_8
long long v26; // rsi
unsigned long long v27; // rax
unsigned int v28; // r14d
unsigned long long v29; // rcx
long long v31; // rax
long long v32; // r12
long long v33; // r15
int v34; // ecx
int v35; // r9d
long long PropertyValue; // rax
long long v37; // rdx
__m128 v38; // xmm4
__m128 v39; // xmm5
long long v40; // rbp
unsigned long long v41; // rax
long long v42; // rdx
int v43; // [rsp+24h] [rbp-B4h]
int v44; // [rsp+28h] [rbp-B0h]
unsigned long long v45; // [rsp+28h] [rbp-B0h]
long long v46; // [rsp+28h] [rbp-B0h]
int v48; // [rsp+40h] [rbp-98h]
int v49; // [rsp+44h] [rbp-94h]
long long v50; // [rsp+48h] [rbp-90h]
long long v51; // [rsp+50h] [rbp-88h]
long long v52; // [rsp+58h] [rbp-80h]
__m128 v53; // [rsp+60h] [rbp-78h]
_QWORD v54[13]; // [rsp+70h] [rbp-68h] BYREF
v14 = a6;
v16 = a4;
length_unsafe = js_typed_array_get_length_unsafe(a1, a2, a3, a4, (long long)a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
v20 = 3LL;
if ( length_unsafe < 0
|| (v21 = length_unsafe,
v43 = v14,
v44 = v16,
v22 = *a5,
v23 = a5[1],
(unsigned int)check_function(a1, *a5, v23, a7, a8, a9, a10, v18, v19, a13, a14)) )
{
v26 = 0LL;
v27 = 0LL;
LABEL_4:
JS_FreeValueRT(*(_QWORD *)(a1 + 24), (_DWORD *)(v27 | v26), v20);
goto LABEL_5;
}
v51 = v23;
v52 = v22;
v28 = 0;
if ( v44 < 2 )
{
v50 = 3LL;
v31 = 0LL;
v45 = 0LL;
}
else
{
v31 = a5[2];
v50 = a5[3];
v45 = v31 & 0xFFFFFFFF00000000LL;
v31 = (unsigned int)v31;
}
v32 = a3;
v33 = a2;
v34 = 0;
v35 = -1;
if ( (v43 & 0xFFFFFFFE) == 2 )
v28 = v21 - 1;
else
v35 = v21;
v49 = v35;
if ( v28 != v35 )
{
LOBYTE(v34) = (v43 & 0xFFFFFFFE) != 2;
v48 = 2 * v34 - 1;
v46 = v31 | v45;
while ( 1 )
{
PropertyValue = JS_GetPropertyValue(a1, v33, v32, (_DWORD *)v28, 0LL, a7, a8, a9, a10, v24, v25, a13, a14);
v40 = PropertyValue;
v20 = v37;
if ( (_DWORD)v37 == 6 )
goto LABEL_23;
v54[0] = PropertyValue;
v54[1] = v37;
v54[2] = v28;
v54[3] = 0LL;
v54[4] = v33;
v54[5] = v32;
v53.m128_i32[0] = 0;
v53.m128_u64[1] = 3LL;
a7 = v53;
v41 = JS_CallInternal(
a1,
v52,
v51,
v46,
v50,
3LL,
v53,
a8,
a9,
a10,
v38,
v39,
a13,
a14,
v53.m128_i8[0],
3,
(long long)v54,
2u);
if ( (_DWORD)v42 == 6 )
{
LABEL_23:
v27 = v40 & 0xFFFFFFFF00000000LL;
v26 = (unsigned int)v40;
goto LABEL_4;
}
if ( (unsigned int)JS_ToBoolFree(a1, v41, v42) )
break;
JS_FreeValueRT(*(_QWORD *)(a1 + 24), (_DWORD *)v40, v20);
v28 += v48;
v32 = a3;
v33 = a2;
if ( v49 == v28 )
goto LABEL_14;
}
if ( (v43 | 2) != 3 )
{
v29 = v40 & 0xFFFFFFFF00000000LL;
v28 = v40;
return v29 | v28;
}
JS_FreeValueRT(*(_QWORD *)(a1 + 24), (_DWORD *)v40, v20);
goto LABEL_16;
}
LABEL_14:
if ( (v43 | 2) == 3 )
{
v28 = -1;
LABEL_16:
v29 = 0LL;
return v29 | v28;
}
LABEL_5:
v28 = 0;
v29 = 0LL;
return v29 | v28;
}
| js_typed_array_find:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xa8
MOV R12D,R9D
MOV R15,R8
MOV R14D,ECX
MOV RBX,RDI
MOV qword ptr [RSP + 0x30],RSI
MOV qword ptr [RSP + 0x38],RDX
CALL 0x00177f2d
MOV R13D,0x3
TEST EAX,EAX
JS 0x00181344
MOV EBP,EAX
MOV dword ptr [RSP + 0x24],R12D
MOV dword ptr [RSP + 0x28],R14D
MOV R14,qword ptr [R15]
MOV R12,qword ptr [R15 + 0x8]
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R12
CALL 0x001415b1
TEST EAX,EAX
JZ 0x0018137d
LAB_00181344:
XOR ESI,ESI
XOR EAX,EAX
LAB_00181348:
OR RSI,RAX
MOV RDI,qword ptr [RBX + 0x18]
MOV RDX,R13
CALL 0x0011d8c6
MOV R13D,0x6
LAB_0018135d:
XOR R14D,R14D
XOR ECX,ECX
LAB_00181362:
MOV EAX,R14D
OR RAX,RCX
MOV RDX,R13
ADD RSP,0xa8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0018137d:
MOV qword ptr [RSP + 0x50],R12
MOV qword ptr [RSP + 0x58],R14
XOR R14D,R14D
CMP dword ptr [RSP + 0x28],0x2
JL 0x001813b4
MOV RAX,qword ptr [R15 + 0x10]
MOV RCX,qword ptr [R15 + 0x18]
MOV qword ptr [RSP + 0x48],RCX
MOV RCX,-0x100000000
AND RCX,RAX
MOV qword ptr [RSP + 0x28],RCX
MOV EAX,EAX
JMP 0x001813c9
LAB_001813b4:
MOV EAX,0x3
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV qword ptr [RSP + 0x28],0x0
LAB_001813c9:
MOV R12,qword ptr [RSP + 0x38]
MOV R15,qword ptr [RSP + 0x30]
MOV EDI,dword ptr [RSP + 0x24]
AND EDI,0xfffffffe
LEA R8D,[RBP + -0x1]
XOR ECX,ECX
CMP EDI,0x2
MOV R9D,0xffffffff
CMOVNZ R9D,EBP
SETNZ DIL
CMOVZ R14D,R8D
MOV dword ptr [RSP + 0x44],R9D
CMP R14D,R9D
JNZ 0x0018141f
LAB_001813ff:
MOV EAX,dword ptr [RSP + 0x24]
OR EAX,0x2
CMP EAX,0x3
JNZ 0x0018152e
MOV R14D,0xffffffff
LAB_00181415:
XOR ECX,ECX
XOR R13D,R13D
JMP 0x00181362
LAB_0018141f:
MOV CL,DIL
LEA ECX,[-0x1 + RCX*0x2]
MOV dword ptr [RSP + 0x40],ECX
OR qword ptr [RSP + 0x28],RAX
LAB_00181432:
MOV R14D,R14D
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R12
MOV RCX,R14
XOR R8D,R8D
CALL 0x0013fe2d
MOV RBP,RAX
MOV R13,RDX
CMP R13D,0x6
JZ 0x00181517
MOV qword ptr [RSP + 0x70],RBP
MOV qword ptr [RSP + 0x78],R13
MOV qword ptr [RSP + 0x80],R14
MOV qword ptr [RSP + 0x88],0x0
MOV qword ptr [RSP + 0x90],R15
MOV qword ptr [RSP + 0x98],R12
MOV dword ptr [RSP + 0x60],0x0
MOV qword ptr [RSP + 0x68],0x3
MOVUPS XMM0,xmmword ptr [RSP + 0x60]
MOVUPS xmmword ptr [RSP],XMM0
LEA RAX,[RSP + 0x70]
MOV qword ptr [RSP + 0x10],RAX
MOV dword ptr [RSP + 0x18],0x2
MOV RDI,RBX
MOV RSI,qword ptr [RSP + 0x58]
MOV RDX,qword ptr [RSP + 0x50]
MOV RCX,qword ptr [RSP + 0x28]
MOV R8,qword ptr [RSP + 0x48]
MOV R9D,0x3
CALL 0x001284ca
CMP EDX,0x6
JZ 0x00181517
MOV RDI,RBX
MOV RSI,RAX
CALL 0x00122d0d
TEST EAX,EAX
JNZ 0x00181539
MOV RDI,qword ptr [RBX + 0x18]
MOV RSI,RBP
MOV RDX,R13
CALL 0x0011d8c6
ADD R14D,dword ptr [RSP + 0x40]
CMP dword ptr [RSP + 0x44],R14D
MOV R12,qword ptr [RSP + 0x38]
MOV R15,qword ptr [RSP + 0x30]
JNZ 0x00181432
JMP 0x001813ff
LAB_00181517:
MOV RCX,-0x100000000
MOV RAX,RBP
AND RAX,RCX
MOV ESI,EBP
JMP 0x00181348
LAB_0018152e:
MOV R13D,0x3
JMP 0x0018135d
LAB_00181539:
MOV EAX,dword ptr [RSP + 0x24]
OR EAX,0x2
CMP EAX,0x3
JNZ 0x00181559
MOV RDI,qword ptr [RBX + 0x18]
MOV RSI,RBP
MOV RDX,R13
CALL 0x0011d8c6
JMP 0x00181415
LAB_00181559:
MOV RAX,-0x100000000
MOV RCX,RBP
AND RCX,RAX
MOV R14,RBP
JMP 0x00181362
|
int1 [16]
js_typed_array_find(long param_1,int8 param_2,int8 param_3,int param_4,
int8 *param_5,uint param_6)
{
int8 uVar1;
int8 uVar2;
int1 auVar3 [16];
uint uVar4;
int iVar5;
ulong uVar6;
uint uVar7;
int8 uVar8;
ulong uVar9;
uint uVar10;
ulong uVar11;
bool bVar12;
int1 auVar13 [12];
int1 auVar14 [16];
int1 auVar15 [16];
ulong local_b0;
int8 local_90;
int1 local_68 [16];
ulong local_58;
int8 local_50;
int8 local_48;
int8 local_40;
uVar4 = js_typed_array_get_length_unsafe();
uVar8 = 3;
if ((int)uVar4 < 0) {
LAB_00181344:
uVar6 = 0;
uVar9 = 0;
LAB_00181348:
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),uVar6 | uVar9,uVar8);
uVar9 = 6;
}
else {
uVar1 = *param_5;
uVar2 = param_5[1];
iVar5 = check_function(param_1,uVar1,uVar2);
if (iVar5 != 0) goto LAB_00181344;
if (param_4 < 2) {
local_90 = 3;
uVar9 = 0;
local_b0 = 0;
}
else {
local_90 = param_5[3];
local_b0 = param_5[2] & 0xffffffff00000000;
uVar9 = param_5[2] & 0xffffffff;
}
bVar12 = (param_6 & 0xfffffffe) != 2;
uVar7 = 0xffffffff;
if (bVar12) {
uVar7 = uVar4;
}
uVar10 = 0;
if (!bVar12) {
uVar10 = uVar4 - 1;
}
if (uVar10 != uVar7) {
do {
uVar11 = (ulong)uVar10;
auVar15 = JS_GetPropertyValue(param_1,param_2,param_3,uVar11,0);
uVar8 = auVar15._8_8_;
uVar6 = auVar15._0_8_;
if (auVar15._8_4_ == 6) {
LAB_00181517:
uVar9 = uVar6 & 0xffffffff00000000;
uVar6 = uVar6 & 0xffffffff;
goto LAB_00181348;
}
local_50 = 0;
local_58 = uVar11;
local_48 = param_2;
local_40 = param_3;
local_68 = auVar15;
auVar13 = JS_CallInternal(param_1,uVar1,uVar2,local_b0 | uVar9,local_90,3,0,3,local_68,2);
if (auVar13._8_4_ == 6) goto LAB_00181517;
iVar5 = JS_ToBoolFree(param_1,auVar13._0_8_);
if (iVar5 != 0) {
if ((param_6 | 2) != 3) {
uVar6 = uVar6 & 0xffffffff00000000;
goto LAB_00181362;
}
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),uVar6,uVar8);
goto LAB_00181415;
}
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),uVar6,uVar8);
uVar10 = uVar10 + (uint)bVar12 * 2 + -1;
} while (uVar7 != uVar10);
}
if ((param_6 | 2) == 3) {
uVar11 = 0xffffffff;
LAB_00181415:
uVar6 = 0;
auVar15._8_8_ = 0;
auVar15._0_8_ = uVar11;
goto LAB_00181362;
}
uVar9 = 3;
}
auVar3._8_8_ = 0;
auVar3._0_8_ = uVar9;
auVar15 = auVar3 << 0x40;
uVar6 = 0;
LAB_00181362:
auVar14._0_8_ = auVar15._0_8_ & 0xffffffff | uVar6;
auVar14._8_8_ = auVar15._8_8_;
return auVar14;
}
| |
29,282 | js_typed_array_find | bluesky950520[P]quickjs/quickjs.c | static JSValue js_typed_array_find(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int mode)
{
JSValue func, this_arg;
JSValue args[3];
JSValue val, index_val, res;
int len, k, end;
int dir;
val = JS_UNDEFINED;
len = js_typed_array_get_length_unsafe(ctx, this_val);
if (len < 0)
goto exception;
func = argv[0];
if (check_function(ctx, func))
goto exception;
this_arg = JS_UNDEFINED;
if (argc > 1)
this_arg = argv[1];
k = 0;
dir = 1;
end = len;
if (mode == ArrayFindLast || mode == ArrayFindLastIndex) {
k = len - 1;
dir = -1;
end = -1;
}
for(; k != end; k += dir) {
index_val = js_int32(k);
val = JS_GetPropertyValue(ctx, this_val, index_val);
if (JS_IsException(val))
goto exception;
args[0] = val;
args[1] = index_val;
args[2] = this_val;
res = JS_Call(ctx, func, this_arg, 3, args);
if (JS_IsException(res))
goto exception;
if (JS_ToBoolFree(ctx, res)) {
if (mode == ArrayFindIndex || mode == ArrayFindLastIndex) {
JS_FreeValue(ctx, val);
return index_val;
} else {
return val;
}
}
JS_FreeValue(ctx, val);
}
if (mode == ArrayFindIndex || mode == ArrayFindLastIndex)
return js_int32(-1);
else
return JS_UNDEFINED;
exception:
JS_FreeValue(ctx, val);
return JS_EXCEPTION;
} | O3 | c | js_typed_array_find:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %r9d, %ebx
movq %r8, %rbp
movl %ecx, %r12d
movq %rsi, %r13
movq %rdi, %r15
movq %rdx, 0x38(%rsp)
callq 0x7a99c
movl $0x6, %edx
testl %eax, %eax
js 0x84016
movl %eax, %r14d
movl %ebx, 0x24(%rsp)
movq %r13, 0x28(%rsp)
movq (%rbp), %r13
movq 0x8(%rbp), %rbx
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x42f63
testl %eax, %eax
je 0x83e3c
xorl %ebx, %ebx
xorl %ecx, %ecx
movl $0x6, %edx
jmp 0x8401a
movq %rbx, 0x50(%rsp)
movq %r13, 0x58(%rsp)
xorl %ebx, %ebx
cmpl $0x2, %r12d
jl 0x83e71
movq 0x10(%rbp), %rax
movq 0x18(%rbp), %rcx
movq %rcx, 0x48(%rsp)
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rax, %rcx
movq %rcx, 0x30(%rsp)
movl %eax, %eax
jmp 0x83e86
movl $0x3, %eax
movq %rax, 0x48(%rsp)
xorl %eax, %eax
movq $0x0, 0x30(%rsp)
movq 0x38(%rsp), %r12
movq 0x28(%rsp), %r13
movl 0x24(%rsp), %edi
andl $-0x2, %edi
leal -0x1(%r14), %esi
xorl %ecx, %ecx
cmpl $0x2, %edi
movl $0xffffffff, %r8d # imm = 0xFFFFFFFF
cmovnel %r14d, %r8d
setne %dil
cmovel %esi, %ebx
movl %r8d, 0x28(%rsp)
cmpl %r8d, %ebx
jne 0x83ed9
movl 0x24(%rsp), %eax
orl $0x2, %eax
cmpl $0x3, %eax
jne 0x84011
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
xorl %edx, %edx
jmp 0x8401a
movb %dil, %cl
leal -0x1(,%rcx,2), %ecx
movl %ecx, 0x44(%rsp)
orq %rax, 0x30(%rsp)
movl %ebx, %ebx
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x416b3
movq %rax, %rbp
movq %rdx, %r14
cmpl $0x6, %r14d
je 0x83fe1
movq %rbp, 0x70(%rsp)
movq %r14, 0x78(%rsp)
movq %rbx, 0x80(%rsp)
movq $0x0, 0x88(%rsp)
movq %r13, 0x90(%rsp)
movq %r12, 0x98(%rsp)
movl $0x0, 0x60(%rsp)
movq $0x3, 0x68(%rsp)
movups 0x60(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x2, 0x18(%rsp)
movq %r15, %rdi
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x48(%rsp), %r8
movl $0x3, %r9d
callq 0x28b06
cmpl $0x6, %edx
je 0x83fe1
movq %r15, %rdi
movq %rax, %rsi
callq 0x2356a
testl %eax, %eax
jne 0x84031
cmpl $-0x9, %r14d
jb 0x83fc9
movq 0x18(%r15), %rdi
movl (%rbp), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rbp)
cmpl $0x1, %eax
jg 0x83fc9
movq %rbp, %rsi
movq %r14, %rdx
callq 0x219cc
addl 0x44(%rsp), %ebx
cmpl %ebx, 0x28(%rsp)
movq 0x38(%rsp), %r12
jne 0x83eec
jmp 0x83ebb
cmpl $-0x9, %r14d
jb 0x83e2e
movq 0x18(%r15), %rdi
movl (%rbp), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rbp)
cmpl $0x1, %eax
jg 0x83e2e
movq %rbp, %rsi
movq %r14, %rdx
callq 0x219cc
jmp 0x83e2e
movl $0x3, %edx
xorl %ebx, %ebx
xorl %ecx, %ecx
movl %ebx, %eax
orq %rcx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x24(%rsp), %eax
orl $0x2, %eax
cmpl $0x3, %eax
jne 0x8406d
cmpl $-0x9, %r14d
jb 0x83ed0
movq 0x18(%r15), %rdi
movl (%rbp), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rbp)
cmpl $0x1, %eax
jg 0x83ed0
movq %rbp, %rsi
movq %r14, %rdx
callq 0x219cc
jmp 0x83ed0
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %rbp, %rcx
andq %rax, %rcx
movq %rbp, %rbx
movq %r14, %rdx
jmp 0x8401a
| js_typed_array_find:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0A8h
mov ebx, r9d
mov rbp, r8
mov r12d, ecx
mov r13, rsi
mov r15, rdi
mov [rsp+0D8h+var_A0], rdx
call js_typed_array_get_length_unsafe
mov edx, 6
test eax, eax
js loc_84016
mov r14d, eax
mov [rsp+0D8h+var_B4], ebx
mov [rsp+0D8h+var_B0], r13
mov r13, [rbp+0]
mov rbx, [rbp+8]
mov rdi, r15
mov rsi, r13
mov rdx, rbx
call check_function
test eax, eax
jz short loc_83E3C
loc_83E2E:
xor ebx, ebx
xor ecx, ecx
mov edx, 6
jmp loc_8401A
loc_83E3C:
mov [rsp+0D8h+var_88], rbx
mov [rsp+0D8h+var_80], r13
xor ebx, ebx
cmp r12d, 2
jl short loc_83E71
mov rax, [rbp+10h]
mov rcx, [rbp+18h]
mov [rsp+0D8h+var_90], rcx
mov rcx, 0FFFFFFFF00000000h
and rcx, rax
mov [rsp+0D8h+var_A8], rcx
mov eax, eax
jmp short loc_83E86
loc_83E71:
mov eax, 3
mov [rsp+0D8h+var_90], rax
xor eax, eax
mov [rsp+0D8h+var_A8], 0
loc_83E86:
mov r12, [rsp+0D8h+var_A0]
mov r13, [rsp+0D8h+var_B0]
mov edi, [rsp+0D8h+var_B4]
and edi, 0FFFFFFFEh
lea esi, [r14-1]
xor ecx, ecx
cmp edi, 2
mov r8d, 0FFFFFFFFh
cmovnz r8d, r14d
setnz dil
cmovz ebx, esi
mov dword ptr [rsp+0D8h+var_B0], r8d
cmp ebx, r8d
jnz short loc_83ED9
loc_83EBB:
mov eax, [rsp+0D8h+var_B4]
or eax, 2
cmp eax, 3
jnz loc_84011
mov ebx, 0FFFFFFFFh
loc_83ED0:
xor ecx, ecx
xor edx, edx
jmp loc_8401A
loc_83ED9:
mov cl, dil
lea ecx, ds:0FFFFFFFFFFFFFFFFh[rcx*2]
mov [rsp+0D8h+var_94], ecx
or [rsp+0D8h+var_A8], rax
loc_83EEC:
mov ebx, ebx
mov rdi, r15
mov rsi, r13
mov rdx, r12
mov rcx, rbx
xor r8d, r8d
call JS_GetPropertyValue
mov rbp, rax
mov r14, rdx
cmp r14d, 6
jz loc_83FE1
mov [rsp+0D8h+var_68], rbp
mov [rsp+0D8h+var_60], r14
mov [rsp+0D8h+var_58], rbx
mov [rsp+0D8h+var_50], 0
mov [rsp+0D8h+var_48], r13
mov [rsp+0D8h+var_40], r12
mov dword ptr [rsp+0D8h+var_78], 0
mov qword ptr [rsp+0D8h+var_78+8], 3
movups xmm0, [rsp+0D8h+var_78]
movups [rsp+0D8h+var_D8], xmm0
lea rax, [rsp+0D8h+var_68]
mov [rsp+0D8h+var_C8], rax
mov [rsp+0D8h+var_C0], 2
mov rdi, r15
mov rsi, [rsp+0D8h+var_80]
mov rdx, [rsp+0D8h+var_88]
mov rcx, [rsp+0D8h+var_A8]
mov r8, [rsp+0D8h+var_90]
mov r9d, 3
call JS_CallInternal
cmp edx, 6
jz short loc_83FE1
mov rdi, r15
mov rsi, rax
call JS_ToBoolFree
test eax, eax
jnz loc_84031
cmp r14d, 0FFFFFFF7h
jb short loc_83FC9
mov rdi, [r15+18h]
mov eax, [rbp+0]
lea ecx, [rax-1]
mov [rbp+0], ecx
cmp eax, 1
jg short loc_83FC9
mov rsi, rbp
mov rdx, r14
call js_free_value_rt
loc_83FC9:
add ebx, [rsp+0D8h+var_94]
cmp dword ptr [rsp+0D8h+var_B0], ebx
mov r12, [rsp+0D8h+var_A0]
jnz loc_83EEC
jmp loc_83EBB
loc_83FE1:
cmp r14d, 0FFFFFFF7h
jb loc_83E2E
mov rdi, [r15+18h]
mov eax, [rbp+0]
lea ecx, [rax-1]
mov [rbp+0], ecx
cmp eax, 1
jg loc_83E2E
mov rsi, rbp
mov rdx, r14
call js_free_value_rt
jmp loc_83E2E
loc_84011:
mov edx, 3
loc_84016:
xor ebx, ebx
xor ecx, ecx
loc_8401A:
mov eax, ebx
or rax, rcx
add rsp, 0A8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_84031:
mov eax, [rsp+0D8h+var_B4]
or eax, 2
cmp eax, 3
jnz short loc_8406D
cmp r14d, 0FFFFFFF7h
jb loc_83ED0
mov rdi, [r15+18h]
mov eax, [rbp+0]
lea ecx, [rax-1]
mov [rbp+0], ecx
cmp eax, 1
jg loc_83ED0
mov rsi, rbp
mov rdx, r14
call js_free_value_rt
jmp loc_83ED0
loc_8406D:
mov rax, 0FFFFFFFF00000000h
mov rcx, rbp
and rcx, rax
mov rbx, rbp
mov rdx, r14
jmp short loc_8401A
| unsigned long long js_typed_array_find(
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)
{
int v14; // ebx
int v16; // r12d
int length_unsafe; // eax
long long v19; // rcx
long long v20; // r8
long long v21; // r9
__m128 v22; // xmm4
__m128 v23; // xmm5
int v24; // r14d
long long v25; // r13
long long v26; // rbx
long long v27; // r9
__m128 v28; // xmm4
__m128 v29; // xmm5
unsigned int v30; // ebx
unsigned long long v31; // rcx
long long v32; // rax
long long v33; // r12
int v34; // ecx
int v35; // r8d
unsigned long long PropertyValue; // rax
long long v37; // rdx
__m128 v38; // xmm4
__m128 v39; // xmm5
unsigned long long v40; // rbp
unsigned int v41; // r14d
unsigned long long v42; // rax
unsigned int v43; // edx
long long v44; // rdi
int v45; // eax
long long v46; // rdi
int v47; // eax
long long v49; // rdi
int v50; // eax
int v51; // [rsp+24h] [rbp-B4h]
int v52; // [rsp+28h] [rbp-B0h]
unsigned long long v53; // [rsp+30h] [rbp-A8h]
long long v54; // [rsp+30h] [rbp-A8h]
int v56; // [rsp+44h] [rbp-94h]
long long v57; // [rsp+48h] [rbp-90h]
long long v58; // [rsp+50h] [rbp-88h]
__m128i v59; // [rsp+60h] [rbp-78h]
_QWORD v60[13]; // [rsp+70h] [rbp-68h] BYREF
v14 = a6;
v16 = a4;
length_unsafe = js_typed_array_get_length_unsafe(a1, a2, a3, a4, (long long)a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
if ( length_unsafe < 0 )
goto LABEL_26;
v24 = length_unsafe;
v51 = v14;
v25 = *a5;
v26 = a5[1];
if ( !(unsigned int)check_function(a1, *a5, v26, v19, v20, v21, a7, a8, a9, a10, v22, v23, a13, a14) )
{
v58 = v26;
v30 = 0;
if ( v16 < 2 )
{
v57 = 3LL;
v32 = 0LL;
v53 = 0LL;
}
else
{
v32 = a5[2];
v57 = a5[3];
v53 = v32 & 0xFFFFFFFF00000000LL;
v32 = (unsigned int)v32;
}
v33 = a3;
v34 = 0;
v35 = -1;
if ( (v51 & 0xFFFFFFFE) == 2 )
v30 = v24 - 1;
else
v35 = v24;
v52 = v35;
if ( v30 != v35 )
{
LOBYTE(v34) = (v51 & 0xFFFFFFFE) != 2;
v56 = 2 * v34 - 1;
v54 = v32 | v53;
while ( 1 )
{
PropertyValue = JS_GetPropertyValue(a1, a2, v33, v30, 0LL, v27, a7, a8, a9, a10, v28, v29, a13, a14);
v40 = PropertyValue;
v41 = v37;
if ( (_DWORD)v37 == 6 )
goto LABEL_35;
v60[0] = PropertyValue;
v60[1] = v37;
v60[2] = v30;
v60[3] = 0LL;
v60[4] = a2;
v60[5] = v33;
v59.m128i_i32[0] = 0;
v59.m128i_i64[1] = 3LL;
a7 = (__m128)v59;
v42 = JS_CallInternal(
a1,
v25,
v58,
v54,
v57,
3LL,
v59,
a8,
a9,
a10,
v38,
v39,
a13,
a14,
v59.m128i_i8[0],
3,
(long long)v60,
2u);
if ( v43 == 6 )
{
LABEL_35:
if ( v41 >= 0xFFFFFFF7 )
{
v46 = *(_QWORD *)(a1 + 24);
v47 = (*(_DWORD *)v40)--;
if ( v47 <= 1 )
js_free_value_rt(v46, (_QWORD *)v40, v41);
}
goto LABEL_3;
}
if ( (unsigned int)JS_ToBoolFree(a1, v42, v43) )
break;
if ( v41 >= 0xFFFFFFF7 )
{
v44 = *(_QWORD *)(a1 + 24);
v45 = (*(_DWORD *)v40)--;
if ( v45 <= 1 )
js_free_value_rt(v44, (_QWORD *)v40, v41);
}
v30 += v56;
v33 = a3;
if ( v52 == v30 )
goto LABEL_11;
}
if ( (v51 | 2) != 3 )
{
v31 = v40 & 0xFFFFFFFF00000000LL;
v30 = v40;
return v31 | v30;
}
if ( v41 >= 0xFFFFFFF7 )
{
v49 = *(_QWORD *)(a1 + 24);
v50 = (*(_DWORD *)v40)--;
if ( v50 <= 1 )
js_free_value_rt(v49, (_QWORD *)v40, v41);
}
goto LABEL_13;
}
LABEL_11:
if ( (v51 | 2) == 3 )
{
v30 = -1;
LABEL_13:
v31 = 0LL;
return v31 | v30;
}
LABEL_26:
v30 = 0;
v31 = 0LL;
return v31 | v30;
}
LABEL_3:
v30 = 0;
v31 = 0LL;
return v31 | v30;
}
| js_typed_array_find:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xa8
MOV EBX,R9D
MOV RBP,R8
MOV R12D,ECX
MOV R13,RSI
MOV R15,RDI
MOV qword ptr [RSP + 0x38],RDX
CALL 0x0017a99c
MOV EDX,0x6
TEST EAX,EAX
JS 0x00184016
MOV R14D,EAX
MOV dword ptr [RSP + 0x24],EBX
MOV qword ptr [RSP + 0x28],R13
MOV R13,qword ptr [RBP]
MOV RBX,qword ptr [RBP + 0x8]
MOV RDI,R15
MOV RSI,R13
MOV RDX,RBX
CALL 0x00142f63
TEST EAX,EAX
JZ 0x00183e3c
LAB_00183e2e:
XOR EBX,EBX
XOR ECX,ECX
MOV EDX,0x6
JMP 0x0018401a
LAB_00183e3c:
MOV qword ptr [RSP + 0x50],RBX
MOV qword ptr [RSP + 0x58],R13
XOR EBX,EBX
CMP R12D,0x2
JL 0x00183e71
MOV RAX,qword ptr [RBP + 0x10]
MOV RCX,qword ptr [RBP + 0x18]
MOV qword ptr [RSP + 0x48],RCX
MOV RCX,-0x100000000
AND RCX,RAX
MOV qword ptr [RSP + 0x30],RCX
MOV EAX,EAX
JMP 0x00183e86
LAB_00183e71:
MOV EAX,0x3
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV qword ptr [RSP + 0x30],0x0
LAB_00183e86:
MOV R12,qword ptr [RSP + 0x38]
MOV R13,qword ptr [RSP + 0x28]
MOV EDI,dword ptr [RSP + 0x24]
AND EDI,0xfffffffe
LEA ESI,[R14 + -0x1]
XOR ECX,ECX
CMP EDI,0x2
MOV R8D,0xffffffff
CMOVNZ R8D,R14D
SETNZ DIL
CMOVZ EBX,ESI
MOV dword ptr [RSP + 0x28],R8D
CMP EBX,R8D
JNZ 0x00183ed9
LAB_00183ebb:
MOV EAX,dword ptr [RSP + 0x24]
OR EAX,0x2
CMP EAX,0x3
JNZ 0x00184011
MOV EBX,0xffffffff
LAB_00183ed0:
XOR ECX,ECX
XOR EDX,EDX
JMP 0x0018401a
LAB_00183ed9:
MOV CL,DIL
LEA ECX,[-0x1 + RCX*0x2]
MOV dword ptr [RSP + 0x44],ECX
OR qword ptr [RSP + 0x30],RAX
LAB_00183eec:
MOV EBX,EBX
MOV RDI,R15
MOV RSI,R13
MOV RDX,R12
MOV RCX,RBX
XOR R8D,R8D
CALL 0x001416b3
MOV RBP,RAX
MOV R14,RDX
CMP R14D,0x6
JZ 0x00183fe1
MOV qword ptr [RSP + 0x70],RBP
MOV qword ptr [RSP + 0x78],R14
MOV qword ptr [RSP + 0x80],RBX
MOV qword ptr [RSP + 0x88],0x0
MOV qword ptr [RSP + 0x90],R13
MOV qword ptr [RSP + 0x98],R12
MOV dword ptr [RSP + 0x60],0x0
MOV qword ptr [RSP + 0x68],0x3
MOVUPS XMM0,xmmword ptr [RSP + 0x60]
MOVUPS xmmword ptr [RSP],XMM0
LEA RAX,[RSP + 0x70]
MOV qword ptr [RSP + 0x10],RAX
MOV dword ptr [RSP + 0x18],0x2
MOV RDI,R15
MOV RSI,qword ptr [RSP + 0x58]
MOV RDX,qword ptr [RSP + 0x50]
MOV RCX,qword ptr [RSP + 0x30]
MOV R8,qword ptr [RSP + 0x48]
MOV R9D,0x3
CALL 0x00128b06
CMP EDX,0x6
JZ 0x00183fe1
MOV RDI,R15
MOV RSI,RAX
CALL 0x0012356a
TEST EAX,EAX
JNZ 0x00184031
CMP R14D,-0x9
JC 0x00183fc9
MOV RDI,qword ptr [R15 + 0x18]
MOV EAX,dword ptr [RBP]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RBP],ECX
CMP EAX,0x1
JG 0x00183fc9
MOV RSI,RBP
MOV RDX,R14
CALL 0x001219cc
LAB_00183fc9:
ADD EBX,dword ptr [RSP + 0x44]
CMP dword ptr [RSP + 0x28],EBX
MOV R12,qword ptr [RSP + 0x38]
JNZ 0x00183eec
JMP 0x00183ebb
LAB_00183fe1:
CMP R14D,-0x9
JC 0x00183e2e
MOV RDI,qword ptr [R15 + 0x18]
MOV EAX,dword ptr [RBP]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RBP],ECX
CMP EAX,0x1
JG 0x00183e2e
MOV RSI,RBP
MOV RDX,R14
CALL 0x001219cc
JMP 0x00183e2e
LAB_00184011:
MOV EDX,0x3
LAB_00184016:
XOR EBX,EBX
XOR ECX,ECX
LAB_0018401a:
MOV EAX,EBX
OR RAX,RCX
ADD RSP,0xa8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00184031:
MOV EAX,dword ptr [RSP + 0x24]
OR EAX,0x2
CMP EAX,0x3
JNZ 0x0018406d
CMP R14D,-0x9
JC 0x00183ed0
MOV RDI,qword ptr [R15 + 0x18]
MOV EAX,dword ptr [RBP]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RBP],ECX
CMP EAX,0x1
JG 0x00183ed0
MOV RSI,RBP
MOV RDX,R14
CALL 0x001219cc
JMP 0x00183ed0
LAB_0018406d:
MOV RAX,-0x100000000
MOV RCX,RBP
AND RCX,RAX
MOV RBX,RBP
MOV RDX,R14
JMP 0x0018401a
|
int1 [16]
js_typed_array_find(long param_1,int8 param_2,int8 param_3,int param_4,
int8 *param_5,uint param_6)
{
int8 uVar1;
int8 uVar2;
int8 uVar3;
int1 auVar4 [16];
uint uVar5;
int iVar6;
ulong uVar8;
ulong uVar9;
uint uVar11;
bool bVar12;
int1 auVar13 [12];
int1 auVar14 [16];
int1 auVar15 [16];
ulong local_a8;
int8 local_90;
int1 local_68 [16];
ulong local_58;
int8 local_50;
int8 local_48;
int8 local_40;
int *piVar7;
int8 uVar10;
uVar5 = js_typed_array_get_length_unsafe();
uVar9 = 6;
if (-1 < (int)uVar5) {
uVar1 = *param_5;
uVar2 = param_5[1];
iVar6 = check_function(param_1,uVar1,uVar2);
if (iVar6 != 0) {
LAB_00183e2e:
uVar8 = 0;
auVar14 = ZEXT816(6) << 0x40;
goto LAB_0018401a;
}
uVar9 = 0;
if (param_4 < 2) {
local_90 = 3;
uVar8 = 0;
local_a8 = 0;
}
else {
local_90 = param_5[3];
local_a8 = param_5[2] & 0xffffffff00000000;
uVar8 = param_5[2] & 0xffffffff;
}
bVar12 = (param_6 & 0xfffffffe) != 2;
if (!bVar12) {
uVar9 = (ulong)(uVar5 - 1);
uVar5 = 0xffffffff;
}
if ((uint)uVar9 != uVar5) {
do {
auVar14 = JS_GetPropertyValue(param_1,param_2,param_3,uVar9,0);
uVar10 = auVar14._8_8_;
piVar7 = auVar14._0_8_;
uVar11 = auVar14._8_4_;
if (uVar11 == 6) {
LAB_00183fe1:
if (0xfffffff6 < uVar11) {
uVar1 = *(int8 *)(param_1 + 0x18);
iVar6 = *piVar7;
*piVar7 = iVar6 + -1;
if (iVar6 < 2) {
js_free_value_rt(uVar1,piVar7,uVar10);
}
}
goto LAB_00183e2e;
}
local_50 = 0;
local_58 = uVar9;
local_48 = param_2;
local_40 = param_3;
local_68 = auVar14;
auVar13 = JS_CallInternal(param_1,uVar1,uVar2,local_a8 | uVar8,local_90,3,0,3,local_68,2);
if (auVar13._8_4_ == 6) goto LAB_00183fe1;
iVar6 = JS_ToBoolFree(param_1,auVar13._0_8_);
if (iVar6 != 0) {
if ((param_6 | 2) == 3) {
if (0xfffffff6 < uVar11) {
uVar1 = *(int8 *)(param_1 + 0x18);
iVar6 = *piVar7;
*piVar7 = iVar6 + -1;
if (iVar6 < 2) {
js_free_value_rt(uVar1,piVar7,uVar10);
}
}
goto LAB_00183ed0;
}
uVar8 = (ulong)piVar7 & 0xffffffff00000000;
goto LAB_0018401a;
}
if (0xfffffff6 < uVar11) {
uVar3 = *(int8 *)(param_1 + 0x18);
iVar6 = *piVar7;
*piVar7 = iVar6 + -1;
if (iVar6 < 2) {
js_free_value_rt(uVar3,piVar7,uVar10);
}
}
uVar11 = (int)uVar9 + (uint)bVar12 * 2 + -1;
uVar9 = (ulong)uVar11;
} while (uVar5 != uVar11);
}
if ((param_6 | 2) == 3) {
uVar9 = 0xffffffff;
LAB_00183ed0:
uVar8 = 0;
auVar14._8_8_ = 0;
auVar14._0_8_ = uVar9;
goto LAB_0018401a;
}
uVar9 = 3;
}
auVar4._8_8_ = 0;
auVar4._0_8_ = uVar9;
auVar14 = auVar4 << 0x40;
uVar8 = 0;
LAB_0018401a:
auVar15._8_8_ = auVar14._8_8_;
auVar15._0_8_ = auVar14._0_8_ & 0xffffffff | uVar8;
return auVar15;
}
| |
29,283 | vsort_sequential_int | davidesantangelo[P]vsort/vsort.c | static void vsort_sequential_int(int *arr, int size)
{
if (!arr || size <= 1)
return;
// Use insertion sort if nearly sorted (check only for modest sizes)
if (size < thresholds.parallel_threshold / 2 && // Avoid check on very large arrays where it's less likely
size < thresholds.radix_threshold && // Avoid if radix sort will be chosen anyway
vsort_is_nearly_sorted_int(arr, size))
{
vsort_log_info("Array (int, size %d) appears nearly sorted, using insertion sort.", size);
insertion_sort_int(arr, 0, size - 1);
return;
}
// Use radix sort for large integer arrays
if (size >= thresholds.radix_threshold)
{
vsort_log_info("Using radix sort for large int array (size: %d)", size);
radix_sort_int(arr, size);
return;
}
// Default to quicksort
quicksort_int(arr, 0, size - 1);
} | O0 | c | vsort_sequential_int:
subq $0x48, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x171c
cmpl $0x1, 0x14(%rsp)
jg 0x1721
jmp 0x189b
movl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x69a9(%rip), %eax # 0x80d8
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0x10(%rsp), %eax
cmpl %ecx, %eax
jge 0x185a
movl 0x14(%rsp), %eax
cmpl 0x698d(%rip), %eax # 0x80dc
jge 0x185a
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x25d0
testb $0x1, %al
jne 0x176c
jmp 0x185a
movl 0x14(%rsp), %esi
leaq 0x3ee9(%rip), %rdi # 0x5660
movb $0x0, %al
callq 0x4190
movq 0x18(%rsp), %rcx
movl 0x14(%rsp), %eax
subl $0x1, %eax
movq %rcx, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
movl %eax, 0x38(%rsp)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x38(%rsp), %eax
jg 0x1858
movq 0x40(%rsp), %rax
movslq 0x34(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x30(%rsp)
movl 0x34(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x2c(%rsp)
movq 0x40(%rsp), %rax
movslq 0x2c(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movl 0x2c(%rsp), %ecx
xorl %eax, %eax
cmpl 0x3c(%rsp), %ecx
movb %al, 0xf(%rsp)
jl 0x1808
movq 0x20(%rsp), %rax
movl (%rax), %eax
cmpl 0x30(%rsp), %eax
setg %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x1812
jmp 0x183c
movq 0x20(%rsp), %rax
movl (%rax), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x4(%rax)
movl 0x2c(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x2c(%rsp)
movq 0x20(%rsp), %rax
addq $-0x4, %rax
movq %rax, 0x20(%rsp)
jmp 0x17e6
movl 0x30(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x4(%rax)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x17a6
jmp 0x189b
movl 0x14(%rsp), %eax
cmpl 0x6878(%rip), %eax # 0x80dc
jl 0x1888
movl 0x14(%rsp), %esi
leaq 0x3e31(%rip), %rdi # 0x56a2
movb $0x0, %al
callq 0x4190
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x2770
jmp 0x189b
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %edx
subl $0x1, %edx
xorl %esi, %esi
callq 0x2c80
addq $0x48, %rsp
retq
| vsort_sequential_int:
sub rsp, 48h
mov [rsp+48h+var_30], rdi
mov [rsp+48h+var_34], esi
cmp [rsp+48h+var_30], 0
jz short loc_171C
cmp [rsp+48h+var_34], 1
jg short loc_1721
loc_171C:
jmp loc_189B
loc_1721:
mov eax, [rsp+48h+var_34]
mov [rsp+48h+var_38], eax
mov eax, cs:dword_80D8
mov ecx, 2
cdq
idiv ecx
mov ecx, eax
mov eax, [rsp+48h+var_38]
cmp eax, ecx
jge loc_185A
mov eax, [rsp+48h+var_34]
cmp eax, cs:dword_80DC
jge loc_185A
mov rdi, [rsp+48h+var_30]
mov esi, [rsp+48h+var_34]
call vsort_is_nearly_sorted_int
test al, 1
jnz short loc_176C
jmp loc_185A
loc_176C:
mov esi, [rsp+48h+var_34]
lea rdi, aArrayIntSizeDA; "Array (int, size %d) appears nearly sor"...
mov al, 0
call vsort_log_info
mov rcx, [rsp+48h+var_30]
mov eax, [rsp+48h+var_34]
sub eax, 1
mov [rsp+48h+var_8], rcx
mov [rsp+48h+var_C], 0
mov [rsp+48h+var_10], eax
mov eax, [rsp+48h+var_C]
add eax, 1
mov [rsp+48h+var_14], eax
loc_17A6:
mov eax, [rsp+48h+var_14]
cmp eax, [rsp+48h+var_10]
jg loc_1858
mov rax, [rsp+48h+var_8]
movsxd rcx, [rsp+48h+var_14]
mov eax, [rax+rcx*4]
mov [rsp+48h+var_18], eax
mov eax, [rsp+48h+var_14]
sub eax, 1
mov [rsp+48h+var_1C], eax
mov rax, [rsp+48h+var_8]
movsxd rcx, [rsp+48h+var_1C]
shl rcx, 2
add rax, rcx
mov [rsp+48h+var_28], rax
loc_17E6:
mov ecx, [rsp+48h+var_1C]
xor eax, eax
cmp ecx, [rsp+48h+var_C]
mov [rsp+48h+var_39], al
jl short loc_1808
mov rax, [rsp+48h+var_28]
mov eax, [rax]
cmp eax, [rsp+48h+var_18]
setnle al
mov [rsp+48h+var_39], al
loc_1808:
mov al, [rsp+48h+var_39]
test al, 1
jnz short loc_1812
jmp short loc_183C
loc_1812:
mov rax, [rsp+48h+var_28]
mov ecx, [rax]
mov rax, [rsp+48h+var_28]
mov [rax+4], ecx
mov eax, [rsp+48h+var_1C]
add eax, 0FFFFFFFFh
mov [rsp+48h+var_1C], eax
mov rax, [rsp+48h+var_28]
add rax, 0FFFFFFFFFFFFFFFCh
mov [rsp+48h+var_28], rax
jmp short loc_17E6
loc_183C:
mov ecx, [rsp+48h+var_18]
mov rax, [rsp+48h+var_28]
mov [rax+4], ecx
mov eax, [rsp+48h+var_14]
add eax, 1
mov [rsp+48h+var_14], eax
jmp loc_17A6
loc_1858:
jmp short loc_189B
loc_185A:
mov eax, [rsp+48h+var_34]
cmp eax, cs:dword_80DC
jl short loc_1888
mov esi, [rsp+48h+var_34]
lea rdi, aUsingRadixSort; "Using radix sort for large int array (s"...
mov al, 0
call vsort_log_info
mov rdi, [rsp+48h+var_30]
mov esi, [rsp+48h+var_34]
call radix_sort_int
jmp short loc_189B
loc_1888:
mov rdi, [rsp+48h+var_30]
mov edx, [rsp+48h+var_34]
sub edx, 1
xor esi, esi
call quicksort_int
loc_189B:
add rsp, 48h
retn
| void vsort_sequential_int(long long a1, int a2, long long a3, long long a4, int a5, int a6)
{
long long v6; // rdx
int v7; // ecx
bool v8; // [rsp+Fh] [rbp-39h]
_DWORD *j; // [rsp+20h] [rbp-28h]
int v10; // [rsp+2Ch] [rbp-1Ch]
int v11; // [rsp+30h] [rbp-18h]
int i; // [rsp+34h] [rbp-14h]
if ( a1 && a2 > 1 )
{
v6 = (unsigned int)(dword_80D8 >> 31);
LODWORD(v6) = dword_80D8 % 2;
v7 = dword_80D8 / 2;
if ( a2 < dword_80D8 / 2 && a2 < dword_80DC && (vsort_is_nearly_sorted_int(a1, (unsigned int)a2, v6) & 1) != 0 )
{
vsort_log_info(
(unsigned int)"Array (int, size %d) appears nearly sorted, using insertion sort.",
a2,
v6,
v7,
a5,
a6);
for ( i = 1; i <= a2 - 1; ++i )
{
v11 = *(_DWORD *)(a1 + 4LL * i);
v10 = i - 1;
for ( j = (_DWORD *)(4LL * (i - 1) + a1); ; --j )
{
v8 = 0;
if ( v10 >= 0 )
v8 = *j > v11;
if ( !v8 )
break;
j[1] = *j;
--v10;
}
j[1] = v11;
}
}
else if ( a2 < dword_80DC )
{
quicksort_int(a1, 0LL, (unsigned int)(a2 - 1));
}
else
{
vsort_log_info((unsigned int)"Using radix sort for large int array (size: %d)", a2, v6, v7, a5, a6);
radix_sort_int(a1, (unsigned int)a2);
}
}
}
| vsort_sequential_int:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV dword ptr [RSP + 0xc],ESI
CMP qword ptr [RSP + 0x10],0x0
JZ 0x0010171c
CMP dword ptr [RSP + 0xc],0x1
JG 0x00101721
LAB_0010171c:
JMP 0x001017c9
LAB_00101721:
MOV EAX,dword ptr [RSP + 0xc]
MOV dword ptr [RSP + 0x8],EAX
MOV EAX,dword ptr [0x001060c8]
MOV ECX,0x2
CDQ
IDIV ECX
MOV ECX,EAX
MOV EAX,dword ptr [RSP + 0x8]
CMP EAX,ECX
JGE 0x00101788
MOV EAX,dword ptr [RSP + 0xc]
CMP EAX,dword ptr [0x001060cc]
JGE 0x00101788
MOV RDI,qword ptr [RSP + 0x10]
MOV ESI,dword ptr [RSP + 0xc]
CALL 0x00102420
TEST AL,0x1
JNZ 0x00101761
JMP 0x00101788
LAB_00101761:
MOV ESI,dword ptr [RSP + 0xc]
LEA RDI,[0x104660]
MOV AL,0x0
CALL 0x00103960
MOV RDI,qword ptr [RSP + 0x10]
MOV EDX,dword ptr [RSP + 0xc]
SUB EDX,0x1
XOR ESI,ESI
CALL 0x001025c0
JMP 0x001017c9
LAB_00101788:
MOV EAX,dword ptr [RSP + 0xc]
CMP EAX,dword ptr [0x001060cc]
JL 0x001017b6
MOV ESI,dword ptr [RSP + 0xc]
LEA RDI,[0x1046a2]
MOV AL,0x0
CALL 0x00103960
MOV RDI,qword ptr [RSP + 0x10]
MOV ESI,dword ptr [RSP + 0xc]
CALL 0x00102690
JMP 0x001017c9
LAB_001017b6:
MOV RDI,qword ptr [RSP + 0x10]
MOV EDX,dword ptr [RSP + 0xc]
SUB EDX,0x1
XOR ESI,ESI
CALL 0x00102ba0
LAB_001017c9:
ADD RSP,0x18
RET
|
void vsort_sequential_int(long param_1,int param_2)
{
ulong uVar1;
if ((param_1 != 0) && (1 < param_2)) {
if ((param_2 < DAT_001060c8 / 2) &&
((param_2 < DAT_001060cc &&
(uVar1 = vsort_is_nearly_sorted_int(param_1,param_2,(long)DAT_001060c8 % 2 & 0xffffffff),
(uVar1 & 1) != 0)))) {
vsort_log_info("Array (int, size %d) appears nearly sorted, using insertion sort.",param_2);
insertion_sort_int(param_1,0,param_2 + -1);
}
else if (param_2 < DAT_001060cc) {
quicksort_int(param_1,0,param_2 + -1);
}
else {
vsort_log_info("Using radix sort for large int array (size: %d)",param_2);
radix_sort_int(param_1,param_2);
}
}
return;
}
| |
29,284 | vsort_sequential_int | davidesantangelo[P]vsort/vsort.c | static void vsort_sequential_int(int *arr, int size)
{
if (!arr || size <= 1)
return;
// Use insertion sort if nearly sorted (check only for modest sizes)
if (size < thresholds.parallel_threshold / 2 && // Avoid check on very large arrays where it's less likely
size < thresholds.radix_threshold && // Avoid if radix sort will be chosen anyway
vsort_is_nearly_sorted_int(arr, size))
{
vsort_log_info("Array (int, size %d) appears nearly sorted, using insertion sort.", size);
insertion_sort_int(arr, 0, size - 1);
return;
}
// Use radix sort for large integer arrays
if (size >= thresholds.radix_threshold)
{
vsort_log_info("Using radix sort for large int array (size: %d)", size);
radix_sort_int(arr, size);
return;
}
// Default to quicksort
quicksort_int(arr, 0, size - 1);
} | O3 | c | vsort_sequential_int:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x438, %rsp # imm = 0x438
movl %esi, %r14d
movq %rdi, %r13
movl 0x4476(%rip), %ecx # 0x60e4
cmpl $0x14, %esi
jl 0x1d36
movl 0x4463(%rip), %eax # 0x60e0
movl %eax, %edx
shrl $0x1f, %edx
addl %eax, %edx
sarl %edx
cmpl %r14d, %edx
jle 0x1d36
cmpl %r14d, %ecx
jle 0x1d36
movzwl %r14w, %eax
imull $0xcccd, %eax, %eax # imm = 0xCCCD
shrl $0x14, %eax
cmpl $0xc8, %r14d
movl $0xa, %edx
cmovael %eax, %edx
cmpl $0x7e4, %r14d # imm = 0x7E4
movl $0x64, %esi
cmovbl %edx, %esi
xorl %edi, %edi
movl %r14d, %eax
xorl %edx, %edx
divl %esi
cmpl %r14d, %esi
movl $0x1, %edx
cmovbel %eax, %edx
cmpl %r14d, %edx
jae 0x1d36
movl %edx, %eax
addl %edx, %edx
leaq (,%rax,4), %r8
addq %r13, %r8
movl $0xffffffff, %r9d # imm = 0xFFFFFFFF
xorl %r10d, %r10d
movl %edi, %r11d
movl %r10d, %edi
movl (%r13,%rdi,4), %ebx
xorl %edi, %edi
cmpl (%r8,%r10,4), %ebx
setg %dil
addl %r11d, %edi
leal (%rdx,%r10), %ebx
leal 0x1(%r9), %r11d
cmpl %r14d, %ebx
jge 0x1d28
addl $0x2, %r9d
addq %rax, %r10
cmpl %esi, %r9d
movl %r11d, %r9d
jb 0x1cf4
addl %edi, %edi
leal (%rdi,%rdi,4), %eax
cmpl %r11d, %eax
jbe 0x1f0c
cmpl %r14d, %ecx
jg 0x1eed
leaq 0x1945(%rip), %rdi # 0x368b
movl %r14d, %esi
xorl %eax, %eax
callq 0x28e3
movl (%r13), %ebx
movl %r14d, %r12d
cmpl $0x2, %r14d
jl 0x1d80
movl $0x1, %eax
movl %ebx, %r15d
movl (%r13,%rax,4), %ecx
cmpl %ebx, %ecx
cmovgl %ecx, %ebx
cmpl %r15d, %ecx
cmovll %ecx, %r15d
incq %rax
cmpq %rax, %r12
jne 0x1d65
jmp 0x1d83
movl %ebx, %r15d
leaq (,%r12,4), %rbp
movq %rbp, %rdi
callq 0x1140
testq %rax, %rax
je 0x1edf
movl %r15d, %edi
negl %edi
movq %r13, %rdx
movl %r15d, %r13d
sarl $0x1f, %r13d
andl %r13d, %edi
testl %r14d, %r14d
jle 0x1dc5
xorl %esi, %esi
movl (%rdx,%rsi,4), %ecx
addl %edi, %ecx
movl %ecx, (%rax,%rsi,4)
incq %rsi
cmpq %rsi, %r12
jne 0x1db5
movl %edi, 0x14(%rsp)
movq %rax, 0x8(%rsp)
movq %rdx, 0x18(%rsp)
movq %rbp, %rdi
callq 0x1140
testq %rax, %rax
je 0x1f99
andl %r15d, %r13d
movl %ebx, %ecx
subl %r13d, %ecx
bsrl %ecx, %ecx
xorl $-0x20, %ecx
addl $0x28, %ecx
shrl $0x3, %ecx
cmpl %r13d, %ebx
movl $0x1, %edx
cmovnel %ecx, %edx
movl %edx, 0x4(%rsp)
leaq 0x1(%r12), %rcx
movq %rcx, 0x28(%rsp)
xorl %r13d, %r13d
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %r15
movq %rax, %rbx
leal (,%r13,8), %ebp
movl $0x400, %edx # imm = 0x400
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x10d0
movl $0x0, %eax
testl %r14d, %r14d
jle 0x1e61
xorl %eax, %eax
movl (%r15,%rax,4), %edx
movl %ebp, %ecx
shrl %cl, %edx
movzbl %dl, %ecx
incl 0x30(%rsp,%rcx,4)
incq %rax
cmpq %rax, %r12
jne 0x1e46
movl 0x30(%rsp), %eax
movl $0x1, %ecx
addl 0x30(%rsp,%rcx,4), %eax
movl %eax, 0x30(%rsp,%rcx,4)
incq %rcx
cmpq $0x100, %rcx # imm = 0x100
jne 0x1e66
movq 0x28(%rsp), %rax
testl %r14d, %r14d
jle 0x1ec6
movl -0x8(%r15,%rax,4), %edx
movl %edx, %esi
movl %ebp, %ecx
shrl %cl, %esi
movzbl %sil, %ecx
movslq 0x30(%rsp,%rcx,4), %rsi
leaq -0x1(%rsi), %rdi
movl %edi, 0x30(%rsp,%rcx,4)
movl %edx, -0x4(%rbx,%rsi,4)
decq %rax
cmpq $0x1, %rax
jg 0x1e84
incl %r13d
movq %r15, %rax
movq %rbx, %r15
cmpl 0x4(%rsp), %r13d
jne 0x1e1e
jmp 0x1f5a
incl %r13d
movq %r15, %rax
movq %rbx, %r15
cmpl 0x4(%rsp), %r13d
jne 0x1e1e
jmp 0x1f73
leaq 0x17d5(%rip), %rdi # 0x36bb
xorl %eax, %eax
callq 0x27bd
decl %r14d
movq %r13, %rdi
movl %r14d, %esi
addq $0x438, %rsp # imm = 0x438
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2406
leaq 0x1736(%rip), %rdi # 0x3649
xorl %ebx, %ebx
movl %r14d, %esi
xorl %eax, %eax
callq 0x28e3
decl %r14d
movl $0x1, %eax
movl (%r13,%rax,4), %ecx
leaq (,%rbx,4), %rdx
addq %r13, %rdx
movl %eax, %esi
movl (%rdx), %edi
cmpl %ecx, %edi
jle 0x1f4a
movl %edi, 0x4(%rdx)
addq $-0x4, %rdx
decl %esi
jg 0x1f39
movl %ecx, 0x4(%rdx)
incq %rax
incq %rbx
cmpq %r14, %rbx
jne 0x1f27
jmp 0x1f87
xorl %eax, %eax
movq 0x18(%rsp), %rdx
movl (%rbx,%rax,4), %ecx
subl 0x14(%rsp), %ecx
movl %ecx, (%rdx,%rax,4)
incq %rax
cmpq %rax, %r12
jne 0x1f61
movq 0x8(%rsp), %rdi
callq 0x1030
movq 0x20(%rsp), %rdi
callq 0x1030
addq $0x438, %rsp # imm = 0x438
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x176a(%rip), %rdi # 0x370a
xorl %eax, %eax
callq 0x27bd
movq 0x8(%rsp), %rdi
callq 0x1030
decl %r14d
movq 0x18(%rsp), %rdi
jmp 0x1ef3
| vsort_sequential_int:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 438h
mov r14d, esi
mov r13, rdi
mov ecx, cs:thresholds_3
cmp esi, 14h
jl loc_1D36
mov eax, cs:thresholds_2
mov edx, eax
shr edx, 1Fh
add edx, eax
sar edx, 1
cmp edx, r14d
jle loc_1D36
cmp ecx, r14d
jle loc_1D36
movzx eax, r14w
imul eax, 0CCCDh
shr eax, 14h
cmp r14d, 0C8h
mov edx, 0Ah
cmovnb edx, eax
cmp r14d, 7E4h
mov esi, 64h ; 'd'
cmovb esi, edx
xor edi, edi
mov eax, r14d
xor edx, edx
div esi
cmp esi, r14d
mov edx, 1
cmovbe edx, eax
cmp edx, r14d
jnb short loc_1D36
mov eax, edx
add edx, edx
lea r8, ds:0[rax*4]
add r8, r13
mov r9d, 0FFFFFFFFh
xor r10d, r10d
loc_1CF4:
mov r11d, edi
mov edi, r10d
mov ebx, [r13+rdi*4+0]
xor edi, edi
cmp ebx, [r8+r10*4]
setnle dil
add edi, r11d
lea ebx, [rdx+r10]
lea r11d, [r9+1]
cmp ebx, r14d
jge short loc_1D28
add r9d, 2
add r10, rax
cmp r9d, esi
mov r9d, r11d
jb short loc_1CF4
loc_1D28:
add edi, edi
lea eax, [rdi+rdi*4]
cmp eax, r11d
jbe loc_1F0C
loc_1D36:
cmp ecx, r14d
jg loc_1EED
lea rdi, aUsingRadixSort; "Using radix sort for large int array (s"...
mov esi, r14d
xor eax, eax
call vsort_log_info
mov ebx, [r13+0]
mov r12d, r14d
cmp r14d, 2
jl short loc_1D80
mov eax, 1
mov r15d, ebx
loc_1D65:
mov ecx, [r13+rax*4+0]
cmp ecx, ebx
cmovg ebx, ecx
cmp ecx, r15d
cmovl r15d, ecx
inc rax
cmp r12, rax
jnz short loc_1D65
jmp short loc_1D83
loc_1D80:
mov r15d, ebx
loc_1D83:
lea rbp, ds:0[r12*4]
mov rdi, rbp
call _malloc
test rax, rax
jz loc_1EDF
mov edi, r15d
neg edi
mov rdx, r13
mov r13d, r15d
sar r13d, 1Fh
and edi, r13d
test r14d, r14d
jle short loc_1DC5
xor esi, esi
loc_1DB5:
mov ecx, [rdx+rsi*4]
add ecx, edi
mov [rax+rsi*4], ecx
inc rsi
cmp r12, rsi
jnz short loc_1DB5
loc_1DC5:
mov [rsp+468h+var_454], edi
mov [rsp+468h+var_460], rax
mov [rsp+468h+var_450], rdx
mov rdi, rbp
call _malloc
test rax, rax
jz loc_1F99
and r13d, r15d
mov ecx, ebx
sub ecx, r13d
bsr ecx, ecx
xor ecx, 0FFFFFFE0h
add ecx, 28h ; '('
shr ecx, 3
cmp ebx, r13d
mov edx, 1
cmovnz edx, ecx
mov [rsp+468h+var_464], edx
lea rcx, [r12+1]
mov [rsp+468h+var_440], rcx
xor r13d, r13d
mov [rsp+468h+var_448], rax
mov r15, [rsp+468h+var_460]
loc_1E1E:
mov rbx, rax
lea ebp, ds:0[r13*8]
mov edx, 400h
lea rdi, [rsp+468h+var_438]
xor esi, esi
call _memset
mov eax, 0
test r14d, r14d
jle short loc_1E61
xor eax, eax
loc_1E46:
mov edx, [r15+rax*4]
mov ecx, ebp
shr edx, cl
movzx ecx, dl
inc [rsp+rcx*4+468h+var_438]
inc rax
cmp r12, rax
jnz short loc_1E46
mov eax, [rsp+468h+var_438]
loc_1E61:
mov ecx, 1
loc_1E66:
add eax, [rsp+rcx*4+468h+var_438]
mov [rsp+rcx*4+468h+var_438], eax
inc rcx
cmp rcx, 100h
jnz short loc_1E66
mov rax, [rsp+468h+var_440]
test r14d, r14d
jle short loc_1EC6
loc_1E84:
mov edx, [r15+rax*4-8]
mov esi, edx
mov ecx, ebp
shr esi, cl
movzx ecx, sil
movsxd rsi, [rsp+rcx*4+468h+var_438]
lea rdi, [rsi-1]
mov [rsp+rcx*4+468h+var_438], edi
mov [rbx+rsi*4-4], edx
dec rax
cmp rax, 1
jg short loc_1E84
inc r13d
mov rax, r15
mov r15, rbx
cmp r13d, [rsp+468h+var_464]
jnz loc_1E1E
jmp loc_1F5A
loc_1EC6:
inc r13d
mov rax, r15
mov r15, rbx
cmp r13d, [rsp+468h+var_464]
jnz loc_1E1E
jmp loc_1F73
loc_1EDF:
lea rdi, aMemoryAllocati; "Memory allocation failed in radix_sort_"...
xor eax, eax
call vsort_log_error
loc_1EED:
dec r14d
mov rdi, r13
loc_1EF3:
mov esi, r14d
add rsp, 438h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp quicksort_int
loc_1F0C:
lea rdi, aArrayIntSizeDA; "Array (int, size %d) appears nearly sor"...
xor ebx, ebx
mov esi, r14d
xor eax, eax
call vsort_log_info
dec r14d
mov eax, 1
loc_1F27:
mov ecx, [r13+rax*4+0]
lea rdx, ds:0[rbx*4]
add rdx, r13
mov esi, eax
loc_1F39:
mov edi, [rdx]
cmp edi, ecx
jle short loc_1F4A
mov [rdx+4], edi
add rdx, 0FFFFFFFFFFFFFFFCh
dec esi
jg short loc_1F39
loc_1F4A:
mov [rdx+4], ecx
inc rax
inc rbx
cmp rbx, r14
jnz short loc_1F27
jmp short loc_1F87
loc_1F5A:
xor eax, eax
mov rdx, [rsp+468h+var_450]
loc_1F61:
mov ecx, [rbx+rax*4]
sub ecx, [rsp+468h+var_454]
mov [rdx+rax*4], ecx
inc rax
cmp r12, rax
jnz short loc_1F61
loc_1F73:
mov rdi, [rsp+468h+var_460]
call _free
mov rdi, [rsp+468h+var_448]
call _free
loc_1F87:
add rsp, 438h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1F99:
lea rdi, aMemoryAllocati_0; "Memory allocation failed in radix_sort_"...
xor eax, eax
call vsort_log_error
mov rdi, [rsp+468h+var_460]
call _free
dec r14d
mov rdi, [rsp+468h+var_450]
jmp loc_1EF3
| long long vsort_sequential_int(int *a1, int a2, unsigned int a3, long long a4, int *a5, int a6)
{
unsigned int v8; // edx
unsigned int v9; // esi
int v10; // edi
long long v11; // rax
long long v12; // r10
unsigned int v13; // r11d
bool v14; // cf
long long v15; // rsi
int v16; // ebx
long long v17; // rax
int v18; // r15d
int v19; // ecx
long long v20; // rax
int v21; // edx
int v22; // ecx
int v23; // r8d
int v24; // r9d
int v25; // edi
long long v26; // rax
int v27; // edx
int v28; // ecx
int v29; // r8d
int v30; // r9d
int v31; // r13d
unsigned int v32; // ecx
unsigned int v33; // ecx
int v34; // edx
int v35; // r13d
long long v36; // r15
long long v37; // rbx
char v38; // bp
int v39; // eax
long long v40; // rax
long long v41; // rcx
long long i; // rcx
long long v43; // rax
unsigned int v44; // edx
long long v45; // rcx
long long v46; // rsi
unsigned int v47; // r14d
int *v48; // rdi
long long result; // rax
long long v50; // rbx
int v51; // r14d
int v52; // ecx
int *v53; // rdx
int v54; // esi
long long v56; // rax
int v57; // [rsp+4h] [rbp-464h]
long long v58; // [rsp+8h] [rbp-460h]
int *v59; // [rsp+18h] [rbp-450h]
long long v60; // [rsp+20h] [rbp-448h]
_DWORD v61[270]; // [rsp+30h] [rbp-438h] BYREF
if ( a2 >= 20 )
{
a3 = thresholds_2 / 2;
if ( thresholds_2 / 2 > a2 && thresholds_3 > a2 )
{
v8 = 10;
if ( (unsigned int)a2 >= 0xC8 )
v8 = (unsigned __int16)a2 / 0x14u;
v9 = 100;
if ( (unsigned int)a2 < 0x7E4 )
v9 = v8;
v10 = 0;
a3 = 1;
if ( v9 <= a2 )
a3 = a2 / v9;
if ( a3 < a2 )
{
v11 = a3;
a3 *= 2;
a5 = &a1[v11];
a6 = -1;
v12 = 0LL;
do
{
v10 += a1[(unsigned int)v12] > a5[v12];
v13 = a6 + 1;
if ( (int)(a3 + v12) >= a2 )
break;
v12 += v11;
v14 = a6 + 2 < v9;
++a6;
}
while ( v14 );
if ( 10 * v10 <= v13 )
{
v50 = 0LL;
vsort_log_info(
(unsigned int)"Array (int, size %d) appears nearly sorted, using insertion sort.",
a2,
a3,
thresholds_3,
(_DWORD)a5,
a6);
v51 = a2 - 1;
result = 1LL;
do
{
v52 = a1[result];
v53 = &a1[v50];
v54 = result;
do
{
if ( *v53 <= v52 )
break;
v53[1] = *v53;
--v53;
}
while ( v54-- > 1 );
v53[1] = v52;
++result;
++v50;
}
while ( v50 != v51 );
return result;
}
}
}
}
if ( thresholds_3 > a2 )
goto LABEL_46;
LODWORD(v15) = a2;
vsort_log_info((unsigned int)"Using radix sort for large int array (size: %d)", a2, a3, thresholds_3, (_DWORD)a5, a6);
v16 = *a1;
if ( a2 < 2 )
{
v18 = *a1;
}
else
{
v17 = 1LL;
v18 = *a1;
do
{
v19 = a1[v17];
if ( v19 > v16 )
v16 = a1[v17];
if ( v19 < v18 )
v18 = a1[v17];
++v17;
}
while ( a2 != v17 );
}
v20 = malloc(4LL * (unsigned int)a2);
if ( !v20 )
{
vsort_log_error(
(unsigned int)"Memory allocation failed in radix_sort_int temp_arr, falling back to quicksort",
a2,
v21,
v22,
v23,
v24);
LABEL_46:
v47 = a2 - 1;
v48 = a1;
return quicksort_int(v48, v47);
}
v25 = (v18 >> 31) & -v18;
if ( a2 > 0 )
{
v15 = 0LL;
do
{
*(_DWORD *)(v20 + 4 * v15) = v25 + a1[v15];
++v15;
}
while ( a2 != v15 );
}
v58 = v20;
v59 = a1;
v26 = malloc(4LL * (unsigned int)a2);
if ( !v26 )
{
vsort_log_error(
(unsigned int)"Memory allocation failed in radix_sort_int output, falling back to quicksort",
v15,
v27,
v28,
v29,
v30);
free(v58);
v47 = a2 - 1;
v48 = a1;
return quicksort_int(v48, v47);
}
v31 = v18 & (v18 >> 31);
_BitScanReverse(&v32, v16 - v31);
v33 = ((v32 ^ 0xFFFFFFE0) + 40) >> 3;
v34 = 1;
if ( v16 != v31 )
v34 = v33;
v57 = v34;
v35 = 0;
v60 = v26;
v36 = v58;
do
{
while ( 1 )
{
v37 = v26;
v38 = 8 * v35;
memset(v61, 0LL, 1024LL);
v39 = 0;
if ( a2 > 0 )
{
v40 = 0LL;
do
{
v41 = (unsigned __int8)(*(_DWORD *)(v36 + 4 * v40) >> v38);
++v61[v41];
++v40;
}
while ( a2 != v40 );
v39 = v61[0];
}
for ( i = 1LL; i != 256; ++i )
{
v39 += v61[i];
v61[i] = v39;
}
v43 = (unsigned int)a2 + 1LL;
if ( a2 > 0 )
break;
++v35;
v26 = v36;
v36 = v37;
if ( v35 == v57 )
goto LABEL_55;
}
do
{
v44 = *(_DWORD *)(v36 + 4 * v43 - 8);
v45 = (unsigned __int8)(v44 >> v38);
v46 = (int)v61[v45];
v61[v45] = v46 - 1;
*(_DWORD *)(v37 + 4 * v46 - 4) = v44;
--v43;
}
while ( v43 > 1 );
++v35;
v26 = v36;
v36 = v37;
}
while ( v35 != v57 );
v56 = 0LL;
do
{
v59[v56] = *(_DWORD *)(v37 + 4 * v56) - v25;
++v56;
}
while ( a2 != v56 );
LABEL_55:
free(v58);
return free(v60);
}
| vsort_sequential_int:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x438
MOV R14D,ESI
MOV R13,RDI
MOV ECX,dword ptr [0x001060e4]
CMP ESI,0x14
JL 0x00101d36
MOV EAX,dword ptr [0x001060e0]
MOV EDX,EAX
SHR EDX,0x1f
ADD EDX,EAX
SAR EDX,0x1
CMP EDX,R14D
JLE 0x00101d36
CMP ECX,R14D
JLE 0x00101d36
MOVZX EAX,R14W
IMUL EAX,EAX,0xcccd
SHR EAX,0x14
CMP R14D,0xc8
MOV EDX,0xa
CMOVNC EDX,EAX
CMP R14D,0x7e4
MOV ESI,0x64
CMOVC ESI,EDX
XOR EDI,EDI
MOV EAX,R14D
XOR EDX,EDX
DIV ESI
CMP ESI,R14D
MOV EDX,0x1
CMOVBE EDX,EAX
CMP EDX,R14D
JNC 0x00101d36
MOV EAX,EDX
ADD EDX,EDX
LEA R8,[RAX*0x4]
ADD R8,R13
MOV R9D,0xffffffff
XOR R10D,R10D
LAB_00101cf4:
MOV R11D,EDI
MOV EDI,R10D
MOV EBX,dword ptr [R13 + RDI*0x4]
XOR EDI,EDI
CMP EBX,dword ptr [R8 + R10*0x4]
SETG DIL
ADD EDI,R11D
LEA EBX,[RDX + R10*0x1]
LEA R11D,[R9 + 0x1]
CMP EBX,R14D
JGE 0x00101d28
ADD R9D,0x2
ADD R10,RAX
CMP R9D,ESI
MOV R9D,R11D
JC 0x00101cf4
LAB_00101d28:
ADD EDI,EDI
LEA EAX,[RDI + RDI*0x4]
CMP EAX,R11D
JBE 0x00101f0c
LAB_00101d36:
CMP ECX,R14D
JG 0x00101eed
LEA RDI,[0x10368b]
MOV ESI,R14D
XOR EAX,EAX
CALL 0x001028e3
MOV EBX,dword ptr [R13]
MOV R12D,R14D
CMP R14D,0x2
JL 0x00101d80
MOV EAX,0x1
MOV R15D,EBX
LAB_00101d65:
MOV ECX,dword ptr [R13 + RAX*0x4]
CMP ECX,EBX
CMOVG EBX,ECX
CMP ECX,R15D
CMOVL R15D,ECX
INC RAX
CMP R12,RAX
JNZ 0x00101d65
JMP 0x00101d83
LAB_00101d80:
MOV R15D,EBX
LAB_00101d83:
LEA RBP,[R12*0x4]
MOV RDI,RBP
CALL 0x00101140
TEST RAX,RAX
JZ 0x00101edf
MOV EDI,R15D
NEG EDI
MOV RDX,R13
MOV R13D,R15D
SAR R13D,0x1f
AND EDI,R13D
TEST R14D,R14D
JLE 0x00101dc5
XOR ESI,ESI
LAB_00101db5:
MOV ECX,dword ptr [RDX + RSI*0x4]
ADD ECX,EDI
MOV dword ptr [RAX + RSI*0x4],ECX
INC RSI
CMP R12,RSI
JNZ 0x00101db5
LAB_00101dc5:
MOV dword ptr [RSP + 0x14],EDI
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x18],RDX
MOV RDI,RBP
CALL 0x00101140
TEST RAX,RAX
JZ 0x00101f99
AND R13D,R15D
MOV ECX,EBX
SUB ECX,R13D
BSR ECX,ECX
XOR ECX,0xffffffe0
ADD ECX,0x28
SHR ECX,0x3
CMP EBX,R13D
MOV EDX,0x1
CMOVNZ EDX,ECX
MOV dword ptr [RSP + 0x4],EDX
LEA RCX,[R12 + 0x1]
MOV qword ptr [RSP + 0x28],RCX
XOR R13D,R13D
MOV qword ptr [RSP + 0x20],RAX
MOV R15,qword ptr [RSP + 0x8]
LAB_00101e1e:
MOV RBX,RAX
LEA EBP,[R13*0x8]
MOV EDX,0x400
LEA RDI,[RSP + 0x30]
XOR ESI,ESI
CALL 0x001010d0
MOV EAX,0x0
TEST R14D,R14D
JLE 0x00101e61
XOR EAX,EAX
LAB_00101e46:
MOV EDX,dword ptr [R15 + RAX*0x4]
MOV ECX,EBP
SHR EDX,CL
MOVZX ECX,DL
INC dword ptr [RSP + RCX*0x4 + 0x30]
INC RAX
CMP R12,RAX
JNZ 0x00101e46
MOV EAX,dword ptr [RSP + 0x30]
LAB_00101e61:
MOV ECX,0x1
LAB_00101e66:
ADD EAX,dword ptr [RSP + RCX*0x4 + 0x30]
MOV dword ptr [RSP + RCX*0x4 + 0x30],EAX
INC RCX
CMP RCX,0x100
JNZ 0x00101e66
MOV RAX,qword ptr [RSP + 0x28]
TEST R14D,R14D
JLE 0x00101ec6
LAB_00101e84:
MOV EDX,dword ptr [R15 + RAX*0x4 + -0x8]
MOV ESI,EDX
MOV ECX,EBP
SHR ESI,CL
MOVZX ECX,SIL
MOVSXD RSI,dword ptr [RSP + RCX*0x4 + 0x30]
LEA RDI,[RSI + -0x1]
MOV dword ptr [RSP + RCX*0x4 + 0x30],EDI
MOV dword ptr [RBX + RSI*0x4 + -0x4],EDX
DEC RAX
CMP RAX,0x1
JG 0x00101e84
INC R13D
MOV RAX,R15
MOV R15,RBX
CMP R13D,dword ptr [RSP + 0x4]
JNZ 0x00101e1e
JMP 0x00101f5a
LAB_00101ec6:
INC R13D
MOV RAX,R15
MOV R15,RBX
CMP R13D,dword ptr [RSP + 0x4]
JNZ 0x00101e1e
JMP 0x00101f73
LAB_00101edf:
LEA RDI,[0x1036bb]
XOR EAX,EAX
CALL 0x001027bd
LAB_00101eed:
DEC R14D
MOV RDI,R13
LAB_00101ef3:
MOV ESI,R14D
ADD RSP,0x438
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00102406
LAB_00101f0c:
LEA RDI,[0x103649]
XOR EBX,EBX
MOV ESI,R14D
XOR EAX,EAX
CALL 0x001028e3
DEC R14D
MOV EAX,0x1
LAB_00101f27:
MOV ECX,dword ptr [R13 + RAX*0x4]
LEA RDX,[RBX*0x4]
ADD RDX,R13
MOV ESI,EAX
LAB_00101f39:
MOV EDI,dword ptr [RDX]
CMP EDI,ECX
JLE 0x00101f4a
MOV dword ptr [RDX + 0x4],EDI
ADD RDX,-0x4
DEC ESI
JG 0x00101f39
LAB_00101f4a:
MOV dword ptr [RDX + 0x4],ECX
INC RAX
INC RBX
CMP RBX,R14
JNZ 0x00101f27
JMP 0x00101f87
LAB_00101f5a:
XOR EAX,EAX
MOV RDX,qword ptr [RSP + 0x18]
LAB_00101f61:
MOV ECX,dword ptr [RBX + RAX*0x4]
SUB ECX,dword ptr [RSP + 0x14]
MOV dword ptr [RDX + RAX*0x4],ECX
INC RAX
CMP R12,RAX
JNZ 0x00101f61
LAB_00101f73:
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x00101030
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x00101030
LAB_00101f87:
ADD RSP,0x438
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00101f99:
LEA RDI,[0x10370a]
XOR EAX,EAX
CALL 0x001027bd
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x00101030
DEC R14D
MOV RDI,qword ptr [RSP + 0x18]
JMP 0x00101ef3
|
void vsort_sequential_int(uint *param_1,uint param_2)
{
void *pvVar1;
void *__ptr;
void *__ptr_00;
void *pvVar2;
ulong uVar3;
byte bVar4;
uint uVar5;
uint uVar6;
long lVar7;
ulong uVar8;
uint *puVar9;
ulong uVar10;
int iVar11;
uint uVar12;
ulong uVar13;
uint uVar14;
uint uVar15;
void *pvVar16;
int aiStack_438 [258];
uVar3 = (ulong)param_2;
if (((0x13 < (int)param_2) && ((int)param_2 < thresholds_2 / 2)) && ((int)param_2 < thresholds_3))
{
uVar15 = 10;
if (199 < param_2) {
uVar15 = (param_2 & 0xffff) / 0x14;
}
uVar10 = 100;
if (param_2 < 0x7e4) {
uVar10 = (ulong)uVar15;
}
iVar11 = 0;
uVar8 = 1;
if ((uint)uVar10 <= param_2) {
uVar8 = uVar3 / uVar10;
}
if ((uint)uVar8 < param_2) {
uVar13 = 0;
uVar15 = 0xffffffff;
do {
iVar11 = (uint)((int)param_1[uVar8 + uVar13] < (int)param_1[uVar13 & 0xffffffff]) + iVar11;
uVar14 = uVar15 + 1;
if ((int)param_2 <= (int)((uint)uVar8 * 2 + (int)uVar13)) break;
uVar12 = uVar15 + 2;
uVar13 = uVar13 + uVar8;
uVar15 = uVar14;
} while (uVar12 < (uint)uVar10);
if ((uint)(iVar11 * 10) <= uVar14) {
uVar10 = 0;
vsort_log_info("Array (int, size %d) appears nearly sorted, using insertion sort.",uVar3);
uVar3 = 1;
do {
uVar15 = param_1[uVar3];
puVar9 = param_1 + uVar10;
uVar8 = uVar3 & 0xffffffff;
do {
if ((int)*puVar9 <= (int)uVar15) break;
puVar9[1] = *puVar9;
puVar9 = puVar9 + -1;
iVar11 = (int)uVar8;
uVar14 = iVar11 - 1;
uVar8 = (ulong)uVar14;
} while (uVar14 != 0 && 0 < iVar11);
puVar9[1] = uVar15;
uVar3 = uVar3 + 1;
uVar10 = uVar10 + 1;
if (uVar10 == param_2 - 1) {
return;
}
} while( true );
}
}
}
if (thresholds_3 <= (int)param_2) {
vsort_log_info("Using radix sort for large int array (size: %d)");
uVar15 = *param_1;
uVar14 = uVar15;
if (1 < (int)param_2) {
uVar10 = 1;
do {
uVar12 = param_1[uVar10];
if ((int)uVar15 < (int)uVar12) {
uVar15 = uVar12;
}
if ((int)uVar12 < (int)uVar14) {
uVar14 = uVar12;
}
uVar10 = uVar10 + 1;
} while (uVar3 != uVar10);
}
__ptr = malloc(uVar3 * 4);
if (__ptr == (void *)0x0) {
vsort_log_error(
"Memory allocation failed in radix_sort_int temp_arr, falling back to quicksort"
);
}
else {
uVar12 = -uVar14 & (int)uVar14 >> 0x1f;
if (0 < (int)param_2) {
uVar10 = 0;
do {
*(uint *)((long)__ptr + uVar10 * 4) = param_1[uVar10] + uVar12;
uVar10 = uVar10 + 1;
} while (uVar3 != uVar10);
}
__ptr_00 = malloc(uVar3 * 4);
if (__ptr_00 != (void *)0x0) {
uVar14 = (int)uVar14 >> 0x1f & uVar14;
uVar5 = uVar15 - uVar14;
uVar6 = 0x1f;
if (uVar5 != 0) {
for (; uVar5 >> uVar6 == 0; uVar6 = uVar6 - 1) {
}
}
uVar5 = 1;
if (uVar15 != uVar14) {
uVar5 = (uVar6 ^ 0xffffffe0) + 0x28 >> 3;
}
uVar15 = 0;
pvVar1 = __ptr_00;
pvVar16 = __ptr;
do {
while( true ) {
pvVar2 = pvVar1;
bVar4 = (char)uVar15 * '\b';
memset(aiStack_438,0,0x400);
iVar11 = 0;
if (0 < (int)param_2) {
uVar10 = 0;
do {
aiStack_438[*(uint *)((long)pvVar16 + uVar10 * 4) >> (bVar4 & 0x1f) & 0xff] =
aiStack_438[*(uint *)((long)pvVar16 + uVar10 * 4) >> (bVar4 & 0x1f) & 0xff] + 1
;
uVar10 = uVar10 + 1;
iVar11 = aiStack_438[0];
} while (uVar3 != uVar10);
}
lVar7 = 1;
do {
iVar11 = iVar11 + aiStack_438[lVar7];
aiStack_438[lVar7] = iVar11;
lVar7 = lVar7 + 1;
} while (lVar7 != 0x100);
lVar7 = uVar3 + 1;
pvVar1 = pvVar16;
if (0 < (int)param_2) break;
uVar15 = uVar15 + 1;
pvVar16 = pvVar2;
if (uVar15 == uVar5) goto LAB_00101f73;
}
do {
uVar14 = *(uint *)((long)pvVar16 + lVar7 * 4 + -8);
uVar6 = uVar14 >> (bVar4 & 0x1f) & 0xff;
iVar11 = aiStack_438[uVar6];
aiStack_438[uVar6] = iVar11 + -1;
*(uint *)((long)pvVar2 + (long)iVar11 * 4 + -4) = uVar14;
lVar7 = lVar7 + -1;
} while (1 < lVar7);
uVar15 = uVar15 + 1;
pvVar16 = pvVar2;
} while (uVar15 != uVar5);
uVar10 = 0;
do {
param_1[uVar10] = *(int *)((long)pvVar2 + uVar10 * 4) - uVar12;
uVar10 = uVar10 + 1;
} while (uVar3 != uVar10);
LAB_00101f73:
free(__ptr);
free(__ptr_00);
return;
}
vsort_log_error("Memory allocation failed in radix_sort_int output, falling back to quicksort"
);
free(__ptr);
}
}
quicksort_int(param_1,param_2 - 1);
return;
}
| |
29,285 | JS_NewAtomUInt32 | bluesky950520[P]quickjs/quickjs.c | JSAtom JS_NewAtomUInt32(JSContext *ctx, uint32_t n)
{
if (n <= JS_ATOM_MAX_INT) {
return __JS_AtomFromUInt32(n);
} else {
char buf[16];
size_t len = u32toa(buf, n);
JSValue val = js_new_string8_len(ctx, buf, len);
if (JS_IsException(val))
return JS_ATOM_NULL;
return __JS_NewAtom(ctx->rt, JS_VALUE_GET_STRING(val),
JS_ATOM_TYPE_STRING);
}
} | O2 | c | JS_NewAtomUInt32:
testl %esi, %esi
js 0x1e054
orl $0x80000000, %esi # imm = 0x80000000
jmp 0x1e095
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x1a032
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x1e098
xorl %esi, %esi
cmpl $0x6, %edx
je 0x1e08e
movq 0x18(%rbx), %rdi
pushq $0x1
popq %rdx
movq %rax, %rsi
callq 0x1e0eb
movl %eax, %esi
addq $0x18, %rsp
popq %rbx
popq %r14
movl %esi, %eax
retq
| JS_NewAtomUInt32:
test esi, esi
js short loc_1E054
or esi, 80000000h
jmp short loc_1E095
loc_1E054:
push r14
push rbx
sub rsp, 18h
mov rbx, rdi
mov r14, rsp
mov rdi, r14
call u32toa
mov rdi, rbx
mov rsi, r14
mov edx, eax
call js_new_string8_len
xor esi, esi
cmp edx, 6
jz short loc_1E08E
mov rdi, [rbx+18h]
push 1
pop rdx
mov rsi, rax
call __JS_NewAtom
mov esi, eax
loc_1E08E:
add rsp, 18h
pop rbx
pop r14
loc_1E095:
mov eax, esi
retn
| long long JS_NewAtomUInt32(long long a1, signed int a2)
{
unsigned int v2; // esi
unsigned int v3; // eax
long long v4; // rax
int v5; // edx
_BYTE v7[40]; // [rsp-28h] [rbp-28h] BYREF
if ( a2 < 0 )
{
v3 = u32toa(v7, a2);
v4 = js_new_string8_len(a1, v7, v3);
v2 = 0;
if ( v5 != 6 )
return (unsigned int)_JS_NewAtom(*(_QWORD *)(a1 + 24), v4, 1LL);
}
else
{
return a2 | 0x80000000;
}
return v2;
}
| JS_NewAtomUInt32:
TEST ESI,ESI
JS 0x0011e054
OR ESI,0x80000000
JMP 0x0011e095
LAB_0011e054:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV R14,RSP
MOV RDI,R14
CALL 0x0011a032
MOV RDI,RBX
MOV RSI,R14
MOV EDX,EAX
CALL 0x0011e098
XOR ESI,ESI
CMP EDX,0x6
JZ 0x0011e08e
MOV RDI,qword ptr [RBX + 0x18]
PUSH 0x1
POP RDX
MOV RSI,RAX
CALL 0x0011e0eb
MOV ESI,EAX
LAB_0011e08e:
ADD RSP,0x18
POP RBX
POP R14
LAB_0011e095:
MOV EAX,ESI
RET
|
uint JS_NewAtomUInt32(long param_1,uint param_2)
{
int4 uVar1;
int1 auVar2 [12];
int1 auStack_28 [24];
if ((int)param_2 < 0) {
uVar1 = u32toa(auStack_28);
auVar2 = js_new_string8_len(param_1,auStack_28,uVar1);
param_2 = 0;
if (auVar2._8_4_ != 6) {
param_2 = __JS_NewAtom(*(int8 *)(param_1 + 0x18),auVar2._0_8_,1);
}
}
else {
param_2 = param_2 | 0x80000000;
}
return param_2;
}
| |
29,286 | fp32_to_bits | monkey531[P]llama/ggml/src/ggml-impl.h | static inline uint32_t fp32_to_bits(float f) {
union {
float as_value;
uint32_t as_bits;
} fp32;
fp32.as_value = f;
return fp32.as_bits;
} | O0 | c | fp32_to_bits:
movss %xmm0, -0x4(%rsp)
movss -0x4(%rsp), %xmm0
movss %xmm0, -0x8(%rsp)
movl -0x8(%rsp), %eax
retq
nopw (%rax,%rax)
| fp32_to_bits:
movss [rsp+var_4], xmm0
movss xmm0, [rsp+var_4]
movss [rsp+var_8], xmm0
mov eax, [rsp+var_8]
retn
| long long fp32_to_bits(float a1)
{
return LODWORD(a1);
}
| fp32_to_bits:
MOVSS dword ptr [RSP + -0x4],XMM0
MOVSS XMM0,dword ptr [RSP + -0x4]
MOVSS dword ptr [RSP + -0x8],XMM0
MOV EAX,dword ptr [RSP + -0x8]
RET
|
int4 fp32_to_bits(int4 param_1)
{
return param_1;
}
| |
29,287 | void fmt::v11::detail::for_each_codepoint<fmt::v11::detail::utf8_to_utf16::utf8_to_utf16(fmt::v11::basic_string_view<char>)::$_0>(fmt::v11::basic_string_view<char>, fmt::v11::detail::utf8_to_utf16::utf8_to_utf16(fmt::v11::basic_string_view<char>)::$_0) | zkingston[P]unknot/build_O0/_deps/fmt-src/include/fmt/format.h | FMT_CONSTEXPR void for_each_codepoint(string_view s, F f) {
auto decode = [f](const char* buf_ptr, const char* ptr) {
auto cp = uint32_t();
auto error = 0;
auto end = utf8_decode(buf_ptr, &cp, &error);
bool result = f(error ? invalid_code_point : cp,
string_view(ptr, error ? 1 : to_unsigned(end - buf_ptr)));
return result ? (error ? buf_ptr + 1 : end) : nullptr;
};
auto p = s.data();
const size_t block_size = 4; // utf8_decode always reads blocks of 4 chars.
if (s.size() >= block_size) {
for (auto end = p + s.size() - block_size + 1; p < end;) {
p = decode(p, p);
if (!p) return;
}
}
auto num_chars_left = to_unsigned(s.data() + s.size() - p);
if (num_chars_left == 0) return;
// Suppress bogus -Wstringop-overflow.
if (FMT_GCC_VERSION) num_chars_left &= 3;
char buf[2 * block_size - 1] = {};
copy<char>(p, p + num_chars_left, buf);
const char* buf_ptr = buf;
do {
auto end = decode(buf_ptr, p);
if (!end) return;
p += end - buf_ptr;
buf_ptr = end;
} while (buf_ptr < buf + num_chars_left);
} | O0 | c | void fmt::v11::detail::for_each_codepoint<fmt::v11::detail::utf8_to_utf16::utf8_to_utf16(fmt::v11::basic_string_view<char>)::$_0>(fmt::v11::basic_string_view<char>, fmt::v11::detail::utf8_to_utf16::utf8_to_utf16(fmt::v11::basic_string_view<char>)::$_0):
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x58(%rsp), %rdi
callq 0xa7d20
movq %rax, 0x40(%rsp)
movq $0x4, 0x38(%rsp)
leaq 0x58(%rsp), %rdi
callq 0xa6b20
cmpq $0x4, %rax
jb 0xc50a7
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x58(%rsp), %rdi
callq 0xa6b20
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq %rcx, %rax
addq $-0x4, %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0xc50a5
movq 0x40(%rsp), %rsi
movq 0x40(%rsp), %rdx
leaq 0x48(%rsp), %rdi
callq 0xc5180
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0xc50a3
jmp 0xc5171
jmp 0xc5071
jmp 0xc50a7
leaq 0x58(%rsp), %rdi
callq 0xa7d20
movq %rax, (%rsp)
leaq 0x58(%rsp), %rdi
callq 0xa6b20
movq (%rsp), %rdi
addq %rax, %rdi
movq 0x40(%rsp), %rax
subq %rax, %rdi
callq 0xaae90
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0xc50e5
jmp 0xc5171
leaq 0x21(%rsp), %rdi
xorl %esi, %esi
movl $0x7, %edx
callq 0x126a0
movq 0x40(%rsp), %rdi
movq 0x40(%rsp), %rsi
addq 0x28(%rsp), %rsi
leaq 0x21(%rsp), %rdx
callq 0xabe40
leaq 0x21(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rsi
movq 0x40(%rsp), %rdx
leaq 0x48(%rsp), %rdi
callq 0xc5180
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xc513c
jmp 0xc5171
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rcx, %rax
addq 0x40(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
leaq 0x21(%rsp), %rcx
addq 0x28(%rsp), %rcx
cmpq %rcx, %rax
jb 0xc5119
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
| _ZN3fmt3v116detail18for_each_codepointIZNS1_13compute_widthENS0_17basic_string_viewIcEEE17count_code_pointsEEvS4_T_:
sub rsp, 68h
mov [rsp+68h+var_10], rdi
mov [rsp+68h+var_8], rsi
mov [rsp+68h+var_18], rdx
mov rax, [rsp+68h+var_18]
mov [rsp+68h+var_20], rax
lea rdi, [rsp+68h+var_10]
call _ZNK3fmt3v1117basic_string_viewIcE4dataEv; fmt::v11::basic_string_view<char>::data(void)
mov [rsp+68h+var_28], rax
mov [rsp+68h+var_30], 4
lea rdi, [rsp+68h+var_10]
call _ZNK3fmt3v1117basic_string_viewIcE4sizeEv; fmt::v11::basic_string_view<char>::size(void)
cmp rax, 4
jb short loc_C50A7
mov rax, [rsp+68h+var_28]
mov [rsp+68h+var_60], rax
lea rdi, [rsp+68h+var_10]
call _ZNK3fmt3v1117basic_string_viewIcE4sizeEv; fmt::v11::basic_string_view<char>::size(void)
mov rcx, rax
mov rax, [rsp+68h+var_60]
add rax, rcx
add rax, 0FFFFFFFFFFFFFFFCh
add rax, 1
mov [rsp+68h+var_38], rax
loc_C5071:
mov rax, [rsp+68h+var_28]
cmp rax, [rsp+68h+var_38]
jnb short loc_C50A5
mov rsi, [rsp+68h+var_28]
mov rdx, [rsp+68h+var_28]
lea rdi, [rsp+68h+var_20]
call _ZZN3fmt3v116detail18for_each_codepointIZNS1_13compute_widthENS0_17basic_string_viewIcEEE17count_code_pointsEEvS4_T_ENKUlPKcS8_E_clES8_S8_; fmt::v11::detail::for_each_codepoint<fmt::v11::detail::compute_width(fmt::v11::basic_string_view<char>)::count_code_points>(fmt::v11::basic_string_view<char>,fmt::v11::detail::compute_width(fmt::v11::basic_string_view<char>)::count_code_points)::{lambda(char const*,char const*)#1}::operator()(char const*,char const*)
mov [rsp+68h+var_28], rax
cmp [rsp+68h+var_28], 0
jnz short loc_C50A3
jmp loc_C5171
loc_C50A3:
jmp short loc_C5071
loc_C50A5:
jmp short $+2
loc_C50A7:
lea rdi, [rsp+68h+var_10]
call _ZNK3fmt3v1117basic_string_viewIcE4dataEv; fmt::v11::basic_string_view<char>::data(void)
mov [rsp+68h+var_68], rax
lea rdi, [rsp+68h+var_10]
call _ZNK3fmt3v1117basic_string_viewIcE4sizeEv; fmt::v11::basic_string_view<char>::size(void)
mov rdi, [rsp+68h+var_68]
add rdi, rax
mov rax, [rsp+68h+var_28]
sub rdi, rax
call _ZN3fmt3v116detail11to_unsignedIlEENSt13make_unsignedIT_E4typeES4_; fmt::v11::detail::to_unsigned<long>(long)
mov [rsp+68h+var_40], rax
cmp [rsp+68h+var_40], 0
jnz short loc_C50E5
jmp loc_C5171
loc_C50E5:
lea rdi, [rsp+68h+var_47]
xor esi, esi
mov edx, 7
call _memset
mov rdi, [rsp+68h+var_28]
mov rsi, [rsp+68h+var_28]
add rsi, [rsp+68h+var_40]
lea rdx, [rsp+68h+var_47]
call _ZN3fmt3v116detail4copyIcPKcPcTnNSt9enable_ifIXntsr23is_back_insert_iteratorIT1_EE5valueEiE4typeELi0EEES7_T0_SA_S7_
lea rax, [rsp+68h+var_47]
mov [rsp+68h+var_50], rax
loc_C5119:
mov rsi, [rsp+68h+var_50]
mov rdx, [rsp+68h+var_28]
lea rdi, [rsp+68h+var_20]
call _ZZN3fmt3v116detail18for_each_codepointIZNS1_13compute_widthENS0_17basic_string_viewIcEEE17count_code_pointsEEvS4_T_ENKUlPKcS8_E_clES8_S8_; fmt::v11::detail::for_each_codepoint<fmt::v11::detail::compute_width(fmt::v11::basic_string_view<char>)::count_code_points>(fmt::v11::basic_string_view<char>,fmt::v11::detail::compute_width(fmt::v11::basic_string_view<char>)::count_code_points)::{lambda(char const*,char const*)#1}::operator()(char const*,char const*)
mov [rsp+68h+var_58], rax
cmp [rsp+68h+var_58], 0
jnz short loc_C513C
jmp short loc_C5171
loc_C513C:
mov rax, [rsp+68h+var_58]
mov rcx, [rsp+68h+var_50]
sub rax, rcx
add rax, [rsp+68h+var_28]
mov [rsp+68h+var_28], rax
mov rax, [rsp+68h+var_58]
mov [rsp+68h+var_50], rax
mov rax, [rsp+68h+var_50]
lea rcx, [rsp+68h+var_47]
add rcx, [rsp+68h+var_40]
cmp rax, rcx
jb short loc_C5119
loc_C5171:
add rsp, 68h
retn
| char * fmt::v11::detail::for_each_codepoint<fmt::v11::detail::compute_width(fmt::v11::basic_string_view<char>)::count_code_points>(
long long a1,
long long a2,
long long a3)
{
char *result; // rax
long long v4; // rax
long long v5; // [rsp+0h] [rbp-68h]
char *v6; // [rsp+18h] [rbp-50h]
_BYTE v7[7]; // [rsp+21h] [rbp-47h] BYREF
char *v8; // [rsp+28h] [rbp-40h]
char *v9; // [rsp+30h] [rbp-38h]
long long v10; // [rsp+38h] [rbp-30h]
char *v11; // [rsp+40h] [rbp-28h]
_QWORD v12[2]; // [rsp+48h] [rbp-20h] BYREF
_QWORD v13[2]; // [rsp+58h] [rbp-10h] BYREF
v13[0] = a1;
v13[1] = a2;
v12[1] = a3;
v12[0] = a3;
v11 = (char *)fmt::v11::basic_string_view<char>::data((long long)v13);
v10 = 4LL;
if ( (unsigned long long)fmt::v11::basic_string_view<char>::size((long long)v13) >= 4 )
{
v9 = &v11[fmt::v11::basic_string_view<char>::size((long long)v13) - 3];
while ( v11 < v9 )
{
result = (char *)fmt::v11::detail::for_each_codepoint<fmt::v11::detail::compute_width(fmt::v11::basic_string_view<char>)::count_code_points>(fmt::v11::basic_string_view<char>,fmt::v11::detail::compute_width(fmt::v11::basic_string_view<char>)::count_code_points)::{lambda(char const*,char const*)#1}::operator()(
v12,
v11,
v11);
v11 = result;
if ( !result )
return result;
}
}
v5 = fmt::v11::basic_string_view<char>::data((long long)v13);
v4 = fmt::v11::basic_string_view<char>::size((long long)v13);
result = (char *)fmt::v11::detail::to_unsigned<long>(v4 + v5 - (_QWORD)v11);
v8 = result;
if ( result )
{
memset(v7, 0LL, sizeof(v7));
ZN3fmt3v116detail4copyIcPKcPcTnNSt9enable_ifIXntsr23is_back_insert_iteratorIT1_EE5valueEiE4typeELi0EEES7_T0_SA_S7_(
v11,
&v11[(_QWORD)v8],
v7);
v6 = v7;
do
{
result = (char *)fmt::v11::detail::for_each_codepoint<fmt::v11::detail::compute_width(fmt::v11::basic_string_view<char>)::count_code_points>(fmt::v11::basic_string_view<char>,fmt::v11::detail::compute_width(fmt::v11::basic_string_view<char>)::count_code_points)::{lambda(char const*,char const*)#1}::operator()(
v12,
v6,
v11);
if ( !result )
break;
v11 += result - v6;
v6 = result;
}
while ( result < &v7[(_QWORD)v8] );
}
return result;
}
| for_each_codepoint<fmt::v11::detail::compute_width(fmt::v11::basic_string_view<char>)::count_code_points>:
SUB RSP,0x68
MOV qword ptr [RSP + 0x58],RDI
MOV qword ptr [RSP + 0x60],RSI
MOV qword ptr [RSP + 0x50],RDX
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x48],RAX
LEA RDI,[RSP + 0x58]
CALL 0x001a7d20
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x38],0x4
LEA RDI,[RSP + 0x58]
CALL 0x001a6b20
CMP RAX,0x4
JC 0x001c50a7
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x8],RAX
LEA RDI,[RSP + 0x58]
CALL 0x001a6b20
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
ADD RAX,RCX
ADD RAX,-0x4
ADD RAX,0x1
MOV qword ptr [RSP + 0x30],RAX
LAB_001c5071:
MOV RAX,qword ptr [RSP + 0x40]
CMP RAX,qword ptr [RSP + 0x30]
JNC 0x001c50a5
MOV RSI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x40]
LEA RDI,[RSP + 0x48]
CALL 0x001c5180
MOV qword ptr [RSP + 0x40],RAX
CMP qword ptr [RSP + 0x40],0x0
JNZ 0x001c50a3
JMP 0x001c5171
LAB_001c50a3:
JMP 0x001c5071
LAB_001c50a5:
JMP 0x001c50a7
LAB_001c50a7:
LEA RDI,[RSP + 0x58]
CALL 0x001a7d20
MOV qword ptr [RSP],RAX
LEA RDI,[RSP + 0x58]
CALL 0x001a6b20
MOV RDI,qword ptr [RSP]
ADD RDI,RAX
MOV RAX,qword ptr [RSP + 0x40]
SUB RDI,RAX
CALL 0x001aae90
MOV qword ptr [RSP + 0x28],RAX
CMP qword ptr [RSP + 0x28],0x0
JNZ 0x001c50e5
JMP 0x001c5171
LAB_001c50e5:
LEA RDI,[RSP + 0x21]
XOR ESI,ESI
MOV EDX,0x7
CALL 0x001126a0
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x40]
ADD RSI,qword ptr [RSP + 0x28]
LEA RDX,[RSP + 0x21]
CALL 0x001abe40
LEA RAX,[RSP + 0x21]
MOV qword ptr [RSP + 0x18],RAX
LAB_001c5119:
MOV RSI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x40]
LEA RDI,[RSP + 0x48]
CALL 0x001c5180
MOV qword ptr [RSP + 0x10],RAX
CMP qword ptr [RSP + 0x10],0x0
JNZ 0x001c513c
JMP 0x001c5171
LAB_001c513c:
MOV RAX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x18]
SUB RAX,RCX
ADD RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RSP + 0x18]
LEA RCX,[RSP + 0x21]
ADD RCX,qword ptr [RSP + 0x28]
CMP RAX,RCX
JC 0x001c5119
LAB_001c5171:
ADD RSP,0x68
RET
|
/* void
fmt::v11::detail::for_each_codepoint<fmt::v11::detail::compute_width(fmt::v11::basic_string_view<char>)::count_code_points>(fmt::v11::basic_string_view<char>,
fmt::v11::detail::compute_width(fmt::v11::basic_string_view<char>)::count_code_points) */
void __thiscall
fmt::v11::detail::
for_each_codepoint<fmt::v11::detail::compute_width(fmt::v11::basic_string_view<char>)::count_code_points>
(detail *this,int8 param_2,int8 param_3)
{
ulong uVar1;
long lVar2;
long lVar3;
char *pcVar4;
char *local_50;
char local_47 [7];
long local_40;
char *local_38;
int8 local_30;
char *local_28;
int8 local_20;
int8 local_18;
detail *local_10;
int8 local_8;
local_20 = param_3;
local_18 = param_3;
local_10 = this;
local_8 = param_2;
local_28 = (char *)basic_string_view<char>::data((basic_string_view<char> *)&local_10);
local_30 = 4;
uVar1 = basic_string_view<char>::size((basic_string_view<char> *)&local_10);
pcVar4 = local_28;
if (uVar1 < 4) {
LAB_001c50a7:
lVar2 = basic_string_view<char>::data((basic_string_view<char> *)&local_10);
lVar3 = basic_string_view<char>::size((basic_string_view<char> *)&local_10);
local_40 = to_unsigned<long>((lVar2 + lVar3) - (long)local_28);
if (local_40 != 0) {
memset(local_47,0,7);
_ZN3fmt3v116detail4copyIcPKcPcTnNSt9enable_ifIXntsr23is_back_insert_iteratorIT1_EE5valueEiE4typeELi0EEES7_T0_SA_S7_
(local_28,local_28 + local_40,local_47);
local_50 = local_47;
do {
pcVar4 = (char *)for_each_codepoint<fmt::v11::detail::compute_width(fmt::v11::basic_string_view<char>)::count_code_points>(fmt::v11::basic_string_view<char>,fmt::v11::detail::compute_width(fmt::v11::basic_string_view<char>)::count_code_points)
::{lambda(char_const*,char_const*)#1}::operator()
((_lambda_char_const__char_const___1_ *)&local_20,local_50,
local_28);
if (pcVar4 == (char *)0x0) {
return;
}
local_28 = local_28 + ((long)pcVar4 - (long)local_50);
local_50 = pcVar4;
} while (pcVar4 < local_47 + local_40);
}
}
else {
lVar2 = basic_string_view<char>::size((basic_string_view<char> *)&local_10);
local_38 = pcVar4 + lVar2 + -3;
do {
if (local_38 <= local_28) goto LAB_001c50a7;
local_28 = (char *)for_each_codepoint<fmt::v11::detail::compute_width(fmt::v11::basic_string_view<char>)::count_code_points>(fmt::v11::basic_string_view<char>,fmt::v11::detail::compute_width(fmt::v11::basic_string_view<char>)::count_code_points)
::{lambda(char_const*,char_const*)#1}::operator()
((_lambda_char_const__char_const___1_ *)&local_20,local_28,
local_28);
} while (local_28 != (char *)0x0);
}
return;
}
| |
29,288 | do_bar() (.resume) | corofx/tests/test_task_move.cpp | auto do_bar() -> task<int, bar> {
co_await bar{marker1};
check_unreachable();
} | O3 | cpp | do_bar() (.resume):
endbr64
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x28(%rdi), %r14
cmpb $0x0, 0x50(%rdi)
jne 0x1918
movq %rdi, %rbx
movq 0x20(%rdi), %rsi
movl $0x13, 0x28(%rdi)
leaq 0x30(%rdi), %rcx
movq %rdi, 0x30(%rdi)
movq %r14, 0x38(%rdi)
addq $0x40, %rdi
movq (%rsi), %rax
movq %r14, %rdx
callq *(%rax)
movb $0x0, 0x4c(%rbx)
movb $0x1, 0x50(%rbx)
movq 0x40(%rbx), %rdi
popq %rbx
popq %r14
popq %rbp
jmpq *(%rdi)
movq %r14, %rdi
callq 0x1a52
movq %r14, %rdi
callq 0x1a6a
leaq 0x2311(%rip), %rdi # 0x3c40
callq 0x1bef
| _Z6do_barv_resume:
endbr64
push rbp
mov rbp, rsp
push r14
push rbx
lea r14, [rdi+28h]
cmp byte ptr [rdi+50h], 0
jnz short loc_1918
mov rbx, rdi
mov rsi, [rdi+20h]
mov dword ptr [rdi+28h], 13h
lea rcx, [rdi+30h]
mov [rdi+30h], rdi
mov [rdi+38h], r14
add rdi, 40h ; '@'
mov rax, [rsi]
mov rdx, r14
call qword ptr [rax]
mov byte ptr [rbx+4Ch], 0
mov byte ptr [rbx+50h], 1
mov rdi, [rbx+40h]
pop rbx
pop r14
pop rbp
jmp qword ptr [rdi]
loc_1918:
mov rdi, r14
call _ZN6corofx14effect_awaiterI3barE12await_resumeEv; corofx::effect_awaiter<bar>::await_resume(void)
mov rdi, r14
call _ZN6corofx14effect_awaiterI3barED2Ev; corofx::effect_awaiter<bar>::~effect_awaiter()
lea rdi, off_3C40; "/workspace/llm4binary/github2025/corofx"...
call _ZN6corofx17check_unreachableESt15source_location; corofx::check_unreachable(std::source_location)
| long long do_bar(long long a1)
{
long long v1; // r14
void ( ***v2)(long long, _QWORD, long long, long long); // rsi
v1 = a1 + 40;
if ( *(_BYTE *)(a1 + 80) )
{
corofx::effect_awaiter<bar>::await_resume(a1 + 40);
corofx::effect_awaiter<bar>::~effect_awaiter(v1);
corofx::check_unreachable(off_3C40);
}
v2 = *(void ( ****)(long long, _QWORD, long long, long long))(a1 + 32);
*(_DWORD *)(a1 + 40) = 19;
*(_QWORD *)(a1 + 48) = a1;
*(_QWORD *)(a1 + 56) = v1;
(**v2)(a1 + 64, v2, v1, a1 + 48);
*(_BYTE *)(a1 + 76) = 0;
*(_BYTE *)(a1 + 80) = 1;
return (**(long long (***)(void))(a1 + 64))();
}
| do_bar:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
LEA R14,[RDI + 0x28]
CMP byte ptr [RDI + 0x50],0x0
JNZ 0x00101918
MOV RBX,RDI
MOV RSI,qword ptr [RDI + 0x20]
MOV dword ptr [RDI + 0x28],0x13
LEA RCX,[RDI + 0x30]
MOV qword ptr [RDI + 0x30],RDI
MOV qword ptr [RDI + 0x38],R14
ADD RDI,0x40
MOV RAX,qword ptr [RSI]
MOV RDX,R14
CALL qword ptr [RAX]
MOV byte ptr [RBX + 0x4c],0x0
MOV byte ptr [RBX + 0x50],0x1
MOV RDI,qword ptr [RBX + 0x40]
POP RBX
POP R14
POP RBP
JMP qword ptr [RDI]
LAB_00101918:
MOV RDI,R14
CALL 0x00101a52
MOV RDI,R14
CALL 0x00101a6a
LEA RDI,[0x103c40]
CALL 0x00101bef
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* do_bar() [clone .resume] */
void do_bar(void)
{
effect_awaiter<bar> *this;
long in_RDI;
int **ppuVar1;
this = (effect_awaiter<bar> *)(in_RDI + 0x28);
if (*(char *)(in_RDI + 0x50) == '\0') {
*(int4 *)(in_RDI + 0x28) = 0x13;
*(long *)(in_RDI + 0x30) = in_RDI;
*(effect_awaiter<bar> **)(in_RDI + 0x38) = this;
(**(code **)**(int8 **)(in_RDI + 0x20))
(in_RDI + 0x40,*(int8 **)(in_RDI + 0x20),this,in_RDI + 0x30);
*(int1 *)(in_RDI + 0x4c) = 0;
*(int1 *)(in_RDI + 0x50) = 1;
/* WARNING: Could not recover jumptable at 0x00101916. Too many branches */
/* WARNING: Treating indirect jump as call */
(*(code *)**(int8 **)(in_RDI + 0x40))();
return;
}
corofx::effect_awaiter<bar>::await_resume(this);
corofx::effect_awaiter<bar>::~effect_awaiter(this);
ppuVar1 = &PTR_s__workspace_llm4binary_github2025_00103c40;
corofx::check_unreachable();
if ((*(char *)(ppuVar1 + 10) == '\x01') && (ppuVar1[8] != (int *)0x0)) {
(**(code **)(ppuVar1[8] + 8))();
}
operator_delete(ppuVar1,0x58);
return;
}
| |
29,289 | testing::UnitTest::PushGTestTrace(testing::internal::TraceInfo const&) | giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/src/gtest.cc | GTEST_LOCK_EXCLUDED_(mutex_) {
internal::MutexLock lock(&mutex_);
impl_->gtest_trace_stack().push_back(trace);
} | O1 | cpp | testing::UnitTest::PushGTestTrace(testing::internal::TraceInfo const&):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x370dc
movl $0x2b8, %edi # imm = 0x2B8
addq 0x40(%r15), %rdi
callq 0x37838
movq %rax, %rdi
movq %r14, %rsi
callq 0x34eda
movq %rbx, %rdi
callq 0x3717a
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2deef
movq %rax, %r14
movq %rbx, %rdi
callq 0x3717a
movq %r14, %rdi
callq 0x8990
movq %rax, %rdi
callq 0x326a4
nop
| _ZN7testing8UnitTest14PushGTestTraceERKNS_8internal9TraceInfoE:
push r15
push r14
push rbx
mov r14, rsi
mov r15, rdi
lea rbx, [rdi+8]
mov rdi, rbx; this
call _ZN7testing8internal9MutexBase4LockEv; testing::internal::MutexBase::Lock(void)
mov edi, 2B8h
add rdi, [r15+40h]
call _ZNK7testing8internal11ThreadLocalISt6vectorINS0_9TraceInfoESaIS3_EEE16GetOrCreateValueEv; testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo>>::GetOrCreateValue(void)
mov rdi, rax
mov rsi, r14
call _ZNSt6vectorIN7testing8internal9TraceInfoESaIS2_EE9push_backERKS2_; std::vector<testing::internal::TraceInfo>::push_back(testing::internal::TraceInfo const&)
mov rdi, rbx; this
call _ZN7testing8internal9MutexBase6UnlockEv; testing::internal::MutexBase::Unlock(void)
pop rbx
pop r14
pop r15
retn
jmp short loc_2DEEF
mov r14, rax
mov rdi, rbx; this
call _ZN7testing8internal9MutexBase6UnlockEv; testing::internal::MutexBase::Unlock(void)
mov rdi, r14
call __Unwind_Resume
loc_2DEEF:
mov rdi, rax
call __clang_call_terminate
| long long testing::UnitTest::PushGTestTrace(long long a1, long long a2)
{
int v2; // edx
int v3; // ecx
int v4; // r8d
int v5; // r9d
long long Value; // rax
testing::internal::MutexBase::Lock((testing::internal::MutexBase *)(a1 + 8));
Value = testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo>>::GetOrCreateValue(
*(_DWORD *)(a1 + 64) + 696,
a2,
v2,
v3,
v4,
v5);
std::vector<testing::internal::TraceInfo>::push_back(Value, a2);
return testing::internal::MutexBase::Unlock((testing::internal::MutexBase *)(a1 + 8));
}
| PushGTestTrace:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RSI
MOV R15,RDI
LEA RBX,[RDI + 0x8]
MOV RDI,RBX
CALL 0x001370dc
MOV EDI,0x2b8
ADD RDI,qword ptr [R15 + 0x40]
LAB_0012debc:
CALL 0x00137838
MOV RDI,RAX
MOV RSI,R14
CALL 0x00134eda
LAB_0012decc:
MOV RDI,RBX
CALL 0x0013717a
POP RBX
POP R14
POP R15
RET
|
/* testing::UnitTest::PushGTestTrace(testing::internal::TraceInfo const&) */
void __thiscall testing::UnitTest::PushGTestTrace(UnitTest *this,TraceInfo *param_1)
{
vector<testing::internal::TraceInfo,std::allocator<testing::internal::TraceInfo>> *this_00;
internal::MutexBase::Lock((MutexBase *)(this + 8));
/* try { // try from 0012debc to 0012decb has its CatchHandler @ 0012dedc */
this_00 = (vector<testing::internal::TraceInfo,std::allocator<testing::internal::TraceInfo>> *)
internal::
ThreadLocal<std::vector<testing::internal::TraceInfo,std::allocator<testing::internal::TraceInfo>>>
::GetOrCreateValue((ThreadLocal<std::vector<testing::internal::TraceInfo,std::allocator<testing::internal::TraceInfo>>>
*)(*(long *)(this + 0x40) + 0x2b8));
std::vector<testing::internal::TraceInfo,std::allocator<testing::internal::TraceInfo>>::push_back
(this_00,param_1);
/* try { // try from 0012decc to 0012ded3 has its CatchHandler @ 0012deda */
internal::MutexBase::Unlock((MutexBase *)(this + 8));
return;
}
| |
29,290 | xorshift64star | bluesky950520[P]quickjs/quickjs.c | static uint64_t xorshift64star(uint64_t *pstate)
{
uint64_t x;
x = *pstate;
x ^= x >> 12;
x ^= x << 25;
x ^= x >> 27;
*pstate = x;
return x * 0x2545F4914F6CDD1D;
} | O0 | c | xorshift64star:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
shrq $0xc, %rax
xorq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
shlq $0x19, %rax
xorq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
shrq $0x1b, %rax
xorq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
movabsq $0x2545f4914f6cdd1d, %rax # imm = 0x2545F4914F6CDD1D
imulq -0x10(%rsp), %rax
retq
nopl (%rax)
| xorshift64star:
mov [rsp+var_8], rdi
mov rax, [rsp+var_8]
mov rax, [rax]
mov [rsp+var_10], rax
mov rax, [rsp+var_10]
shr rax, 0Ch
xor rax, [rsp+var_10]
mov [rsp+var_10], rax
mov rax, [rsp+var_10]
shl rax, 19h
xor rax, [rsp+var_10]
mov [rsp+var_10], rax
mov rax, [rsp+var_10]
shr rax, 1Bh
xor rax, [rsp+var_10]
mov [rsp+var_10], rax
mov rcx, [rsp+var_10]
mov rax, [rsp+var_8]
mov [rax], rcx
mov rax, 2545F4914F6CDD1Dh
imul rax, [rsp+var_10]
retn
| long long xorshift64star(unsigned long long *a1)
{
unsigned long long v2; // [rsp+0h] [rbp-10h]
unsigned long long v3; // [rsp+0h] [rbp-10h]
v2 = *a1 ^ (*a1 >> 12) ^ ((*a1 ^ (*a1 >> 12)) << 25);
v3 = v2 ^ (v2 >> 27);
*a1 = v3;
return 0x2545F4914F6CDD1DLL * v3;
}
| xorshift64star:
MOV qword ptr [RSP + -0x8],RDI
MOV RAX,qword ptr [RSP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + -0x10],RAX
MOV RAX,qword ptr [RSP + -0x10]
SHR RAX,0xc
XOR RAX,qword ptr [RSP + -0x10]
MOV qword ptr [RSP + -0x10],RAX
MOV RAX,qword ptr [RSP + -0x10]
SHL RAX,0x19
XOR RAX,qword ptr [RSP + -0x10]
MOV qword ptr [RSP + -0x10],RAX
MOV RAX,qword ptr [RSP + -0x10]
SHR RAX,0x1b
XOR RAX,qword ptr [RSP + -0x10]
MOV qword ptr [RSP + -0x10],RAX
MOV RCX,qword ptr [RSP + -0x10]
MOV RAX,qword ptr [RSP + -0x8]
MOV qword ptr [RAX],RCX
MOV RAX,0x2545f4914f6cdd1d
IMUL RAX,qword ptr [RSP + -0x10]
RET
|
long xorshift64star(ulong *param_1)
{
ulong uVar1;
uVar1 = *param_1 >> 0xc ^ *param_1;
uVar1 = uVar1 << 0x19 ^ uVar1;
uVar1 = uVar1 >> 0x1b ^ uVar1;
*param_1 = uVar1;
return uVar1 * 0x2545f4914f6cdd1d;
}
| |
29,291 | xorshift64star | bluesky950520[P]quickjs/quickjs.c | static uint64_t xorshift64star(uint64_t *pstate)
{
uint64_t x;
x = *pstate;
x ^= x >> 12;
x ^= x << 25;
x ^= x >> 27;
*pstate = x;
return x * 0x2545F4914F6CDD1D;
} | O1 | c | xorshift64star:
movq 0x1c8(%rdi), %rax
movq %rax, %rcx
shrq $0xc, %rcx
xorq %rax, %rcx
movq %rcx, %rax
shlq $0x19, %rax
xorq %rcx, %rax
movq %rax, %rcx
shrq $0x1b, %rcx
xorq %rax, %rcx
movabsq $0x2545f4914f6cdd1d, %rax # imm = 0x2545F4914F6CDD1D
imulq %rcx, %rax
shrq $0xc, %rax
movabsq $0x3ff0000000000000, %rdx # imm = 0x3FF0000000000000
orq %rax, %rdx
movq %rdx, %xmm0
addsd 0x20a9d(%rip), %xmm0 # 0xa2af8
movq %rcx, 0x1c8(%rdi)
movq %xmm0, %rax
movl $0x7, %edx
retq
| js_math_random:
mov rax, [rdi+1C8h]
mov rcx, rax
shr rcx, 0Ch
xor rcx, rax
mov rax, rcx
shl rax, 19h
xor rax, rcx
mov rcx, rax
shr rcx, 1Bh
xor rcx, rax
mov rax, 2545F4914F6CDD1Dh
imul rax, rcx
shr rax, 0Ch
mov rdx, 3FF0000000000000h
or rdx, rax
movq xmm0, rdx
addsd xmm0, cs:qword_A2AF8
mov [rdi+1C8h], rcx
movq rax, xmm0
mov edx, 7
retn
| long long js_math_random(long long a1)
{
long long v1; // rcx
long long result; // rax
v1 = *(_QWORD *)(a1 + 456) ^ (*(_QWORD *)(a1 + 456) >> 12) ^ ((*(_QWORD *)(a1 + 456) ^ (*(_QWORD *)(a1 + 456) >> 12)) << 25) ^ ((*(_QWORD *)(a1 + 456) ^ (*(_QWORD *)(a1 + 456) >> 12) ^ ((*(_QWORD *)(a1 + 456) ^ (*(_QWORD *)(a1 + 456) >> 12)) << 25)) >> 27);
*(_QWORD *)(a1 + 456) = v1;
*(double *)&result = COERCE_DOUBLE(((unsigned long long)(0x2545F4914F6CDD1DLL * v1) >> 12) | 0x3FF0000000000000LL)
+ -1.0;
return result;
}
| js_math_random:
MOV RAX,qword ptr [RDI + 0x1c8]
MOV RCX,RAX
SHR RCX,0xc
XOR RCX,RAX
MOV RAX,RCX
SHL RAX,0x19
XOR RAX,RCX
MOV RCX,RAX
SHR RCX,0x1b
XOR RCX,RAX
MOV RAX,0x2545f4914f6cdd1d
IMUL RAX,RCX
SHR RAX,0xc
MOV RDX,0x3ff0000000000000
OR RDX,RAX
MOVQ XMM0,RDX
ADDSD XMM0,qword ptr [0x001a2af8]
MOV qword ptr [RDI + 0x1c8],RCX
MOVQ RAX,XMM0
MOV EDX,0x7
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int1 [16] js_math_random(long param_1)
{
ulong uVar1;
double dVar2;
int1 auVar3 [16];
uVar1 = *(ulong *)(param_1 + 0x1c8) >> 0xc ^ *(ulong *)(param_1 + 0x1c8);
uVar1 = uVar1 << 0x19 ^ uVar1;
uVar1 = uVar1 >> 0x1b ^ uVar1;
dVar2 = (double)(uVar1 * 0x2545f4914f6cdd1d >> 0xc | 0x3ff0000000000000) + _DAT_001a2af8;
*(ulong *)(param_1 + 0x1c8) = uVar1;
auVar3._8_8_ = 7;
auVar3._0_8_ = dVar2;
return auVar3;
}
| |
29,292 | xorshift64star | bluesky950520[P]quickjs/quickjs.c | static uint64_t xorshift64star(uint64_t *pstate)
{
uint64_t x;
x = *pstate;
x ^= x >> 12;
x ^= x << 25;
x ^= x >> 27;
*pstate = x;
return x * 0x2545F4914F6CDD1D;
} | O2 | c | xorshift64star:
movq 0x1c8(%rdi), %rax
movq %rax, %rcx
shrq $0xc, %rcx
xorq %rax, %rcx
movq %rcx, %rax
shlq $0x19, %rax
xorq %rcx, %rax
movq %rax, %rcx
shrq $0x1b, %rcx
xorq %rax, %rcx
movq %rcx, 0x1c8(%rdi)
movabsq $0x2545f4914f6cdd1d, %rax # imm = 0x2545F4914F6CDD1D
imulq %rcx, %rax
shrq $0xc, %rax
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
orq %rax, %rcx
movq %rcx, %xmm0
addsd 0x1b1bf(%rip), %xmm0 # 0x88ac8
movq %xmm0, %rax
pushq $0x7
popq %rdx
retq
| js_math_random:
mov rax, [rdi+1C8h]
mov rcx, rax
shr rcx, 0Ch
xor rcx, rax
mov rax, rcx
shl rax, 19h
xor rax, rcx
mov rcx, rax
shr rcx, 1Bh
xor rcx, rax
mov [rdi+1C8h], rcx
mov rax, 2545F4914F6CDD1Dh
imul rax, rcx
shr rax, 0Ch
mov rcx, 3FF0000000000000h
or rcx, rax
movq xmm0, rcx
addsd xmm0, cs:qword_88AC8
movq rax, xmm0
push 7
pop rdx
retn
| long long js_math_random(long long a1)
{
long long v1; // rcx
long long result; // rax
v1 = *(_QWORD *)(a1 + 456) ^ (*(_QWORD *)(a1 + 456) >> 12) ^ ((*(_QWORD *)(a1 + 456) ^ (*(_QWORD *)(a1 + 456) >> 12)) << 25) ^ ((*(_QWORD *)(a1 + 456) ^ (*(_QWORD *)(a1 + 456) >> 12) ^ ((*(_QWORD *)(a1 + 456) ^ (*(_QWORD *)(a1 + 456) >> 12)) << 25)) >> 27);
*(_QWORD *)(a1 + 456) = v1;
*(double *)&result = COERCE_DOUBLE(((unsigned long long)(0x2545F4914F6CDD1DLL * v1) >> 12) | 0x3FF0000000000000LL)
+ -1.0;
return result;
}
| js_math_random:
MOV RAX,qword ptr [RDI + 0x1c8]
MOV RCX,RAX
SHR RCX,0xc
XOR RCX,RAX
MOV RAX,RCX
SHL RAX,0x19
XOR RAX,RCX
MOV RCX,RAX
SHR RCX,0x1b
XOR RCX,RAX
MOV qword ptr [RDI + 0x1c8],RCX
MOV RAX,0x2545f4914f6cdd1d
IMUL RAX,RCX
SHR RAX,0xc
MOV RCX,0x3ff0000000000000
OR RCX,RAX
MOVQ XMM0,RCX
ADDSD XMM0,qword ptr [0x00188ac8]
MOVQ RAX,XMM0
PUSH 0x7
POP RDX
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int1 [16] js_math_random(long param_1)
{
ulong uVar1;
int1 auVar2 [16];
uVar1 = *(ulong *)(param_1 + 0x1c8) >> 0xc ^ *(ulong *)(param_1 + 0x1c8);
uVar1 = uVar1 << 0x19 ^ uVar1;
uVar1 = uVar1 >> 0x1b ^ uVar1;
*(ulong *)(param_1 + 0x1c8) = uVar1;
auVar2._8_8_ = 7;
auVar2._0_8_ = (double)(uVar1 * 0x2545f4914f6cdd1d >> 0xc | 0x3ff0000000000000) + _DAT_00188ac8;
return auVar2;
}
| |
29,293 | ma_net_write | eloqsql/libmariadb/libmariadb/ma_net.c | int ma_net_write(NET *net, const uchar *packet, size_t len)
{
uchar buff[NET_HEADER_SIZE];
while (len >= MAX_PACKET_LENGTH)
{
const ulong max_len= MAX_PACKET_LENGTH;
int3store(buff,max_len);
buff[3]= (uchar)net->pkt_nr++;
if (ma_net_write_buff(net,(char*) buff,NET_HEADER_SIZE) ||
ma_net_write_buff(net, (char *)packet, max_len))
return 1;
packet+= max_len;
len-= max_len;
}
/* write last remaining packet, size can be zero */
int3store(buff, len);
buff[3]= (uchar)net->pkt_nr++;
if (ma_net_write_buff(net,(char*) buff,NET_HEADER_SIZE) ||
ma_net_write_buff(net, (char *)packet, len))
return 1;
return 0;
} | O0 | c | ma_net_write:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
cmpq $0xffffff, -0x28(%rbp) # imm = 0xFFFFFF
jb 0x46120
movq $0xffffff, -0x30(%rbp) # imm = 0xFFFFFF
movb $-0x1, -0xc(%rbp)
movb $-0x1, -0xb(%rbp)
movb $-0x1, -0xa(%rbp)
movq -0x18(%rbp), %rcx
movl 0x60(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x60(%rcx)
movb %al, -0x9(%rbp)
movq -0x18(%rbp), %rdi
leaq -0xc(%rbp), %rsi
movl $0x4, %edx
callq 0x461c0
cmpl $0x0, %eax
jne 0x460f3
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0xffffff, %edx # imm = 0xFFFFFF
callq 0x461c0
cmpl $0x0, %eax
je 0x460ff
movl $0x1, -0x10(%rbp)
jmp 0x4618e
movq -0x20(%rbp), %rax
addq $0xffffff, %rax # imm = 0xFFFFFF
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
subq $0xffffff, %rax # imm = 0xFFFFFF
movq %rax, -0x28(%rbp)
jmp 0x46091
jmp 0x46122
movq -0x28(%rbp), %rax
movb %al, -0xc(%rbp)
movq -0x28(%rbp), %rax
shrq $0x8, %rax
movb %al, -0xb(%rbp)
movq -0x28(%rbp), %rax
shrq $0x10, %rax
movb %al, -0xa(%rbp)
movq -0x18(%rbp), %rcx
movl 0x60(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x60(%rcx)
movb %al, -0x9(%rbp)
movq -0x18(%rbp), %rdi
leaq -0xc(%rbp), %rsi
movl $0x4, %edx
callq 0x461c0
cmpl $0x0, %eax
jne 0x4617e
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x461c0
cmpl $0x0, %eax
je 0x46187
movl $0x1, -0x10(%rbp)
jmp 0x4618e
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x34(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x461af
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
callq 0x134b0
nopw %cs:(%rax,%rax)
| ma_net_write:
push rbp
mov rbp, rsp
sub rsp, 40h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_28], rdx
loc_46091:
cmp [rbp+var_28], 0FFFFFFh
jb loc_46120
mov [rbp+var_30], 0FFFFFFh
mov [rbp+var_C], 0FFh
mov [rbp+var_B], 0FFh
mov [rbp+var_A], 0FFh
mov rcx, [rbp+var_18]
mov eax, [rcx+60h]
mov edx, eax
add edx, 1
mov [rcx+60h], edx
mov [rbp+var_9], al
mov rdi, [rbp+var_18]
lea rsi, [rbp+var_C]
mov edx, 4
call ma_net_write_buff
cmp eax, 0
jnz short loc_460F3
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov edx, 0FFFFFFh
call ma_net_write_buff
cmp eax, 0
jz short loc_460FF
loc_460F3:
mov [rbp+var_10], 1
jmp loc_4618E
loc_460FF:
mov rax, [rbp+var_20]
add rax, 0FFFFFFh
mov [rbp+var_20], rax
mov rax, [rbp+var_28]
sub rax, 0FFFFFFh
mov [rbp+var_28], rax
jmp loc_46091
loc_46120:
jmp short $+2
loc_46122:
mov rax, [rbp+var_28]
mov [rbp+var_C], al
mov rax, [rbp+var_28]
shr rax, 8
mov [rbp+var_B], al
mov rax, [rbp+var_28]
shr rax, 10h
mov [rbp+var_A], al
mov rcx, [rbp+var_18]
mov eax, [rcx+60h]
mov edx, eax
add edx, 1
mov [rcx+60h], edx
mov [rbp+var_9], al
mov rdi, [rbp+var_18]
lea rsi, [rbp+var_C]
mov edx, 4
call ma_net_write_buff
cmp eax, 0
jnz short loc_4617E
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
call ma_net_write_buff
cmp eax, 0
jz short loc_46187
loc_4617E:
mov [rbp+var_10], 1
jmp short loc_4618E
loc_46187:
mov [rbp+var_10], 0
loc_4618E:
mov eax, [rbp+var_10]
mov [rbp+var_34], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_461AF
mov eax, [rbp+var_34]
add rsp, 40h
pop rbp
retn
loc_461AF:
call ___stack_chk_fail
| _BOOL8 ma_net_write(long long a1, long long a2, unsigned long long a3)
{
int v3; // eax
int v4; // eax
__int16 v9; // [rsp+34h] [rbp-Ch] BYREF
char v10; // [rsp+36h] [rbp-Ah]
char v11; // [rsp+37h] [rbp-9h]
unsigned long long v12; // [rsp+38h] [rbp-8h]
v12 = __readfsqword(0x28u);
while ( a3 >= 0xFFFFFF )
{
v9 = -1;
v10 = -1;
v3 = *(_DWORD *)(a1 + 96);
*(_DWORD *)(a1 + 96) = v3 + 1;
v11 = v3;
if ( (unsigned int)ma_net_write_buff(a1, &v9, 4LL) || (unsigned int)ma_net_write_buff(a1, a2, 0xFFFFFFLL) )
return 1;
a2 += 0xFFFFFFLL;
a3 -= 0xFFFFFFLL;
}
v9 = a3;
v10 = BYTE2(a3);
v4 = *(_DWORD *)(a1 + 96);
*(_DWORD *)(a1 + 96) = v4 + 1;
v11 = v4;
return (unsigned int)ma_net_write_buff(a1, &v9, 4LL) || (unsigned int)ma_net_write_buff(a1, a2, a3);
}
| ma_net_write:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
LAB_00146091:
CMP qword ptr [RBP + -0x28],0xffffff
JC 0x00146120
MOV qword ptr [RBP + -0x30],0xffffff
MOV byte ptr [RBP + -0xc],0xff
MOV byte ptr [RBP + -0xb],0xff
MOV byte ptr [RBP + -0xa],0xff
MOV RCX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RCX + 0x60]
MOV EDX,EAX
ADD EDX,0x1
MOV dword ptr [RCX + 0x60],EDX
MOV byte ptr [RBP + -0x9],AL
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[RBP + -0xc]
MOV EDX,0x4
CALL 0x001461c0
CMP EAX,0x0
JNZ 0x001460f3
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV EDX,0xffffff
CALL 0x001461c0
CMP EAX,0x0
JZ 0x001460ff
LAB_001460f3:
MOV dword ptr [RBP + -0x10],0x1
JMP 0x0014618e
LAB_001460ff:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0xffffff
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x28]
SUB RAX,0xffffff
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00146091
LAB_00146120:
JMP 0x00146122
LAB_00146122:
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RBP + -0xc],AL
MOV RAX,qword ptr [RBP + -0x28]
SHR RAX,0x8
MOV byte ptr [RBP + -0xb],AL
MOV RAX,qword ptr [RBP + -0x28]
SHR RAX,0x10
MOV byte ptr [RBP + -0xa],AL
MOV RCX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RCX + 0x60]
MOV EDX,EAX
ADD EDX,0x1
MOV dword ptr [RCX + 0x60],EDX
MOV byte ptr [RBP + -0x9],AL
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[RBP + -0xc]
MOV EDX,0x4
CALL 0x001461c0
CMP EAX,0x0
JNZ 0x0014617e
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
CALL 0x001461c0
CMP EAX,0x0
JZ 0x00146187
LAB_0014617e:
MOV dword ptr [RBP + -0x10],0x1
JMP 0x0014618e
LAB_00146187:
MOV dword ptr [RBP + -0x10],0x0
LAB_0014618e:
MOV EAX,dword ptr [RBP + -0x10]
MOV dword ptr [RBP + -0x34],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001461af
MOV EAX,dword ptr [RBP + -0x34]
ADD RSP,0x40
POP RBP
RET
LAB_001461af:
CALL 0x001134b0
|
int4 ma_net_write(long param_1,long param_2,ulong param_3)
{
int iVar1;
long in_FS_OFFSET;
ulong local_30;
long local_28;
int4 local_18;
int1 local_14;
int1 local_13;
int1 local_12;
int1 local_11;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_28 = param_2;
for (local_30 = param_3; 0xfffffe < local_30; local_30 = local_30 - 0xffffff) {
local_14 = 0xff;
local_13 = 0xff;
local_12 = 0xff;
iVar1 = *(int *)(param_1 + 0x60);
*(int *)(param_1 + 0x60) = iVar1 + 1;
local_11 = (int1)iVar1;
iVar1 = ma_net_write_buff(param_1,&local_14,4);
if (iVar1 != 0) {
LAB_001460f3:
local_18 = 1;
goto LAB_0014618e;
}
iVar1 = ma_net_write_buff(param_1,local_28,0xffffff);
if (iVar1 != 0) goto LAB_001460f3;
local_28 = local_28 + 0xffffff;
}
local_14 = (int1)local_30;
local_13 = (int1)(local_30 >> 8);
local_12 = (int1)(local_30 >> 0x10);
iVar1 = *(int *)(param_1 + 0x60);
*(int *)(param_1 + 0x60) = iVar1 + 1;
local_11 = (int1)iVar1;
iVar1 = ma_net_write_buff(param_1,&local_14,4);
if (iVar1 == 0) {
iVar1 = ma_net_write_buff(param_1,local_28,local_30);
if (iVar1 == 0) {
local_18 = 0;
goto LAB_0014618e;
}
}
local_18 = 1;
LAB_0014618e:
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_18;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
29,294 | ma_net_write | eloqsql/libmariadb/libmariadb/ma_net.c | int ma_net_write(NET *net, const uchar *packet, size_t len)
{
uchar buff[NET_HEADER_SIZE];
while (len >= MAX_PACKET_LENGTH)
{
const ulong max_len= MAX_PACKET_LENGTH;
int3store(buff,max_len);
buff[3]= (uchar)net->pkt_nr++;
if (ma_net_write_buff(net,(char*) buff,NET_HEADER_SIZE) ||
ma_net_write_buff(net, (char *)packet, max_len))
return 1;
packet+= max_len;
len-= max_len;
}
/* write last remaining packet, size can be zero */
int3store(buff, len);
buff[3]= (uchar)net->pkt_nr++;
if (ma_net_write_buff(net,(char*) buff,NET_HEADER_SIZE) ||
ma_net_write_buff(net, (char *)packet, len))
return 1;
return 0;
} | O3 | c | ma_net_write:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
cmpq $0xffffff, %rdx # imm = 0xFFFFFF
jb 0x31484
leaq -0x34(%rbp), %r12
movl $0x1, %r13d
movw $0xffff, -0x34(%rbp) # imm = 0xFFFF
movb $-0x1, -0x32(%rbp)
movl 0x60(%r15), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x60(%r15)
movb %al, -0x31(%rbp)
movl $0x4, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x314f1
testl %eax, %eax
jne 0x314cb
movl $0xffffff, %edx # imm = 0xFFFFFF
movq %r15, %rdi
movq %r14, %rsi
callq 0x314f1
testl %eax, %eax
jne 0x314cb
addq $0xffffff, %r14 # imm = 0xFFFFFF
addq $-0xffffff, %rbx # imm = 0xFF000001
cmpq $0xfffffe, %rbx # imm = 0xFFFFFE
ja 0x3142d
leaq -0x34(%rbp), %rsi
movb %bl, (%rsi)
movb %bh, -0x33(%rbp)
movl %ebx, %eax
shrl $0x10, %eax
movb %al, 0x2(%rsi)
movl 0x60(%r15), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x60(%r15)
movb %al, 0x3(%rsi)
movl $0x4, %edx
movq %r15, %rdi
callq 0x314f1
movl $0x1, %r13d
testl %eax, %eax
jne 0x314cb
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x314f1
movl %eax, %r13d
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x314ec
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13500
| ma_net_write:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
cmp rdx, 0FFFFFFh
jb short loc_31484
lea r12, [rbp+var_34]
mov r13d, 1
loc_3142D:
mov [rbp+var_34], 0FFFFh
mov [rbp+var_32], 0FFh
mov eax, [r15+60h]
lea ecx, [rax+1]
mov [r15+60h], ecx
mov [rbp+var_31], al
mov edx, 4
mov rdi, r15
mov rsi, r12
call ma_net_write_buff
test eax, eax
jnz short loc_314CB
mov edx, 0FFFFFFh
mov rdi, r15
mov rsi, r14
call ma_net_write_buff
test eax, eax
jnz short loc_314CB
add r14, 0FFFFFFh
add rbx, 0FFFFFFFFFF000001h
cmp rbx, 0FFFFFEh
ja short loc_3142D
loc_31484:
lea rsi, [rbp+var_34]
mov [rsi], bl
mov byte ptr [rbp+var_34+1], bh
mov eax, ebx
shr eax, 10h
mov [rsi+2], al
mov eax, [r15+60h]
lea ecx, [rax+1]
mov [r15+60h], ecx
mov [rsi+3], al
mov edx, 4
mov rdi, r15
call ma_net_write_buff
mov r13d, 1
test eax, eax
jnz short loc_314CB
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call ma_net_write_buff
mov r13d, eax
loc_314CB:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_314EC
mov eax, r13d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_314EC:
call ___stack_chk_fail
| long long ma_net_write(long long a1, long long a2, unsigned long long a3)
{
unsigned long long v3; // rbx
unsigned int v5; // r13d
int v6; // eax
int v7; // eax
__int16 v9; // [rsp+Ch] [rbp-34h] BYREF
char v10; // [rsp+Eh] [rbp-32h]
char v11; // [rsp+Fh] [rbp-31h]
unsigned long long v12; // [rsp+10h] [rbp-30h]
v3 = a3;
v12 = __readfsqword(0x28u);
if ( a3 < 0xFFFFFF )
{
LABEL_6:
v9 = v3;
v10 = BYTE2(v3);
v7 = *(_DWORD *)(a1 + 96);
*(_DWORD *)(a1 + 96) = v7 + 1;
v11 = v7;
v5 = 1;
if ( !(unsigned int)ma_net_write_buff(a1, &v9, 4LL) )
return (unsigned int)ma_net_write_buff(a1, a2, v3);
}
else
{
v5 = 1;
while ( 1 )
{
v9 = -1;
v10 = -1;
v6 = *(_DWORD *)(a1 + 96);
*(_DWORD *)(a1 + 96) = v6 + 1;
v11 = v6;
if ( (unsigned int)ma_net_write_buff(a1, &v9, 4LL) || (unsigned int)ma_net_write_buff(a1, a2, 0xFFFFFFLL) )
break;
a2 += 0xFFFFFFLL;
v3 -= 0xFFFFFFLL;
if ( v3 <= 0xFFFFFE )
goto LABEL_6;
}
}
return v5;
}
| ma_net_write:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
CMP RDX,0xffffff
JC 0x00131484
LEA R12,[RBP + -0x34]
MOV R13D,0x1
LAB_0013142d:
MOV word ptr [RBP + -0x34],0xffff
MOV byte ptr [RBP + -0x32],0xff
MOV EAX,dword ptr [R15 + 0x60]
LEA ECX,[RAX + 0x1]
MOV dword ptr [R15 + 0x60],ECX
MOV byte ptr [RBP + -0x31],AL
MOV EDX,0x4
MOV RDI,R15
MOV RSI,R12
CALL 0x001314f1
TEST EAX,EAX
JNZ 0x001314cb
MOV EDX,0xffffff
MOV RDI,R15
MOV RSI,R14
CALL 0x001314f1
TEST EAX,EAX
JNZ 0x001314cb
ADD R14,0xffffff
ADD RBX,-0xffffff
CMP RBX,0xfffffe
JA 0x0013142d
LAB_00131484:
LEA RSI,[RBP + -0x34]
MOV byte ptr [RSI],BL
MOV byte ptr [RBP + -0x33],BH
MOV EAX,EBX
SHR EAX,0x10
MOV byte ptr [RSI + 0x2],AL
MOV EAX,dword ptr [R15 + 0x60]
LEA ECX,[RAX + 0x1]
MOV dword ptr [R15 + 0x60],ECX
MOV byte ptr [RSI + 0x3],AL
MOV EDX,0x4
MOV RDI,R15
CALL 0x001314f1
MOV R13D,0x1
TEST EAX,EAX
JNZ 0x001314cb
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x001314f1
MOV R13D,EAX
LAB_001314cb:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001314ec
MOV EAX,R13D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001314ec:
CALL 0x00113500
|
int4 ma_net_write(long param_1,long param_2,ulong param_3)
{
int iVar1;
int4 uVar2;
long in_FS_OFFSET;
int2 local_3c;
int1 local_3a;
int1 local_39;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
if (0xfffffe < param_3) {
uVar2 = 1;
do {
local_3c = 0xffff;
local_3a = 0xff;
iVar1 = *(int *)(param_1 + 0x60);
*(int *)(param_1 + 0x60) = iVar1 + 1;
local_39 = (int1)iVar1;
iVar1 = ma_net_write_buff(param_1,&local_3c,4);
if (iVar1 != 0) goto LAB_001314cb;
iVar1 = ma_net_write_buff(param_1,param_2,0xffffff);
if (iVar1 != 0) goto LAB_001314cb;
param_2 = param_2 + 0xffffff;
param_3 = param_3 - 0xffffff;
} while (0xfffffe < param_3);
}
local_3c = (int2)param_3;
local_3a = (int1)(param_3 >> 0x10);
iVar1 = *(int *)(param_1 + 0x60);
*(int *)(param_1 + 0x60) = iVar1 + 1;
local_39 = (int1)iVar1;
iVar1 = ma_net_write_buff(param_1,&local_3c,4);
uVar2 = 1;
if (iVar1 == 0) {
uVar2 = ma_net_write_buff(param_1,param_2,param_3);
}
LAB_001314cb:
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return uVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
29,295 | js_async_generator_resume_next | bluesky950520[P]quickjs/quickjs.c | static void js_async_generator_resume_next(JSContext *ctx,
JSAsyncGeneratorData *s)
{
JSAsyncGeneratorRequest *next;
JSValue func_ret, value;
for(;;) {
if (list_empty(&s->queue))
break;
next = list_entry(s->queue.next, JSAsyncGeneratorRequest, link);
switch(s->state) {
case JS_ASYNC_GENERATOR_STATE_EXECUTING:
/* only happens when restarting execution after await() */
goto resume_exec;
case JS_ASYNC_GENERATOR_STATE_AWAITING_RETURN:
goto done;
case JS_ASYNC_GENERATOR_STATE_SUSPENDED_START:
if (next->completion_type == GEN_MAGIC_NEXT) {
goto exec_no_arg;
} else {
js_async_generator_complete(ctx, s);
}
break;
case JS_ASYNC_GENERATOR_STATE_COMPLETED:
if (next->completion_type == GEN_MAGIC_NEXT) {
js_async_generator_resolve(ctx, s, JS_UNDEFINED, TRUE);
} else if (next->completion_type == GEN_MAGIC_RETURN) {
s->state = JS_ASYNC_GENERATOR_STATE_AWAITING_RETURN;
js_async_generator_completed_return(ctx, s, next->result);
} else {
js_async_generator_reject(ctx, s, next->result);
}
goto done;
case JS_ASYNC_GENERATOR_STATE_SUSPENDED_YIELD:
case JS_ASYNC_GENERATOR_STATE_SUSPENDED_YIELD_STAR:
value = js_dup(next->result);
if (next->completion_type == GEN_MAGIC_THROW &&
s->state == JS_ASYNC_GENERATOR_STATE_SUSPENDED_YIELD) {
JS_Throw(ctx, value);
s->func_state.throw_flag = TRUE;
} else {
/* 'yield' returns a value. 'yield *' also returns a value
in case the 'throw' method is called */
s->func_state.frame.cur_sp[-1] = value;
s->func_state.frame.cur_sp[0] =
js_int32(next->completion_type);
s->func_state.frame.cur_sp++;
exec_no_arg:
s->func_state.throw_flag = FALSE;
}
s->state = JS_ASYNC_GENERATOR_STATE_EXECUTING;
resume_exec:
func_ret = async_func_resume(ctx, &s->func_state);
if (JS_IsException(func_ret)) {
value = JS_GetException(ctx);
js_async_generator_complete(ctx, s);
js_async_generator_reject(ctx, s, value);
JS_FreeValue(ctx, value);
} else if (JS_VALUE_GET_TAG(func_ret) == JS_TAG_INT) {
int func_ret_code, ret;
value = s->func_state.frame.cur_sp[-1];
s->func_state.frame.cur_sp[-1] = JS_UNDEFINED;
func_ret_code = JS_VALUE_GET_INT(func_ret);
switch(func_ret_code) {
case FUNC_RET_YIELD:
case FUNC_RET_YIELD_STAR:
if (func_ret_code == FUNC_RET_YIELD_STAR)
s->state = JS_ASYNC_GENERATOR_STATE_SUSPENDED_YIELD_STAR;
else
s->state = JS_ASYNC_GENERATOR_STATE_SUSPENDED_YIELD;
js_async_generator_resolve(ctx, s, value, FALSE);
JS_FreeValue(ctx, value);
break;
case FUNC_RET_AWAIT:
ret = js_async_generator_await(ctx, s, value);
JS_FreeValue(ctx, value);
if (ret < 0) {
/* exception: throw it */
s->func_state.throw_flag = TRUE;
goto resume_exec;
}
goto done;
default:
abort();
}
} else {
assert(JS_IsUndefined(func_ret));
/* end of function */
value = s->func_state.frame.cur_sp[-1];
s->func_state.frame.cur_sp[-1] = JS_UNDEFINED;
js_async_generator_complete(ctx, s);
js_async_generator_resolve(ctx, s, value, TRUE);
JS_FreeValue(ctx, value);
}
break;
default:
abort();
}
}
done: ;
} | O0 | c | js_async_generator_resume_next:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq 0xc8(%rsp), %rdi
addq $0x78, %rdi
callq 0x23ab0
cmpl $0x0, %eax
je 0x96b52
jmp 0x970c8
movq 0xc8(%rsp), %rax
movq 0x80(%rax), %rax
movq %rax, 0xc0(%rsp)
movq 0xc8(%rsp), %rax
movl 0x8(%rax), %eax
movq %rax, 0x10(%rsp)
subq $0x5, %rax
ja 0x970be
movq 0x10(%rsp), %rax
leaq 0x74721(%rip), %rcx # 0x10b2b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x96dc7
jmp 0x970ca
movq 0xc0(%rsp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x96bb5
jmp 0x96da9
movq 0xd0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
callq 0x970e0
jmp 0x970c3
movq 0xc0(%rsp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x96c21
movq 0xd0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
movl $0x0, 0x90(%rsp)
movq $0x3, 0x98(%rsp)
movq 0x90(%rsp), %rdx
movq 0x98(%rsp), %rcx
movl $0x1, %r8d
callq 0x97130
jmp 0x96c8c
movq 0xc0(%rsp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x96c65
movq 0xc8(%rsp), %rax
movl $0x4, 0x8(%rax)
movq 0xd0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
movq 0xc0(%rsp), %rax
movq 0x18(%rax), %rdx
movq 0x20(%rax), %rcx
callq 0x971e0
jmp 0x96c8a
movq 0xd0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
movq 0xc0(%rsp), %rax
movq 0x18(%rax), %rdx
movq 0x20(%rax), %rcx
callq 0x97490
jmp 0x96c8c
jmp 0x970ca
movq 0xc0(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x20(%rax), %rsi
callq 0x216d0
movq %rax, 0x80(%rsp)
movq %rdx, 0x88(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0xc0(%rsp), %rax
cmpl $0x2, 0x10(%rax)
jne 0x96d2d
movq 0xc8(%rsp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x96d2d
movq 0xd0(%rsp), %rdi
movq 0xa0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
callq 0x2cf00
movq %rax, 0x70(%rsp)
movq %rdx, 0x78(%rsp)
movq 0xc8(%rsp), %rax
movl $0x1, 0x24(%rax)
jmp 0x96db8
movq 0xc8(%rsp), %rax
movq 0x70(%rax), %rax
movq 0xa0(%rsp), %rcx
movq %rcx, -0x10(%rax)
movq 0xa8(%rsp), %rcx
movq %rcx, -0x8(%rax)
movq 0xc8(%rsp), %rax
movq 0x70(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0xc0(%rsp), %rax
movl 0x10(%rax), %edi
callq 0x33cc0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x60(%rsp)
movq %rdx, 0x68(%rsp)
movq 0x60(%rsp), %rcx
movq %rcx, (%rax)
movq 0x68(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0xc8(%rsp), %rax
movq 0x70(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x70(%rax)
movq 0xc8(%rsp), %rax
movl $0x0, 0x24(%rax)
movq 0xc8(%rsp), %rax
movl $0x3, 0x8(%rax)
movq 0xd0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
addq $0x10, %rsi
callq 0x72320
movq %rax, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0xb0(%rsp), %rdi
movq 0xb8(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0x96eaf
movq 0xd0(%rsp), %rdi
callq 0x2cf70
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0xd0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
callq 0x970e0
movq 0xd0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
movq 0xa0(%rsp), %rdx
movq 0xa8(%rsp), %rcx
callq 0x97490
movq 0xd0(%rsp), %rdi
movq 0xa0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
callq 0x23c90
jmp 0x970bc
movq 0xb8(%rsp), %rax
cmpl $0x0, %eax
jne 0x9700a
movq 0xc8(%rsp), %rax
movq 0x70(%rax), %rax
movups -0x10(%rax), %xmm0
movaps %xmm0, 0xa0(%rsp)
movq 0xc8(%rsp), %rax
movq 0x70(%rax), %rax
movl $0x0, 0x28(%rsp)
movq $0x3, 0x30(%rsp)
movups 0x28(%rsp), %xmm0
movups %xmm0, -0x10(%rax)
movl 0xb0(%rsp), %eax
movl %eax, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0x96f9a
jmp 0x96f1b
movl 0x4(%rsp), %eax
decl %eax
subl $0x1, %eax
ja 0x97000
jmp 0x96f2c
cmpl $0x2, 0x3c(%rsp)
jne 0x96f44
movq 0xc8(%rsp), %rax
movl $0x2, 0x8(%rax)
jmp 0x96f53
movq 0xc8(%rsp), %rax
movl $0x1, 0x8(%rax)
movq 0xd0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
movq 0xa0(%rsp), %rdx
movq 0xa8(%rsp), %rcx
xorl %r8d, %r8d
callq 0x97130
movq 0xd0(%rsp), %rdi
movq 0xa0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
callq 0x23c90
jmp 0x97005
movq 0xd0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
movq 0xa0(%rsp), %rdx
movq 0xa8(%rsp), %rcx
callq 0x974d0
movl %eax, 0x38(%rsp)
movq 0xd0(%rsp), %rdi
movq 0xa0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
callq 0x23c90
cmpl $0x0, 0x38(%rsp)
jge 0x96ffb
movq 0xc8(%rsp), %rax
movl $0x1, 0x24(%rax)
jmp 0x96dc7
jmp 0x970ca
callq 0xe090
jmp 0x970ba
movq 0xc8(%rsp), %rax
movq 0x70(%rax), %rax
movq -0x10(%rax), %rcx
movq %rcx, 0xa0(%rsp)
movq -0x8(%rax), %rax
movq %rax, 0xa8(%rsp)
movq 0xc8(%rsp), %rax
movq 0x70(%rax), %rax
movl $0x0, 0x18(%rsp)
movq $0x3, 0x20(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rax)
movq 0x20(%rsp), %rcx
movq %rcx, -0x8(%rax)
movq 0xd0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
callq 0x970e0
movq 0xd0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
movq 0xa0(%rsp), %rdx
movq 0xa8(%rsp), %rcx
movl $0x1, %r8d
callq 0x97130
movq 0xd0(%rsp), %rdi
movq 0xa0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
callq 0x23c90
jmp 0x970bc
jmp 0x970c3
callq 0xe090
jmp 0x96b37
jmp 0x970ca
addq $0xd8, %rsp
retq
nopw %cs:(%rax,%rax)
| js_async_generator_resume_next:
sub rsp, 0D8h
mov [rsp+0D8h+var_8], rdi
mov [rsp+0D8h+var_10], rsi
loc_96B37:
mov rdi, [rsp+0D8h+var_10]
add rdi, 78h ; 'x'
call list_empty_0
cmp eax, 0
jz short loc_96B52
jmp loc_970C8
loc_96B52:
mov rax, [rsp+0D8h+var_10]
mov rax, [rax+80h]
mov [rsp+0D8h+var_18], rax
mov rax, [rsp+0D8h+var_10]
mov eax, [rax+8]
mov [rsp+0D8h+var_C8], rax
sub rax, 5; switch 6 cases
ja def_96B96; jumptable 0000000000096B96 default case
mov rax, [rsp+0D8h+var_C8]
lea rcx, jpt_96B96
movsxd rax, ds:(jpt_96B96 - 10B2B0h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_96B98:
jmp loc_96DC7; jumptable 0000000000096B96 case 3
loc_96B9D:
jmp loc_970CA; jumptable 0000000000096B96 case 4
loc_96BA2:
mov rax, [rsp+0D8h+var_18]; jumptable 0000000000096B96 case 0
cmp dword ptr [rax+10h], 0
jnz short loc_96BB5
jmp loc_96DA9
loc_96BB5:
mov rdi, [rsp+0D8h+var_8]
mov rsi, [rsp+0D8h+var_10]
call js_async_generator_complete
jmp loc_970C3
loc_96BCF:
mov rax, [rsp+0D8h+var_18]; jumptable 0000000000096B96 case 5
cmp dword ptr [rax+10h], 0
jnz short loc_96C21
mov rdi, [rsp+0D8h+var_8]
mov rsi, [rsp+0D8h+var_10]
mov dword ptr [rsp+0D8h+var_48], 0
mov [rsp+0D8h+var_40], 3
mov rdx, [rsp+0D8h+var_48]
mov rcx, [rsp+0D8h+var_40]
mov r8d, 1
call js_async_generator_resolve
jmp short loc_96C8C
loc_96C21:
mov rax, [rsp+0D8h+var_18]
cmp dword ptr [rax+10h], 1
jnz short loc_96C65
mov rax, [rsp+0D8h+var_10]
mov dword ptr [rax+8], 4
mov rdi, [rsp+0D8h+var_8]
mov rsi, [rsp+0D8h+var_10]
mov rax, [rsp+0D8h+var_18]
mov rdx, [rax+18h]
mov rcx, [rax+20h]
call js_async_generator_completed_return
jmp short loc_96C8A
loc_96C65:
mov rdi, [rsp+0D8h+var_8]
mov rsi, [rsp+0D8h+var_10]
mov rax, [rsp+0D8h+var_18]
mov rdx, [rax+18h]
mov rcx, [rax+20h]
call js_async_generator_reject
loc_96C8A:
jmp short $+2
loc_96C8C:
jmp loc_970CA
loc_96C91:
mov rax, [rsp+0D8h+var_18]; jumptable 0000000000096B96 cases 1,2
mov rdi, [rax+18h]
mov rsi, [rax+20h]
call js_dup
mov [rsp+0D8h+var_58], rax
mov [rsp+0D8h+var_50], rdx
mov rax, [rsp+0D8h+var_58]
mov qword ptr [rsp+0D8h+var_38], rax
mov rax, [rsp+0D8h+var_50]
mov qword ptr [rsp+0D8h+var_38+8], rax
mov rax, [rsp+0D8h+var_18]
cmp dword ptr [rax+10h], 2
jnz short loc_96D2D
mov rax, [rsp+0D8h+var_10]
cmp dword ptr [rax+8], 1
jnz short loc_96D2D
mov rdi, [rsp+0D8h+var_8]
mov rsi, qword ptr [rsp+0D8h+var_38]
mov rdx, qword ptr [rsp+0D8h+var_38+8]
call JS_Throw
mov [rsp+0D8h+var_68], rax
mov [rsp+0D8h+var_60], rdx
mov rax, [rsp+0D8h+var_10]
mov dword ptr [rax+24h], 1
jmp loc_96DB8
loc_96D2D:
mov rax, [rsp+0D8h+var_10]
mov rax, [rax+70h]
mov rcx, qword ptr [rsp+0D8h+var_38]
mov [rax-10h], rcx
mov rcx, qword ptr [rsp+0D8h+var_38+8]
mov [rax-8], rcx
mov rax, [rsp+0D8h+var_10]
mov rax, [rax+70h]
mov [rsp+0D8h+var_D0], rax
mov rax, [rsp+0D8h+var_18]
mov edi, [rax+10h]
call js_int32
mov rcx, rax
mov rax, [rsp+0D8h+var_D0]
mov [rsp+0D8h+var_78], rcx
mov [rsp+0D8h+var_70], rdx
mov rcx, [rsp+0D8h+var_78]
mov [rax], rcx
mov rcx, [rsp+0D8h+var_70]
mov [rax+8], rcx
mov rax, [rsp+0D8h+var_10]
mov rcx, [rax+70h]
add rcx, 10h
mov [rax+70h], rcx
loc_96DA9:
mov rax, [rsp+0D8h+var_10]
mov dword ptr [rax+24h], 0
loc_96DB8:
mov rax, [rsp+0D8h+var_10]
mov dword ptr [rax+8], 3
loc_96DC7:
mov rdi, [rsp+0D8h+var_8]
mov rsi, [rsp+0D8h+var_10]
add rsi, 10h
call async_func_resume
mov [rsp+0D8h+var_88], rax
mov [rsp+0D8h+var_80], rdx
mov rax, [rsp+0D8h+var_88]
mov [rsp+0D8h+var_28], rax
mov rax, [rsp+0D8h+var_80]
mov [rsp+0D8h+var_20], rax
mov rdi, [rsp+0D8h+var_28]
mov rsi, [rsp+0D8h+var_20]
call JS_IsException_1
cmp eax, 0
jz loc_96EAF
mov rdi, [rsp+0D8h+var_8]
call JS_GetException
mov [rsp+0D8h+var_98], rax
mov [rsp+0D8h+var_90], rdx
mov rax, [rsp+0D8h+var_98]
mov qword ptr [rsp+0D8h+var_38], rax
mov rax, [rsp+0D8h+var_90]
mov qword ptr [rsp+0D8h+var_38+8], rax
mov rdi, [rsp+0D8h+var_8]
mov rsi, [rsp+0D8h+var_10]
call js_async_generator_complete
mov rdi, [rsp+0D8h+var_8]
mov rsi, [rsp+0D8h+var_10]
mov rdx, qword ptr [rsp+0D8h+var_38]
mov rcx, qword ptr [rsp+0D8h+var_38+8]
call js_async_generator_reject
mov rdi, [rsp+0D8h+var_8]
mov rsi, qword ptr [rsp+0D8h+var_38]
mov rdx, qword ptr [rsp+0D8h+var_38+8]
call JS_FreeValue
jmp loc_970BC
loc_96EAF:
mov rax, [rsp+0D8h+var_20]
cmp eax, 0
jnz loc_9700A
mov rax, [rsp+0D8h+var_10]
mov rax, [rax+70h]
movups xmm0, xmmword ptr [rax-10h]
movaps [rsp+0D8h+var_38], xmm0
mov rax, [rsp+0D8h+var_10]
mov rax, [rax+70h]
mov dword ptr [rsp+0D8h+var_B0], 0
mov qword ptr [rsp+0D8h+var_B0+8], 3
movups xmm0, [rsp+0D8h+var_B0]
movups xmmword ptr [rax-10h], xmm0
mov eax, dword ptr [rsp+0D8h+var_28]
mov [rsp+0D8h+var_9C], eax
mov eax, [rsp+0D8h+var_9C]
mov [rsp+0D8h+var_D4], eax
test eax, eax
jz loc_96F9A
jmp short $+2
loc_96F1B:
mov eax, [rsp+0D8h+var_D4]
dec eax
sub eax, 1
ja loc_97000
jmp short $+2
loc_96F2C:
cmp [rsp+0D8h+var_9C], 2
jnz short loc_96F44
mov rax, [rsp+0D8h+var_10]
mov dword ptr [rax+8], 2
jmp short loc_96F53
loc_96F44:
mov rax, [rsp+0D8h+var_10]
mov dword ptr [rax+8], 1
loc_96F53:
mov rdi, [rsp+0D8h+var_8]
mov rsi, [rsp+0D8h+var_10]
mov rdx, qword ptr [rsp+0D8h+var_38]
mov rcx, qword ptr [rsp+0D8h+var_38+8]
xor r8d, r8d
call js_async_generator_resolve
mov rdi, [rsp+0D8h+var_8]
mov rsi, qword ptr [rsp+0D8h+var_38]
mov rdx, qword ptr [rsp+0D8h+var_38+8]
call JS_FreeValue
jmp short loc_97005
loc_96F9A:
mov rdi, [rsp+0D8h+var_8]
mov rsi, [rsp+0D8h+var_10]
mov rdx, qword ptr [rsp+0D8h+var_38]
mov rcx, qword ptr [rsp+0D8h+var_38+8]
call js_async_generator_await
mov [rsp+0D8h+var_A0], eax
mov rdi, [rsp+0D8h+var_8]
mov rsi, qword ptr [rsp+0D8h+var_38]
mov rdx, qword ptr [rsp+0D8h+var_38+8]
call JS_FreeValue
cmp [rsp+0D8h+var_A0], 0
jge short loc_96FFB
mov rax, [rsp+0D8h+var_10]
mov dword ptr [rax+24h], 1
jmp loc_96DC7
loc_96FFB:
jmp loc_970CA
loc_97000:
call _abort
loc_97005:
jmp loc_970BA
loc_9700A:
mov rax, [rsp+0D8h+var_10]
mov rax, [rax+70h]
mov rcx, [rax-10h]
mov qword ptr [rsp+0D8h+var_38], rcx
mov rax, [rax-8]
mov qword ptr [rsp+0D8h+var_38+8], rax
mov rax, [rsp+0D8h+var_10]
mov rax, [rax+70h]
mov dword ptr [rsp+0D8h+var_C0], 0
mov [rsp+0D8h+var_B8], 3
mov rcx, [rsp+0D8h+var_C0]
mov [rax-10h], rcx
mov rcx, [rsp+0D8h+var_B8]
mov [rax-8], rcx
mov rdi, [rsp+0D8h+var_8]
mov rsi, [rsp+0D8h+var_10]
call js_async_generator_complete
mov rdi, [rsp+0D8h+var_8]
mov rsi, [rsp+0D8h+var_10]
mov rdx, qword ptr [rsp+0D8h+var_38]
mov rcx, qword ptr [rsp+0D8h+var_38+8]
mov r8d, 1
call js_async_generator_resolve
mov rdi, [rsp+0D8h+var_8]
mov rsi, qword ptr [rsp+0D8h+var_38]
mov rdx, qword ptr [rsp+0D8h+var_38+8]
call JS_FreeValue
loc_970BA:
jmp short $+2
loc_970BC:
jmp short loc_970C3
def_96B96:
call _abort; jumptable 0000000000096B96 default case
loc_970C3:
jmp loc_96B37
loc_970C8:
jmp short $+2
loc_970CA:
add rsp, 0D8h
retn
| long long js_async_generator_resume_next(
long long a1,
long long a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
long long result; // rax
double v11; // xmm4_8
double v12; // xmm5_8
__int128 v13; // rax
long long v14; // rdx
int v15; // edx
__int128 v16; // rax
long long v17; // rax
long long *v18; // [rsp+8h] [rbp-D0h]
long long v19; // [rsp+18h] [rbp-C0h]
__m128 v20; // [rsp+28h] [rbp-B0h]
int v21; // [rsp+38h] [rbp-A0h]
const char *v22; // [rsp+50h] [rbp-88h]
__int128 v23; // [rsp+A0h] [rbp-38h]
__int128 v24; // [rsp+A0h] [rbp-38h]
__int128 v25; // [rsp+A0h] [rbp-38h]
int v26; // [rsp+B8h] [rbp-20h]
long long v27; // [rsp+C0h] [rbp-18h]
LABEL_1:
while ( 1 )
{
result = list_empty_0(a2 + 120);
if ( (_DWORD)result )
return result;
v27 = *(_QWORD *)(a2 + 128);
result = *(unsigned int *)(a2 + 8);
switch ( *(_DWORD *)(a2 + 8) )
{
case 0:
if ( !*(_DWORD *)(v27 + 16) )
goto LABEL_14;
js_async_generator_complete(a1, a2);
continue;
case 1:
case 2:
*(_QWORD *)&v13 = js_dup(*(_DWORD **)(v27 + 24), *(_QWORD *)(v27 + 32));
if ( *(_DWORD *)(v27 + 16) == 2 && *(_DWORD *)(a2 + 8) == 1 )
{
JS_Throw(a1, v13, *((long long *)&v13 + 1));
*(_DWORD *)(a2 + 36) = 1;
}
else
{
*(_OWORD *)(*(_QWORD *)(a2 + 112) - 16LL) = v13;
v18 = *(long long **)(a2 + 112);
*v18 = js_int32(*(_DWORD *)(v27 + 16));
v18[1] = v14;
*(_QWORD *)(a2 + 112) += 16LL;
LABEL_14:
*(_DWORD *)(a2 + 36) = 0;
}
*(_DWORD *)(a2 + 8) = 3;
break;
case 3:
goto LABEL_16;
case 4:
return result;
case 5:
if ( !*(_DWORD *)(v27 + 16) )
return js_async_generator_resolve(a1, a2, 0, 3LL, 1LL);
if ( *(_DWORD *)(v27 + 16) != 1 )
return js_async_generator_reject(a1, a2, *(_QWORD *)(v27 + 24), *(_QWORD *)(v27 + 32));
*(_DWORD *)(a2 + 8) = 4;
return js_async_generator_completed_return(a1, a2, *(_QWORD *)(v27 + 24), *(_QWORD *)(v27 + 32));
default:
abort((const char *)(a2 + 120));
}
while ( 1 )
{
LABEL_16:
v22 = (const char *)async_func_resume(a1, a2 + 16, a3, a4, a5, a6, v11, v12, a9, a10);
v26 = v15;
if ( JS_IsException_1((long long)v22, v15) )
{
*(_QWORD *)&v16 = JS_GetException(a1);
v23 = v16;
js_async_generator_complete(a1, a2);
js_async_generator_reject(a1, a2, v23, *((_QWORD *)&v23 + 1));
JS_FreeValue(a1, v23, *((long long *)&v23 + 1));
goto LABEL_1;
}
if ( v26 )
{
v25 = *(_OWORD *)(*(_QWORD *)(a2 + 112) - 16LL);
v17 = *(_QWORD *)(a2 + 112);
LODWORD(v19) = 0;
*(_QWORD *)(v17 - 16) = v19;
*(_QWORD *)(v17 - 8) = 3LL;
js_async_generator_complete(a1, a2);
js_async_generator_resolve(a1, a2, v25, *((_QWORD *)&v25 + 1), 1LL);
JS_FreeValue(a1, v25, *((long long *)&v25 + 1));
goto LABEL_1;
}
v24 = *(_OWORD *)(*(_QWORD *)(a2 + 112) - 16LL);
v20.m128_i32[0] = 0;
v20.m128_u64[1] = 3LL;
a3 = v20;
*(__m128 *)(*(_QWORD *)(a2 + 112) - 16LL) = v20;
if ( (_DWORD)v22 )
break;
v21 = js_async_generator_await(a1, a2, v24, *((_QWORD *)&v24 + 1));
result = JS_FreeValue(a1, v24, *((long long *)&v24 + 1));
if ( v21 >= 0 )
return result;
*(_DWORD *)(a2 + 36) = 1;
}
if ( (unsigned int)((_DWORD)v22 - 1) > 1 )
abort(v22);
if ( (_DWORD)v22 == 2 )
*(_DWORD *)(a2 + 8) = 2;
else
*(_DWORD *)(a2 + 8) = 1;
js_async_generator_resolve(a1, a2, v24, *((_QWORD *)&v24 + 1), 0LL);
JS_FreeValue(a1, v24, *((long long *)&v24 + 1));
}
}
| js_async_generator_resume_next:
SUB RSP,0xd8
MOV qword ptr [RSP + 0xd0],RDI
MOV qword ptr [RSP + 0xc8],RSI
LAB_00196b37:
MOV RDI,qword ptr [RSP + 0xc8]
ADD RDI,0x78
CALL 0x00123ab0
CMP EAX,0x0
JZ 0x00196b52
JMP 0x001970c8
LAB_00196b52:
MOV RAX,qword ptr [RSP + 0xc8]
MOV RAX,qword ptr [RAX + 0x80]
MOV qword ptr [RSP + 0xc0],RAX
MOV RAX,qword ptr [RSP + 0xc8]
MOV EAX,dword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x10],RAX
SUB RAX,0x5
JA 0x001970be
MOV RAX,qword ptr [RSP + 0x10]
LEA RCX,[0x20b2b0]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_3:
JMP 0x00196dc7
caseD_4:
JMP 0x001970ca
caseD_0:
MOV RAX,qword ptr [RSP + 0xc0]
CMP dword ptr [RAX + 0x10],0x0
JNZ 0x00196bb5
JMP 0x00196da9
LAB_00196bb5:
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0xc8]
CALL 0x001970e0
JMP 0x001970c3
caseD_5:
MOV RAX,qword ptr [RSP + 0xc0]
CMP dword ptr [RAX + 0x10],0x0
JNZ 0x00196c21
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0xc8]
MOV dword ptr [RSP + 0x90],0x0
MOV qword ptr [RSP + 0x98],0x3
MOV RDX,qword ptr [RSP + 0x90]
MOV RCX,qword ptr [RSP + 0x98]
MOV R8D,0x1
CALL 0x00197130
JMP 0x00196c8c
LAB_00196c21:
MOV RAX,qword ptr [RSP + 0xc0]
CMP dword ptr [RAX + 0x10],0x1
JNZ 0x00196c65
MOV RAX,qword ptr [RSP + 0xc8]
MOV dword ptr [RAX + 0x8],0x4
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0xc8]
MOV RAX,qword ptr [RSP + 0xc0]
MOV RDX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RAX + 0x20]
CALL 0x001971e0
JMP 0x00196c8a
LAB_00196c65:
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0xc8]
MOV RAX,qword ptr [RSP + 0xc0]
MOV RDX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RAX + 0x20]
CALL 0x00197490
LAB_00196c8a:
JMP 0x00196c8c
LAB_00196c8c:
JMP 0x001970ca
caseD_1:
MOV RAX,qword ptr [RSP + 0xc0]
MOV RDI,qword ptr [RAX + 0x18]
MOV RSI,qword ptr [RAX + 0x20]
CALL 0x001216d0
MOV qword ptr [RSP + 0x80],RAX
MOV qword ptr [RSP + 0x88],RDX
MOV RAX,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0xa0],RAX
MOV RAX,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0xa8],RAX
MOV RAX,qword ptr [RSP + 0xc0]
CMP dword ptr [RAX + 0x10],0x2
JNZ 0x00196d2d
MOV RAX,qword ptr [RSP + 0xc8]
CMP dword ptr [RAX + 0x8],0x1
JNZ 0x00196d2d
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0xa0]
MOV RDX,qword ptr [RSP + 0xa8]
CALL 0x0012cf00
MOV qword ptr [RSP + 0x70],RAX
MOV qword ptr [RSP + 0x78],RDX
MOV RAX,qword ptr [RSP + 0xc8]
MOV dword ptr [RAX + 0x24],0x1
JMP 0x00196db8
LAB_00196d2d:
MOV RAX,qword ptr [RSP + 0xc8]
MOV RAX,qword ptr [RAX + 0x70]
MOV RCX,qword ptr [RSP + 0xa0]
MOV qword ptr [RAX + -0x10],RCX
MOV RCX,qword ptr [RSP + 0xa8]
MOV qword ptr [RAX + -0x8],RCX
MOV RAX,qword ptr [RSP + 0xc8]
MOV RAX,qword ptr [RAX + 0x70]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSP + 0xc0]
MOV EDI,dword ptr [RAX + 0x10]
CALL 0x00133cc0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x60],RCX
MOV qword ptr [RSP + 0x68],RDX
MOV RCX,qword ptr [RSP + 0x60]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x68]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RSP + 0xc8]
MOV RCX,qword ptr [RAX + 0x70]
ADD RCX,0x10
MOV qword ptr [RAX + 0x70],RCX
LAB_00196da9:
MOV RAX,qword ptr [RSP + 0xc8]
MOV dword ptr [RAX + 0x24],0x0
LAB_00196db8:
MOV RAX,qword ptr [RSP + 0xc8]
MOV dword ptr [RAX + 0x8],0x3
LAB_00196dc7:
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0xc8]
ADD RSI,0x10
CALL 0x00172320
MOV qword ptr [RSP + 0x50],RAX
MOV qword ptr [RSP + 0x58],RDX
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0xb0],RAX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0xb8],RAX
MOV RDI,qword ptr [RSP + 0xb0]
MOV RSI,qword ptr [RSP + 0xb8]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x00196eaf
MOV RDI,qword ptr [RSP + 0xd0]
CALL 0x0012cf70
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x48],RDX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0xa0],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0xa8],RAX
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0xc8]
CALL 0x001970e0
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0xc8]
MOV RDX,qword ptr [RSP + 0xa0]
MOV RCX,qword ptr [RSP + 0xa8]
CALL 0x00197490
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0xa0]
MOV RDX,qword ptr [RSP + 0xa8]
CALL 0x00123c90
JMP 0x001970bc
LAB_00196eaf:
MOV RAX,qword ptr [RSP + 0xb8]
CMP EAX,0x0
JNZ 0x0019700a
MOV RAX,qword ptr [RSP + 0xc8]
MOV RAX,qword ptr [RAX + 0x70]
MOVUPS XMM0,xmmword ptr [RAX + -0x10]
MOVAPS xmmword ptr [RSP + 0xa0],XMM0
MOV RAX,qword ptr [RSP + 0xc8]
MOV RAX,qword ptr [RAX + 0x70]
MOV dword ptr [RSP + 0x28],0x0
MOV qword ptr [RSP + 0x30],0x3
MOVUPS XMM0,xmmword ptr [RSP + 0x28]
MOVUPS xmmword ptr [RAX + -0x10],XMM0
MOV EAX,dword ptr [RSP + 0xb0]
MOV dword ptr [RSP + 0x3c],EAX
MOV EAX,dword ptr [RSP + 0x3c]
MOV dword ptr [RSP + 0x4],EAX
TEST EAX,EAX
JZ 0x00196f9a
JMP 0x00196f1b
LAB_00196f1b:
MOV EAX,dword ptr [RSP + 0x4]
DEC EAX
SUB EAX,0x1
JA 0x00197000
JMP 0x00196f2c
LAB_00196f2c:
CMP dword ptr [RSP + 0x3c],0x2
JNZ 0x00196f44
MOV RAX,qword ptr [RSP + 0xc8]
MOV dword ptr [RAX + 0x8],0x2
JMP 0x00196f53
LAB_00196f44:
MOV RAX,qword ptr [RSP + 0xc8]
MOV dword ptr [RAX + 0x8],0x1
LAB_00196f53:
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0xc8]
MOV RDX,qword ptr [RSP + 0xa0]
MOV RCX,qword ptr [RSP + 0xa8]
XOR R8D,R8D
CALL 0x00197130
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0xa0]
MOV RDX,qword ptr [RSP + 0xa8]
CALL 0x00123c90
JMP 0x00197005
LAB_00196f9a:
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0xc8]
MOV RDX,qword ptr [RSP + 0xa0]
MOV RCX,qword ptr [RSP + 0xa8]
CALL 0x001974d0
MOV dword ptr [RSP + 0x38],EAX
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0xa0]
MOV RDX,qword ptr [RSP + 0xa8]
CALL 0x00123c90
CMP dword ptr [RSP + 0x38],0x0
JGE 0x00196ffb
MOV RAX,qword ptr [RSP + 0xc8]
MOV dword ptr [RAX + 0x24],0x1
JMP 0x00196dc7
LAB_00196ffb:
JMP 0x001970ca
LAB_00197000:
CALL 0x0010e090
LAB_00197005:
JMP 0x001970ba
LAB_0019700a:
MOV RAX,qword ptr [RSP + 0xc8]
MOV RAX,qword ptr [RAX + 0x70]
MOV RCX,qword ptr [RAX + -0x10]
MOV qword ptr [RSP + 0xa0],RCX
MOV RAX,qword ptr [RAX + -0x8]
MOV qword ptr [RSP + 0xa8],RAX
MOV RAX,qword ptr [RSP + 0xc8]
MOV RAX,qword ptr [RAX + 0x70]
MOV dword ptr [RSP + 0x18],0x0
MOV qword ptr [RSP + 0x20],0x3
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX + -0x10],RCX
MOV RCX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX + -0x8],RCX
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0xc8]
CALL 0x001970e0
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0xc8]
MOV RDX,qword ptr [RSP + 0xa0]
MOV RCX,qword ptr [RSP + 0xa8]
MOV R8D,0x1
CALL 0x00197130
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0xa0]
MOV RDX,qword ptr [RSP + 0xa8]
CALL 0x00123c90
LAB_001970ba:
JMP 0x001970bc
LAB_001970bc:
JMP 0x001970c3
default:
CALL 0x0010e090
LAB_001970c3:
JMP 0x00196b37
LAB_001970c8:
JMP 0x001970ca
LAB_001970ca:
ADD RSP,0xd8
RET
|
void js_async_generator_resume_next(int8 param_1,long param_2)
{
long lVar1;
int1 (*pauVar2) [16];
int8 uVar3;
int8 uVar4;
int iVar5;
int1 auVar6 [16];
uint uStack_bc;
int4 uStack_ac;
uint uStack_44;
int local_28;
LAB_00196b37:
iVar5 = list_empty(param_2 + 0x78);
if (iVar5 != 0) {
return;
}
lVar1 = *(long *)(param_2 + 0x80);
switch(*(int4 *)(param_2 + 8)) {
case 0:
if (*(int *)(lVar1 + 0x10) == 0) {
LAB_00196da9:
*(int4 *)(param_2 + 0x24) = 0;
goto LAB_00196db8;
}
js_async_generator_complete(param_1,param_2);
goto LAB_00196b37;
case 1:
case 2:
auVar6 = js_dup(*(int8 *)(lVar1 + 0x18),*(int8 *)(lVar1 + 0x20));
if ((*(int *)(lVar1 + 0x10) != 2) || (*(int *)(param_2 + 8) != 1)) {
*(int1 (*) [16])(*(long *)(param_2 + 0x70) + -0x10) = auVar6;
pauVar2 = *(int1 (**) [16])(param_2 + 0x70);
auVar6 = js_int32(*(int4 *)(lVar1 + 0x10));
*pauVar2 = auVar6;
*(long *)(param_2 + 0x70) = *(long *)(param_2 + 0x70) + 0x10;
goto LAB_00196da9;
}
JS_Throw(param_1,auVar6._0_8_,auVar6._8_8_);
*(int4 *)(param_2 + 0x24) = 1;
LAB_00196db8:
*(int4 *)(param_2 + 8) = 3;
break;
case 3:
break;
case 4:
return;
case 5:
if (*(int *)(lVar1 + 0x10) == 0) {
js_async_generator_resolve(param_1,param_2,(ulong)uStack_44 << 0x20,3,1);
return;
}
if (*(int *)(lVar1 + 0x10) == 1) {
*(int4 *)(param_2 + 8) = 4;
js_async_generator_completed_return
(param_1,param_2,*(int8 *)(lVar1 + 0x18),*(int8 *)(lVar1 + 0x20));
return;
}
js_async_generator_reject
(param_1,param_2,*(int8 *)(lVar1 + 0x18),*(int8 *)(lVar1 + 0x20));
return;
default:
/* WARNING: Subroutine does not return */
abort();
}
while( true ) {
auVar6 = async_func_resume(param_1,param_2 + 0x10);
iVar5 = JS_IsException(auVar6._0_8_,auVar6._8_8_);
if (iVar5 != 0) break;
if (auVar6._8_4_ != 0) {
uVar3 = *(int8 *)(*(long *)(param_2 + 0x70) + -0x10);
uVar4 = *(int8 *)(*(long *)(param_2 + 0x70) + -8);
lVar1 = *(long *)(param_2 + 0x70);
*(ulong *)(lVar1 + -0x10) = (ulong)uStack_bc << 0x20;
*(int8 *)(lVar1 + -8) = 3;
js_async_generator_complete(param_1,param_2);
js_async_generator_resolve(param_1,param_2,uVar3,uVar4,1);
JS_FreeValue(param_1,uVar3,uVar4);
goto LAB_00196b37;
}
uVar3 = *(int8 *)(*(long *)(param_2 + 0x70) + -0x10);
uVar4 = *(int8 *)(*(long *)(param_2 + 0x70) + -8);
lVar1 = *(long *)(param_2 + 0x70);
*(int4 *)(lVar1 + -0x10) = 0;
*(int4 *)(lVar1 + -0xc) = uStack_ac;
*(int4 *)(lVar1 + -8) = 3;
*(int4 *)(lVar1 + -4) = 0;
local_28 = auVar6._0_4_;
if (local_28 != 0) {
if (local_28 != 1 && local_28 != 2) {
/* WARNING: Subroutine does not return */
abort();
}
if (local_28 == 2) {
*(int4 *)(param_2 + 8) = 2;
}
else {
*(int4 *)(param_2 + 8) = 1;
}
js_async_generator_resolve(param_1,param_2,uVar3,uVar4,0);
JS_FreeValue(param_1,uVar3,uVar4);
goto LAB_00196b37;
}
iVar5 = js_async_generator_await(param_1,param_2,uVar3,uVar4);
JS_FreeValue(param_1,uVar3,uVar4);
if (-1 < iVar5) {
return;
}
*(int4 *)(param_2 + 0x24) = 1;
}
auVar6 = JS_GetException(param_1);
js_async_generator_complete(param_1,param_2);
js_async_generator_reject(param_1,param_2,auVar6._0_8_,auVar6._8_8_);
JS_FreeValue(param_1,auVar6._0_8_,auVar6._8_8_);
goto LAB_00196b37;
}
| |
29,296 | js_async_generator_resume_next | bluesky950520[P]quickjs/quickjs.c | static void js_async_generator_resume_next(JSContext *ctx,
JSAsyncGeneratorData *s)
{
JSAsyncGeneratorRequest *next;
JSValue func_ret, value;
for(;;) {
if (list_empty(&s->queue))
break;
next = list_entry(s->queue.next, JSAsyncGeneratorRequest, link);
switch(s->state) {
case JS_ASYNC_GENERATOR_STATE_EXECUTING:
/* only happens when restarting execution after await() */
goto resume_exec;
case JS_ASYNC_GENERATOR_STATE_AWAITING_RETURN:
goto done;
case JS_ASYNC_GENERATOR_STATE_SUSPENDED_START:
if (next->completion_type == GEN_MAGIC_NEXT) {
goto exec_no_arg;
} else {
js_async_generator_complete(ctx, s);
}
break;
case JS_ASYNC_GENERATOR_STATE_COMPLETED:
if (next->completion_type == GEN_MAGIC_NEXT) {
js_async_generator_resolve(ctx, s, JS_UNDEFINED, TRUE);
} else if (next->completion_type == GEN_MAGIC_RETURN) {
s->state = JS_ASYNC_GENERATOR_STATE_AWAITING_RETURN;
js_async_generator_completed_return(ctx, s, next->result);
} else {
js_async_generator_reject(ctx, s, next->result);
}
goto done;
case JS_ASYNC_GENERATOR_STATE_SUSPENDED_YIELD:
case JS_ASYNC_GENERATOR_STATE_SUSPENDED_YIELD_STAR:
value = js_dup(next->result);
if (next->completion_type == GEN_MAGIC_THROW &&
s->state == JS_ASYNC_GENERATOR_STATE_SUSPENDED_YIELD) {
JS_Throw(ctx, value);
s->func_state.throw_flag = TRUE;
} else {
/* 'yield' returns a value. 'yield *' also returns a value
in case the 'throw' method is called */
s->func_state.frame.cur_sp[-1] = value;
s->func_state.frame.cur_sp[0] =
js_int32(next->completion_type);
s->func_state.frame.cur_sp++;
exec_no_arg:
s->func_state.throw_flag = FALSE;
}
s->state = JS_ASYNC_GENERATOR_STATE_EXECUTING;
resume_exec:
func_ret = async_func_resume(ctx, &s->func_state);
if (JS_IsException(func_ret)) {
value = JS_GetException(ctx);
js_async_generator_complete(ctx, s);
js_async_generator_reject(ctx, s, value);
JS_FreeValue(ctx, value);
} else if (JS_VALUE_GET_TAG(func_ret) == JS_TAG_INT) {
int func_ret_code, ret;
value = s->func_state.frame.cur_sp[-1];
s->func_state.frame.cur_sp[-1] = JS_UNDEFINED;
func_ret_code = JS_VALUE_GET_INT(func_ret);
switch(func_ret_code) {
case FUNC_RET_YIELD:
case FUNC_RET_YIELD_STAR:
if (func_ret_code == FUNC_RET_YIELD_STAR)
s->state = JS_ASYNC_GENERATOR_STATE_SUSPENDED_YIELD_STAR;
else
s->state = JS_ASYNC_GENERATOR_STATE_SUSPENDED_YIELD;
js_async_generator_resolve(ctx, s, value, FALSE);
JS_FreeValue(ctx, value);
break;
case FUNC_RET_AWAIT:
ret = js_async_generator_await(ctx, s, value);
JS_FreeValue(ctx, value);
if (ret < 0) {
/* exception: throw it */
s->func_state.throw_flag = TRUE;
goto resume_exec;
}
goto done;
default:
abort();
}
} else {
assert(JS_IsUndefined(func_ret));
/* end of function */
value = s->func_state.frame.cur_sp[-1];
s->func_state.frame.cur_sp[-1] = JS_UNDEFINED;
js_async_generator_complete(ctx, s);
js_async_generator_resolve(ctx, s, value, TRUE);
JS_FreeValue(ctx, value);
}
break;
default:
abort();
}
}
done: ;
} | O1 | c | js_async_generator_resume_next:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
leaq 0x78(%rsi), %rax
movq %rax, 0x18(%rsp)
cmpq %rax, 0x80(%rsi)
je 0x55a1f
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsi), %r12
movq %r12, 0x8(%rsp)
movl 0x8(%rbx), %ecx
cmpq $0x5, %rcx
ja 0x55a8b
movq 0x80(%rbx), %rax
leaq 0x47690(%rip), %rsi # 0x9cd8c
movslq (%rsi,%rcx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
movq 0x18(%rax), %r13
movq 0x20(%rax), %r12
movq %r13, 0x20(%rsp)
cmpl $-0x9, %r12d
jb 0x5571f
movq 0x20(%rsp), %rdx
incl (%rdx)
cmpl $0x1, %ecx
jne 0x55787
cmpl $0x2, 0x10(%rax)
jne 0x55787
movq 0x18(%r14), %r15
movq 0xf0(%r15), %rsi
movq 0xf8(%r15), %rdx
movq %r15, %rdi
callq 0x1d8c6
movq %r13, 0xf0(%r15)
movq %r12, 0xf8(%r15)
movl $0x1, 0x24(%rbx)
movq 0x8(%rsp), %r12
jmp 0x557b6
cmpl $0x0, 0x10(%rax)
je 0x557af
cmpl $0x5, %ecx
je 0x55a0d
movl $0x5, 0x8(%rbx)
movq 0x18(%r14), %rdi
movq %r12, %rsi
callq 0x3b4ca
jmp 0x55a0d
movq 0x70(%rbx), %rcx
movq %r13, -0x10(%rcx)
movq %r12, -0x8(%rcx)
movq 0x70(%rbx), %rcx
movl 0x10(%rax), %eax
movq %rax, (%rcx)
movq $0x0, 0x8(%rcx)
addq $0x10, 0x70(%rbx)
movq 0x8(%rsp), %r12
movl $0x0, 0x24(%rbx)
movl $0x3, 0x8(%rbx)
movq %r14, %rdi
movq %r12, %rsi
callq 0x43156
testl %edx, %edx
jne 0x55945
movq 0x70(%rbx), %rcx
movq -0x10(%rcx), %r13
movq -0x8(%rcx), %rbp
movl $0x0, -0x10(%rcx)
movq $0x3, -0x8(%rcx)
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jae 0x55821
movl %eax, 0x8(%rbx)
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %rbp, %rcx
xorl %r8d, %r8d
callq 0x55a90
movq 0x18(%r14), %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x1d8c6
jmp 0x558a3
testl %eax, %eax
jne 0x55a8b
movq %r13, 0x40(%rsp)
movq %rbp, 0x48(%rsp)
movq 0x88(%r14), %rsi
movq 0x90(%r14), %rdx
movq %r14, %rdi
leaq 0x40(%rsp), %r8
xorl %r9d, %r9d
callq 0x53351
movq %rdx, %r12
cmpl $0x6, %r12d
je 0x55882
movq %rax, %r15
movq (%rbx), %rsi
movq %r14, %rdi
leaq 0x20(%rsp), %rdx
xorl %ecx, %ecx
callq 0x55d10
testl %eax, %eax
je 0x558b2
movq 0x18(%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1d8c6
movq 0x18(%r14), %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x1d8c6
movl $0x1, 0x24(%rbx)
movl $0x5, %r15d
movq 0x8(%rsp), %r12
cmpl $0x5, %r15d
je 0x557bd
jmp 0x559a5
movl $0x8, %eax
movl $0x0, 0x48(%rsp,%rax)
movq $0x3, 0x50(%rsp,%rax)
addq $0x10, %rax
cmpq $0x18, %rax
je 0x558b7
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
leaq 0x20(%rsp), %rcx
leaq 0x50(%rsp), %r8
callq 0x10dec
movl %eax, 0x14(%rsp)
movq 0x18(%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1d8c6
movl $0x8, %r15d
movq 0x18(%rsp,%r15), %rsi
movq 0x20(%rsp,%r15), %rdx
movq 0x18(%r14), %rdi
callq 0x1d8c6
addq $0x10, %r15
cmpq $0x18, %r15
je 0x55903
cmpl $0x0, 0x14(%rsp)
jne 0x55882
movq 0x18(%r14), %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x1d8c6
movl $0x6, %r15d
jmp 0x5589e
cmpl $0x6, %edx
jne 0x559ac
movq 0x18(%r14), %rax
movq 0xf0(%rax), %r15
movq 0xf8(%rax), %r12
movl $0x0, 0xf0(%rax)
movq $0x4, 0xf8(%rax)
cmpl $0x5, 0x8(%rbx)
je 0x5598c
movl $0x5, 0x8(%rbx)
movq 0x18(%r14), %rdi
movq 0x8(%rsp), %rsi
callq 0x3b4ca
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
movl $0x1, %r8d
callq 0x55c30
jmp 0x559f9
testl %r15d, %r15d
jne 0x55a1f
jmp 0x55a0d
movq 0x70(%rbx), %rax
movq -0x10(%rax), %r15
movq -0x8(%rax), %r12
movl $0x0, -0x10(%rax)
movq $0x3, -0x8(%rax)
cmpl $0x5, 0x8(%rbx)
je 0x559e2
movl $0x5, 0x8(%rbx)
movq 0x18(%r14), %rdi
movq 0x8(%rsp), %rsi
callq 0x3b4ca
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
movl $0x1, %r8d
callq 0x55a90
movq 0x18(%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1d8c6
movq 0x8(%rsp), %r12
movq 0x18(%rsp), %rax
cmpq %rax, 0x80(%rbx)
jne 0x556e1
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x10(%rax), %ecx
cmpl $0x1, %ecx
je 0x55a54
testl %ecx, %ecx
jne 0x55a70
movl $0x3, %ecx
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movl $0x1, %r8d
callq 0x55a90
jmp 0x55a1f
movl $0x4, 0x8(%rbx)
movq 0x18(%rax), %rdx
movq 0x20(%rax), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x55af2
jmp 0x55a1f
movq 0x18(%rax), %rdx
movq 0x20(%rax), %rcx
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %r8d
callq 0x55c30
jmp 0x55a1f
callq 0xe090
| js_async_generator_resume_next:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
lea rax, [rsi+78h]
mov [rsp+0A8h+var_90], rax
cmp [rsi+80h], rax
jz loc_55A1F; jumptable 0000000000055703 case 4
mov rbx, rsi
mov r14, rdi
lea r12, [rsi+10h]
mov [rsp+0A8h+var_A0], r12
loc_556E1:
mov ecx, [rbx+8]
cmp rcx, 5; switch 6 cases
ja def_55703; jumptable 0000000000055703 default case
mov rax, [rbx+80h]
lea rsi, jpt_55703
movsxd rdx, ds:(jpt_55703 - 9CD8Ch)[rsi+rcx*4]
add rdx, rsi
jmp rdx; switch jump
loc_55705:
mov r13, [rax+18h]; jumptable 0000000000055703 cases 1,2
mov r12, [rax+20h]
mov [rsp+0A8h+var_88], r13
cmp r12d, 0FFFFFFF7h
jb short loc_5571F
mov rdx, [rsp+0A8h+var_88]
inc dword ptr [rdx]
loc_5571F:
cmp ecx, 1
jnz short loc_55787
cmp dword ptr [rax+10h], 2
jnz short loc_55787
mov r15, [r14+18h]
mov rsi, [r15+0F0h]
mov rdx, [r15+0F8h]
mov rdi, r15
call JS_FreeValueRT
mov [r15+0F0h], r13
mov [r15+0F8h], r12
mov dword ptr [rbx+24h], 1
mov r12, [rsp+0A8h+var_A0]
jmp short loc_557B6
loc_55760:
cmp dword ptr [rax+10h], 0; jumptable 0000000000055703 case 0
jz short loc_557AF
cmp ecx, 5
jz loc_55A0D
mov dword ptr [rbx+8], 5
mov rdi, [r14+18h]
mov rsi, r12
call async_func_free
jmp loc_55A0D
loc_55787:
mov rcx, [rbx+70h]
mov [rcx-10h], r13
mov [rcx-8], r12
mov rcx, [rbx+70h]
mov eax, [rax+10h]
mov [rcx], rax
mov qword ptr [rcx+8], 0
add qword ptr [rbx+70h], 10h
mov r12, [rsp+0A8h+var_A0]
loc_557AF:
mov dword ptr [rbx+24h], 0
loc_557B6:
mov dword ptr [rbx+8], 3
loc_557BD:
mov rdi, r14; jumptable 0000000000055703 case 3
mov rsi, r12
call async_func_resume
test edx, edx
jnz loc_55945
mov rcx, [rbx+70h]
mov r13, [rcx-10h]
mov rbp, [rcx-8]
mov dword ptr [rcx-10h], 0
mov qword ptr [rcx-8], 3
lea ecx, [rax-1]
cmp ecx, 2
jnb short loc_55821
mov [rbx+8], eax
xor r15d, r15d
mov rdi, r14
mov rsi, rbx
mov rdx, r13
mov rcx, rbp
xor r8d, r8d
call js_async_generator_resolve
mov rdi, [r14+18h]
mov rsi, r13
mov rdx, rbp
call JS_FreeValueRT
jmp loc_558A3
loc_55821:
test eax, eax
jnz def_55703; jumptable 0000000000055703 default case
mov [rsp+0A8h+var_68], r13
mov [rsp+0A8h+var_60], rbp
mov rsi, [r14+88h]
mov rdx, [r14+90h]
mov rdi, r14
lea r8, [rsp+0A8h+var_68]
xor r9d, r9d
call js_promise_resolve
mov r12, rdx
cmp r12d, 6
jz short loc_55882
mov r15, rax
mov rsi, [rbx]
mov rdi, r14
lea rdx, [rsp+0A8h+var_88]
xor ecx, ecx
call js_async_generator_resolve_function_create
test eax, eax
jz short loc_558B2
mov rdi, [r14+18h]
mov rsi, r15
mov rdx, r12
call JS_FreeValueRT
loc_55882:
mov rdi, [r14+18h]
mov rsi, r13
mov rdx, rbp
call JS_FreeValueRT
mov dword ptr [rbx+24h], 1
mov r15d, 5
loc_5589E:
mov r12, [rsp+0A8h+var_A0]
loc_558A3:
cmp r15d, 5
jz loc_557BD; jumptable 0000000000055703 case 3
jmp loc_559A5
loc_558B2:
mov eax, 8
loc_558B7:
mov dword ptr [rsp+rax+0A8h+var_60], 0
mov [rsp+rax+0A8h+var_58], 3
add rax, 10h
cmp rax, 18h
jz short loc_558B7
mov rdi, r14
mov rsi, r15
mov rdx, r12
lea rcx, [rsp+0A8h+var_88]
lea r8, [rsp+0A8h+var_58]
call perform_promise_then
mov [rsp+0A8h+var_94], eax
mov rdi, [r14+18h]
mov rsi, r15
mov rdx, r12
call JS_FreeValueRT
mov r15d, 8
loc_55903:
mov rsi, [rsp+r15+0A8h+var_90]
mov rdx, [rsp+r15+0A8h+var_88]
mov rdi, [r14+18h]
call JS_FreeValueRT
add r15, 10h
cmp r15, 18h
jz short loc_55903
cmp [rsp+0A8h+var_94], 0
jnz loc_55882
mov rdi, [r14+18h]
mov rsi, r13
mov rdx, rbp
call JS_FreeValueRT
mov r15d, 6
jmp loc_5589E
loc_55945:
cmp edx, 6
jnz short loc_559AC
mov rax, [r14+18h]
mov r15, [rax+0F0h]
mov r12, [rax+0F8h]
mov dword ptr [rax+0F0h], 0
mov qword ptr [rax+0F8h], 4
cmp dword ptr [rbx+8], 5
jz short loc_5598C
mov dword ptr [rbx+8], 5
mov rdi, [r14+18h]
mov rsi, [rsp+0A8h+var_A0]
call async_func_free
loc_5598C:
mov rdi, r14
mov rsi, rbx
mov rdx, r15
mov rcx, r12
mov r8d, 1
call js_async_generator_resolve_or_reject
jmp short loc_559F9
loc_559A5:
test r15d, r15d
jnz short loc_55A1F; jumptable 0000000000055703 case 4
jmp short loc_55A0D
loc_559AC:
mov rax, [rbx+70h]
mov r15, [rax-10h]
mov r12, [rax-8]
mov dword ptr [rax-10h], 0
mov qword ptr [rax-8], 3
cmp dword ptr [rbx+8], 5
jz short loc_559E2
mov dword ptr [rbx+8], 5
mov rdi, [r14+18h]
mov rsi, [rsp+0A8h+var_A0]
call async_func_free
loc_559E2:
mov rdi, r14
mov rsi, rbx
mov rdx, r15
mov rcx, r12
mov r8d, 1
call js_async_generator_resolve
loc_559F9:
mov rdi, [r14+18h]
mov rsi, r15
mov rdx, r12
call JS_FreeValueRT
mov r12, [rsp+0A8h+var_A0]
loc_55A0D:
mov rax, [rsp+0A8h+var_90]
cmp [rbx+80h], rax
jnz loc_556E1
loc_55A1F:
add rsp, 78h; jumptable 0000000000055703 case 4
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_55A2E:
mov ecx, [rax+10h]; jumptable 0000000000055703 case 5
cmp ecx, 1
jz short loc_55A54
test ecx, ecx
jnz short loc_55A70
mov ecx, 3
mov rdi, r14
mov rsi, rbx
xor edx, edx
mov r8d, 1
call js_async_generator_resolve
jmp short loc_55A1F; jumptable 0000000000055703 case 4
loc_55A54:
mov dword ptr [rbx+8], 4
mov rdx, [rax+18h]
mov rcx, [rax+20h]
mov rdi, r14
mov rsi, rbx
call js_async_generator_completed_return
jmp short loc_55A1F; jumptable 0000000000055703 case 4
loc_55A70:
mov rdx, [rax+18h]
mov rcx, [rax+20h]
mov rdi, r14
mov rsi, rbx
mov r8d, 1
call js_async_generator_resolve_or_reject
jmp short loc_55A1F; jumptable 0000000000055703 case 4
def_55703:
call _abort; jumptable 0000000000055703 default case
| long long js_async_generator_resume_next(
const char *a1,
long long a2,
long long a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
long long a12,
long long a13,
long long a14)
{
long long result; // rax
long long v15; // r14
long long v16; // r12
long long v17; // rcx
long long v18; // r13
long long v19; // r12
long long v20; // r15
long long v21; // rcx
int v22; // eax
int v23; // edx
__m128 v24; // xmm4
__m128 v25; // xmm5
long long v26; // rcx
_DWORD *v27; // r13
long long v28; // rbp
long long v29; // rcx
int v30; // r15d
_DWORD *v31; // rax
long long v32; // rdx
long long v33; // r12
_DWORD *v34; // r15
long long v35; // rax
long long v36; // r15
long long v37; // rax
_DWORD *v38; // r15
long long v39; // r12
long long v40; // rax
int v41; // ecx
long long v42; // [rsp+8h] [rbp-A0h]
int v43; // [rsp+14h] [rbp-94h]
long long v44; // [rsp+18h] [rbp-90h]
_QWORD v45[4]; // [rsp+20h] [rbp-88h] BYREF
_DWORD *v46; // [rsp+40h] [rbp-68h] BYREF
long long v47; // [rsp+48h] [rbp-60h]
_QWORD v48[11]; // [rsp+50h] [rbp-58h] BYREF
result = a2 + 120;
v44 = a2 + 120;
if ( *(_QWORD *)(a2 + 128) == a2 + 120 )
return result;
v15 = (long long)a1;
v16 = a2 + 16;
v42 = a2 + 16;
do
{
v17 = *(unsigned int *)(a2 + 8);
result = *(_QWORD *)(a2 + 128);
switch ( *(_DWORD *)(a2 + 8) )
{
case 0:
if ( !*(_DWORD *)(result + 16) )
goto LABEL_13;
if ( (_DWORD)v17 != 5 )
{
*(_DWORD *)(a2 + 8) = 5;
a1 = *(const char **)(v15 + 24);
async_func_free((long long)a1, v16);
}
goto LABEL_42;
case 1:
case 2:
v18 = *(_QWORD *)(result + 24);
v19 = *(_QWORD *)(result + 32);
v45[0] = v18;
if ( (unsigned int)v19 >= 0xFFFFFFF7 )
{
a3 = v45[0];
++*(_DWORD *)v45[0];
}
if ( (_DWORD)v17 == 1 && *(_DWORD *)(result + 16) == 2 )
{
v20 = *(_QWORD *)(v15 + 24);
JS_FreeValueRT(v20, *(_DWORD **)(v20 + 240), *(_QWORD *)(v20 + 248));
*(_QWORD *)(v20 + 240) = v18;
*(_QWORD *)(v20 + 248) = v19;
*(_DWORD *)(a2 + 36) = 1;
v16 = a2 + 16;
}
else
{
v21 = *(_QWORD *)(a2 + 112);
*(_QWORD *)(v21 - 16) = v18;
*(_QWORD *)(v21 - 8) = v19;
v17 = *(_QWORD *)(a2 + 112);
*(_QWORD *)v17 = *(unsigned int *)(result + 16);
*(_QWORD *)(v17 + 8) = 0LL;
*(_QWORD *)(a2 + 112) += 16LL;
v16 = a2 + 16;
LABEL_13:
*(_DWORD *)(a2 + 36) = 0;
}
*(_DWORD *)(a2 + 8) = 3;
break;
case 3:
goto LABEL_15;
case 4:
return result;
case 5:
v41 = *(_DWORD *)(result + 16);
if ( v41 == 1 )
{
*(_DWORD *)(a2 + 8) = 4;
return js_async_generator_completed_return(v15, a2, *(_QWORD *)(result + 24), *(_QWORD *)(result + 32));
}
else if ( v41 )
{
return js_async_generator_resolve_or_reject(v15, a2, *(_QWORD *)(result + 24), *(_QWORD *)(result + 32), 1LL);
}
else
{
return js_async_generator_resolve(v15, a2, 0LL, 3LL, 1LL);
}
default:
goto LABEL_49;
}
do
{
LABEL_15:
a1 = (const char *)v15;
v22 = async_func_resume(v15, v16, a3, v17, a13, a14, a4, a5, a6, a7, a8, a9, a10, a11);
if ( v23 )
{
if ( v23 == 6 )
{
v37 = *(_QWORD *)(v15 + 24);
v38 = *(_DWORD **)(v37 + 240);
v39 = *(_QWORD *)(v37 + 248);
*(_DWORD *)(v37 + 240) = 0;
*(_QWORD *)(v37 + 248) = 4LL;
if ( *(_DWORD *)(a2 + 8) != 5 )
{
*(_DWORD *)(a2 + 8) = 5;
async_func_free(*(_QWORD *)(v15 + 24), v42);
}
js_async_generator_resolve_or_reject(v15, a2, v38, v39, 1LL);
}
else
{
v40 = *(_QWORD *)(a2 + 112);
v38 = *(_DWORD **)(v40 - 16);
v39 = *(_QWORD *)(v40 - 8);
*(_DWORD *)(v40 - 16) = 0;
*(_QWORD *)(v40 - 8) = 3LL;
if ( *(_DWORD *)(a2 + 8) != 5 )
{
*(_DWORD *)(a2 + 8) = 5;
async_func_free(*(_QWORD *)(v15 + 24), v42);
}
js_async_generator_resolve(v15, a2, v38, v39, 1LL);
}
a1 = *(const char **)(v15 + 24);
JS_FreeValueRT((long long)a1, v38, v39);
v16 = a2 + 16;
goto LABEL_42;
}
v26 = *(_QWORD *)(a2 + 112);
v27 = *(_DWORD **)(v26 - 16);
v28 = *(_QWORD *)(v26 - 8);
*(_DWORD *)(v26 - 16) = 0;
*(_QWORD *)(v26 - 8) = 3LL;
v29 = (unsigned int)(v22 - 1);
if ( (unsigned int)v29 < 2 )
{
*(_DWORD *)(a2 + 8) = v22;
v30 = 0;
js_async_generator_resolve(v15, a2, v27, v28, 0LL);
a1 = *(const char **)(v15 + 24);
result = JS_FreeValueRT((long long)a1, v27, v28);
continue;
}
if ( v22 )
LABEL_49:
abort(a1);
v46 = v27;
v47 = v28;
v31 = js_promise_resolve(
(long long *)v15,
*(_DWORD **)(v15 + 136),
*(_QWORD *)(v15 + 144),
v29,
(long long)&v46,
0LL,
a4,
a5,
a6,
a7,
v24,
v25,
a10,
a11);
v33 = v32;
if ( (_DWORD)v32 != 6 )
{
v34 = v31;
if ( (unsigned int)js_async_generator_resolve_function_create(v15, *(_QWORD *)a2, v45, 0LL) )
{
JS_FreeValueRT(*(_QWORD *)(v15 + 24), v34, v33);
}
else
{
v35 = 1LL;
do
{
LODWORD(v48[v35 - 1]) = 0;
v48[v35] = 3LL;
v35 += 2LL;
}
while ( v35 == 3 );
v43 = perform_promise_then(v15, (long long)v34, v33, (long long)v45, (long long)v48);
JS_FreeValueRT(*(_QWORD *)(v15 + 24), v34, v33);
v36 = 1LL;
do
{
JS_FreeValueRT(*(_QWORD *)(v15 + 24), (_DWORD *)v45[v36 - 1], v45[v36]);
v36 += 2LL;
}
while ( v36 == 3 );
if ( !v43 )
{
a1 = *(const char **)(v15 + 24);
result = JS_FreeValueRT((long long)a1, v27, v28);
v30 = 6;
goto LABEL_23;
}
}
}
a1 = *(const char **)(v15 + 24);
result = JS_FreeValueRT((long long)a1, v27, v28);
*(_DWORD *)(a2 + 36) = 1;
v30 = 5;
LABEL_23:
v16 = a2 + 16;
}
while ( v30 == 5 );
if ( v30 )
return result;
LABEL_42:
result = v44;
}
while ( *(_QWORD *)(a2 + 128) != v44 );
return result;
}
| |||
29,297 | my_strcasecmp_mb | eloqsql/strings/ctype-mb.c | int my_strcasecmp_mb(CHARSET_INFO * cs,const char *s, const char *t)
{
register uint32 l;
register const uchar *map=cs->to_upper;
while (*s && *t)
{
/* Pointing after the '\0' is safe here. */
if ((l=my_ismbchar(cs, s, s + cs->mbmaxlen)))
{
while (l--)
if (*s++ != *t++)
return 1;
}
else if (my_ci_charlen(cs, (const uchar *) t, (const uchar *) t + cs->mbmaxlen) > 1)
return 1;
else if (map[(uchar) *s++] != map[(uchar) *t++])
return 1;
}
/* At least one of '*s' and '*t' is zero here. */
return (*t != *s);
} | O3 | c | my_strcasecmp_mb:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movb (%rsi), %cl
testb %cl, %cl
je 0x3b53b
cmpb $0x0, (%rbx)
je 0x3b53d
movq %rsi, %r15
movq %rdi, %r14
movq 0x50(%rdi), %r12
movl 0x9c(%r14), %edx
addq %r15, %rdx
movq 0xb8(%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0xc0(%rax)
cmpl $0x2, %eax
jge 0x3b500
movl 0x9c(%r14), %edx
addq %rbx, %rdx
movq 0xb8(%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0xc0(%rax)
movl %eax, %ecx
movl $0x1, %eax
cmpl $0x1, %ecx
jg 0x3b54b
movzbl (%r15), %ecx
movb (%r12,%rcx), %cl
movzbl (%rbx), %edx
cmpb (%r12,%rdx), %cl
jne 0x3b54b
incq %r15
incq %rbx
jmp 0x3b529
movl %eax, %eax
leaq (%r15,%rax), %rcx
leaq (%rbx,%rax), %rdx
xorl %esi, %esi
cmpl %esi, %eax
je 0x3b523
movb (%r15,%rsi), %dil
leaq 0x1(%rsi), %r8
cmpb (%rbx,%rsi), %dil
movq %r8, %rsi
je 0x3b50c
jmp 0x3b546
movq %rcx, %r15
movq %rdx, %rbx
movb (%r15), %cl
testb %cl, %cl
je 0x3b53b
cmpb $0x0, (%rbx)
jne 0x3b49c
jmp 0x3b53d
xorl %ecx, %ecx
xorl %eax, %eax
cmpb %cl, (%rbx)
setne %al
jmp 0x3b54b
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| my_strcasecmp_mb:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rbx, rdx
mov cl, [rsi]
test cl, cl
jz loc_3B53B
cmp byte ptr [rbx], 0
jz loc_3B53D
mov r15, rsi
mov r14, rdi
mov r12, [rdi+50h]
loc_3B49C:
mov edx, [r14+9Ch]
add rdx, r15
mov rax, [r14+0B8h]
mov rdi, r14
mov rsi, r15
call qword ptr [rax+0C0h]
cmp eax, 2
jge short loc_3B500
mov edx, [r14+9Ch]
add rdx, rbx
mov rax, [r14+0B8h]
mov rdi, r14
mov rsi, rbx
call qword ptr [rax+0C0h]
mov ecx, eax
mov eax, 1
cmp ecx, 1
jg short loc_3B54B
movzx ecx, byte ptr [r15]
mov cl, [r12+rcx]
movzx edx, byte ptr [rbx]
cmp cl, [r12+rdx]
jnz short loc_3B54B
inc r15
inc rbx
jmp short loc_3B529
loc_3B500:
mov eax, eax
lea rcx, [r15+rax]
lea rdx, [rbx+rax]
xor esi, esi
loc_3B50C:
cmp eax, esi
jz short loc_3B523
mov dil, [r15+rsi]
lea r8, [rsi+1]
cmp dil, [rbx+rsi]
mov rsi, r8
jz short loc_3B50C
jmp short loc_3B546
loc_3B523:
mov r15, rcx
mov rbx, rdx
loc_3B529:
mov cl, [r15]
test cl, cl
jz short loc_3B53B
cmp byte ptr [rbx], 0
jnz loc_3B49C
jmp short loc_3B53D
loc_3B53B:
xor ecx, ecx
loc_3B53D:
xor eax, eax
cmp [rbx], cl
setnz al
jmp short loc_3B54B
loc_3B546:
mov eax, 1
loc_3B54B:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| _BOOL8 my_strcasecmp_mb(long long a1, unsigned __int8 *a2, _BYTE *a3)
{
_BYTE *v3; // rbx
unsigned __int8 v4; // cl
unsigned __int8 *v5; // r15
long long v6; // r12
int v7; // eax
int v8; // ecx
_BOOL8 result; // rax
long long i; // rsi
v3 = a3;
v4 = *a2;
if ( *a2 )
{
if ( *a3 )
{
v5 = a2;
v6 = *(_QWORD *)(a1 + 80);
do
{
v7 = (*(long long ( **)(long long, unsigned __int8 *, unsigned __int8 *))(*(_QWORD *)(a1 + 184) + 192LL))(
a1,
v5,
&v5[*(unsigned int *)(a1 + 156)]);
if ( v7 >= 2 )
{
for ( i = 0LL; v7 != (_DWORD)i; ++i )
{
if ( v5[i] != v3[i] )
return 1LL;
}
v5 += (unsigned int)v7;
v3 += (unsigned int)v7;
}
else
{
v8 = (*(long long ( **)(long long, _BYTE *, _BYTE *))(*(_QWORD *)(a1 + 184) + 192LL))(
a1,
v3,
&v3[*(unsigned int *)(a1 + 156)]);
result = 1LL;
if ( v8 > 1 || *(_BYTE *)(v6 + *v5) != *(_BYTE *)(v6 + (unsigned __int8)*v3) )
return result;
++v5;
++v3;
}
v4 = *v5;
if ( !*v5 )
goto LABEL_16;
}
while ( *v3 );
}
}
else
{
LABEL_16:
v4 = 0;
}
return *v3 != v4;
}
| my_strcasecmp_mb:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RDX
MOV CL,byte ptr [RSI]
TEST CL,CL
JZ 0x0013b53b
CMP byte ptr [RBX],0x0
JZ 0x0013b53d
MOV R15,RSI
MOV R14,RDI
MOV R12,qword ptr [RDI + 0x50]
LAB_0013b49c:
MOV EDX,dword ptr [R14 + 0x9c]
ADD RDX,R15
MOV RAX,qword ptr [R14 + 0xb8]
MOV RDI,R14
MOV RSI,R15
CALL qword ptr [RAX + 0xc0]
CMP EAX,0x2
JGE 0x0013b500
MOV EDX,dword ptr [R14 + 0x9c]
ADD RDX,RBX
MOV RAX,qword ptr [R14 + 0xb8]
MOV RDI,R14
MOV RSI,RBX
CALL qword ptr [RAX + 0xc0]
MOV ECX,EAX
MOV EAX,0x1
CMP ECX,0x1
JG 0x0013b54b
MOVZX ECX,byte ptr [R15]
MOV CL,byte ptr [R12 + RCX*0x1]
MOVZX EDX,byte ptr [RBX]
CMP CL,byte ptr [R12 + RDX*0x1]
JNZ 0x0013b54b
INC R15
INC RBX
JMP 0x0013b529
LAB_0013b500:
MOV EAX,EAX
LEA RCX,[R15 + RAX*0x1]
LEA RDX,[RBX + RAX*0x1]
XOR ESI,ESI
LAB_0013b50c:
CMP EAX,ESI
JZ 0x0013b523
MOV DIL,byte ptr [R15 + RSI*0x1]
LEA R8,[RSI + 0x1]
CMP DIL,byte ptr [RBX + RSI*0x1]
MOV RSI,R8
JZ 0x0013b50c
JMP 0x0013b546
LAB_0013b523:
MOV R15,RCX
MOV RBX,RDX
LAB_0013b529:
MOV CL,byte ptr [R15]
TEST CL,CL
JZ 0x0013b53b
CMP byte ptr [RBX],0x0
JNZ 0x0013b49c
JMP 0x0013b53d
LAB_0013b53b:
XOR ECX,ECX
LAB_0013b53d:
XOR EAX,EAX
CMP byte ptr [RBX],CL
SETNZ AL
JMP 0x0013b54b
LAB_0013b546:
MOV EAX,0x1
LAB_0013b54b:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
bool my_strcasecmp_mb(long param_1,byte *param_2,byte *param_3)
{
byte *pbVar1;
byte *pbVar2;
long lVar3;
uint uVar4;
int iVar5;
byte bVar6;
byte *pbVar7;
long lVar8;
byte *pbVar9;
bVar6 = *param_2;
if (bVar6 == 0) {
LAB_0013b53b:
bVar6 = 0;
}
else if (*param_3 != 0) {
lVar3 = *(long *)(param_1 + 0x50);
pbVar7 = param_3;
do {
uVar4 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xc0))
(param_1,param_2,param_2 + *(uint *)(param_1 + 0x9c));
if ((int)uVar4 < 2) {
iVar5 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xc0))
(param_1,pbVar7,pbVar7 + *(uint *)(param_1 + 0x9c));
if (1 < iVar5) {
return true;
}
if (*(char *)(lVar3 + (ulong)*param_2) != *(char *)(lVar3 + (ulong)*pbVar7)) {
return true;
}
pbVar9 = param_2 + 1;
param_3 = pbVar7 + 1;
}
else {
pbVar9 = param_2 + uVar4;
param_3 = pbVar7 + uVar4;
lVar8 = 0;
while (uVar4 != (uint)lVar8) {
pbVar1 = param_2 + lVar8;
pbVar2 = pbVar7 + lVar8;
lVar8 = lVar8 + 1;
if (*pbVar1 != *pbVar2) {
return true;
}
}
}
bVar6 = *pbVar9;
if (bVar6 == 0) goto LAB_0013b53b;
pbVar7 = param_3;
param_2 = pbVar9;
} while (*param_3 != 0);
}
return *param_3 != bVar6;
}
| |
29,298 | Query_compressed_log_event::Query_compressed_log_event(unsigned char const*, unsigned int, Format_description_log_event const*, Log_event_type) | eloqsql/sql/log_event.cc | Query_compressed_log_event::Query_compressed_log_event(const uchar *buf,
uint event_len,
const Format_description_log_event
*description_event,
Log_event_type event_type)
:Query_log_event(buf, event_len, description_event, event_type),
query_buf(NULL)
{
if (query)
{
uint32 un_len= binlog_get_uncompress_len((uchar*) query);
if (!un_len)
{
query= 0;
return;
}
/* Reserve one byte for '\0' */
query_buf= (Log_event::Byte*) my_malloc(PSI_INSTRUMENT_ME,
ALIGN_SIZE(un_len + 1), MYF(MY_WME));
if (query_buf && !binlog_buf_uncompress((uchar*) query, (uchar *) query_buf,
q_len, &un_len))
{
query_buf[un_len]= 0;
query= (char*) query_buf;
q_len= un_len;
}
else
{
query= 0;
}
}
} | O0 | cpp | Query_compressed_log_event::Query_compressed_log_event(unsigned char const*, unsigned int, Format_description_log_event const*, Log_event_type):
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
callq 0x4c6f0
movq -0x40(%rbp), %rax
leaq 0x22d22e(%rip), %rcx # 0x27a750
addq $0x10, %rcx
movq %rcx, (%rax)
movq $0x0, 0x158(%rax)
cmpq $0x0, 0xb8(%rax)
je 0x4d62a
movq -0x40(%rbp), %rax
movq 0xb8(%rax), %rdi
callq 0x4b110
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0x4d56f
movq -0x40(%rbp), %rax
movq $0x0, 0xb8(%rax)
jmp 0x4d62a
movl -0x28(%rbp), %eax
incl %eax
movl %eax, %esi
addq $0x7, %rsi
andq $-0x8, %rsi
xorl %edi, %edi
movl $0x10, %edx
callq 0xba940
movq %rax, -0x48(%rbp)
jmp 0x4d590
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x158(%rax)
cmpq $0x0, 0x158(%rax)
je 0x4d619
movq -0x40(%rbp), %rax
movq 0xb8(%rax), %rdi
movq 0x158(%rax), %rsi
movl 0xd0(%rax), %edx
leaq -0x28(%rbp), %rcx
callq 0x4b220
movl %eax, -0x4c(%rbp)
jmp 0x4d5cf
movl -0x4c(%rbp), %eax
cmpl $0x0, %eax
jne 0x4d619
movq -0x40(%rbp), %rax
movq 0x158(%rax), %rcx
movl -0x28(%rbp), %edx
movb $0x0, (%rcx,%rdx)
movq 0x158(%rax), %rcx
movq %rcx, 0xb8(%rax)
movl -0x28(%rbp), %ecx
movl %ecx, 0xd0(%rax)
jmp 0x4d628
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x67a10
jmp 0x4d630
movq -0x40(%rbp), %rax
movq $0x0, 0xb8(%rax)
jmp 0x4d62a
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3b710
nopl (%rax)
| _ZN26Query_compressed_log_eventC2EPKhjPK28Format_description_log_event14Log_event_type:
push rbp; Alternative name is 'Query_compressed_log_event::Query_compressed_log_event(unsigned char const*, unsigned int, Format_description_log_event const*, Log_event_type)'
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_20], rcx
mov [rbp+var_24], r8d
mov rdi, [rbp+var_8]
mov [rbp+var_40], rdi
mov rsi, [rbp+var_10]
mov edx, [rbp+var_14]
mov rcx, [rbp+var_20]
mov r8d, [rbp+var_24]
call _ZN15Query_log_eventC2EPKhjPK28Format_description_log_event14Log_event_type; Query_log_event::Query_log_event(uchar const*,uint,Format_description_log_event const*,Log_event_type)
mov rax, [rbp+var_40]
lea rcx, _ZTV26Query_compressed_log_event; `vtable for'Query_compressed_log_event
add rcx, 10h
mov [rax], rcx
mov qword ptr [rax+158h], 0
cmp qword ptr [rax+0B8h], 0
jz loc_4D62A
mov rax, [rbp+var_40]
mov rdi, [rax+0B8h]; unsigned __int8 *
call _Z25binlog_get_uncompress_lenPKh; binlog_get_uncompress_len(uchar const*)
mov [rbp+var_28], eax
cmp [rbp+var_28], 0
jnz short loc_4D56F
mov rax, [rbp+var_40]
mov qword ptr [rax+0B8h], 0
jmp loc_4D62A
loc_4D56F:
mov eax, [rbp+var_28]
inc eax
mov esi, eax
add rsi, 7
and rsi, 0FFFFFFFFFFFFFFF8h
xor edi, edi
mov edx, 10h
call my_malloc
mov [rbp+var_48], rax
jmp short $+2
loc_4D590:
mov rax, [rbp+var_40]
mov rcx, [rbp+var_48]
mov [rax+158h], rcx
cmp qword ptr [rax+158h], 0
jz short loc_4D619
mov rax, [rbp+var_40]
mov rdi, [rax+0B8h]; unsigned __int8 *
mov rsi, [rax+158h]; unsigned __int8 *
mov edx, [rax+0D0h]; unsigned int
lea rcx, [rbp+var_28]; unsigned int *
call _Z21binlog_buf_uncompressPKhPhjPj; binlog_buf_uncompress(uchar const*,uchar *,uint,uint *)
mov [rbp+var_4C], eax
jmp short $+2
loc_4D5CF:
mov eax, [rbp+var_4C]
cmp eax, 0
jnz short loc_4D619
mov rax, [rbp+var_40]
mov rcx, [rax+158h]
mov edx, [rbp+var_28]
mov byte ptr [rcx+rdx], 0
mov rcx, [rax+158h]
mov [rax+0B8h], rcx
mov ecx, [rbp+var_28]
mov [rax+0D0h], ecx
jmp short loc_4D628
mov rdi, [rbp+var_40]; this
mov rcx, rax
mov eax, edx
mov [rbp+var_30], rcx
mov [rbp+var_34], eax
call _ZN15Query_log_eventD2Ev; Query_log_event::~Query_log_event()
jmp short loc_4D630
loc_4D619:
mov rax, [rbp+var_40]
mov qword ptr [rax+0B8h], 0
loc_4D628:
jmp short $+2
loc_4D62A:
add rsp, 50h
pop rbp
retn
loc_4D630:
mov rdi, [rbp+var_30]
call __Unwind_Resume
| long long Query_compressed_log_event::Query_compressed_log_event(
long long a1,
unsigned __int8 *a2,
unsigned int a3,
Format_description_log_event *a4,
int a5)
{
long long result; // rax
unsigned int v6[2]; // [rsp+28h] [rbp-28h] BYREF
Format_description_log_event *v7; // [rsp+30h] [rbp-20h]
unsigned int v8; // [rsp+3Ch] [rbp-14h]
unsigned __int8 *v9; // [rsp+40h] [rbp-10h]
long long v10; // [rsp+48h] [rbp-8h]
v10 = a1;
v9 = a2;
v8 = a3;
v7 = a4;
v6[1] = a5;
Query_log_event::Query_log_event(a1, a2, a3, a4, a5);
result = a1;
*(_QWORD *)a1 = &`vtable for'Query_compressed_log_event + 2;
*(_QWORD *)(a1 + 344) = 0LL;
if ( *(_QWORD *)(a1 + 184) )
{
v6[0] = binlog_get_uncompress_len(*(const unsigned __int8 **)(a1 + 184));
if ( v6[0] )
{
*(_QWORD *)(a1 + 344) = my_malloc(0LL, (v6[0] + 1 + 7LL) & 0xFFFFFFFFFFFFFFF8LL, 16LL);
if ( !*(_QWORD *)(a1 + 344)
|| (unsigned int)binlog_buf_uncompress(
*(const unsigned __int8 **)(a1 + 184),
*(unsigned __int8 **)(a1 + 344),
*(_DWORD *)(a1 + 208),
v6) )
{
result = a1;
*(_QWORD *)(a1 + 184) = 0LL;
}
else
{
result = a1;
*(_BYTE *)(*(_QWORD *)(a1 + 344) + v6[0]) = 0;
*(_QWORD *)(a1 + 184) = *(_QWORD *)(a1 + 344);
*(_DWORD *)(a1 + 208) = v6[0];
}
}
else
{
result = a1;
*(_QWORD *)(a1 + 184) = 0LL;
}
}
return result;
}
| Query_compressed_log_event:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV dword ptr [RBP + -0x24],R8D
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x40],RDI
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x14]
MOV RCX,qword ptr [RBP + -0x20]
MOV R8D,dword ptr [RBP + -0x24]
CALL 0x0014c6f0
MOV RAX,qword ptr [RBP + -0x40]
LEA RCX,[0x37a750]
ADD RCX,0x10
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x158],0x0
CMP qword ptr [RAX + 0xb8],0x0
JZ 0x0014d62a
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RAX + 0xb8]
CALL 0x0014b110
MOV dword ptr [RBP + -0x28],EAX
CMP dword ptr [RBP + -0x28],0x0
JNZ 0x0014d56f
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX + 0xb8],0x0
JMP 0x0014d62a
LAB_0014d56f:
MOV EAX,dword ptr [RBP + -0x28]
INC EAX
MOV ESI,EAX
ADD RSI,0x7
AND RSI,-0x8
LAB_0014d57e:
XOR EDI,EDI
MOV EDX,0x10
CALL 0x001ba940
MOV qword ptr [RBP + -0x48],RAX
JMP 0x0014d590
LAB_0014d590:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x158],RCX
CMP qword ptr [RAX + 0x158],0x0
JZ 0x0014d619
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RAX + 0xb8]
MOV RSI,qword ptr [RAX + 0x158]
MOV EDX,dword ptr [RAX + 0xd0]
LEA RCX,[RBP + -0x28]
CALL 0x0014b220
LAB_0014d5ca:
MOV dword ptr [RBP + -0x4c],EAX
JMP 0x0014d5cf
LAB_0014d5cf:
MOV EAX,dword ptr [RBP + -0x4c]
CMP EAX,0x0
JNZ 0x0014d619
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RAX + 0x158]
MOV EDX,dword ptr [RBP + -0x28]
MOV byte ptr [RCX + RDX*0x1],0x0
MOV RCX,qword ptr [RAX + 0x158]
MOV qword ptr [RAX + 0xb8],RCX
MOV ECX,dword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0xd0],ECX
JMP 0x0014d628
LAB_0014d619:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX + 0xb8],0x0
LAB_0014d628:
JMP 0x0014d62a
LAB_0014d62a:
ADD RSP,0x50
POP RBP
RET
|
/* Query_compressed_log_event::Query_compressed_log_event(unsigned char const*, unsigned int,
Format_description_log_event const*, Log_event_type) */
void __thiscall
Query_compressed_log_event::Query_compressed_log_event
(Query_compressed_log_event *this,int8 param_1,int4 param_2,int8 param_3
,int4 param_5)
{
int iVar1;
int8 uVar2;
uint local_30;
int4 local_2c;
int8 local_28;
int4 local_1c;
int8 local_18;
Query_compressed_log_event *local_10;
local_2c = param_5;
local_28 = param_3;
local_1c = param_2;
local_18 = param_1;
local_10 = this;
Query_log_event::Query_log_event((Query_log_event *)this,param_1,param_2,param_3,param_5);
*(int ***)this = &PTR_print_0037a760;
*(int8 *)(this + 0x158) = 0;
if (*(long *)(this + 0xb8) != 0) {
local_30 = binlog_get_uncompress_len(*(uchar **)(this + 0xb8));
if (local_30 == 0) {
*(int8 *)(this + 0xb8) = 0;
}
else {
/* try { // try from 0014d57e to 0014d5c9 has its CatchHandler @ 0014d602 */
uVar2 = my_malloc(0,(ulong)(local_30 + 1) + 7 & 0xfffffffffffffff8,0x10);
*(int8 *)(this + 0x158) = uVar2;
if ((*(long *)(this + 0x158) == 0) ||
(iVar1 = binlog_buf_uncompress
(*(uchar **)(this + 0xb8),*(uchar **)(this + 0x158),
*(uint *)(this + 0xd0),&local_30), iVar1 != 0)) {
*(int8 *)(this + 0xb8) = 0;
}
else {
*(int1 *)(*(long *)(this + 0x158) + (ulong)local_30) = 0;
*(int8 *)(this + 0xb8) = *(int8 *)(this + 0x158);
*(uint *)(this + 0xd0) = local_30;
}
}
}
return;
}
| |
29,299 | minja::Value::at(unsigned long) | monkey531[P]llama/common/./minja.hpp | Value& at(size_t index) {
if (is_null())
throw std::runtime_error("Undefined value or reference");
if (is_array()) return array_->at(index);
if (is_object()) return object_->at(index);
throw std::runtime_error("Value is not an array or object: " + dump());
} | O0 | cpp | minja::Value::at(unsigned long):
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq 0x78(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xb6150
testb $0x1, %al
jne 0xc6686
jmp 0xc66de
movl $0x10, %edi
callq 0x52670
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x11646d(%rip), %rsi # 0x1dcb0f
callq 0x52460
jmp 0xc66a9
movq 0x8(%rsp), %rdi
movq 0x1a08eb(%rip), %rsi # 0x266fa0
movq 0x1a08a4(%rip), %rdx # 0x266f60
callq 0x52a60
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
callq 0x52e60
jmp 0xc6825
movq 0x10(%rsp), %rdi
callq 0xb8380
testb $0x1, %al
jne 0xc66ee
jmp 0xc6716
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
callq 0xb7930
movq %rax, %rdi
movq 0x70(%rsp), %rsi
callq 0xb9ff0
movq %rax, 0x80(%rsp)
jmp 0xc6815
movq 0x10(%rsp), %rdi
callq 0xb6db0
testb $0x1, %al
jne 0xc6726
jmp 0xc674e
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0xb7a10
movq %rax, %rdi
leaq 0x70(%rsp), %rsi
callq 0xc6830
movq %rax, 0x80(%rsp)
jmp 0xc6815
movb $0x1, 0x1f(%rsp)
movl $0x10, %edi
callq 0x52670
movq 0x10(%rsp), %rsi
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0xb6dd0
jmp 0xc6779
leaq 0x1163ff(%rip), %rsi # 0x1dcb7f
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x5cf00
jmp 0xc6791
movq (%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x524b0
jmp 0xc67a1
movq (%rsp), %rdi
movb $0x0, 0x1f(%rsp)
movq 0x1a07ef(%rip), %rsi # 0x266fa0
movq 0x1a07a8(%rip), %rdx # 0x266f60
callq 0x52a60
jmp 0xc682f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0xc6801
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0xc67f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x53408
leaq 0x20(%rsp), %rdi
callq 0x53408
testb $0x1, 0x1f(%rsp)
jne 0xc680a
jmp 0xc6813
movq (%rsp), %rdi
callq 0x52e60
jmp 0xc6825
movq 0x80(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0x52ae0
nop
| _ZN5minja5Value2atEm:
sub rsp, 88h
mov [rsp+88h+var_10], rdi
mov [rsp+88h+var_18], rsi
mov rdi, [rsp+88h+var_10]; this
mov [rsp+88h+var_78], rdi
call _ZNK5minja5Value7is_nullEv; minja::Value::is_null(void)
test al, 1
jnz short loc_C6686
jmp short loc_C66DE
loc_C6686:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+88h+var_80], rax
lea rsi, aUndefinedValue; "Undefined value or reference"
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_C66A9:
mov rdi, [rsp+88h+var_80]; void *
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
mov rdi, [rsp+88h+var_80]; void *
mov rcx, rax
mov eax, edx
mov [rsp+88h+var_20], rcx
mov [rsp+88h+var_24], eax
call ___cxa_free_exception
jmp loc_C6825
loc_C66DE:
mov rdi, [rsp+88h+var_78]; this
call _ZNK5minja5Value8is_arrayEv; minja::Value::is_array(void)
test al, 1
jnz short loc_C66EE
jmp short loc_C6716
loc_C66EE:
mov rdi, [rsp+88h+var_78]
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
mov rsi, [rsp+88h+var_18]
call _ZNSt6vectorIN5minja5ValueESaIS1_EE2atEm; std::vector<minja::Value>::at(ulong)
mov [rsp+88h+var_8], rax
jmp loc_C6815
loc_C6716:
mov rdi, [rsp+88h+var_78]; this
call _ZNK5minja5Value9is_objectEv; minja::Value::is_object(void)
test al, 1
jnz short loc_C6726
jmp short loc_C674E
loc_C6726:
mov rdi, [rsp+88h+var_78]
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
lea rsi, [rsp+88h+var_18]
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE2atIRmTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OSS_
mov [rsp+88h+var_8], rax
jmp loc_C6815
loc_C674E:
mov [rsp+88h+var_69], 1
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rsi, [rsp+88h+var_78]
mov [rsp+88h+var_88], rax
lea rdi, [rsp+88h+var_68]
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
jmp short $+2
loc_C6779:
lea rsi, aValueIsNotAnAr; "Value is not an array or object: "
lea rdi, [rsp+88h+var_48]
lea rdx, [rsp+88h+var_68]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
jmp short $+2
loc_C6791:
mov rdi, [rsp+88h+var_88]
lea rsi, [rsp+88h+var_48]
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
jmp short $+2
loc_C67A1:
mov rdi, [rsp+88h+var_88]; void *
mov [rsp+88h+var_69], 0
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp short loc_C682F
mov rcx, rax
mov eax, edx
mov [rsp+88h+var_20], rcx
mov [rsp+88h+var_24], eax
jmp short loc_C6801
mov rcx, rax
mov eax, edx
mov [rsp+88h+var_20], rcx
mov [rsp+88h+var_24], eax
jmp short loc_C67F7
mov rcx, rax
mov eax, edx
mov [rsp+88h+var_20], rcx
mov [rsp+88h+var_24], eax
lea rdi, [rsp+88h+var_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_C67F7:
lea rdi, [rsp+88h+var_68]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_C6801:
test [rsp+88h+var_69], 1
jnz short loc_C680A
jmp short loc_C6813
loc_C680A:
mov rdi, [rsp+88h+var_88]; void *
call ___cxa_free_exception
loc_C6813:
jmp short loc_C6825
loc_C6815:
mov rax, [rsp+88h+var_8]
add rsp, 88h
retn
loc_C6825:
mov rdi, [rsp+88h+var_20]
call __Unwind_Resume
loc_C682F:
nop
| long long minja::Value::at(minja::Value *this, long long a2)
{
_QWORD *v2; // rax
long long v3; // rax
void *v5; // [rsp+0h] [rbp-88h]
std::runtime_error *exception; // [rsp+8h] [rbp-80h]
_BYTE v7[32]; // [rsp+20h] [rbp-68h] BYREF
_BYTE v8[36]; // [rsp+40h] [rbp-48h] BYREF
long long v9[2]; // [rsp+70h] [rbp-18h] BYREF
v9[1] = (long long)this;
v9[0] = a2;
if ( (minja::Value::is_null(this) & 1) != 0 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Undefined value or reference");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( minja::Value::is_array(this) )
{
v2 = (_QWORD *)std::__shared_ptr_access<std::vector<minja::Value>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->((long long)this + 16);
return std::vector<minja::Value>::at(v2, v9[0]);
}
else
{
if ( (minja::Value::is_object(this) & 1) == 0 )
{
v5 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v7, (long long)this, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v8, (long long)"Value is not an array or object: ", (long long)v7);
std::runtime_error::runtime_error(v5, v8);
__cxa_throw(
v5,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v3 = 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->((long long)this + 32);
return ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE2atIRmTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OSS_(
v3,
v9);
}
}
| at:
SUB RSP,0x88
MOV qword ptr [RSP + 0x78],RDI
MOV qword ptr [RSP + 0x70],RSI
MOV RDI,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0x10],RDI
CALL 0x001b6150
TEST AL,0x1
JNZ 0x001c6686
JMP 0x001c66de
LAB_001c6686:
MOV EDI,0x10
CALL 0x00152670
MOV RDI,RAX
MOV RAX,RDI
MOV qword ptr [RSP + 0x8],RAX
LAB_001c669b:
LEA RSI,[0x2dcb0f]
CALL 0x00152460
LAB_001c66a7:
JMP 0x001c66a9
LAB_001c66a9:
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [0x00366fa0]
MOV RDX,qword ptr [0x00366f60]
CALL 0x00152a60
LAB_001c66de:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x001b8380
TEST AL,0x1
JNZ 0x001c66ee
JMP 0x001c6716
LAB_001c66ee:
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x10
CALL 0x001b7930
MOV RDI,RAX
MOV RSI,qword ptr [RSP + 0x70]
CALL 0x001b9ff0
MOV qword ptr [RSP + 0x80],RAX
JMP 0x001c6815
LAB_001c6716:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x001b6db0
TEST AL,0x1
JNZ 0x001c6726
JMP 0x001c674e
LAB_001c6726:
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x20
CALL 0x001b7a10
MOV RDI,RAX
LEA RSI,[RSP + 0x70]
CALL 0x001c6830
MOV qword ptr [RSP + 0x80],RAX
JMP 0x001c6815
LAB_001c674e:
MOV byte ptr [RSP + 0x1f],0x1
MOV EDI,0x10
CALL 0x00152670
MOV RSI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP],RAX
LAB_001c6766:
LEA RDI,[RSP + 0x20]
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x001b6dd0
JMP 0x001c6779
LAB_001c6779:
LEA RSI,[0x2dcb7f]
LEA RDI,[RSP + 0x40]
LEA RDX,[RSP + 0x20]
CALL 0x0015cf00
JMP 0x001c6791
LAB_001c6791:
MOV RDI,qword ptr [RSP]
LEA RSI,[RSP + 0x40]
CALL 0x001524b0
JMP 0x001c67a1
LAB_001c67a1:
MOV RDI,qword ptr [RSP]
MOV byte ptr [RSP + 0x1f],0x0
MOV RSI,qword ptr [0x00366fa0]
MOV RDX,qword ptr [0x00366f60]
CALL 0x00152a60
LAB_001c6815:
MOV RAX,qword ptr [RSP + 0x80]
ADD RSP,0x88
RET
|
/* minja::Value::at(unsigned long) */
int8 __thiscall minja::Value::at(Value *this,ulong param_1)
{
ulong uVar1;
vector<minja::Value,std::allocator<minja::Value>> *this_00;
int8 uVar2;
runtime_error *prVar3;
int1 local_68 [32];
string local_48 [48];
ulong local_18;
Value *local_10;
int8 local_8;
local_18 = param_1;
local_10 = this;
uVar1 = is_null(this);
if ((uVar1 & 1) != 0) {
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001c669b to 001c66a6 has its CatchHandler @ 001c66c1 */
std::runtime_error::runtime_error(prVar3,"Undefined value or reference");
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_00366fa0,PTR__runtime_error_00366f60);
}
uVar1 = is_array(this);
if ((uVar1 & 1) == 0) {
uVar1 = is_object(this);
if ((uVar1 & 1) == 0) {
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001c6766 to 001c6776 has its CatchHandler @ 001c67bf */
dump_abi_cxx11_((int)local_68,SUB81(this,0));
/* try { // try from 001c6779 to 001c678e has its CatchHandler @ 001c67cf */
std::operator+((char *)local_48,(string *)"Value is not an array or object: ");
/* try { // try from 001c6791 to 001c67bc has its CatchHandler @ 001c67df */
std::runtime_error::runtime_error(prVar3,local_48);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_00366fa0,PTR__runtime_error_00366f60);
}
uVar2 = 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_8 = _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE2atIRmTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OSS_
(uVar2,&local_18);
}
else {
this_00 = (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));
local_8 = std::vector<minja::Value,std::allocator<minja::Value>>::at(this_00,local_18);
}
return local_8;
}
|
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.