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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
27,800 | google::protobuf::io::CodedOutputStream::WriteLittleEndian64ToArray(unsigned long, unsigned char*) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/coded_stream.h | inline uint8_t* CodedOutputStream::WriteLittleEndian64ToArray(uint64_t value,
uint8_t* target) {
#if defined(PROTOBUF_LITTLE_ENDIAN) && \
!defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
memcpy(target, &value, sizeof(value));
#else
uint32_t part0 = static_cast<uint32_t>(value);
uint32_t part1 = static_cast<uint32_t>(value >> 32);
target[0] = static_cast<uint8_t>(part0);
target[1] = static_cast<uint8_t>(part0 >> 8);
target[2] = static_cast<uint8_t>(part0 >> 16);
target[3] = static_cast<uint8_t>(part0 >> 24);
target[4] = static_cast<uint8_t>(part1);
target[5] = static_cast<uint8_t>(part1 >> 8);
target[6] = static_cast<uint8_t>(part1 >> 16);
target[7] = static_cast<uint8_t>(part1 >> 24);
#endif
return target + sizeof(value);
} | O0 | c | google::protobuf::io::CodedOutputStream::WriteLittleEndian64ToArray(unsigned long, unsigned char*):
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
movq %rcx, (%rax)
movq -0x10(%rsp), %rax
addq $0x8, %rax
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| _ZN6google8protobuf2io17CodedOutputStream26WriteLittleEndian64ToArrayEmPh:
mov [rsp+var_8], rdi
mov [rsp+var_10], rsi
mov rax, [rsp+var_10]
mov rcx, [rsp+var_8]
mov [rax], rcx
mov rax, [rsp+var_10]
add rax, 8
retn
| _QWORD * google::protobuf::io::CodedOutputStream::WriteLittleEndian64ToArray(
google::protobuf::io::CodedOutputStream *this,
_QWORD *a2,
unsigned __int8 *a3)
{
*a2 = this;
return a2 + 1;
}
| WriteLittleEndian64ToArray:
MOV qword ptr [RSP + -0x8],RDI
MOV qword ptr [RSP + -0x10],RSI
MOV RAX,qword ptr [RSP + -0x10]
MOV RCX,qword ptr [RSP + -0x8]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RSP + -0x10]
ADD RAX,0x8
RET
|
/* google::protobuf::io::CodedOutputStream::WriteLittleEndian64ToArray(unsigned long, unsigned
char*) */
uchar * google::protobuf::io::CodedOutputStream::WriteLittleEndian64ToArray
(ulong param_1,uchar *param_2)
{
*(ulong *)param_2 = param_1;
return param_2 + 8;
}
| |
27,801 | pow5mult | eloqsql/strings/dtoa.c | static Bigint *pow5mult(Bigint *b, int k, Stack_alloc *alloc)
{
Bigint *b1, *p5, *p51=NULL;
int i;
static int p05[3]= { 5, 25, 125 };
my_bool overflow= FALSE;
if ((i= k & 3))
b= multadd(b, p05[i-1], 0, alloc);
if (!(k>>= 2))
return b;
p5= p5_a;
for (;;)
{
if (k & 1)
{
b1= mult(b, p5, alloc);
Bfree(b, alloc);
b= b1;
}
if (!(k>>= 1))
break;
/* Calculate next power of 5 */
if (overflow)
{
p51= mult(p5, p5, alloc);
Bfree(p5, alloc);
p5= p51;
}
else if (p5 < p5_a + P5A_MAX)
++p5;
else if (p5 == p5_a + P5A_MAX)
{
p5= mult(p5, p5, alloc);
overflow= TRUE;
}
}
if (p51)
Bfree(p51, alloc);
return b;
} | O0 | c | pow5mult:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x38(%rbp)
movb $0x0, -0x3d(%rbp)
movl -0x14(%rbp), %eax
andl $0x3, %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
je 0x71f53
movq -0x10(%rbp), %rdi
movl -0x3c(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x31233f(%rip), %rax # 0x384280
movl (%rax,%rcx,4), %esi
movq -0x20(%rbp), %rcx
xorl %edx, %edx
callq 0x728a0
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
sarl $0x2, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x71f6e
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x72064
leaq 0x31231b(%rip), %rax # 0x384290
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x71fae
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x72070
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x722c0
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
sarl %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x71fc0
jmp 0x72048
cmpb $0x0, -0x3d(%rbp)
je 0x71ff2
movq -0x30(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x72070
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x722c0
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x72043
leaq 0x312297(%rip), %rax # 0x384290
addq $0x90, %rax
cmpq %rax, -0x30(%rbp)
jae 0x72013
movq -0x30(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x30(%rbp)
jmp 0x72041
leaq 0x312276(%rip), %rax # 0x384290
addq $0x90, %rax
cmpq %rax, -0x30(%rbp)
jne 0x7203f
movq -0x30(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x72070
movq %rax, -0x30(%rbp)
movb $0x1, -0x3d(%rbp)
jmp 0x72041
jmp 0x72043
jmp 0x71f79
cmpq $0x0, -0x38(%rbp)
je 0x7205c
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x722c0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
| pow5mult:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_38], 0
mov [rbp+var_3D], 0
mov eax, [rbp+var_14]
and eax, 3
mov [rbp+var_3C], eax
cmp eax, 0
jz short loc_71F53
mov rdi, [rbp+var_10]
mov eax, [rbp+var_3C]
sub eax, 1
movsxd rcx, eax
lea rax, pow5mult_p05
mov esi, [rax+rcx*4]
mov rcx, [rbp+var_20]
xor edx, edx
call multadd
mov [rbp+var_10], rax
loc_71F53:
mov eax, [rbp+var_14]
sar eax, 2
mov [rbp+var_14], eax
cmp eax, 0
jnz short loc_71F6E
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
jmp loc_72064
loc_71F6E:
lea rax, p5_a
mov [rbp+var_30], rax
loc_71F79:
mov eax, [rbp+var_14]
and eax, 1
cmp eax, 0
jz short loc_71FAE
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
call mult
mov [rbp+var_28], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
call Bfree
mov rax, [rbp+var_28]
mov [rbp+var_10], rax
loc_71FAE:
mov eax, [rbp+var_14]
sar eax, 1
mov [rbp+var_14], eax
cmp eax, 0
jnz short loc_71FC0
jmp loc_72048
loc_71FC0:
cmp [rbp+var_3D], 0
jz short loc_71FF2
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
call mult
mov [rbp+var_38], rax
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_20]
call Bfree
mov rax, [rbp+var_38]
mov [rbp+var_30], rax
jmp short loc_72043
loc_71FF2:
lea rax, p5_a
add rax, 90h
cmp [rbp+var_30], rax
jnb short loc_72013
mov rax, [rbp+var_30]
add rax, 18h
mov [rbp+var_30], rax
jmp short loc_72041
loc_72013:
lea rax, p5_a
add rax, 90h
cmp [rbp+var_30], rax
jnz short loc_7203F
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
call mult
mov [rbp+var_30], rax
mov [rbp+var_3D], 1
loc_7203F:
jmp short $+2
loc_72041:
jmp short $+2
loc_72043:
jmp loc_71F79
loc_72048:
cmp [rbp+var_38], 0
jz short loc_7205C
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_20]
call Bfree
loc_7205C:
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
loc_72064:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
| long long pow5mult(long long a1, int a2, long long a3)
{
char v4; // [rsp+3h] [rbp-3Dh]
_BYTE v5[12]; // [rsp+4h] [rbp-3Ch]
_UNKNOWN **v6; // [rsp+10h] [rbp-30h]
long long v7; // [rsp+18h] [rbp-28h]
int v9; // [rsp+2Ch] [rbp-14h]
long long v10; // [rsp+30h] [rbp-10h]
v10 = a1;
*(_DWORD *)&v5[8] = 0;
v4 = 0;
*(_QWORD *)v5 = a2 & 3;
if ( (a2 & 3) != 0 )
v10 = multadd(a1, pow5mult_p05[*(_DWORD *)v5 - 1], 0LL, a3);
v9 = a2 >> 2;
if ( !(a2 >> 2) )
return v10;
v6 = &p5_a;
while ( 1 )
{
if ( (v9 & 1) != 0 )
{
v7 = mult(v10, v6, a3);
Bfree(v10, a3);
v10 = v7;
}
v9 >>= 1;
if ( !v9 )
break;
if ( v4 )
{
*(_QWORD *)&v5[4] = mult(v6, v6, a3);
Bfree(v6, a3);
v6 = *(_UNKNOWN ***)&v5[4];
}
else if ( v6 >= &p5_a + 18 )
{
if ( v6 == &p5_a + 18 )
{
v6 = (_UNKNOWN **)mult(v6, v6, a3);
v4 = 1;
}
}
else
{
v6 += 3;
}
}
if ( *(_QWORD *)&v5[4] )
Bfree(*(_QWORD *)&v5[4], a3);
return v10;
}
| pow5mult:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x38],0x0
MOV byte ptr [RBP + -0x3d],0x0
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x3
MOV dword ptr [RBP + -0x3c],EAX
CMP EAX,0x0
JZ 0x00171f53
MOV RDI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x3c]
SUB EAX,0x1
MOVSXD RCX,EAX
LEA RAX,[0x484280]
MOV ESI,dword ptr [RAX + RCX*0x4]
MOV RCX,qword ptr [RBP + -0x20]
XOR EDX,EDX
CALL 0x001728a0
MOV qword ptr [RBP + -0x10],RAX
LAB_00171f53:
MOV EAX,dword ptr [RBP + -0x14]
SAR EAX,0x2
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JNZ 0x00171f6e
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00172064
LAB_00171f6e:
LEA RAX,[0x484290]
MOV qword ptr [RBP + -0x30],RAX
LAB_00171f79:
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x1
CMP EAX,0x0
JZ 0x00171fae
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x00172070
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x001722c0
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x10],RAX
LAB_00171fae:
MOV EAX,dword ptr [RBP + -0x14]
SAR EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JNZ 0x00171fc0
JMP 0x00172048
LAB_00171fc0:
CMP byte ptr [RBP + -0x3d],0x0
JZ 0x00171ff2
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x00172070
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x001722c0
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x30],RAX
JMP 0x00172043
LAB_00171ff2:
LEA RAX,[0x484290]
ADD RAX,0x90
CMP qword ptr [RBP + -0x30],RAX
JNC 0x00172013
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x18
MOV qword ptr [RBP + -0x30],RAX
JMP 0x00172041
LAB_00172013:
LEA RAX,[0x484290]
ADD RAX,0x90
CMP qword ptr [RBP + -0x30],RAX
JNZ 0x0017203f
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x00172070
MOV qword ptr [RBP + -0x30],RAX
MOV byte ptr [RBP + -0x3d],0x1
LAB_0017203f:
JMP 0x00172041
LAB_00172041:
JMP 0x00172043
LAB_00172043:
JMP 0x00171f79
LAB_00172048:
CMP qword ptr [RBP + -0x38],0x0
JZ 0x0017205c
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x001722c0
LAB_0017205c:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
LAB_00172064:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
int8 pow5mult(int8 param_1,uint param_2,int8 param_3)
{
bool bVar1;
int8 uVar2;
int1 *local_40;
int1 *local_38;
uint local_1c;
int8 local_18;
int8 local_10;
local_40 = (int1 *)0x0;
bVar1 = false;
local_18 = param_1;
if ((param_2 & 3) != 0) {
local_18 = multadd(param_1,*(int4 *)(pow5mult_p05 + (long)(int)((param_2 & 3) - 1) * 4),0,
param_3);
}
local_1c = (int)param_2 >> 2;
if (local_1c == 0) {
local_10 = local_18;
}
else {
local_38 = p5_a;
while( true ) {
if ((local_1c & 1) != 0) {
uVar2 = mult(local_18,local_38,param_3);
Bfree(local_18,param_3);
local_18 = uVar2;
}
local_1c = (int)local_1c >> 1;
if (local_1c == 0) break;
if (bVar1) {
local_40 = (int1 *)mult(local_38,local_38,param_3);
Bfree(local_38,param_3);
local_38 = local_40;
}
else if (local_38 < (int1 *)0x484320) {
local_38 = local_38 + 0x18;
}
else if (local_38 == (int1 *)0x484320) {
local_38 = (int1 *)mult(0x484320,0x484320,param_3);
bVar1 = true;
}
}
if (local_40 != (int1 *)0x0) {
Bfree(local_40,param_3);
}
local_10 = local_18;
}
return local_10;
}
| |
27,802 | arena_destroy | eshkol/src/core/memory/arena.c | void arena_destroy(Arena* arena) {
assert(arena != NULL);
// Free all blocks
Block* block = arena->first;
while (block) {
Block* next = block->next;
free(block);
block = next;
}
// Free arena control structure
free(arena);
} | O0 | c | arena_destroy:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4035
jmp 0x4054
leaq 0x3040(%rip), %rdi # 0x707c
leaq 0x3a7b(%rip), %rsi # 0x7abe
movl $0xba, %edx
leaq 0x3b7c(%rip), %rcx # 0x7bcb
callq 0x10a0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4085
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x4060
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| arena_destroy:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
cmp [rbp+var_8], 0
jz short loc_4035
jmp short loc_4054
loc_4035:
lea rdi, aArenaNull; "arena != NULL"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eshkol"...
mov edx, 0BAh
lea rcx, aVoidArenaDestr; "void arena_destroy(Arena *)"
call ___assert_fail
loc_4054:
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov [rbp+var_10], rax
loc_4060:
cmp [rbp+var_10], 0
jz short loc_4085
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_18], rax
mov rdi, [rbp+var_10]
call _free
mov rax, [rbp+var_18]
mov [rbp+var_10], rax
jmp short loc_4060
loc_4085:
mov rdi, [rbp+var_8]
call _free
add rsp, 20h
pop rbp
retn
| long long arena_destroy(long long a1)
{
_QWORD *v2; // [rsp+8h] [rbp-18h]
_QWORD *i; // [rsp+10h] [rbp-10h]
if ( !a1 )
__assert_fail(
"arena != NULL",
"/workspace/llm4binary/github2025/eshkol/src/core/memory/arena.c",
186LL,
"void arena_destroy(Arena *)");
for ( i = *(_QWORD **)(a1 + 8); i; i = v2 )
{
v2 = (_QWORD *)*i;
free(i);
}
return free(a1);
}
| arena_destroy:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
CMP qword ptr [RBP + -0x8],0x0
JZ 0x00104035
JMP 0x00104054
LAB_00104035:
LEA RDI,[0x10707c]
LEA RSI,[0x107abe]
MOV EDX,0xba
LEA RCX,[0x107bcb]
CALL 0x001010a0
LAB_00104054:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x10],RAX
LAB_00104060:
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00104085
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00101030
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00104060
LAB_00104085:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00101030
ADD RSP,0x20
POP RBP
RET
|
void arena_destroy(void *param_1)
{
int8 *puVar1;
int8 *local_18;
if (param_1 != (void *)0x0) {
local_18 = *(int8 **)((long)param_1 + 8);
while (local_18 != (int8 *)0x0) {
puVar1 = (int8 *)*local_18;
free(local_18);
local_18 = puVar1;
}
free(param_1);
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("arena != NULL","/workspace/llm4binary/github2025/eshkol/src/core/memory/arena.c",
0xba,"void arena_destroy(Arena *)");
}
| |
27,803 | 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>::at(unsigned long) | monkey531[P]llama/common/json.hpp | reference at(size_type idx)
{
// at only works for arrays
if (JSON_HEDLEY_LIKELY(is_array()))
{
JSON_TRY
{
return set_parent(m_data.m_value.array->at(idx));
}
JSON_CATCH (std::out_of_range&)
{
// create better exception explanation
JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
}
} | O0 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::at(unsigned long):
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xe8240
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x178a66
jmp 0x178bea
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0xb8(%rsp), %rsi
callq 0x179220
movq %rax, 0x18(%rsp)
jmp 0x178a83
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdi
movq $-0x1, %rdx
callq 0x179200
movq %rax, 0x10(%rsp)
jmp 0x178aa0
movq 0x10(%rsp), %rax
addq $0xc8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
movl 0xac(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x178ca4
movq 0xb0(%rsp), %rdi
callq 0x5e0f0
movq %rax, 0xa0(%rsp)
movb $0x1, 0x5f(%rsp)
movl $0x20, %edi
callq 0x5e6b0
movq %rax, 0x8(%rsp)
movq 0xb8(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0xe8010
jmp 0x178b12
leaq 0xa7f42(%rip), %rsi # 0x220a5b
leaq 0xa7f48(%rip), %rcx # 0x220a68
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rdx
callq 0x179260
jmp 0x178b34
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rdi
movl $0x191, %esi # imm = 0x191
leaq 0x80(%rsp), %rdx
callq 0xe7db0
jmp 0x178b52
movq 0x8(%rsp), %rdi
movb $0x0, 0x5f(%rsp)
leaq 0x138455(%rip), %rsi # 0x2b0fb8
leaq -0x917aa(%rip), %rdx # 0xe73c0
callq 0x5eb30
jmp 0x178cb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x178bcb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x178bc1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x5f5d8
leaq 0x60(%rsp), %rdi
callq 0x5f5d8
testb $0x1, 0x5f(%rsp)
jne 0x178bd4
jmp 0x178bde
movq 0x8(%rsp), %rdi
callq 0x5efd0
callq 0x5ee00
jmp 0x178be5
jmp 0x178ca4
movb $0x1, 0x2f(%rsp)
movl $0x20, %edi
callq 0x5e6b0
movq 0x20(%rsp), %rdi
movq %rax, (%rsp)
callq 0xef030
movq %rax, 0x30(%rsp)
leaq 0xa7e66(%rip), %rsi # 0x220a79
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x179320
jmp 0x178c24
movq 0x20(%rsp), %rcx
movq (%rsp), %rdi
movl $0x130, %esi # imm = 0x130
leaq 0x38(%rsp), %rdx
callq 0xeedd0
jmp 0x178c3e
movq (%rsp), %rdi
movb $0x0, 0x2f(%rsp)
leaq 0x1383ea(%rip), %rsi # 0x2b1038
leaq -0x89b75(%rip), %rdx # 0xef0e0
callq 0x5eb30
jmp 0x178cb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x178c90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x5f5d8
testb $0x1, 0x2f(%rsp)
jne 0x178c99
jmp 0x178ca2
movq (%rsp), %rdi
callq 0x5efd0
jmp 0x178ca4
movq 0xb0(%rsp), %rdi
callq 0x5ebf0
movq %rax, %rdi
callq 0x6c1c0
nopl (%rax)
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atEm:
sub rsp, 0C8h
mov qword ptr [rsp+0C8h+var_8], rdi
mov [rsp+0C8h+var_10], rsi
mov rdi, qword ptr [rsp+0C8h+var_8]
mov qword ptr [rsp+0C8h+var_A8], rdi; int
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8is_arrayEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::is_array(void)
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_178A66
jmp loc_178BEA
loc_178A66:
mov rax, qword ptr [rsp+0C8h+var_A8]
mov rdi, [rax+8]
mov rsi, [rsp+0C8h+var_10]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE2atEm; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::at(ulong)
mov [rsp+0C8h+var_B0], rax
jmp short $+2
loc_178A83:
mov rsi, [rsp+0C8h+var_B0]
mov rdi, qword ptr [rsp+0C8h+var_A8]
mov rdx, 0FFFFFFFFFFFFFFFFh
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10set_parentERSD_m; 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_parent(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>&,ulong)
mov [rsp+0C8h+var_B8], rax
jmp short $+2
loc_178AA0:
mov rax, [rsp+0C8h+var_B8]
add rsp, 0C8h
retn
mov rcx, rax
mov eax, edx
mov [rsp+0C8h+var_18], rcx
mov [rsp+0C8h+var_1C], eax
mov eax, [rsp+0C8h+var_1C]
mov ecx, 1
cmp eax, ecx
jnz loc_178CA4
mov rdi, [rsp+0C8h+var_18]; void *
call ___cxa_begin_catch
mov [rsp+0C8h+var_28], rax
mov [rsp+0C8h+var_69], 1
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov [rsp+0C8h+var_C0], rax; int
mov rsi, [rsp+0C8h+var_10]; unsigned __int64
lea rdi, [rsp+0C8h+var_68]; this
call _ZNSt7__cxx119to_stringEm; std::to_string(ulong)
jmp short $+2
loc_178B12:
lea rsi, aArrayIndex; "array index "
lea rcx, aIsOutOfRange; " is out of range"
lea rdi, [rsp+0C8h+var_48]; int
lea rdx, [rsp+0C8h+var_68]; int
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA13_KcS8_RA17_S9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[13],std::string,char const(&)[17]>(char const(&)[13],std::string,char const(&)[17] &&)
jmp short $+2
loc_178B34:
mov rcx, qword ptr [rsp+0C8h+var_A8]
mov rdi, [rsp+0C8h+var_C0]; int
mov esi, 191h
lea rdx, [rsp+0C8h+var_48]
call _ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
jmp short $+2
loc_178B52:
mov rdi, [rsp+0C8h+var_C0]; void *
mov [rsp+0C8h+var_69], 0
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail12out_of_rangeE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail12out_of_rangeD2Ev; void (*)(void *)
call ___cxa_throw
jmp loc_178CB9
mov rcx, rax
mov eax, edx
mov [rsp+0C8h+var_18], rcx
mov [rsp+0C8h+var_1C], eax
jmp short loc_178BCB
mov rcx, rax
mov eax, edx
mov [rsp+0C8h+var_18], rcx
mov [rsp+0C8h+var_1C], eax
jmp short loc_178BC1
mov rcx, rax
mov eax, edx
mov [rsp+0C8h+var_18], rcx
mov [rsp+0C8h+var_1C], eax
lea rdi, [rsp+0C8h+var_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_178BC1:
lea rdi, [rsp+0C8h+var_68]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_178BCB:
test [rsp+0C8h+var_69], 1
jnz short loc_178BD4
jmp short loc_178BDE
loc_178BD4:
mov rdi, [rsp+0C8h+var_C0]; void *
call ___cxa_free_exception
loc_178BDE:
call ___cxa_end_catch
jmp short $+2
loc_178BE5:
jmp loc_178CA4
loc_178BEA:
mov [rsp+0C8h+var_99], 1
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rdi, qword ptr [rsp+0C8h+var_A8]
mov [rsp+0C8h+var_C8], rax; int
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
mov qword ptr [rsp+0C8h+var_98], rax; int
lea rsi, aCannotUseAtWit; "cannot use at() with "
lea rdi, [rsp+0C8h+var_90]; int
lea rdx, [rsp+0C8h+var_98]; int
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA22_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(char const(&)[22],char const* &&)
jmp short $+2
loc_178C24:
mov rcx, qword ptr [rsp+0C8h+var_A8]
mov rdi, [rsp+0C8h+var_C8]; int
mov esi, 130h
lea rdx, [rsp+0C8h+var_90]
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
jmp short $+2
loc_178C3E:
mov rdi, [rsp+0C8h+var_C8]; void *
mov [rsp+0C8h+var_99], 0
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail10type_errorD2Ev; void (*)(void *)
call ___cxa_throw
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::at(
long long a1,
unsigned long long a2)
{
int v3; // ecx
int v4; // r8d
int v5; // r9d
int exception; // [rsp+0h] [rbp-C8h]
nlohmann::json_abi_v3_11_3::detail::type_error *v7; // [rsp+0h] [rbp-C8h]
void *v8; // [rsp+8h] [rbp-C0h]
int v9; // [rsp+10h] [rbp-B8h]
long long v10; // [rsp+18h] [rbp-B0h]
long long v11; // [rsp+18h] [rbp-B0h]
int v12[2]; // [rsp+30h] [rbp-98h] BYREF
int v13[9]; // [rsp+38h] [rbp-90h] BYREF
unsigned long long v14; // [rsp+B8h] [rbp-10h]
int v15[2]; // [rsp+C0h] [rbp-8h]
*(_QWORD *)v15 = a1;
v14 = a2;
if ( !nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::is_array((_BYTE *)a1) )
{
exception = (unsigned int)__cxa_allocate_exception(0x20uLL);
*(_QWORD *)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>::type_name((_BYTE *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(
(int)v13,
(int)"cannot use at() with ",
(int)v12,
v3,
v4,
v5,
exception,
v8,
v9,
v10);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
v7,
304,
(long long)v13,
a1);
__cxa_throw(
v7,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::type_error::~type_error);
}
v11 = std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::at(
*(_QWORD *)(a1 + 8),
v14);
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>::set_parent(
a1,
v11,
-1LL);
}
| _M_ptr:
PUSH RAX
MOV qword ptr [RSP],RDI
MOV RDI,qword ptr [RSP]
CALL 0x00178a40
POP RCX
RET
|
/* __gnu_cxx::__aligned_membuf<std::pair<int const, std::__cxx11::string > >::_M_ptr() const */
void __thiscall
__gnu_cxx::__aligned_membuf<std::pair<int_const,std::__cxx11::string>>::_M_ptr
(__aligned_membuf<std::pair<int_const,std::__cxx11::string>> *this)
{
_M_addr(this);
return;
}
| |
27,804 | mysql_free_result | eloqsql/libmariadb/libmariadb/mariadb_lib.c | void STDCALL
mysql_free_result(MYSQL_RES *result)
{
if (result)
{
if (result->handle && result->handle->status == MYSQL_STATUS_USE_RESULT)
{
result->handle->methods->db_skip_result(result->handle);
result->handle->status=MYSQL_STATUS_READY;
}
free_rows(result->data);
if (result->fields)
ma_free_root(&result->field_alloc,MYF(0));
if (result->row)
free(result->row);
free(result);
}
return;
} | O3 | c | mysql_free_result:
testq %rdi, %rdi
je 0x19bfd
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x78(%rdi), %rdi
testq %rdi, %rdi
je 0x19bc6
cmpl $0x2, 0x488(%rdi)
jne 0x19bc6
movq 0x4d0(%rdi), %rax
callq *0x18(%rax)
movq 0x78(%rbx), %rax
movl $0x0, 0x488(%rax)
movq 0x18(%rbx), %rdi
callq 0x19326
cmpq $0x0, 0x10(%rbx)
je 0x19be1
leaq 0x28(%rbx), %rdi
xorl %esi, %esi
callq 0x21823
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x19bef
callq 0x13570
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x13570
retq
| mysql_free_result:
test rdi, rdi
jz short locret_19BFD
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
mov rdi, [rdi+78h]
test rdi, rdi
jz short loc_19BC6
cmp dword ptr [rdi+488h], 2
jnz short loc_19BC6
mov rax, [rdi+4D0h]
call qword ptr [rax+18h]
mov rax, [rbx+78h]
mov dword ptr [rax+488h], 0
loc_19BC6:
mov rdi, [rbx+18h]
call free_rows
cmp qword ptr [rbx+10h], 0
jz short loc_19BE1
lea rdi, [rbx+28h]
xor esi, esi
call ma_free_root
loc_19BE1:
mov rdi, [rbx+60h]
test rdi, rdi
jz short loc_19BEF
call _free
loc_19BEF:
mov rdi, rbx
add rsp, 8
pop rbx
pop rbp
jmp _free
locret_19BFD:
retn
| long long mysql_free_result(_QWORD *a1)
{
long long v2; // rdi
long long v3; // rdi
long long result; // rax
if ( a1 )
{
v2 = a1[15];
if ( v2 && *(_DWORD *)(v2 + 1160) == 2 )
{
(*(void ( **)(long long))(*(_QWORD *)(v2 + 1232) + 24LL))(v2);
*(_DWORD *)(a1[15] + 1160LL) = 0;
}
free_rows(a1[3]);
if ( a1[2] )
ma_free_root(a1 + 5, 0LL);
v3 = a1[12];
if ( v3 )
free(v3);
return free(a1);
}
return result;
}
| mysql_free_result:
TEST RDI,RDI
JZ 0x00119bfd
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x78]
TEST RDI,RDI
JZ 0x00119bc6
CMP dword ptr [RDI + 0x488],0x2
JNZ 0x00119bc6
MOV RAX,qword ptr [RDI + 0x4d0]
CALL qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBX + 0x78]
MOV dword ptr [RAX + 0x488],0x0
LAB_00119bc6:
MOV RDI,qword ptr [RBX + 0x18]
CALL 0x00119326
CMP qword ptr [RBX + 0x10],0x0
JZ 0x00119be1
LEA RDI,[RBX + 0x28]
XOR ESI,ESI
CALL 0x00121823
LAB_00119be1:
MOV RDI,qword ptr [RBX + 0x60]
TEST RDI,RDI
JZ 0x00119bef
CALL 0x00113570
LAB_00119bef:
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x00113570
LAB_00119bfd:
RET
|
void mysql_free_result(void *param_1)
{
long lVar1;
if (param_1 != (void *)0x0) {
lVar1 = *(long *)((long)param_1 + 0x78);
if ((lVar1 != 0) && (*(int *)(lVar1 + 0x488) == 2)) {
(**(code **)(*(long *)(lVar1 + 0x4d0) + 0x18))();
*(int4 *)(*(long *)((long)param_1 + 0x78) + 0x488) = 0;
}
free_rows(*(int8 *)((long)param_1 + 0x18));
if (*(long *)((long)param_1 + 0x10) != 0) {
ma_free_root((long)param_1 + 0x28,0);
}
if (*(void **)((long)param_1 + 0x60) != (void *)0x0) {
free(*(void **)((long)param_1 + 0x60));
}
free(param_1);
return;
}
return;
}
| |
27,805 | end_loop | fabiosvm[P]rak/src/compiler.c | static inline void end_loop(RakCompiler *comp)
{
int len = comp->loop->jumps.len;
uint32_t instr = rak_jump_instr((uint16_t) comp->chunk.instrs.len);
for (int i = 0; i < len; ++i)
{
uint16_t jump = rak_slice_get(&comp->loop->jumps, i);
patch_instr(comp, jump, instr);
}
comp->loop = comp->loop->parent;
} | O3 | c | end_loop:
movq 0x2830(%rdi), %rax
movslq 0x10(%rax), %rcx
testq %rcx, %rcx
jle 0x657c
movl 0xffc(%rdi), %edx
movzwl %dx, %edx
shll $0x8, %edx
orl $0xd, %edx
movq 0x1000(%rdi), %rsi
xorl %r8d, %r8d
movzwl 0x14(%rax,%r8,2), %r9d
movl %edx, (%rsi,%r9,4)
incq %r8
cmpq %r8, %rcx
jne 0x656a
movq (%rax), %rax
movq %rax, 0x2830(%rdi)
retq
nop
| end_loop:
mov rax, [rdi+2830h]
movsxd rcx, dword ptr [rax+10h]
test rcx, rcx
jle short loc_657C
mov edx, [rdi+0FFCh]
movzx edx, dx
shl edx, 8
or edx, 0Dh
mov rsi, [rdi+1000h]
xor r8d, r8d
loc_656A:
movzx r9d, word ptr [rax+r8*2+14h]
mov [rsi+r9*4], edx
inc r8
cmp rcx, r8
jnz short loc_656A
loc_657C:
mov rax, [rax]
mov [rdi+2830h], rax
retn
| long long end_loop(long long a1)
{
long long *v1; // rax
long long v2; // rcx
int v3; // edx
long long v4; // rsi
long long i; // r8
long long result; // rax
v1 = *(long long **)(a1 + 10288);
v2 = *((int *)v1 + 4);
if ( v2 > 0 )
{
v3 = ((unsigned __int16)*(_DWORD *)(a1 + 4092) << 8) | 0xD;
v4 = *(_QWORD *)(a1 + 4096);
for ( i = 0LL; i != v2; ++i )
*(_DWORD *)(v4 + 4LL * *((unsigned __int16 *)v1 + i + 10)) = v3;
}
result = *v1;
*(_QWORD *)(a1 + 10288) = result;
return result;
}
| end_loop:
MOV RAX,qword ptr [RDI + 0x2830]
MOVSXD RCX,dword ptr [RAX + 0x10]
TEST RCX,RCX
JLE 0x0010657c
MOV EDX,dword ptr [RDI + 0xffc]
MOVZX EDX,DX
SHL EDX,0x8
OR EDX,0xd
MOV RSI,qword ptr [RDI + 0x1000]
XOR R8D,R8D
LAB_0010656a:
MOVZX R9D,word ptr [RAX + R8*0x2 + 0x14]
MOV dword ptr [RSI + R9*0x4],EDX
INC R8
CMP RCX,R8
JNZ 0x0010656a
LAB_0010657c:
MOV RAX,qword ptr [RAX]
MOV qword ptr [RDI + 0x2830],RAX
RET
|
void end_loop(long param_1)
{
int iVar1;
uint uVar2;
int8 *puVar3;
long lVar4;
long lVar5;
puVar3 = *(int8 **)(param_1 + 0x2830);
iVar1 = *(int *)(puVar3 + 2);
if (0 < (long)iVar1) {
uVar2 = *(uint *)(param_1 + 0xffc);
lVar4 = *(long *)(param_1 + 0x1000);
lVar5 = 0;
do {
*(uint *)(lVar4 + (ulong)*(ushort *)((long)puVar3 + lVar5 * 2 + 0x14) * 4) =
(uVar2 & 0xffff) << 8 | 0xd;
lVar5 = lVar5 + 1;
} while (iVar1 != lVar5);
}
*(int8 *)(param_1 + 0x2830) = *puVar3;
return;
}
| |
27,806 | PFS_partitioned_buffer_scalable_container<PFS_buffer_scalable_container<PFS_mutex, 1024, 1024, PFS_buffer_default_array<PFS_mutex>, PFS_buffer_default_allocator<PFS_mutex>>, 2>::deallocate(PFS_mutex*) | eloqsql/storage/perfschema/pfs_buffer_container.h | void deallocate(value_type *safe_pfs)
{
/*
One issue here is that we do not know which partition
the record belongs to.
Each record points to the parent page,
and each page points to the parent buffer,
so using static_deallocate here,
which will find the correct partition by itself.
*/
B::static_deallocate(safe_pfs);
} | O0 | c | PFS_partitioned_buffer_scalable_container<PFS_buffer_scalable_container<PFS_mutex, 1024, 1024, PFS_buffer_default_array<PFS_mutex>, PFS_buffer_default_allocator<PFS_mutex>>, 2>::deallocate(PFS_mutex*):
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40760
addq $0x10, %rsp
popq %rbp
retq
nop
| _ZN41PFS_partitioned_buffer_scalable_containerI29PFS_buffer_scalable_containerI9PFS_mutexLi1024ELi1024E24PFS_buffer_default_arrayIS1_E28PFS_buffer_default_allocatorIS1_EELi2EE10deallocateEPS1_:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rdi, [rbp+var_10]
call _ZN29PFS_buffer_scalable_containerI9PFS_mutexLi1024ELi1024E24PFS_buffer_default_arrayIS0_E28PFS_buffer_default_allocatorIS0_EE17static_deallocateEPS0_; PFS_buffer_scalable_container<PFS_mutex,1024,1024,PFS_buffer_default_array<PFS_mutex>,PFS_buffer_default_allocator<PFS_mutex>>::static_deallocate(PFS_mutex*)
add rsp, 10h
pop rbp
retn
| long long PFS_partitioned_buffer_scalable_container<PFS_buffer_scalable_container<PFS_mutex,1024,1024,PFS_buffer_default_array<PFS_mutex>,PFS_buffer_default_allocator<PFS_mutex>>,2>::deallocate(
long long a1,
long long a2)
{
return PFS_buffer_scalable_container<PFS_mutex,1024,1024,PFS_buffer_default_array<PFS_mutex>,PFS_buffer_default_allocator<PFS_mutex>>::static_deallocate(a2);
}
| deallocate:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00140760
ADD RSP,0x10
POP RBP
RET
|
/* PFS_partitioned_buffer_scalable_container<PFS_buffer_scalable_container<PFS_mutex, 1024, 1024,
PFS_buffer_default_array<PFS_mutex>, PFS_buffer_default_allocator<PFS_mutex> >,
2>::deallocate(PFS_mutex*) */
void __thiscall
PFS_partitioned_buffer_scalable_container<PFS_buffer_scalable_container<PFS_mutex,1024,1024,PFS_buffer_default_array<PFS_mutex>,PFS_buffer_default_allocator<PFS_mutex>>,2>
::deallocate(PFS_partitioned_buffer_scalable_container<PFS_buffer_scalable_container<PFS_mutex,1024,1024,PFS_buffer_default_array<PFS_mutex>,PFS_buffer_default_allocator<PFS_mutex>>,2>
*this,PFS_mutex *param_1)
{
PFS_buffer_scalable_container<PFS_mutex,1024,1024,PFS_buffer_default_array<PFS_mutex>,PFS_buffer_default_allocator<PFS_mutex>>
::static_deallocate(param_1);
return;
}
| |
27,807 | my_wildcmp_8bit_impl | eloqsql/strings/ctype-simple.c | static
int my_wildcmp_8bit_impl(CHARSET_INFO *cs,
const char *str,const char *str_end,
const char *wildstr,const char *wildend,
int escape, int w_one, int w_many, int recurse_level)
{
int result= -1; /* Not found, using wildcards */
if (my_string_stack_guard && my_string_stack_guard(recurse_level))
return 1;
while (wildstr != wildend)
{
while (*wildstr != w_many && *wildstr != w_one)
{
if (*wildstr == escape && wildstr+1 != wildend)
wildstr++;
if (str == str_end || likeconv(cs,*wildstr++) != likeconv(cs,*str++))
return(1); /* No match */
if (wildstr == wildend)
return(str != str_end); /* Match if both are at end */
result=1; /* Found an anchor char */
}
if (*wildstr == w_one)
{
do
{
if (str == str_end) /* Skip one char if possible */
return(result);
INC_PTR(cs,str,str_end);
} while (++wildstr < wildend && *wildstr == w_one);
if (wildstr == wildend)
break;
}
if (*wildstr == w_many)
{ /* Found w_many */
uchar cmp;
wildstr++;
/* Remove any '%' and '_' from the wild search string */
for (; wildstr != wildend ; wildstr++)
{
if (*wildstr == w_many)
continue;
if (*wildstr == w_one)
{
if (str == str_end)
return(-1);
INC_PTR(cs,str,str_end);
continue;
}
break; /* Not a wild character */
}
if (wildstr == wildend)
return(0); /* Ok if w_many is last */
if (str == str_end)
return(-1);
if ((cmp= *wildstr) == escape && wildstr+1 != wildend)
cmp= *++wildstr;
INC_PTR(cs,wildstr,wildend); /* This is compared trough cmp */
cmp=likeconv(cs,cmp);
do
{
/*
Find the next character in the subject string equal to 'cmp', then
check recursively my_wildcmp_8bit_impl() for the pattern remainder.
*/
while (str != str_end && (uchar) likeconv(cs,*str) != cmp)
str++;
if (str++ == str_end)
return(-1); /* 'cmp' was not found in the subject string */
{
int tmp=my_wildcmp_8bit_impl(cs,str,str_end,
wildstr,wildend,escape,w_one,
w_many, recurse_level+1);
if (tmp <= 0)
return(tmp);
}
/*
The recursion call did not match. But it returned 1, which means
the pattern remainder has some non-special characters.
Continue, there is a chance that we'll find another 'cmp'
at a different position in the subject string.
*/
} while (str != str_end);
return(-1);
}
}
return(str != str_end ? 1 : 0);
} | O3 | c | my_wildcmp_8bit_impl:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r14
movl 0x20(%rbp), %r10d
leaq 0x335b15(%rip), %rax # 0x36ea10
movq (%rax), %rax
testq %rax, %rax
je 0x38f2e
movq %rbx, -0x30(%rbp)
movq %rdi, %rbx
movl %r10d, %edi
movl %r9d, %r15d
callq *%rax
movl 0x20(%rbp), %r10d
movq %rbx, %rdi
movq -0x30(%rbp), %rbx
movl %r15d, %r9d
movl $0x1, %r15d
testl %eax, %eax
jne 0x39054
movl 0x18(%rbp), %r11d
movl 0x10(%rbp), %r8d
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
cmpq %r12, %r13
je 0x3904a
movb (%r13), %al
movsbl %al, %ecx
cmpl %r11d, %ecx
sete %sil
cmpl %r8d, %ecx
sete %dl
orb %dl, %sil
je 0x38fab
testb %dl, %dl
je 0x38fa1
incq %r13
movq %r13, %rax
cmpq %rbx, %r14
je 0x39054
movq %r14, %rcx
movq %rax, %r13
cmpq %r12, %rax
jae 0x38f8e
leaq 0x1(%rcx), %r14
movsbl (%r13), %edx
leaq 0x1(%r13), %rax
cmpl %r8d, %edx
je 0x38f68
incq %rcx
cmpq %r12, %r13
je 0x39047
movb (%r13), %al
movq %rcx, %r14
movsbl %al, %eax
cmpl %r11d, %eax
jne 0x38f3c
jmp 0x3900c
movl $0x1, %r15d
cmpq %rbx, %r14
je 0x39054
leaq 0x1(%r13), %rax
cmpq %r12, %rax
cmoveq %r13, %rax
cmpl %r9d, %ecx
cmoveq %rax, %r13
movq 0x58(%rdi), %rax
movzbl (%r13), %ecx
movb (%rax,%rcx), %cl
movzbl (%r14), %edx
cmpb (%rax,%rdx), %cl
jne 0x39054
incq %r14
incq %r13
cmpq %r12, %r13
je 0x3904a
movb (%r13), %al
movsbl %al, %ecx
cmpl %r8d, %ecx
sete %dl
cmpl %r11d, %ecx
je 0x38f5e
cmpl %r8d, %ecx
jne 0x38fab
jmp 0x38f5e
leaq 0x1(%r13), %rax
xorl %r15d, %r15d
cmpq %r12, %rax
je 0x39054
addq $0x2, %r13
movb -0x1(%r13), %al
movsbl %al, %ecx
cmpl %r11d, %ecx
je 0x39039
cmpl %r8d, %ecx
jne 0x39066
cmpq %rbx, %r14
je 0x39111
incq %r14
leaq 0x1(%r13), %rax
cmpq %r12, %r13
movq %rax, %r13
jne 0x3901c
jmp 0x39054
movq %rcx, %r14
xorl %r15d, %r15d
cmpq %rbx, %r14
setne %r15b
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
cmpq %rbx, %r14
je 0x39054
movzbl %al, %ecx
leaq -0x1(%r13), %rdx
cmpl %r9d, %ecx
jne 0x39089
cmpq %r12, %r13
je 0x39089
movb (%r13), %al
movq %r13, %rdx
incq %rdx
movq 0x58(%rdi), %rcx
movzbl %al, %eax
movb (%rcx,%rax), %r13b
incl %r10d
cmpq %rbx, %r14
je 0x39054
movq 0x58(%rdi), %rax
movzbl (%r14), %ecx
cmpb %r13b, (%rax,%rcx)
je 0x390b7
incq %r14
cmpq %rbx, %r14
jne 0x390a3
jmp 0x39054
incq %r14
subq $0x8, %rsp
movq %rdi, -0x48(%rbp)
movq %r14, %rsi
movq %rdx, %rcx
movq %rbx, %rdx
movq %rcx, -0x38(%rbp)
movq %r8, %rax
movq %r12, %r8
movl %r9d, -0x30(%rbp)
movq %r10, -0x40(%rbp)
pushq %r10
pushq %r11
pushq %rax
callq 0x38ed3
addq $0x20, %rsp
testl %eax, %eax
jle 0x3911c
cmpq %rbx, %r14
movl -0x30(%rbp), %r9d
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %r10
movl 0x18(%rbp), %r11d
movl 0x10(%rbp), %r8d
movq -0x38(%rbp), %rdx
jne 0x3909a
jmp 0x39054
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
jmp 0x39054
movl %eax, %r15d
jmp 0x39054
| my_wildcmp_8bit_impl:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r12, r8
mov r13, rcx
mov rbx, rdx
mov r14, rsi
mov r10d, [rbp+arg_10]
lea rax, my_string_stack_guard
mov rax, [rax]
test rax, rax
jz short loc_38F2E
mov [rbp+var_30], rbx
mov rbx, rdi
mov edi, r10d
mov r15d, r9d
call rax
mov r10d, [rbp+arg_10]
mov rdi, rbx
mov rbx, [rbp+var_30]
mov r9d, r15d
mov r15d, 1
test eax, eax
jnz loc_39054
loc_38F2E:
mov r11d, [rbp+arg_8]
mov r8d, [rbp+arg_0]
mov r15d, 0FFFFFFFFh
loc_38F3C:
cmp r13, r12
jz loc_3904A
mov al, [r13+0]
movsx ecx, al
cmp ecx, r11d
setz sil
cmp ecx, r8d
setz dl
or sil, dl
jz short loc_38FAB
loc_38F5E:
test dl, dl
jz short loc_38FA1
inc r13
mov rax, r13
loc_38F68:
cmp r14, rbx
jz loc_39054
mov rcx, r14
mov r13, rax
cmp rax, r12
jnb short loc_38F8E
lea r14, [rcx+1]
movsx edx, byte ptr [r13+0]
lea rax, [r13+1]
cmp edx, r8d
jz short loc_38F68
loc_38F8E:
inc rcx
cmp r13, r12
jz loc_39047
mov al, [r13+0]
mov r14, rcx
loc_38FA1:
movsx eax, al
cmp eax, r11d
jnz short loc_38F3C
jmp short loc_3900C
loc_38FAB:
mov r15d, 1
cmp r14, rbx
jz loc_39054
lea rax, [r13+1]
cmp rax, r12
cmovz rax, r13
cmp ecx, r9d
cmovz r13, rax
mov rax, [rdi+58h]
movzx ecx, byte ptr [r13+0]
mov cl, [rax+rcx]
movzx edx, byte ptr [r14]
cmp cl, [rax+rdx]
jnz short loc_39054
inc r14
inc r13
cmp r13, r12
jz short loc_3904A
mov al, [r13+0]
movsx ecx, al
cmp ecx, r8d
setz dl
cmp ecx, r11d
jz loc_38F5E
cmp ecx, r8d
jnz short loc_38FAB
jmp loc_38F5E
loc_3900C:
lea rax, [r13+1]
xor r15d, r15d
cmp rax, r12
jz short loc_39054
add r13, 2
loc_3901C:
mov al, [r13-1]
movsx ecx, al
cmp ecx, r11d
jz short loc_39039
cmp ecx, r8d
jnz short loc_39066
cmp r14, rbx
jz loc_39111
inc r14
loc_39039:
lea rax, [r13+1]
cmp r13, r12
mov r13, rax
jnz short loc_3901C
jmp short loc_39054
loc_39047:
mov r14, rcx
loc_3904A:
xor r15d, r15d
cmp r14, rbx
setnz r15b
loc_39054:
mov eax, r15d
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_39066:
mov r15d, 0FFFFFFFFh
cmp r14, rbx
jz short loc_39054
movzx ecx, al
lea rdx, [r13-1]
cmp ecx, r9d
jnz short loc_39089
cmp r13, r12
jz short loc_39089
mov al, [r13+0]
mov rdx, r13
loc_39089:
inc rdx
mov rcx, [rdi+58h]
movzx eax, al
mov r13b, [rcx+rax]
inc r10d
loc_3909A:
cmp r14, rbx
jz short loc_39054
mov rax, [rdi+58h]
loc_390A3:
movzx ecx, byte ptr [r14]
cmp [rax+rcx], r13b
jz short loc_390B7
inc r14
cmp r14, rbx
jnz short loc_390A3
jmp short loc_39054
loc_390B7:
inc r14
sub rsp, 8
mov [rbp+var_48], rdi
mov rsi, r14
mov rcx, rdx
mov rdx, rbx
mov [rbp+var_38], rcx
mov rax, r8
mov r8, r12
mov dword ptr [rbp+var_30], r9d
mov [rbp+var_40], r10
push r10
push r11
push rax
call my_wildcmp_8bit_impl
add rsp, 20h
test eax, eax
jle short loc_3911C
cmp r14, rbx
mov r9d, dword ptr [rbp+var_30]
mov rdi, [rbp+var_48]
mov r10, [rbp+var_40]
mov r11d, [rbp+arg_8]
mov r8d, [rbp+arg_0]
mov rdx, [rbp+var_38]
jnz short loc_3909A
jmp loc_39054
loc_39111:
mov r15d, 0FFFFFFFFh
jmp loc_39054
loc_3911C:
mov r15d, eax
jmp loc_39054
| long long my_wildcmp_8bit_impl(
long long a1,
unsigned __int8 *a2,
unsigned __int8 *a3,
char *a4,
char *a5,
int a6,
int a7,
int a8,
unsigned int a9)
{
unsigned __int8 *v11; // rbx
unsigned int v13; // r10d
int v14; // r15d
int v15; // eax
unsigned int v16; // r15d
int v17; // r11d
int v18; // r8d
signed __int8 v19; // al
int v20; // ecx
bool v21; // dl
char *v22; // rax
unsigned __int8 *v23; // rcx
int v24; // edx
unsigned __int8 *v25; // rcx
char *v26; // rax
char *v27; // r13
unsigned __int8 v28; // al
char *v31; // rdx
_BYTE *v32; // rdx
char v33; // r13
long long v34; // r10
int v35; // eax
long long v36; // [rsp+10h] [rbp-40h]
_BYTE *v37; // [rsp+18h] [rbp-38h]
int v39; // [rsp+20h] [rbp-30h]
v11 = a3;
v13 = a9;
if ( my_string_stack_guard )
{
v14 = a6;
v15 = my_string_stack_guard(a9);
v13 = a9;
v11 = a3;
a6 = v14;
v16 = 1;
if ( v15 )
return v16;
}
v17 = a8;
v18 = a7;
v16 = -1;
do
{
if ( a4 == a5 )
return a2 != v11;
v19 = *a4;
v20 = *a4;
v21 = v20 == a7;
if ( v20 != a7 && v20 != a8 )
{
do
{
v16 = 1;
if ( a2 == v11 )
return v16;
v26 = a4 + 1;
if ( a4 + 1 == a5 )
v26 = a4;
if ( v20 == a6 )
a4 = v26;
if ( *(_BYTE *)(*(_QWORD *)(a1 + 88) + (unsigned __int8)*a4) != *(_BYTE *)(*(_QWORD *)(a1 + 88) + *a2) )
return v16;
++a2;
if ( ++a4 == a5 )
return a2 != v11;
v19 = *a4;
v20 = *a4;
v21 = v20 == a7;
}
while ( v20 != a8 && v20 != a7 );
}
if ( v21 )
{
v22 = a4 + 1;
do
{
if ( a2 == v11 )
return v16;
v23 = a2;
a4 = v22;
if ( v22 >= a5 )
break;
++a2;
v24 = *v22++;
}
while ( v24 == a7 );
v25 = v23 + 1;
if ( a4 == a5 )
{
a2 = v25;
return a2 != v11;
}
v19 = *a4;
a2 = v25;
}
}
while ( v19 != a8 );
v16 = 0;
if ( a4 + 1 == a5 )
return v16;
v27 = a4 + 2;
while ( 1 )
{
v28 = *(v27 - 1);
if ( (char)v28 == a8 )
goto LABEL_31;
if ( (char)v28 != a7 )
break;
if ( a2 == v11 )
return (unsigned int)-1;
++a2;
LABEL_31:
if ( v27++ == a5 )
return v16;
}
v16 = -1;
if ( a2 != v11 )
{
v31 = v27 - 1;
if ( v28 == a6 && v27 != a5 )
{
v28 = *v27;
v31 = v27;
}
v32 = v31 + 1;
v33 = *(_BYTE *)(*(_QWORD *)(a1 + 88) + v28);
v34 = v13 + 1;
while ( a2 != v11 )
{
while ( *(_BYTE *)(*(_QWORD *)(a1 + 88) + *a2) != v33 )
{
if ( ++a2 == v11 )
return v16;
}
++a2;
v37 = v32;
v39 = a6;
v36 = v34;
v35 = my_wildcmp_8bit_impl(a1, (_DWORD)a2, (_DWORD)v11, (_DWORD)v32, (_DWORD)a5, a6, v18, v17, v34);
if ( v35 <= 0 )
return (unsigned int)v35;
a6 = v39;
v34 = v36;
v17 = a8;
v18 = a7;
v32 = v37;
if ( a2 == v11 )
return v16;
}
}
return v16;
}
| my_wildcmp_8bit_impl:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R12,R8
MOV R13,RCX
MOV RBX,RDX
MOV R14,RSI
MOV R10D,dword ptr [RBP + 0x20]
LEA RAX,[0x46ea10]
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x00138f2e
MOV qword ptr [RBP + -0x30],RBX
MOV RBX,RDI
MOV EDI,R10D
MOV R15D,R9D
CALL RAX
MOV R10D,dword ptr [RBP + 0x20]
MOV RDI,RBX
MOV RBX,qword ptr [RBP + -0x30]
MOV R9D,R15D
MOV R15D,0x1
TEST EAX,EAX
JNZ 0x00139054
LAB_00138f2e:
MOV R11D,dword ptr [RBP + 0x18]
MOV R8D,dword ptr [RBP + 0x10]
MOV R15D,0xffffffff
LAB_00138f3c:
CMP R13,R12
JZ 0x0013904a
MOV AL,byte ptr [R13]
MOVSX ECX,AL
CMP ECX,R11D
SETZ SIL
CMP ECX,R8D
SETZ DL
OR SIL,DL
JZ 0x00138fab
LAB_00138f5e:
TEST DL,DL
JZ 0x00138fa1
INC R13
MOV RAX,R13
LAB_00138f68:
CMP R14,RBX
JZ 0x00139054
MOV RCX,R14
MOV R13,RAX
CMP RAX,R12
JNC 0x00138f8e
LEA R14,[RCX + 0x1]
MOVSX EDX,byte ptr [R13]
LEA RAX,[R13 + 0x1]
CMP EDX,R8D
JZ 0x00138f68
LAB_00138f8e:
INC RCX
CMP R13,R12
JZ 0x00139047
MOV AL,byte ptr [R13]
MOV R14,RCX
LAB_00138fa1:
MOVSX EAX,AL
CMP EAX,R11D
JNZ 0x00138f3c
JMP 0x0013900c
LAB_00138fab:
MOV R15D,0x1
CMP R14,RBX
JZ 0x00139054
LEA RAX,[R13 + 0x1]
CMP RAX,R12
CMOVZ RAX,R13
CMP ECX,R9D
CMOVZ R13,RAX
MOV RAX,qword ptr [RDI + 0x58]
MOVZX ECX,byte ptr [R13]
MOV CL,byte ptr [RAX + RCX*0x1]
MOVZX EDX,byte ptr [R14]
CMP CL,byte ptr [RAX + RDX*0x1]
JNZ 0x00139054
INC R14
INC R13
CMP R13,R12
JZ 0x0013904a
MOV AL,byte ptr [R13]
MOVSX ECX,AL
CMP ECX,R8D
SETZ DL
CMP ECX,R11D
JZ 0x00138f5e
CMP ECX,R8D
JNZ 0x00138fab
JMP 0x00138f5e
LAB_0013900c:
LEA RAX,[R13 + 0x1]
XOR R15D,R15D
CMP RAX,R12
JZ 0x00139054
ADD R13,0x2
LAB_0013901c:
MOV AL,byte ptr [R13 + -0x1]
MOVSX ECX,AL
CMP ECX,R11D
JZ 0x00139039
CMP ECX,R8D
JNZ 0x00139066
CMP R14,RBX
JZ 0x00139111
INC R14
LAB_00139039:
LEA RAX,[R13 + 0x1]
CMP R13,R12
MOV R13,RAX
JNZ 0x0013901c
JMP 0x00139054
LAB_00139047:
MOV R14,RCX
LAB_0013904a:
XOR R15D,R15D
CMP R14,RBX
SETNZ R15B
LAB_00139054:
MOV EAX,R15D
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00139066:
MOV R15D,0xffffffff
CMP R14,RBX
JZ 0x00139054
MOVZX ECX,AL
LEA RDX,[R13 + -0x1]
CMP ECX,R9D
JNZ 0x00139089
CMP R13,R12
JZ 0x00139089
MOV AL,byte ptr [R13]
MOV RDX,R13
LAB_00139089:
INC RDX
MOV RCX,qword ptr [RDI + 0x58]
MOVZX EAX,AL
MOV R13B,byte ptr [RCX + RAX*0x1]
INC R10D
LAB_0013909a:
CMP R14,RBX
JZ 0x00139054
MOV RAX,qword ptr [RDI + 0x58]
LAB_001390a3:
MOVZX ECX,byte ptr [R14]
CMP byte ptr [RAX + RCX*0x1],R13B
JZ 0x001390b7
INC R14
CMP R14,RBX
JNZ 0x001390a3
JMP 0x00139054
LAB_001390b7:
INC R14
SUB RSP,0x8
MOV qword ptr [RBP + -0x48],RDI
MOV RSI,R14
MOV RCX,RDX
MOV RDX,RBX
MOV qword ptr [RBP + -0x38],RCX
MOV RAX,R8
MOV R8,R12
MOV dword ptr [RBP + -0x30],R9D
MOV qword ptr [RBP + -0x40],R10
PUSH R10
PUSH R11
PUSH RAX
CALL 0x00138ed3
ADD RSP,0x20
TEST EAX,EAX
JLE 0x0013911c
CMP R14,RBX
MOV R9D,dword ptr [RBP + -0x30]
MOV RDI,qword ptr [RBP + -0x48]
MOV R10,qword ptr [RBP + -0x40]
MOV R11D,dword ptr [RBP + 0x18]
MOV R8D,dword ptr [RBP + 0x10]
MOV RDX,qword ptr [RBP + -0x38]
JNZ 0x0013909a
JMP 0x00139054
LAB_00139111:
MOV R15D,0xffffffff
JMP 0x00139054
LAB_0013911c:
MOV R15D,EAX
JMP 0x00139054
|
uint my_wildcmp_8bit_impl
(long param_1,byte *param_2,byte *param_3,byte *param_4,byte *param_5,ulong param_6,
uint param_7,uint param_8,int param_9)
{
char cVar1;
byte bVar2;
int iVar3;
uint uVar4;
byte *pbVar5;
uint uVar6;
byte *pbVar7;
bool bVar8;
if (my_string_stack_guard != (code *)0x0) {
param_6 = param_6 & 0xffffffff;
iVar3 = (*my_string_stack_guard)(param_9);
if (iVar3 != 0) {
return 1;
}
}
uVar4 = 0xffffffff;
while (param_4 != param_5) {
bVar2 = *param_4;
uVar6 = (uint)(char)bVar2;
bVar8 = uVar6 == param_7;
if (uVar6 != param_8 && !bVar8) {
do {
uVar4 = 1;
if (param_2 == param_3) {
return 1;
}
pbVar5 = param_4 + 1;
if (param_4 + 1 == param_5) {
pbVar5 = param_4;
}
if (uVar6 == (uint)param_6) {
param_4 = pbVar5;
}
if (*(char *)(*(long *)(param_1 + 0x58) + (ulong)*param_4) !=
*(char *)(*(long *)(param_1 + 0x58) + (ulong)*param_2)) {
return 1;
}
param_2 = param_2 + 1;
param_4 = param_4 + 1;
if (param_4 == param_5) goto LAB_0013904a;
bVar2 = *param_4;
uVar6 = (uint)(char)bVar2;
bVar8 = uVar6 == param_7;
} while ((uVar6 != param_8) && (uVar6 != param_7));
}
if (bVar8) {
do {
pbVar5 = param_2;
param_4 = param_4 + 1;
if (pbVar5 == param_3) {
return uVar4;
}
} while ((param_4 < param_5) && (param_2 = pbVar5 + 1, (int)(char)*param_4 == param_7));
param_2 = pbVar5 + 1;
if (param_4 == param_5) break;
bVar2 = *param_4;
}
if ((int)(char)bVar2 == param_8) {
if (param_4 + 1 != param_5) {
pbVar5 = param_4 + 2;
do {
bVar2 = pbVar5[-1];
if ((int)(char)bVar2 != param_8) {
if ((int)(char)bVar2 != param_7) {
if (param_2 == param_3) {
return 0xffffffff;
}
pbVar7 = pbVar5 + -1;
if (((uint)bVar2 == (uint)param_6) && (pbVar5 != param_5)) {
bVar2 = *pbVar5;
pbVar7 = pbVar5;
}
cVar1 = *(char *)(*(long *)(param_1 + 0x58) + (ulong)bVar2);
while( true ) {
if (param_2 == param_3) {
return 0xffffffff;
}
while (*(char *)(*(long *)(param_1 + 0x58) + (ulong)*param_2) != cVar1) {
param_2 = param_2 + 1;
if (param_2 == param_3) {
return 0xffffffff;
}
}
param_2 = param_2 + 1;
uVar4 = my_wildcmp_8bit_impl
(param_1,param_2,param_3,pbVar7 + 1,param_5,param_6,param_7,
param_8,param_9 + 1);
if ((int)uVar4 < 1) break;
param_6 = param_6 & 0xffffffff;
if (param_2 == param_3) {
return 0xffffffff;
}
}
return uVar4;
}
if (param_2 == param_3) {
return 0xffffffff;
}
param_2 = param_2 + 1;
}
bVar8 = pbVar5 != param_5;
pbVar5 = pbVar5 + 1;
} while (bVar8);
}
return 0;
}
}
LAB_0013904a:
return (uint)(param_2 != param_3);
}
| |
27,808 | ftxui::hcenter(std::shared_ptr<ftxui::Node>) | Andrewchistyakov[P]flashcards_lyc/build_O2/_deps/ftxui-src/src/ftxui/dom/composite_decorator.cpp | Element hcenter(Element child) {
return hbox(filler(), std::move(child), filler());
} | O2 | cpp | ftxui::hcenter(std::shared_ptr<ftxui::Node>):
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rsp), %rdi
callq 0x1e524
leaq 0x28(%rsp), %rbx
movups (%r15), %xmm0
andq $0x0, 0x8(%r15)
movaps %xmm0, -0x8(%rbx)
andq $0x0, (%r15)
movq %rsp, %rdi
callq 0x1e524
leaq 0x10(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rsp, %rcx
movq %r14, %rdi
callq 0x1e289
leaq 0x8(%rsp), %rdi
callq 0x13452
movq %rbx, %rdi
callq 0x13452
leaq 0x18(%rsp), %rdi
callq 0x13452
movq %r14, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x13452
jmp 0x1e0d7
movq %rax, %r14
movq %rbx, %rdi
callq 0x13452
leaq 0x18(%rsp), %rdi
callq 0x13452
movq %r14, %rdi
callq 0xc7f0
| _ZN5ftxui7hcenterESt10shared_ptrINS_4NodeEE:
push r15
push r14
push rbx
sub rsp, 30h
mov r15, rsi
mov r14, rdi
lea rdi, [rsp+48h+var_38]; this
call _ZN5ftxui6fillerEv; ftxui::filler(void)
lea rbx, [rsp+48h+var_20]
movups xmm0, xmmword ptr [r15]
and qword ptr [r15+8], 0
movaps xmmword ptr [rbx-8], xmm0
and qword ptr [r15], 0
mov rdi, rsp; this
call _ZN5ftxui6fillerEv; ftxui::filler(void)
lea rsi, [rsp+48h+var_38]
lea rdx, [rsp+48h+var_28]
mov rcx, rsp
mov rdi, r14
call _ZN5ftxui4hboxIJSt10shared_ptrINS_4NodeEES3_S3_EEES3_DpT_; ftxui::hbox<std::shared_ptr<ftxui::Node>,std::shared_ptr<ftxui::Node>,std::shared_ptr<ftxui::Node>>(std::shared_ptr<ftxui::Node>,std::shared_ptr<ftxui::Node>,std::shared_ptr<ftxui::Node>)
lea rdi, [rsp+48h+var_40]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, rbx
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+48h+var_30]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rax, r14
add rsp, 30h
pop rbx
pop r14
pop r15
retn
mov r14, rax
lea rdi, [rsp+arg_0]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp short loc_1E0D7
mov r14, rax
loc_1E0D7:
mov rdi, rbx
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+arg_10]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, r14
call __Unwind_Resume
| long long ftxui::hcenter(long long a1, __int128 *a2)
{
__int128 v2; // xmm0
int v3; // r8d
int v4; // r9d
char v6[8]; // [rsp+0h] [rbp-48h] BYREF
long long v7; // [rsp+8h] [rbp-40h] BYREF
_BYTE v8[8]; // [rsp+10h] [rbp-38h] BYREF
long long v9; // [rsp+18h] [rbp-30h] BYREF
_OWORD v10[2]; // [rsp+20h] [rbp-28h] BYREF
ftxui::filler((ftxui *)v8);
v2 = *a2;
*((_QWORD *)a2 + 1) = 0LL;
v10[0] = v2;
*(_QWORD *)a2 = 0LL;
ftxui::filler((ftxui *)v6);
ftxui::hbox<std::shared_ptr<ftxui::Node>,std::shared_ptr<ftxui::Node>,std::shared_ptr<ftxui::Node>>(
a1,
(unsigned int)v8,
(unsigned int)v10,
(unsigned int)v6,
v3,
v4,
v6[0]);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v7);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count((_QWORD *)v10 + 1);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v9);
return a1;
}
| hcenter:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R15,RSI
MOV R14,RDI
LEA RDI,[RSP + 0x10]
CALL 0x0011e524
LEA RBX,[RSP + 0x28]
MOVUPS XMM0,xmmword ptr [R15]
AND qword ptr [R15 + 0x8],0x0
MOVAPS xmmword ptr [RBX + -0x8],XMM0
AND qword ptr [R15],0x0
LAB_0011e07f:
MOV RDI,RSP
CALL 0x0011e524
LAB_0011e087:
LEA RSI,[RSP + 0x10]
LEA RDX,[RSP + 0x20]
MOV RCX,RSP
MOV RDI,R14
CALL 0x0011e289
LAB_0011e09c:
LEA RDI,[RSP + 0x8]
CALL 0x00113452
MOV RDI,RBX
CALL 0x00113452
LEA RDI,[RSP + 0x18]
CALL 0x00113452
MOV RAX,R14
ADD RSP,0x30
POP RBX
POP R14
POP R15
RET
|
/* ftxui::hcenter(std::shared_ptr<ftxui::Node>) */
ftxui * __thiscall ftxui::hcenter(ftxui *this,int8 *param_2)
{
ftxui afStack_48 [8];
__shared_count<(__gnu_cxx::_Lock_policy)2> local_40 [8];
ftxui local_38 [8];
__shared_count<(__gnu_cxx::_Lock_policy)2> local_30 [8];
int8 local_28;
int8 uStack_20;
filler(local_38);
local_28 = *param_2;
uStack_20 = param_2[1];
param_2[1] = 0;
*param_2 = 0;
/* try { // try from 0011e07f to 0011e086 has its CatchHandler @ 0011e0d4 */
filler(afStack_48);
/* try { // try from 0011e087 to 0011e09b has its CatchHandler @ 0011e0c5 */
hbox<std::shared_ptr<ftxui::Node>,std::shared_ptr<ftxui::Node>,std::shared_ptr<ftxui::Node>>
(this,local_38,&local_28,afStack_48);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_40);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&uStack_20);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_30);
return this;
}
| |
27,809 | write_hook_for_undo_row_update | eloqsql/storage/maria/ma_blockrec.c | my_bool write_hook_for_undo_row_update(enum translog_record_type type
__attribute__ ((unused)),
TRN *trn, MARIA_HA *tbl_info,
LSN *lsn, void *hook_arg)
{
MARIA_SHARE *share= tbl_info->s;
share->state.state.checksum+= *(ha_checksum *)hook_arg;
return write_hook_for_undo(type, trn, tbl_info, lsn, hook_arg);
} | O3 | c | write_hook_for_undo_row_update:
pushq %rbp
movq %rsp, %rbp
movq (%rdx), %rax
movl (%r8), %edx
addl %edx, 0x48(%rax)
movq (%rcx), %rax
movq %rax, 0x98(%rsi)
movq 0xa0(%rsi), %rcx
movq %rcx, %rdx
shlq $0x8, %rdx
je 0x4e883
xorl %eax, %eax
popq %rbp
retq
orq %rax, %rcx
movq %rcx, 0xa0(%rsi)
jmp 0x4e87f
| write_hook_for_undo_row_update:
push rbp
mov rbp, rsp
mov rax, [rdx]
mov edx, [r8]
add [rax+48h], edx
mov rax, [rcx]
mov [rsi+98h], rax
mov rcx, [rsi+0A0h]
mov rdx, rcx
shl rdx, 8
jz short loc_4E883
loc_4E87F:
xor eax, eax
pop rbp
retn
loc_4E883:
or rcx, rax
mov [rsi+0A0h], rcx
jmp short loc_4E87F
| long long write_hook_for_undo_row_update(long long a1, long long a2, long long a3, long long *a4, _DWORD *a5)
{
long long v5; // rax
*(_DWORD *)(*(_QWORD *)a3 + 72LL) += *a5;
v5 = *a4;
*(_QWORD *)(a2 + 152) = *a4;
if ( !(*(_QWORD *)(a2 + 160) << 8) )
*(_QWORD *)(a2 + 160) |= v5;
return 0LL;
}
| write_hook_for_undo_row_update:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDX]
MOV EDX,dword ptr [R8]
ADD dword ptr [RAX + 0x48],EDX
MOV RAX,qword ptr [RCX]
MOV qword ptr [RSI + 0x98],RAX
MOV RCX,qword ptr [RSI + 0xa0]
MOV RDX,RCX
SHL RDX,0x8
JZ 0x0014e883
LAB_0014e87f:
XOR EAX,EAX
POP RBP
RET
LAB_0014e883:
OR RCX,RAX
MOV qword ptr [RSI + 0xa0],RCX
JMP 0x0014e87f
|
int8
write_hook_for_undo_row_update
(int8 param_1,long param_2,long *param_3,ulong *param_4,int *param_5)
{
ulong uVar1;
*(int *)(*param_3 + 0x48) = *(int *)(*param_3 + 0x48) + *param_5;
uVar1 = *param_4;
*(ulong *)(param_2 + 0x98) = uVar1;
if ((*(ulong *)(param_2 + 0xa0) & 0xffffffffffffff) == 0) {
*(ulong *)(param_2 + 0xa0) = *(ulong *)(param_2 + 0xa0) | uVar1;
}
return 0;
}
| |
27,810 | Cache::isPolicyValid() | EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/src/Cache.cpp | bool Cache::isPolicyValid() {
if (!this->isPowerOfTwo(policy.cacheSize)) {
fprintf(stderr, "Invalid Cache Size %d\n", policy.cacheSize);
return false;
}
if (!this->isPowerOfTwo(policy.blockSize)) {
fprintf(stderr, "Invalid Block Size %d\n", policy.blockSize);
return false;
}
if (policy.cacheSize % policy.blockSize != 0) {
fprintf(stderr, "cacheSize %% blockSize != 0\n");
return false;
}
if (policy.blockNum * policy.blockSize != policy.cacheSize) {
fprintf(stderr, "blockNum * blockSize != cacheSize\n");
return false;
}
if (policy.blockNum % policy.associativity != 0) {
fprintf(stderr, "blockNum %% associativity != 0\n");
return false;
}
return true;
} | O0 | cpp | Cache::isPolicyValid():
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq %rdi, (%rsp)
movl 0x30(%rdi), %esi
callq 0x9400
testb $0x1, %al
jne 0x83b7
movq (%rsp), %rax
movq 0x7c3f(%rip), %rcx # 0xffd8
movq (%rcx), %rdi
movl 0x30(%rax), %edx
leaq 0x40e4(%rip), %rsi # 0xc48a
movb $0x0, %al
callq 0x6240
movb $0x0, 0x17(%rsp)
jmp 0x8484
movq (%rsp), %rdi
movl 0x34(%rdi), %esi
callq 0x9400
testb $0x1, %al
jne 0x83f0
movq (%rsp), %rax
movq 0x7c06(%rip), %rcx # 0xffd8
movq (%rcx), %rdi
movl 0x34(%rax), %edx
leaq 0x40c2(%rip), %rsi # 0xc4a1
movb $0x0, %al
callq 0x6240
movb $0x0, 0x17(%rsp)
jmp 0x8484
movq (%rsp), %rcx
movl 0x30(%rcx), %eax
xorl %edx, %edx
divl 0x34(%rcx)
cmpl $0x0, %edx
je 0x8420
movq 0x7bd0(%rip), %rax # 0xffd8
movq (%rax), %rdi
leaq 0x40a6(%rip), %rsi # 0xc4b8
movb $0x0, %al
callq 0x6240
movb $0x0, 0x17(%rsp)
jmp 0x8484
movq (%rsp), %rcx
movl 0x38(%rcx), %eax
imull 0x34(%rcx), %eax
cmpl 0x30(%rcx), %eax
je 0x844f
movq 0x7ba1(%rip), %rax # 0xffd8
movq (%rax), %rdi
leaq 0x4094(%rip), %rsi # 0xc4d5
movb $0x0, %al
callq 0x6240
movb $0x0, 0x17(%rsp)
jmp 0x8484
movq (%rsp), %rcx
movl 0x38(%rcx), %eax
xorl %edx, %edx
divl 0x3c(%rcx)
cmpl $0x0, %edx
je 0x847f
movq 0x7b71(%rip), %rax # 0xffd8
movq (%rax), %rdi
leaq 0x4087(%rip), %rsi # 0xc4f8
movb $0x0, %al
callq 0x6240
movb $0x0, 0x17(%rsp)
jmp 0x8484
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nop
| _ZN5Cache13isPolicyValidEv:
sub rsp, 18h
mov [rsp+18h+var_10], rdi
mov rdi, [rsp+18h+var_10]; this
mov [rsp+18h+var_18], rdi
mov esi, [rdi+30h]; unsigned int
call _ZN5Cache12isPowerOfTwoEj; Cache::isPowerOfTwo(uint)
test al, 1
jnz short loc_83B7
mov rax, [rsp+18h+var_18]
mov rcx, cs:stderr_ptr
mov rdi, [rcx]
mov edx, [rax+30h]
lea rsi, aInvalidCacheSi; "Invalid Cache Size %d\n"
mov al, 0
call _fprintf
mov [rsp+18h+var_1], 0
jmp loc_8484
loc_83B7:
mov rdi, [rsp+18h+var_18]; this
mov esi, [rdi+34h]; unsigned int
call _ZN5Cache12isPowerOfTwoEj; Cache::isPowerOfTwo(uint)
test al, 1
jnz short loc_83F0
mov rax, [rsp+18h+var_18]
mov rcx, cs:stderr_ptr
mov rdi, [rcx]
mov edx, [rax+34h]
lea rsi, aInvalidBlockSi; "Invalid Block Size %d\n"
mov al, 0
call _fprintf
mov [rsp+18h+var_1], 0
jmp loc_8484
loc_83F0:
mov rcx, [rsp+18h+var_18]
mov eax, [rcx+30h]
xor edx, edx
div dword ptr [rcx+34h]
cmp edx, 0
jz short loc_8420
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aCachesizeBlock_0; "cacheSize %% blockSize != 0\n"
mov al, 0
call _fprintf
mov [rsp+18h+var_1], 0
jmp short loc_8484
loc_8420:
mov rcx, [rsp+18h+var_18]
mov eax, [rcx+38h]
imul eax, [rcx+34h]
cmp eax, [rcx+30h]
jz short loc_844F
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aBlocknumBlocks; "blockNum * blockSize != cacheSize\n"
mov al, 0
call _fprintf
mov [rsp+18h+var_1], 0
jmp short loc_8484
loc_844F:
mov rcx, [rsp+18h+var_18]
mov eax, [rcx+38h]
xor edx, edx
div dword ptr [rcx+3Ch]
cmp edx, 0
jz short loc_847F
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aBlocknumAssoci; "blockNum %% associativity != 0\n"
mov al, 0
call _fprintf
mov [rsp+18h+var_1], 0
jmp short loc_8484
loc_847F:
mov [rsp+18h+var_1], 1
loc_8484:
mov al, [rsp+18h+var_1]
and al, 1
add rsp, 18h
retn
| char Cache::isPolicyValid(Cache *this)
{
if ( (Cache::isPowerOfTwo(this, *((_DWORD *)this + 12)) & 1) != 0 )
{
if ( (Cache::isPowerOfTwo(this, *((_DWORD *)this + 13)) & 1) != 0 )
{
if ( *((_DWORD *)this + 12) % *((_DWORD *)this + 13) )
{
fprintf(stderr, "cacheSize %% blockSize != 0\n");
return 0;
}
else if ( *((_DWORD *)this + 13) * *((_DWORD *)this + 14) == *((_DWORD *)this + 12) )
{
if ( *((_DWORD *)this + 14) % *((_DWORD *)this + 15) )
{
fprintf(stderr, "blockNum %% associativity != 0\n");
return 0;
}
else
{
return 1;
}
}
else
{
fprintf(stderr, "blockNum * blockSize != cacheSize\n");
return 0;
}
}
else
{
fprintf(stderr, "Invalid Block Size %d\n", *((_DWORD *)this + 13));
return 0;
}
}
else
{
fprintf(stderr, "Invalid Cache Size %d\n", *((_DWORD *)this + 12));
return 0;
}
}
| isPolicyValid:
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDI
MOV RDI,qword ptr [RSP + 0x8]
MOV qword ptr [RSP],RDI
MOV ESI,dword ptr [RDI + 0x30]
CALL 0x00109400
TEST AL,0x1
JNZ 0x001083b7
MOV RAX,qword ptr [RSP]
MOV RCX,qword ptr [0x0010ffd8]
MOV RDI,qword ptr [RCX]
MOV EDX,dword ptr [RAX + 0x30]
LEA RSI,[0x10c48a]
MOV AL,0x0
CALL 0x00106240
MOV byte ptr [RSP + 0x17],0x0
JMP 0x00108484
LAB_001083b7:
MOV RDI,qword ptr [RSP]
MOV ESI,dword ptr [RDI + 0x34]
CALL 0x00109400
TEST AL,0x1
JNZ 0x001083f0
MOV RAX,qword ptr [RSP]
MOV RCX,qword ptr [0x0010ffd8]
MOV RDI,qword ptr [RCX]
MOV EDX,dword ptr [RAX + 0x34]
LEA RSI,[0x10c4a1]
MOV AL,0x0
CALL 0x00106240
MOV byte ptr [RSP + 0x17],0x0
JMP 0x00108484
LAB_001083f0:
MOV RCX,qword ptr [RSP]
MOV EAX,dword ptr [RCX + 0x30]
XOR EDX,EDX
DIV dword ptr [RCX + 0x34]
CMP EDX,0x0
JZ 0x00108420
MOV RAX,qword ptr [0x0010ffd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x10c4b8]
MOV AL,0x0
CALL 0x00106240
MOV byte ptr [RSP + 0x17],0x0
JMP 0x00108484
LAB_00108420:
MOV RCX,qword ptr [RSP]
MOV EAX,dword ptr [RCX + 0x38]
IMUL EAX,dword ptr [RCX + 0x34]
CMP EAX,dword ptr [RCX + 0x30]
JZ 0x0010844f
MOV RAX,qword ptr [0x0010ffd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x10c4d5]
MOV AL,0x0
CALL 0x00106240
MOV byte ptr [RSP + 0x17],0x0
JMP 0x00108484
LAB_0010844f:
MOV RCX,qword ptr [RSP]
MOV EAX,dword ptr [RCX + 0x38]
XOR EDX,EDX
DIV dword ptr [RCX + 0x3c]
CMP EDX,0x0
JZ 0x0010847f
MOV RAX,qword ptr [0x0010ffd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x10c4f8]
MOV AL,0x0
CALL 0x00106240
MOV byte ptr [RSP + 0x17],0x0
JMP 0x00108484
LAB_0010847f:
MOV byte ptr [RSP + 0x17],0x1
LAB_00108484:
MOV AL,byte ptr [RSP + 0x17]
AND AL,0x1
ADD RSP,0x18
RET
|
/* Cache::isPolicyValid() */
int8 __thiscall Cache::isPolicyValid(Cache *this)
{
int iVar1;
ulong uVar2;
int4 extraout_var;
int4 extraout_var_00;
int4 extraout_var_01;
int4 extraout_var_02;
int4 extraout_var_03;
int1 local_1;
uVar2 = isPowerOfTwo(this,*(uint *)(this + 0x30));
if ((uVar2 & 1) == 0) {
iVar1 = fprintf(*(FILE **)PTR_stderr_0010ffd8,"Invalid Cache Size %d\n",
(ulong)*(uint *)(this + 0x30));
uVar2 = CONCAT44(extraout_var,iVar1);
local_1 = 0;
}
else {
uVar2 = isPowerOfTwo(this,*(uint *)(this + 0x34));
if ((uVar2 & 1) == 0) {
iVar1 = fprintf(*(FILE **)PTR_stderr_0010ffd8,"Invalid Block Size %d\n",
(ulong)*(uint *)(this + 0x34));
uVar2 = CONCAT44(extraout_var_00,iVar1);
local_1 = 0;
}
else if (*(uint *)(this + 0x30) % *(uint *)(this + 0x34) == 0) {
if (*(int *)(this + 0x38) * *(int *)(this + 0x34) == *(int *)(this + 0x30)) {
uVar2 = (ulong)*(uint *)(this + 0x38) / (ulong)*(uint *)(this + 0x3c);
if (*(uint *)(this + 0x38) % *(uint *)(this + 0x3c) == 0) {
local_1 = 1;
}
else {
iVar1 = fprintf(*(FILE **)PTR_stderr_0010ffd8,"blockNum %% associativity != 0\n");
uVar2 = CONCAT44(extraout_var_03,iVar1);
local_1 = 0;
}
}
else {
iVar1 = fprintf(*(FILE **)PTR_stderr_0010ffd8,"blockNum * blockSize != cacheSize\n");
uVar2 = CONCAT44(extraout_var_02,iVar1);
local_1 = 0;
}
}
else {
iVar1 = fprintf(*(FILE **)PTR_stderr_0010ffd8,"cacheSize %% blockSize != 0\n");
uVar2 = CONCAT44(extraout_var_01,iVar1);
local_1 = 0;
}
}
return CONCAT71((int7)(uVar2 >> 8),local_1);
}
| |
27,811 | Cache::isPolicyValid() | EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/src/Cache.cpp | bool Cache::isPolicyValid() {
if (!this->isPowerOfTwo(policy.cacheSize)) {
fprintf(stderr, "Invalid Cache Size %d\n", policy.cacheSize);
return false;
}
if (!this->isPowerOfTwo(policy.blockSize)) {
fprintf(stderr, "Invalid Block Size %d\n", policy.blockSize);
return false;
}
if (policy.cacheSize % policy.blockSize != 0) {
fprintf(stderr, "cacheSize %% blockSize != 0\n");
return false;
}
if (policy.blockNum * policy.blockSize != policy.cacheSize) {
fprintf(stderr, "blockNum * blockSize != cacheSize\n");
return false;
}
if (policy.blockNum % policy.associativity != 0) {
fprintf(stderr, "blockNum %% associativity != 0\n");
return false;
}
return true;
} | O1 | cpp | Cache::isPolicyValid():
pushq %rbx
movl 0x30(%rdi), %ecx
leal -0x1(%rcx), %eax
movl %ecx, %edx
xorl %eax, %edx
cmpl %eax, %edx
jbe 0x444c
movl 0x34(%rdi), %r8d
leal -0x1(%r8), %eax
movl %r8d, %edx
xorl %eax, %edx
cmpl %eax, %edx
jbe 0x4463
movl %ecx, %eax
xorl %edx, %edx
divl %r8d
testl %edx, %edx
jne 0x4482
movl 0x38(%rdi), %eax
imull %eax, %r8d
cmpl %ecx, %r8d
jne 0x4489
xorl %edx, %edx
divl 0x3c(%rdi)
movb $0x1, %bl
testl %edx, %edx
jne 0x4490
movl %ebx, %eax
popq %rbx
retq
movq 0x4b85(%rip), %rax # 0x8fd8
movq (%rax), %rdi
leaq 0x1fd3(%rip), %rsi # 0x6430
xorl %ebx, %ebx
movl %ecx, %edx
jmp 0x4479
movq 0x4b6e(%rip), %rax # 0x8fd8
movq (%rax), %rdi
leaq 0x1fd3(%rip), %rsi # 0x6447
xorl %ebx, %ebx
movl %r8d, %edx
xorl %eax, %eax
callq 0x31f0
jmp 0x4448
callq 0x33a6
jmp 0x4495
callq 0x33be
jmp 0x4495
callq 0x33da
xorl %ebx, %ebx
jmp 0x4448
nop
| _ZN5Cache13isPolicyValidEv:
push rbx
mov ecx, [rdi+30h]
lea eax, [rcx-1]
mov edx, ecx
xor edx, eax
cmp edx, eax
jbe short loc_444C
mov r8d, [rdi+34h]
lea eax, [r8-1]
mov edx, r8d
xor edx, eax
cmp edx, eax
jbe short loc_4463
mov eax, ecx
xor edx, edx
div r8d
test edx, edx
jnz short loc_4482
mov eax, [rdi+38h]
imul r8d, eax
cmp r8d, ecx
jnz short loc_4489
xor edx, edx
div dword ptr [rdi+3Ch]
mov bl, 1
test edx, edx
jnz short loc_4490
loc_4448:
mov eax, ebx
pop rbx
retn
loc_444C:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aInvalidCacheSi; "Invalid Cache Size %d\n"
xor ebx, ebx
mov edx, ecx
jmp short loc_4479
loc_4463:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aInvalidBlockSi; "Invalid Block Size %d\n"
xor ebx, ebx
mov edx, r8d
loc_4479:
xor eax, eax
call _fprintf
jmp short loc_4448
loc_4482:
call _ZN5Cache13isPolicyValidEv_cold_1; Cache::isPolicyValid(void) [clone]
jmp short loc_4495
loc_4489:
call _ZN5Cache13isPolicyValidEv_cold_2; Cache::isPolicyValid(void) [clone]
jmp short loc_4495
loc_4490:
call _ZN5Cache13isPolicyValidEv_cold_3; Cache::isPolicyValid(void) [clone]
loc_4495:
xor ebx, ebx
jmp short loc_4448
| long long Cache::isPolicyValid(Cache *this)
{
unsigned int v1; // ebx
unsigned int v2; // ecx
unsigned int v3; // r8d
unsigned int v4; // eax
v2 = *((_DWORD *)this + 12);
if ( ((v2 - 1) ^ v2) <= v2 - 1 )
{
v1 = 0;
fprintf(stderr, "Invalid Cache Size %d\n", v2);
return v1;
}
v3 = *((_DWORD *)this + 13);
if ( ((v3 - 1) ^ v3) <= v3 - 1 )
{
v1 = 0;
fprintf(stderr, "Invalid Block Size %d\n", v3);
return v1;
}
if ( v2 % v3 )
{
Cache::isPolicyValid();
return 0;
}
v4 = *((_DWORD *)this + 14);
if ( v4 * v3 != v2 )
{
Cache::isPolicyValid();
return 0;
}
LOBYTE(v1) = 1;
if ( v4 % *((_DWORD *)this + 15) )
{
Cache::isPolicyValid();
return 0;
}
return v1;
}
| isPolicyValid:
PUSH RBX
MOV ECX,dword ptr [RDI + 0x30]
LEA EAX,[RCX + -0x1]
MOV EDX,ECX
XOR EDX,EAX
CMP EDX,EAX
JBE 0x0010444c
MOV R8D,dword ptr [RDI + 0x34]
LEA EAX,[R8 + -0x1]
MOV EDX,R8D
XOR EDX,EAX
CMP EDX,EAX
JBE 0x00104463
MOV EAX,ECX
XOR EDX,EDX
DIV R8D
TEST EDX,EDX
JNZ 0x00104482
MOV EAX,dword ptr [RDI + 0x38]
IMUL R8D,EAX
CMP R8D,ECX
JNZ 0x00104489
XOR EDX,EDX
DIV dword ptr [RDI + 0x3c]
MOV BL,0x1
TEST EDX,EDX
JNZ 0x00104490
LAB_00104448:
MOV EAX,EBX
POP RBX
RET
LAB_0010444c:
MOV RAX,qword ptr [0x00108fd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x106430]
XOR EBX,EBX
MOV EDX,ECX
JMP 0x00104479
LAB_00104463:
MOV RAX,qword ptr [0x00108fd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x106447]
XOR EBX,EBX
MOV EDX,R8D
LAB_00104479:
XOR EAX,EAX
CALL 0x001031f0
JMP 0x00104448
LAB_00104482:
CALL 0x001033a6
JMP 0x00104495
LAB_00104489:
CALL 0x001033be
JMP 0x00104495
LAB_00104490:
CALL 0x001033da
LAB_00104495:
XOR EBX,EBX
JMP 0x00104448
|
/* Cache::isPolicyValid() */
ulong __thiscall Cache::isPolicyValid(Cache *this)
{
uint uVar1;
uint uVar2;
int8 unaff_RBX;
ulong uVar3;
char *__format;
FILE *__stream;
uVar1 = *(uint *)(this + 0x30);
if (uVar1 - 1 < (uVar1 ^ uVar1 - 1)) {
uVar2 = *(uint *)(this + 0x34);
if (uVar2 - 1 < (uVar2 ^ uVar2 - 1)) {
if (uVar1 % uVar2 == 0) {
if (uVar2 * *(uint *)(this + 0x38) == uVar1) {
uVar3 = CONCAT71((int7)((ulong)unaff_RBX >> 8),1);
if (*(uint *)(this + 0x38) % *(uint *)(this + 0x3c) == 0) goto LAB_00104448;
isPolicyValid();
}
else {
isPolicyValid();
}
}
else {
isPolicyValid();
}
uVar3 = 0;
goto LAB_00104448;
}
__stream = *(FILE **)PTR_stderr_00108fd8;
__format = "Invalid Block Size %d\n";
uVar1 = uVar2;
}
else {
__stream = *(FILE **)PTR_stderr_00108fd8;
__format = "Invalid Cache Size %d\n";
}
uVar3 = 0;
fprintf(__stream,__format,(ulong)uVar1);
LAB_00104448:
return uVar3 & 0xffffffff;
}
| |
27,812 | Cache::isPolicyValid() | EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/src/Cache.cpp | bool Cache::isPolicyValid() {
if (!this->isPowerOfTwo(policy.cacheSize)) {
fprintf(stderr, "Invalid Cache Size %d\n", policy.cacheSize);
return false;
}
if (!this->isPowerOfTwo(policy.blockSize)) {
fprintf(stderr, "Invalid Block Size %d\n", policy.blockSize);
return false;
}
if (policy.cacheSize % policy.blockSize != 0) {
fprintf(stderr, "cacheSize %% blockSize != 0\n");
return false;
}
if (policy.blockNum * policy.blockSize != policy.cacheSize) {
fprintf(stderr, "blockNum * blockSize != cacheSize\n");
return false;
}
if (policy.blockNum % policy.associativity != 0) {
fprintf(stderr, "blockNum %% associativity != 0\n");
return false;
}
return true;
} | O2 | cpp | Cache::isPolicyValid():
pushq %rbx
movl 0x30(%rdi), %ecx
leal -0x1(%rcx), %eax
movl %ecx, %edx
xorl %eax, %edx
cmpl %eax, %edx
jbe 0x41e6
movl 0x34(%rdi), %r8d
leal -0x1(%r8), %eax
movl %r8d, %edx
xorl %eax, %edx
cmpl %eax, %edx
jbe 0x41fd
movl %ecx, %eax
xorl %edx, %edx
divl %r8d
testl %edx, %edx
jne 0x421c
movl 0x38(%rdi), %eax
imull %eax, %r8d
cmpl %ecx, %r8d
jne 0x422f
xorl %edx, %edx
divl 0x3c(%rdi)
movb $0x1, %bl
testl %edx, %edx
jne 0x424f
movl %ebx, %eax
popq %rbx
retq
movq 0x3deb(%rip), %rax # 0x7fd8
movq (%rax), %rdi
leaq 0x1225(%rip), %rsi # 0x541c
xorl %ebx, %ebx
movl %ecx, %edx
jmp 0x4213
movq 0x3dd4(%rip), %rax # 0x7fd8
movq (%rax), %rdi
leaq 0x1225(%rip), %rsi # 0x5433
xorl %ebx, %ebx
movl %r8d, %edx
xorl %eax, %eax
callq 0x31f0
jmp 0x41e2
movq 0x3db5(%rip), %rax # 0x7fd8
movq (%rax), %rdi
leaq 0x121d(%rip), %rsi # 0x544a
jmp 0x4260
movq 0x3da2(%rip), %rax # 0x7fd8
movq (%rax), %rcx
leaq 0x1227(%rip), %rdi # 0x5467
pushq $0x22
popq %rsi
pushq $0x1
popq %rdx
callq 0x32a0
xorl %ebx, %ebx
jmp 0x41e2
movq 0x3d82(%rip), %rax # 0x7fd8
movq (%rax), %rdi
leaq 0x122a(%rip), %rsi # 0x548a
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x31f0
jmp 0x41e2
| _ZN5Cache13isPolicyValidEv:
push rbx
mov ecx, [rdi+30h]
lea eax, [rcx-1]
mov edx, ecx
xor edx, eax
cmp edx, eax
jbe short loc_41E6
mov r8d, [rdi+34h]
lea eax, [r8-1]
mov edx, r8d
xor edx, eax
cmp edx, eax
jbe short loc_41FD
mov eax, ecx
xor edx, edx
div r8d
test edx, edx
jnz short loc_421C
mov eax, [rdi+38h]
imul r8d, eax
cmp r8d, ecx
jnz short loc_422F
xor edx, edx
div dword ptr [rdi+3Ch]
mov bl, 1
test edx, edx
jnz short loc_424F
loc_41E2:
mov eax, ebx
pop rbx
retn
loc_41E6:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aInvalidCacheSi; "Invalid Cache Size %d\n"
xor ebx, ebx
mov edx, ecx
jmp short loc_4213
loc_41FD:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aInvalidBlockSi; "Invalid Block Size %d\n"
xor ebx, ebx
mov edx, r8d
loc_4213:
xor eax, eax
call _fprintf
jmp short loc_41E2
loc_421C:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aCachesizeBlock_0; "cacheSize %% blockSize != 0\n"
jmp short loc_4260
loc_422F:
mov rax, cs:stderr_ptr
mov rcx, [rax]
lea rdi, aBlocknumBlocks; "blockNum * blockSize != cacheSize\n"
push 22h ; '"'
pop rsi
push 1
pop rdx
call _fwrite
xor ebx, ebx
jmp short loc_41E2
loc_424F:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aBlocknumAssoci; "blockNum %% associativity != 0\n"
loc_4260:
xor ebx, ebx
xor eax, eax
call _fprintf
jmp loc_41E2
| long long Cache::isPolicyValid(Cache *this)
{
unsigned int v1; // ebx
unsigned int v2; // ecx
unsigned int v3; // r8d
long long v4; // rdx
unsigned int v5; // eax
long long v7; // rdi
const char *v8; // rsi
long long v9; // rdx
long long v10; // rdi
const char *v11; // rsi
v2 = *((_DWORD *)this + 12);
if ( ((v2 - 1) ^ v2) <= v2 - 1 )
{
v7 = stderr;
v8 = "Invalid Cache Size %d\n";
v1 = 0;
v9 = v2;
LABEL_9:
fprintf(v7, v8, v9);
return v1;
}
v3 = *((_DWORD *)this + 13);
if ( ((v3 - 1) ^ v3) <= v3 - 1 )
{
v7 = stderr;
v8 = "Invalid Block Size %d\n";
v1 = 0;
v9 = v3;
goto LABEL_9;
}
v4 = v2 % v3;
if ( v2 % v3 )
{
v10 = stderr;
v11 = "cacheSize %% blockSize != 0\n";
LABEL_13:
v1 = 0;
fprintf(v10, v11, v4);
return v1;
}
v5 = *((_DWORD *)this + 14);
if ( v5 * v3 != v2 )
{
fwrite("blockNum * blockSize != cacheSize\n", 34LL, 1LL, stderr);
return 0;
}
v4 = v5 % *((_DWORD *)this + 15);
LOBYTE(v1) = 1;
if ( (_DWORD)v4 )
{
v10 = stderr;
v11 = "blockNum %% associativity != 0\n";
goto LABEL_13;
}
return v1;
}
| isPolicyValid:
PUSH RBX
MOV ECX,dword ptr [RDI + 0x30]
LEA EAX,[RCX + -0x1]
MOV EDX,ECX
XOR EDX,EAX
CMP EDX,EAX
JBE 0x001041e6
MOV R8D,dword ptr [RDI + 0x34]
LEA EAX,[R8 + -0x1]
MOV EDX,R8D
XOR EDX,EAX
CMP EDX,EAX
JBE 0x001041fd
MOV EAX,ECX
XOR EDX,EDX
DIV R8D
TEST EDX,EDX
JNZ 0x0010421c
MOV EAX,dword ptr [RDI + 0x38]
IMUL R8D,EAX
CMP R8D,ECX
JNZ 0x0010422f
XOR EDX,EDX
DIV dword ptr [RDI + 0x3c]
MOV BL,0x1
TEST EDX,EDX
JNZ 0x0010424f
LAB_001041e2:
MOV EAX,EBX
POP RBX
RET
LAB_001041e6:
MOV RAX,qword ptr [0x00107fd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x10541c]
XOR EBX,EBX
MOV EDX,ECX
JMP 0x00104213
LAB_001041fd:
MOV RAX,qword ptr [0x00107fd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x105433]
XOR EBX,EBX
MOV EDX,R8D
LAB_00104213:
XOR EAX,EAX
CALL 0x001031f0
JMP 0x001041e2
LAB_0010421c:
MOV RAX,qword ptr [0x00107fd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x10544a]
JMP 0x00104260
LAB_0010422f:
MOV RAX,qword ptr [0x00107fd8]
MOV RCX,qword ptr [RAX]
LEA RDI,[0x105467]
PUSH 0x22
POP RSI
PUSH 0x1
POP RDX
CALL 0x001032a0
XOR EBX,EBX
JMP 0x001041e2
LAB_0010424f:
MOV RAX,qword ptr [0x00107fd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x10548a]
LAB_00104260:
XOR EBX,EBX
XOR EAX,EAX
CALL 0x001031f0
JMP 0x001041e2
|
/* Cache::isPolicyValid() */
ulong __thiscall Cache::isPolicyValid(Cache *this)
{
uint uVar1;
uint uVar2;
int8 unaff_RBX;
ulong uVar3;
char *pcVar4;
FILE *pFVar5;
uVar1 = *(uint *)(this + 0x30);
if (uVar1 - 1 < (uVar1 ^ uVar1 - 1)) {
uVar2 = *(uint *)(this + 0x34);
if (uVar2 - 1 < (uVar2 ^ uVar2 - 1)) {
if (uVar1 % uVar2 == 0) {
if (uVar2 * *(uint *)(this + 0x38) != uVar1) {
fwrite("blockNum * blockSize != cacheSize\n",0x22,1,*(FILE **)PTR_stderr_00107fd8);
uVar3 = 0;
goto LAB_001041e2;
}
uVar3 = CONCAT71((int7)((ulong)unaff_RBX >> 8),1);
if (*(uint *)(this + 0x38) % *(uint *)(this + 0x3c) == 0) goto LAB_001041e2;
pFVar5 = *(FILE **)PTR_stderr_00107fd8;
pcVar4 = "blockNum %% associativity != 0\n";
}
else {
pFVar5 = *(FILE **)PTR_stderr_00107fd8;
pcVar4 = "cacheSize %% blockSize != 0\n";
}
uVar3 = 0;
fprintf(pFVar5,pcVar4);
goto LAB_001041e2;
}
pFVar5 = *(FILE **)PTR_stderr_00107fd8;
pcVar4 = "Invalid Block Size %d\n";
uVar1 = uVar2;
}
else {
pFVar5 = *(FILE **)PTR_stderr_00107fd8;
pcVar4 = "Invalid Cache Size %d\n";
}
uVar3 = 0;
fprintf(pFVar5,pcVar4,(ulong)uVar1);
LAB_001041e2:
return uVar3 & 0xffffffff;
}
| |
27,813 | Cache::isPolicyValid() | EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/src/Cache.cpp | bool Cache::isPolicyValid() {
if (!this->isPowerOfTwo(policy.cacheSize)) {
fprintf(stderr, "Invalid Cache Size %d\n", policy.cacheSize);
return false;
}
if (!this->isPowerOfTwo(policy.blockSize)) {
fprintf(stderr, "Invalid Block Size %d\n", policy.blockSize);
return false;
}
if (policy.cacheSize % policy.blockSize != 0) {
fprintf(stderr, "cacheSize %% blockSize != 0\n");
return false;
}
if (policy.blockNum * policy.blockSize != policy.cacheSize) {
fprintf(stderr, "blockNum * blockSize != cacheSize\n");
return false;
}
if (policy.blockNum % policy.associativity != 0) {
fprintf(stderr, "blockNum %% associativity != 0\n");
return false;
}
return true;
} | O3 | cpp | Cache::isPolicyValid():
pushq %rbx
movl 0x30(%rdi), %ecx
leal -0x1(%rcx), %eax
movl %ecx, %edx
xorl %eax, %edx
cmpl %eax, %edx
jbe 0x4438
movl 0x34(%rdi), %r8d
leal -0x1(%r8), %eax
movl %r8d, %edx
xorl %eax, %edx
cmpl %eax, %edx
jbe 0x444f
movl %ecx, %eax
xorl %edx, %edx
divl %r8d
testl %edx, %edx
jne 0x446e
movl 0x38(%rdi), %eax
imull %eax, %r8d
cmpl %ecx, %r8d
jne 0x4475
xorl %edx, %edx
divl 0x3c(%rdi)
movb $0x1, %bl
testl %edx, %edx
jne 0x447c
movl %ebx, %eax
popq %rbx
retq
movq 0x4b99(%rip), %rax # 0x8fd8
movq (%rax), %rdi
leaq 0x1fe7(%rip), %rsi # 0x6430
xorl %ebx, %ebx
movl %ecx, %edx
jmp 0x4465
movq 0x4b82(%rip), %rax # 0x8fd8
movq (%rax), %rdi
leaq 0x1fe7(%rip), %rsi # 0x6447
xorl %ebx, %ebx
movl %r8d, %edx
xorl %eax, %eax
callq 0x31f0
jmp 0x4434
callq 0x33a6
jmp 0x4481
callq 0x33be
jmp 0x4481
callq 0x33da
xorl %ebx, %ebx
jmp 0x4434
nop
| _ZN5Cache13isPolicyValidEv:
push rbx
mov ecx, [rdi+30h]
lea eax, [rcx-1]
mov edx, ecx
xor edx, eax
cmp edx, eax
jbe short loc_4438
mov r8d, [rdi+34h]
lea eax, [r8-1]
mov edx, r8d
xor edx, eax
cmp edx, eax
jbe short loc_444F
mov eax, ecx
xor edx, edx
div r8d
test edx, edx
jnz short loc_446E
mov eax, [rdi+38h]
imul r8d, eax
cmp r8d, ecx
jnz short loc_4475
xor edx, edx
div dword ptr [rdi+3Ch]
mov bl, 1
test edx, edx
jnz short loc_447C
loc_4434:
mov eax, ebx
pop rbx
retn
loc_4438:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aInvalidCacheSi; "Invalid Cache Size %d\n"
xor ebx, ebx
mov edx, ecx
jmp short loc_4465
loc_444F:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aInvalidBlockSi; "Invalid Block Size %d\n"
xor ebx, ebx
mov edx, r8d
loc_4465:
xor eax, eax
call _fprintf
jmp short loc_4434
loc_446E:
call _ZN5Cache13isPolicyValidEv_cold_1; Cache::isPolicyValid(void) [clone]
jmp short loc_4481
loc_4475:
call _ZN5Cache13isPolicyValidEv_cold_2; Cache::isPolicyValid(void) [clone]
jmp short loc_4481
loc_447C:
call _ZN5Cache13isPolicyValidEv_cold_3; Cache::isPolicyValid(void) [clone]
loc_4481:
xor ebx, ebx
jmp short loc_4434
| long long Cache::isPolicyValid(Cache *this)
{
unsigned int v1; // ebx
unsigned int v2; // ecx
unsigned int v3; // r8d
unsigned int v4; // eax
v2 = *((_DWORD *)this + 12);
if ( ((v2 - 1) ^ v2) <= v2 - 1 )
{
v1 = 0;
fprintf(stderr, "Invalid Cache Size %d\n", v2);
return v1;
}
v3 = *((_DWORD *)this + 13);
if ( ((v3 - 1) ^ v3) <= v3 - 1 )
{
v1 = 0;
fprintf(stderr, "Invalid Block Size %d\n", v3);
return v1;
}
if ( v2 % v3 )
{
Cache::isPolicyValid();
return 0;
}
v4 = *((_DWORD *)this + 14);
if ( v4 * v3 != v2 )
{
Cache::isPolicyValid();
return 0;
}
LOBYTE(v1) = 1;
if ( v4 % *((_DWORD *)this + 15) )
{
Cache::isPolicyValid();
return 0;
}
return v1;
}
| isPolicyValid:
PUSH RBX
MOV ECX,dword ptr [RDI + 0x30]
LEA EAX,[RCX + -0x1]
MOV EDX,ECX
XOR EDX,EAX
CMP EDX,EAX
JBE 0x00104438
MOV R8D,dword ptr [RDI + 0x34]
LEA EAX,[R8 + -0x1]
MOV EDX,R8D
XOR EDX,EAX
CMP EDX,EAX
JBE 0x0010444f
MOV EAX,ECX
XOR EDX,EDX
DIV R8D
TEST EDX,EDX
JNZ 0x0010446e
MOV EAX,dword ptr [RDI + 0x38]
IMUL R8D,EAX
CMP R8D,ECX
JNZ 0x00104475
XOR EDX,EDX
DIV dword ptr [RDI + 0x3c]
MOV BL,0x1
TEST EDX,EDX
JNZ 0x0010447c
LAB_00104434:
MOV EAX,EBX
POP RBX
RET
LAB_00104438:
MOV RAX,qword ptr [0x00108fd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x106430]
XOR EBX,EBX
MOV EDX,ECX
JMP 0x00104465
LAB_0010444f:
MOV RAX,qword ptr [0x00108fd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x106447]
XOR EBX,EBX
MOV EDX,R8D
LAB_00104465:
XOR EAX,EAX
CALL 0x001031f0
JMP 0x00104434
LAB_0010446e:
CALL 0x001033a6
JMP 0x00104481
LAB_00104475:
CALL 0x001033be
JMP 0x00104481
LAB_0010447c:
CALL 0x001033da
LAB_00104481:
XOR EBX,EBX
JMP 0x00104434
|
/* Cache::isPolicyValid() */
ulong __thiscall Cache::isPolicyValid(Cache *this)
{
uint uVar1;
uint uVar2;
int8 unaff_RBX;
ulong uVar3;
char *__format;
FILE *__stream;
uVar1 = *(uint *)(this + 0x30);
if (uVar1 - 1 < (uVar1 ^ uVar1 - 1)) {
uVar2 = *(uint *)(this + 0x34);
if (uVar2 - 1 < (uVar2 ^ uVar2 - 1)) {
if (uVar1 % uVar2 == 0) {
if (uVar2 * *(uint *)(this + 0x38) == uVar1) {
uVar3 = CONCAT71((int7)((ulong)unaff_RBX >> 8),1);
if (*(uint *)(this + 0x38) % *(uint *)(this + 0x3c) == 0) goto LAB_00104434;
isPolicyValid();
}
else {
isPolicyValid();
}
}
else {
isPolicyValid();
}
uVar3 = 0;
goto LAB_00104434;
}
__stream = *(FILE **)PTR_stderr_00108fd8;
__format = "Invalid Block Size %d\n";
uVar1 = uVar2;
}
else {
__stream = *(FILE **)PTR_stderr_00108fd8;
__format = "Invalid Cache Size %d\n";
}
uVar3 = 0;
fprintf(__stream,__format,(ulong)uVar1);
LAB_00104434:
return uVar3 & 0xffffffff;
}
| |
27,814 | print_comment | eloqsql/mysys/my_getopt.c | static uint print_comment(const char *comment,
int curpos, int startpos, int width)
{
const char *end= strend(comment);
int endpos= startpos + width;
for (; curpos < startpos; curpos++)
putchar(' ');
if (*comment == '.' || *comment == ',')
{
putchar(*comment);
comment++;
curpos++;
}
while (end - comment > endpos - curpos)
{
const char *line_end;
for (line_end= comment + endpos - curpos;
line_end > comment && *line_end != ' ';
line_end--);
for (; comment < line_end; comment++)
putchar(*comment);
while (*comment == ' ')
comment++; /* skip the space, as a newline will take it's place now */
putchar('\n');
for (curpos= 0; curpos < startpos; curpos++)
putchar(' ');
}
printf("%s", comment);
return curpos + (int)(end - comment);
} | O0 | c | print_comment:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc6d70
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x7b328
movl $0x20, %edi
callq 0x36b20
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7b30b
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
je 0x7b340
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x7b361
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
callq 0x36b20
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7b363
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl -0x24(%rbp), %ecx
subl -0xc(%rbp), %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jle 0x7b448
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
addq %rcx, %rax
movslq -0xc(%rbp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpq -0x8(%rbp), %rcx
movb %al, -0x31(%rbp)
jbe 0x7b3ba
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x7b3c3
jmp 0x7b3d3
jmp 0x7b3c5
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x7b39b
jmp 0x7b3d5
movq -0x8(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x7b3f9
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
callq 0x36b20
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x7b3d5
jmp 0x7b3fb
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x7b415
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x7b3fb
movl $0xa, %edi
callq 0x36b20
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x7b443
movl $0x20, %edi
callq 0x36b20
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7b426
jmp 0x7b363
movq -0x8(%rbp), %rsi
leaq 0x4f43b(%rip), %rdi # 0xca88e
movb $0x0, %al
callq 0x36070
movl -0xc(%rbp), %eax
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rdx
subq %rdx, %rcx
addl %ecx, %eax
addq $0x40, %rsp
popq %rbp
retq
| print_comment:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_10], edx
mov [rbp+var_14], ecx
mov rdi, [rbp+var_8]
call strend
mov [rbp+var_20], rax
mov eax, [rbp+var_10]
add eax, [rbp+var_14]
mov [rbp+var_24], eax
loc_7B30B:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_10]
jge short loc_7B328
mov edi, 20h ; ' '
call _putchar
mov eax, [rbp+var_C]
add eax, 1
mov [rbp+var_C], eax
jmp short loc_7B30B
loc_7B328:
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax]
cmp eax, 2Eh ; '.'
jz short loc_7B340
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax]
cmp eax, 2Ch ; ','
jnz short loc_7B361
loc_7B340:
mov rax, [rbp+var_8]
movsx edi, byte ptr [rax]
call _putchar
mov rax, [rbp+var_8]
add rax, 1
mov [rbp+var_8], rax
mov eax, [rbp+var_C]
add eax, 1
mov [rbp+var_C], eax
loc_7B361:
jmp short $+2
loc_7B363:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_8]
sub rax, rcx
mov ecx, [rbp+var_24]
sub ecx, [rbp+var_C]
movsxd rcx, ecx
cmp rax, rcx
jle loc_7B448
mov rax, [rbp+var_8]
movsxd rcx, [rbp+var_24]
add rax, rcx
movsxd rdx, [rbp+var_C]
xor ecx, ecx
sub rcx, rdx
add rax, rcx
mov [rbp+var_30], rax
loc_7B39B:
mov rcx, [rbp+var_30]
xor eax, eax
cmp rcx, [rbp+var_8]
mov [rbp+var_31], al
jbe short loc_7B3BA
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax]
cmp eax, 20h ; ' '
setnz al
mov [rbp+var_31], al
loc_7B3BA:
mov al, [rbp+var_31]
test al, 1
jnz short loc_7B3C3
jmp short loc_7B3D3
loc_7B3C3:
jmp short $+2
loc_7B3C5:
mov rax, [rbp+var_30]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_30], rax
jmp short loc_7B39B
loc_7B3D3:
jmp short $+2
loc_7B3D5:
mov rax, [rbp+var_8]
cmp rax, [rbp+var_30]
jnb short loc_7B3F9
mov rax, [rbp+var_8]
movsx edi, byte ptr [rax]
call _putchar
mov rax, [rbp+var_8]
add rax, 1
mov [rbp+var_8], rax
jmp short loc_7B3D5
loc_7B3F9:
jmp short $+2
loc_7B3FB:
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax]
cmp eax, 20h ; ' '
jnz short loc_7B415
mov rax, [rbp+var_8]
add rax, 1
mov [rbp+var_8], rax
jmp short loc_7B3FB
loc_7B415:
mov edi, 0Ah
call _putchar
mov [rbp+var_C], 0
loc_7B426:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_10]
jge short loc_7B443
mov edi, 20h ; ' '
call _putchar
mov eax, [rbp+var_C]
add eax, 1
mov [rbp+var_C], eax
jmp short loc_7B426
loc_7B443:
jmp loc_7B363
loc_7B448:
mov rsi, [rbp+var_8]
lea rdi, aErrorCouldnTEx+2Ah; "%s"
mov al, 0
call _printf
mov eax, [rbp+var_C]
mov rcx, [rbp+var_20]
mov rdx, [rbp+var_8]
sub rcx, rdx
add eax, ecx
add rsp, 40h
pop rbp
retn
| long long print_comment(const char *a1, int j, int a3, int a4)
{
bool v5; // [rsp+Fh] [rbp-31h]
const char *i; // [rsp+10h] [rbp-30h]
int v7; // [rsp+1Ch] [rbp-24h]
long long v8; // [rsp+20h] [rbp-20h]
const char *v12; // [rsp+38h] [rbp-8h]
v12 = a1;
v8 = strend(a1);
v7 = a4 + a3;
while ( j < a3 )
{
putchar(32LL);
++j;
}
if ( *a1 == 46 || *a1 == 44 )
{
putchar((unsigned int)*a1);
v12 = a1 + 1;
++j;
}
while ( v8 - (long long)v12 > v7 - j )
{
for ( i = &v12[v7 - j]; ; --i )
{
v5 = 0;
if ( i > v12 )
v5 = *i != 32;
if ( !v5 )
break;
}
while ( v12 < i )
putchar((unsigned int)*v12++);
while ( *v12 == 32 )
++v12;
putchar(10LL);
for ( j = 0; j < a3; ++j )
putchar(32LL);
}
printf("%s", v12);
return (unsigned int)(v8 - (_DWORD)v12 + j);
}
| print_comment:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV dword ptr [RBP + -0x10],EDX
MOV dword ptr [RBP + -0x14],ECX
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001c6d70
MOV qword ptr [RBP + -0x20],RAX
MOV EAX,dword ptr [RBP + -0x10]
ADD EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x24],EAX
LAB_0017b30b:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x10]
JGE 0x0017b328
MOV EDI,0x20
CALL 0x00136b20
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
JMP 0x0017b30b
LAB_0017b328:
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2e
JZ 0x0017b340
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2c
JNZ 0x0017b361
LAB_0017b340:
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EDI,byte ptr [RAX]
CALL 0x00136b20
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x1
MOV qword ptr [RBP + -0x8],RAX
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
LAB_0017b361:
JMP 0x0017b363
LAB_0017b363:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x8]
SUB RAX,RCX
MOV ECX,dword ptr [RBP + -0x24]
SUB ECX,dword ptr [RBP + -0xc]
MOVSXD RCX,ECX
CMP RAX,RCX
JLE 0x0017b448
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RBP + -0x24]
ADD RAX,RCX
MOVSXD RDX,dword ptr [RBP + -0xc]
XOR ECX,ECX
SUB RCX,RDX
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
LAB_0017b39b:
MOV RCX,qword ptr [RBP + -0x30]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x8]
MOV byte ptr [RBP + -0x31],AL
JBE 0x0017b3ba
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x20
SETNZ AL
MOV byte ptr [RBP + -0x31],AL
LAB_0017b3ba:
MOV AL,byte ptr [RBP + -0x31]
TEST AL,0x1
JNZ 0x0017b3c3
JMP 0x0017b3d3
LAB_0017b3c3:
JMP 0x0017b3c5
LAB_0017b3c5:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0017b39b
LAB_0017b3d3:
JMP 0x0017b3d5
LAB_0017b3d5:
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x0017b3f9
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EDI,byte ptr [RAX]
CALL 0x00136b20
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x1
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0017b3d5
LAB_0017b3f9:
JMP 0x0017b3fb
LAB_0017b3fb:
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x20
JNZ 0x0017b415
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x1
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0017b3fb
LAB_0017b415:
MOV EDI,0xa
CALL 0x00136b20
MOV dword ptr [RBP + -0xc],0x0
LAB_0017b426:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x10]
JGE 0x0017b443
MOV EDI,0x20
CALL 0x00136b20
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
JMP 0x0017b426
LAB_0017b443:
JMP 0x0017b363
LAB_0017b448:
MOV RSI,qword ptr [RBP + -0x8]
LEA RDI,[0x1ca88e]
MOV AL,0x0
CALL 0x00136070
MOV EAX,dword ptr [RBP + -0xc]
MOV RCX,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x8]
SUB RCX,RDX
ADD EAX,ECX
ADD RSP,0x40
POP RBP
RET
|
int print_comment(char *param_1,int param_2,int param_3,int param_4)
{
long lVar1;
bool bVar2;
char *local_38;
int local_14;
char *local_10;
lVar1 = strend(param_1);
for (local_14 = param_2; local_14 < param_3; local_14 = local_14 + 1) {
putchar(0x20);
}
if ((*param_1 == '.') || (local_10 = param_1, *param_1 == ',')) {
putchar((int)*param_1);
local_10 = param_1 + 1;
local_14 = local_14 + 1;
}
while ((long)((param_3 + param_4) - local_14) < lVar1 - (long)local_10) {
local_38 = local_10 + ((long)(param_3 + param_4) - (long)local_14);
while( true ) {
bVar2 = false;
if (local_10 < local_38) {
bVar2 = *local_38 != ' ';
}
if (!bVar2) break;
local_38 = local_38 + -1;
}
for (; local_10 < local_38; local_10 = local_10 + 1) {
putchar((int)*local_10);
}
for (; *local_10 == ' '; local_10 = local_10 + 1) {
}
putchar(10);
for (local_14 = 0; local_14 < param_3; local_14 = local_14 + 1) {
putchar(0x20);
}
}
printf("%s",local_10);
return local_14 + ((int)lVar1 - (int)local_10);
}
| |
27,815 | print_comment | eloqsql/mysys/my_getopt.c | static uint print_comment(const char *comment,
int curpos, int startpos, int width)
{
const char *end= strend(comment);
int endpos= startpos + width;
for (; curpos < startpos; curpos++)
putchar(' ');
if (*comment == '.' || *comment == ',')
{
putchar(*comment);
comment++;
curpos++;
}
while (end - comment > endpos - curpos)
{
const char *line_end;
for (line_end= comment + endpos - curpos;
line_end > comment && *line_end != ' ';
line_end--);
for (; comment < line_end; comment++)
putchar(*comment);
while (*comment == ' ')
comment++; /* skip the space, as a newline will take it's place now */
putchar('\n');
for (curpos= 0; curpos < startpos; curpos++)
putchar(' ');
}
printf("%s", comment);
return curpos + (int)(end - comment);
} | O3 | c | print_comment:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %rbx
callq 0x90e6c
movq %rax, %r14
cmpl $0x15, %r15d
jg 0x5fa41
addl $-0x16, %r15d
movl $0x20, %edi
callq 0x36b50
incl %r15d
jne 0x5fa2c
movl $0x16, %r15d
movzbl (%rbx), %edi
movl %edi, %eax
orl $0x2, %eax
cmpl $0x2e, %eax
jne 0x5fa59
callq 0x36b50
incq %rbx
incl %r15d
movq %r14, %r12
subq %rbx, %r12
movl $0x4f, %eax
subl %r15d, %eax
cltq
cmpq %rax, %r12
jle 0x5fb0c
movl %r15d, %eax
incq %r14
movq %rbx, %r15
subq %rax, %r15
addq $0x4f, %r15
cmpq %rbx, %r15
jbe 0x5fa98
cmpb $0x20, (%r15)
je 0x5fa98
decq %r15
cmpq %rbx, %r15
ja 0x5fa87
movq %rbx, %r15
cmpq %r15, %rbx
jae 0x5fab8
movq %r15, %r12
subq %rbx, %r12
xorl %r13d, %r13d
movsbl (%rbx,%r13), %edi
callq 0x36b50
incq %r13
cmpq %r13, %r12
jne 0x5faa6
cmpq %r15, %rbx
cmovaq %rbx, %r15
movq %r14, %r12
subq %r15, %r12
decq %r15
movq %r15, %rbx
decq %r12
cmpb $0x20, 0x1(%rbx)
leaq 0x1(%rbx), %rbx
je 0x5facb
movl $0xa, %edi
callq 0x36b50
movl $0x16, %r15d
movl $0x20, %edi
callq 0x36b50
decl %r15d
jne 0x5fae8
movl $0x16, %eax
cmpq $0x3a, %r12
jge 0x5fa78
movl $0x16, %r15d
leaq 0x33da3(%rip), %rsi # 0x938b6
movl $0x1, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x36a10
addl %r15d, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| print_comment:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15d, esi
mov rbx, rdi
call strend
mov r14, rax
cmp r15d, 15h
jg short loc_5FA41
add r15d, 0FFFFFFEAh
loc_5FA2C:
mov edi, 20h ; ' '
call _putchar
inc r15d
jnz short loc_5FA2C
mov r15d, 16h
loc_5FA41:
movzx edi, byte ptr [rbx]
mov eax, edi
or eax, 2
cmp eax, 2Eh ; '.'
jnz short loc_5FA59
call _putchar
inc rbx
inc r15d
loc_5FA59:
mov r12, r14
sub r12, rbx
mov eax, 4Fh ; 'O'
sub eax, r15d
cdqe
cmp r12, rax
jle loc_5FB0C
mov eax, r15d
inc r14
loc_5FA78:
mov r15, rbx
sub r15, rax
add r15, 4Fh ; 'O'
cmp r15, rbx
jbe short loc_5FA98
loc_5FA87:
cmp byte ptr [r15], 20h ; ' '
jz short loc_5FA98
dec r15
cmp r15, rbx
ja short loc_5FA87
mov r15, rbx
loc_5FA98:
cmp rbx, r15
jnb short loc_5FAB8
mov r12, r15
sub r12, rbx
xor r13d, r13d
loc_5FAA6:
movsx edi, byte ptr [rbx+r13]
call _putchar
inc r13
cmp r12, r13
jnz short loc_5FAA6
loc_5FAB8:
cmp rbx, r15
cmova r15, rbx
mov r12, r14
sub r12, r15
dec r15
mov rbx, r15
loc_5FACB:
dec r12
cmp byte ptr [rbx+1], 20h ; ' '
lea rbx, [rbx+1]
jz short loc_5FACB
mov edi, 0Ah
call _putchar
mov r15d, 16h
loc_5FAE8:
mov edi, 20h ; ' '
call _putchar
dec r15d
jnz short loc_5FAE8
mov eax, 16h
cmp r12, 3Ah ; ':'
jge loc_5FA78
mov r15d, 16h
loc_5FB0C:
lea rsi, aErrorCouldnTEx+2Ah; "%s"
mov edi, 1
mov rdx, rbx
xor eax, eax
call ___printf_chk
add r12d, r15d
mov eax, r12d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long print_comment(const char *a1, int a2)
{
unsigned int v2; // r15d
const char *v3; // rbx
long long v4; // r14
int v5; // r15d
long long v6; // rdi
long long v7; // r12
long long v8; // rax
long long v9; // r14
const char *v10; // r15
long long v11; // r13
int v13; // r15d
v2 = a2;
v3 = a1;
v4 = strend(a1);
if ( a2 <= 21 )
{
v5 = a2 - 22;
do
{
putchar(32LL);
++v5;
}
while ( v5 );
v2 = 22;
}
v6 = *(unsigned __int8 *)a1;
if ( (*(unsigned __int8 *)v3 | 2) == 0x2E )
{
putchar(v6);
++v3;
++v2;
}
LODWORD(v7) = v4 - (_DWORD)v3;
if ( v4 - (long long)v3 > (int)(79 - v2) )
{
v8 = v2;
v9 = v4 + 1;
do
{
v10 = &v3[-v8 + 79];
if ( v10 > v3 )
{
while ( *v10 != 32 )
{
if ( --v10 <= v3 )
{
v10 = v3;
break;
}
}
}
if ( v3 < v10 )
{
v11 = 0LL;
do
putchar((unsigned int)v3[v11++]);
while ( v10 - v3 != v11 );
}
if ( v3 > v10 )
v10 = v3;
v7 = v9 - (_QWORD)v10;
v3 = v10 - 1;
do
--v7;
while ( *++v3 == 32 );
putchar(10LL);
v13 = 22;
do
{
putchar(32LL);
--v13;
}
while ( v13 );
v8 = 22LL;
}
while ( v7 >= 58 );
v2 = 22;
}
__printf_chk(1LL, "%s", v3);
return v2 + (unsigned int)v7;
}
| print_comment:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15D,ESI
MOV RBX,RDI
CALL 0x00190e6c
MOV R14,RAX
CMP R15D,0x15
JG 0x0015fa41
ADD R15D,-0x16
LAB_0015fa2c:
MOV EDI,0x20
CALL 0x00136b50
INC R15D
JNZ 0x0015fa2c
MOV R15D,0x16
LAB_0015fa41:
MOVZX EDI,byte ptr [RBX]
MOV EAX,EDI
OR EAX,0x2
CMP EAX,0x2e
JNZ 0x0015fa59
CALL 0x00136b50
INC RBX
INC R15D
LAB_0015fa59:
MOV R12,R14
SUB R12,RBX
MOV EAX,0x4f
SUB EAX,R15D
CDQE
CMP R12,RAX
JLE 0x0015fb0c
MOV EAX,R15D
INC R14
LAB_0015fa78:
MOV R15,RBX
SUB R15,RAX
ADD R15,0x4f
CMP R15,RBX
JBE 0x0015fa98
LAB_0015fa87:
CMP byte ptr [R15],0x20
JZ 0x0015fa98
DEC R15
CMP R15,RBX
JA 0x0015fa87
MOV R15,RBX
LAB_0015fa98:
CMP RBX,R15
JNC 0x0015fab8
MOV R12,R15
SUB R12,RBX
XOR R13D,R13D
LAB_0015faa6:
MOVSX EDI,byte ptr [RBX + R13*0x1]
CALL 0x00136b50
INC R13
CMP R12,R13
JNZ 0x0015faa6
LAB_0015fab8:
CMP RBX,R15
CMOVA R15,RBX
MOV R12,R14
SUB R12,R15
DEC R15
MOV RBX,R15
LAB_0015facb:
DEC R12
CMP byte ptr [RBX + 0x1],0x20
LEA RBX,[RBX + 0x1]
JZ 0x0015facb
MOV EDI,0xa
CALL 0x00136b50
MOV R15D,0x16
LAB_0015fae8:
MOV EDI,0x20
CALL 0x00136b50
DEC R15D
JNZ 0x0015fae8
MOV EAX,0x16
CMP R12,0x3a
JGE 0x0015fa78
MOV R15D,0x16
LAB_0015fb0c:
LEA RSI,[0x1938b6]
MOV EDI,0x1
MOV RDX,RBX
XOR EAX,EAX
CALL 0x00136a10
ADD R12D,R15D
MOV EAX,R12D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int print_comment(byte *param_1,uint param_2)
{
long lVar1;
long lVar2;
int iVar3;
ulong uVar4;
byte *pbVar5;
byte *pbVar6;
uVar4 = (ulong)param_2;
lVar1 = strend();
if ((int)param_2 < 0x16) {
iVar3 = param_2 - 0x16;
do {
putchar(0x20);
iVar3 = iVar3 + 1;
} while (iVar3 != 0);
uVar4 = 0x16;
}
if ((*param_1 | 2) == 0x2e) {
putchar((uint)*param_1);
param_1 = param_1 + 1;
uVar4 = (ulong)((int)uVar4 + 1);
}
lVar2 = lVar1 - (long)param_1;
iVar3 = (int)uVar4;
if (0x4f - iVar3 < lVar2) {
do {
pbVar5 = param_1 + (0x4f - uVar4);
pbVar6 = pbVar5;
for (; (param_1 < pbVar5 && (pbVar6 = pbVar5, *pbVar5 != 0x20)); pbVar5 = pbVar5 + -1) {
pbVar6 = param_1;
}
if (param_1 < pbVar6) {
lVar2 = 0;
do {
putchar((int)(char)param_1[lVar2]);
lVar2 = lVar2 + 1;
} while ((long)pbVar6 - (long)param_1 != lVar2);
}
if (pbVar6 < param_1) {
pbVar6 = param_1;
}
lVar2 = (lVar1 + 1) - (long)pbVar6;
param_1 = pbVar6 + -1;
do {
lVar2 = lVar2 + -1;
pbVar5 = param_1 + 1;
param_1 = param_1 + 1;
} while (*pbVar5 == 0x20);
putchar(10);
iVar3 = 0x16;
do {
putchar(0x20);
iVar3 = iVar3 + -1;
} while (iVar3 != 0);
uVar4 = 0x16;
} while (0x39 < lVar2);
iVar3 = 0x16;
}
__printf_chk(1,"%s",param_1);
return (int)lVar2 + iVar3;
}
| |
27,816 | ma_remove_table_from_trnman | eloqsql/storage/maria/ma_state.c | void _ma_remove_table_from_trnman(MARIA_HA *info)
{
MARIA_SHARE *share= info->s;
TRN *trn= info->trn;
MARIA_USED_TABLES *tables, **prev;
DBUG_ENTER("_ma_remove_table_from_trnman");
DBUG_PRINT("enter", ("trn: %p used_tables: %p share: %p in_trans: %d",
trn, trn->used_tables, share, share->in_trans));
mysql_mutex_assert_owner(&share->intern_lock);
if (trn == &dummy_transaction_object)
DBUG_VOID_RETURN;
/* First remove share from used_tables */
for (prev= (MARIA_USED_TABLES**) (char*) &trn->used_tables;
(tables= *prev);
prev= &tables->next)
{
if (tables->share == share)
{
*prev= tables->next;
/*
We don't have to and can't call decrement_share_in_trans(share) here
as we know there is an active MARIA_HA handler around.
*/
share->in_trans--;
my_free(tables);
break;
}
}
if (!tables)
{
/*
This can only happens in case of rename of intermediate table as
part of alter table
*/
DBUG_PRINT("warning", ("share: %p where not in used_tables_list", share));
}
/* Reset trn and remove table from used_instances */
_ma_reset_trn_for_table(info);
DBUG_VOID_RETURN;
} | O3 | c | ma_remove_table_from_trnman:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
cmpq 0x34ce66(%rip), %rdi # 0x38df70
je 0x4116c
movq (%rbx), %rax
addq $0x58, %rdi
movq %rdi, %rcx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x41135
cmpq %rax, 0x8(%rdi)
jne 0x41113
movq (%rdi), %rdx
movq %rdx, (%rcx)
decl 0x7ac(%rax)
callq 0xa72ae
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x41164
leaq 0x10(%rbx), %rcx
movq 0x10(%rbx), %rdx
testq %rdx, %rdx
je 0x41159
movq %rax, 0x18(%rdx)
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rax
jmp 0x4115b
xorl %edx, %edx
movq %rdx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rcx)
movq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| _ma_remove_table_from_trnman:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
mov rdi, [rdi+8]
cmp rdi, cs:dummy_transaction_object_ptr
jz short loc_4116C
mov rax, [rbx]
add rdi, 58h ; 'X'
loc_41113:
mov rcx, rdi
mov rdi, [rdi]
test rdi, rdi
jz short loc_41135
cmp [rdi+8], rax
jnz short loc_41113
mov rdx, [rdi]
mov [rcx], rdx
dec dword ptr [rax+7ACh]
call my_free
loc_41135:
mov rax, [rbx+18h]
test rax, rax
jz short loc_41164
lea rcx, [rbx+10h]
mov rdx, [rbx+10h]
test rdx, rdx
jz short loc_41159
mov [rdx+18h], rax
mov rdx, [rbx+10h]
mov rax, [rbx+18h]
jmp short loc_4115B
loc_41159:
xor edx, edx
loc_4115B:
mov [rax], rdx
xorps xmm0, xmm0
movups xmmword ptr [rcx], xmm0
loc_41164:
mov qword ptr [rbx+8], 0
loc_4116C:
add rsp, 8
pop rbx
pop rbp
retn
| _QWORD * ma_remove_table_from_trnman(_QWORD *a1)
{
_QWORD *result; // rax
_QWORD *v3; // rdi
long long v4; // rax
_QWORD *v5; // rdi
_QWORD *v6; // rcx
long long v7; // rdx
long long v8; // rdx
v3 = (_QWORD *)a1[1];
if ( v3 != dummy_transaction_object )
{
v4 = *a1;
v5 = v3 + 11;
while ( 1 )
{
v6 = v5;
v5 = (_QWORD *)*v5;
if ( !v5 )
break;
if ( v5[1] == v4 )
{
*v6 = *v5;
--*(_DWORD *)(v4 + 1964);
my_free(v5);
break;
}
}
result = (_QWORD *)a1[3];
if ( result )
{
v7 = a1[2];
if ( v7 )
{
*(_QWORD *)(v7 + 24) = result;
v8 = a1[2];
result = (_QWORD *)a1[3];
}
else
{
v8 = 0LL;
}
*result = v8;
*((_OWORD *)a1 + 1) = 0LL;
}
a1[1] = 0LL;
}
return result;
}
| _ma_remove_table_from_trnman:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x8]
CMP RDI,qword ptr [0x0048df70]
JZ 0x0014116c
MOV RAX,qword ptr [RBX]
ADD RDI,0x58
LAB_00141113:
MOV RCX,RDI
MOV RDI,qword ptr [RDI]
TEST RDI,RDI
JZ 0x00141135
CMP qword ptr [RDI + 0x8],RAX
JNZ 0x00141113
MOV RDX,qword ptr [RDI]
MOV qword ptr [RCX],RDX
DEC dword ptr [RAX + 0x7ac]
CALL 0x001a72ae
LAB_00141135:
MOV RAX,qword ptr [RBX + 0x18]
TEST RAX,RAX
JZ 0x00141164
LEA RCX,[RBX + 0x10]
MOV RDX,qword ptr [RBX + 0x10]
TEST RDX,RDX
JZ 0x00141159
MOV qword ptr [RDX + 0x18],RAX
MOV RDX,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RBX + 0x18]
JMP 0x0014115b
LAB_00141159:
XOR EDX,EDX
LAB_0014115b:
MOV qword ptr [RAX],RDX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RCX],XMM0
LAB_00141164:
MOV qword ptr [RBX + 0x8],0x0
LAB_0014116c:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void _ma_remove_table_from_trnman(long *param_1)
{
int *piVar1;
long *plVar2;
long lVar3;
long *plVar4;
if ((int *)param_1[1] != PTR_dummy_transaction_object_0048df70) {
lVar3 = *param_1;
plVar2 = (long *)((int *)param_1[1] + 0x58);
do {
plVar4 = plVar2;
plVar2 = (long *)*plVar4;
if (plVar2 == (long *)0x0) goto LAB_00141135;
} while (plVar2[1] != lVar3);
*plVar4 = *plVar2;
piVar1 = (int *)(lVar3 + 0x7ac);
*piVar1 = *piVar1 + -1;
my_free();
LAB_00141135:
plVar2 = (long *)param_1[3];
if (plVar2 != (long *)0x0) {
if (param_1[2] == 0) {
lVar3 = 0;
}
else {
*(long **)(param_1[2] + 0x18) = plVar2;
lVar3 = param_1[2];
plVar2 = (long *)param_1[3];
}
*plVar2 = lVar3;
param_1[2] = 0;
param_1[3] = 0;
}
param_1[1] = 0;
}
return;
}
| |
27,817 | glfwInputChar | untodesu[P]riteg/build_O0/_deps/glfw-src/src/input.c | void _glfwInputChar(_GLFWwindow* window, unsigned int codepoint, int mods, GLFWbool plain)
{
if (codepoint < 32 || (codepoint > 126 && codepoint < 160))
return;
if (!window->lockKeyMods)
mods &= ~(GLFW_MOD_CAPS_LOCK | GLFW_MOD_NUM_LOCK);
if (window->callbacks.charmods)
window->callbacks.charmods((GLFWwindow*) window, codepoint, mods);
if (plain)
{
if (window->callbacks.character)
window->callbacks.character((GLFWwindow*) window, codepoint);
}
} | O0 | c | glfwInputChar:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
cmpl $0x20, -0xc(%rbp)
jb 0x22b2a
cmpl $0x7e, -0xc(%rbp)
jbe 0x22b2c
cmpl $0xa0, -0xc(%rbp)
jae 0x22b2c
jmp 0x22b8e
movq -0x8(%rbp), %rax
cmpl $0x0, 0x70(%rax)
jne 0x22b3f
movl -0x10(%rbp), %eax
andl $-0x31, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x330(%rax)
je 0x22b64
movq -0x8(%rbp), %rax
movq 0x330(%rax), %rax
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq *%rax
cmpl $0x0, -0x14(%rbp)
je 0x22b8e
movq -0x8(%rbp), %rax
cmpq $0x0, 0x328(%rax)
je 0x22b8c
movq -0x8(%rbp), %rax
movq 0x328(%rax), %rax
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq *%rax
jmp 0x22b8e
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _glfwInputChar:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_10], edx
mov [rbp+var_14], ecx
cmp [rbp+var_C], 20h ; ' '
jb short loc_22B2A
cmp [rbp+var_C], 7Eh ; '~'
jbe short loc_22B2C
cmp [rbp+var_C], 0A0h
jnb short loc_22B2C
loc_22B2A:
jmp short loc_22B8E
loc_22B2C:
mov rax, [rbp+var_8]
cmp dword ptr [rax+70h], 0
jnz short loc_22B3F
mov eax, [rbp+var_10]
and eax, 0FFFFFFCFh
mov [rbp+var_10], eax
loc_22B3F:
mov rax, [rbp+var_8]
cmp qword ptr [rax+330h], 0
jz short loc_22B64
mov rax, [rbp+var_8]
mov rax, [rax+330h]
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
mov edx, [rbp+var_10]
call rax
loc_22B64:
cmp [rbp+var_14], 0
jz short loc_22B8E
mov rax, [rbp+var_8]
cmp qword ptr [rax+328h], 0
jz short loc_22B8C
mov rax, [rbp+var_8]
mov rax, [rax+328h]
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
call rax
loc_22B8C:
jmp short $+2
loc_22B8E:
add rsp, 20h
pop rbp
retn
| long long glfwInputChar(long long a1, unsigned int a2, unsigned int a3, int a4)
{
long long result; // rax
unsigned int v6; // [rsp+10h] [rbp-10h]
v6 = a3;
if ( a2 >= 0x20 && (a2 <= 0x7E || a2 >= 0xA0) )
{
if ( !*(_DWORD *)(a1 + 112) )
v6 = a3 & 0xFFFFFFCF;
result = a1;
if ( *(_QWORD *)(a1 + 816) )
result = (*(long long ( **)(long long, _QWORD, _QWORD))(a1 + 816))(a1, a2, v6);
if ( a4 )
{
result = a1;
if ( *(_QWORD *)(a1 + 808) )
return (*(long long ( **)(long long, _QWORD))(a1 + 808))(a1, a2);
}
}
return result;
}
| _glfwInputChar:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV dword ptr [RBP + -0x10],EDX
MOV dword ptr [RBP + -0x14],ECX
CMP dword ptr [RBP + -0xc],0x20
JC 0x00122b2a
CMP dword ptr [RBP + -0xc],0x7e
JBE 0x00122b2c
CMP dword ptr [RBP + -0xc],0xa0
JNC 0x00122b2c
LAB_00122b2a:
JMP 0x00122b8e
LAB_00122b2c:
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x70],0x0
JNZ 0x00122b3f
MOV EAX,dword ptr [RBP + -0x10]
AND EAX,0xffffffcf
MOV dword ptr [RBP + -0x10],EAX
LAB_00122b3f:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x330],0x0
JZ 0x00122b64
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x330]
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
MOV EDX,dword ptr [RBP + -0x10]
CALL RAX
LAB_00122b64:
CMP dword ptr [RBP + -0x14],0x0
JZ 0x00122b8e
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x328],0x0
JZ 0x00122b8c
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x328]
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
CALL RAX
LAB_00122b8c:
JMP 0x00122b8e
LAB_00122b8e:
ADD RSP,0x20
POP RBP
RET
|
void _glfwInputChar(long param_1,uint param_2,uint param_3,int param_4)
{
uint local_18;
if ((0x1f < param_2) && ((param_2 < 0x7f || (0x9f < param_2)))) {
local_18 = param_3;
if (*(int *)(param_1 + 0x70) == 0) {
local_18 = param_3 & 0xffffffcf;
}
if (*(long *)(param_1 + 0x330) != 0) {
(**(code **)(param_1 + 0x330))(param_1,param_2,local_18);
}
if ((param_4 != 0) && (*(long *)(param_1 + 0x328) != 0)) {
(**(code **)(param_1 + 0x328))(param_1,param_2);
}
}
return;
}
| |
27,818 | testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>> const&>::~MatcherBase() | seiftnesse[P]memoryallocator/build_O3/_deps/googletest-src/googletest/include/gtest/gtest-matchers.h | ~MatcherBase() override { Destroy(); } | O3 | c | testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>> const&>::~MatcherBase():
pushq %rax
leaq 0x1d494(%rip), %rax # 0x59b48
movq %rax, (%rdi)
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x3c6db
cmpq $0x0, 0x18(%rax)
je 0x3c6db
movq 0x10(%rdi), %rax
lock
decl (%rax)
jne 0x3c6db
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdi
callq *0x18(%rax)
popq %rax
retq
movq %rax, %rdi
callq 0xf53d
nop
| _ZN7testing8internal11MatcherBaseIRKSt17basic_string_viewIcSt11char_traitsIcEEED2Ev:
push rax
lea rax, off_59B48
mov [rdi], rax
mov rax, [rdi+8]
test rax, rax
jz short loc_3C6DB
cmp qword ptr [rax+18h], 0
jz short loc_3C6DB
mov rax, [rdi+10h]
lock dec dword ptr [rax]
jnz short loc_3C6DB
mov rax, [rdi+8]
mov rdi, [rdi+10h]
call qword ptr [rax+18h]
loc_3C6DB:
pop rax
retn
mov rdi, rax
call __clang_call_terminate
| void __spoils<rdx,rcx,r8,r9,r10,r11,xmm4,xmm5> testing::internal::MatcherBase<std::string_view const&>::~MatcherBase(
long long a1)
{
long long v1; // rax
*(_QWORD *)a1 = &off_59B48;
v1 = *(_QWORD *)(a1 + 8);
if ( v1 && *(_QWORD *)(v1 + 24) && !_InterlockedDecrement(*(volatile signed __int32 **)(a1 + 16)) )
(*(void ( **)(_QWORD))(*(_QWORD *)(a1 + 8) + 24LL))(*(_QWORD *)(a1 + 16));
}
| ~MatcherBase:
PUSH RAX
LEA RAX,[0x159b48]
MOV qword ptr [RDI],RAX
MOV RAX,qword ptr [RDI + 0x8]
TEST RAX,RAX
JZ 0x0013c6db
CMP qword ptr [RAX + 0x18],0x0
JZ 0x0013c6db
MOV RAX,qword ptr [RDI + 0x10]
DEC.LOCK dword ptr [RAX]
JNZ 0x0013c6db
MOV RAX,qword ptr [RDI + 0x8]
MOV RDI,qword ptr [RDI + 0x10]
LAB_0013c6d8:
CALL qword ptr [RAX + 0x18]
LAB_0013c6db:
POP RAX
RET
|
/* testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char> >
const&>::~MatcherBase() */
int8 __thiscall
testing::internal::MatcherBase<std::basic_string_view<char,std::char_traits<char>>const&>::
~MatcherBase(MatcherBase<std::basic_string_view<char,std::char_traits<char>>const&> *this)
{
int *piVar1;
int8 in_RAX;
*(int ***)this = &PTR__MatcherBase_00159b48;
if ((*(long *)(this + 8) != 0) && (*(long *)(*(long *)(this + 8) + 0x18) != 0)) {
piVar1 = *(int **)(this + 0x10);
LOCK();
*piVar1 = *piVar1 + -1;
UNLOCK();
if (*piVar1 == 0) {
/* try { // try from 0013c6d8 to 0013c6da has its CatchHandler @ 0013c6dd */
(**(code **)(*(long *)(this + 8) + 0x18))(*(int8 *)(this + 0x10));
}
}
return in_RAX;
}
| |
27,819 | bchange | eloqsql/strings/bchange.c | void bchange(register uchar *dst, size_t old_length, register const uchar *src,
size_t new_length, size_t tot_length)
{
size_t rest=tot_length-old_length;
if (old_length < new_length)
bmove_upp(dst+rest+new_length,dst+tot_length,rest);
else
bmove(dst+new_length,dst+old_length,rest);
memcpy(dst,src,new_length);
} | O3 | c | bchange:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq %r8, %rdx
subq %rsi, %rdx
cmpq %rcx, %rsi
jae 0x4f86e
leaq (%r15,%rdx), %rdi
addq %rbx, %rdi
addq %r15, %r8
movq %r8, %rsi
callq 0x4f894
jmp 0x4f87a
leaq (%r15,%rbx), %rdi
addq %r15, %rsi
callq 0x265d0
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x26290
nop
| bchange:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rcx
mov r14, rdx
mov r15, rdi
mov rdx, r8
sub rdx, rsi
cmp rsi, rcx
jnb short loc_4F86E
lea rdi, [r15+rdx]
add rdi, rbx
add r8, r15
mov rsi, r8
call bmove_upp
jmp short loc_4F87A
loc_4F86E:
lea rdi, [r15+rbx]
add rsi, r15
call _memmove
loc_4F87A:
mov rdi, r15
mov rsi, r14
mov rdx, rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp _memcpy
| long long bchange(long long a1, unsigned long long a2, long long a3, unsigned long long a4, long long a5)
{
long long v7; // rdx
v7 = a5 - a2;
if ( a2 >= a4 )
memmove(a1 + a4, a1 + a2, v7);
else
bmove_upp(a4 + a1 + v7, a1 + a5, v7);
return memcpy(a1, a3, a4);
}
| bchange:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R14,RDX
MOV R15,RDI
MOV RDX,R8
SUB RDX,RSI
CMP RSI,RCX
JNC 0x0014f86e
LEA RDI,[R15 + RDX*0x1]
ADD RDI,RBX
ADD R8,R15
MOV RSI,R8
CALL 0x0014f894
JMP 0x0014f87a
LAB_0014f86e:
LEA RDI,[R15 + RBX*0x1]
ADD RSI,R15
CALL 0x001265d0
LAB_0014f87a:
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x00126290
|
void bchange(void *param_1,ulong param_2,void *param_3,ulong param_4,long param_5)
{
if (param_2 < param_4) {
bmove_upp((long)param_1 + param_4 + (param_5 - param_2),param_5 + (long)param_1);
}
else {
memmove((void *)((long)param_1 + param_4),(void *)(param_2 + (long)param_1),param_5 - param_2);
}
memcpy(param_1,param_3,param_4);
return;
}
| |
27,820 | OpenSubdiv::v3_6_0::Far::GregoryConverter<float>::getIrregularFacePointSize(int, int) const | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/catmarkPatchBuilder.cpp | int
GregoryConverter<REAL>::getIrregularFacePointSize(
int cIndexNear, int cIndexFar) const {
CornerTopology const & corner = _corners[cIndexNear];
CornerTopology const & adjCorner = _corners[cIndexFar];
if (corner.isSharp && adjCorner.isSharp) return 2;
int thisSize = corner.isSharp
? 6
: (1 + corner.ringPoints.GetSize());
int adjSize = (adjCorner.isRegular || adjCorner.isSharp)
? 0
: (1 + adjCorner.ringPoints.GetSize() - 6);
return thisSize + adjSize;
} | O0 | cpp | OpenSubdiv::v3_6_0::Far::GregoryConverter<float>::getIrregularFacePointSize(int, int) const:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x18, %rcx
movslq -0x14(%rbp), %rdx
imulq $0xe0, %rdx, %rdx
addq %rdx, %rcx
movq %rcx, -0x20(%rbp)
addq $0x18, %rax
movslq -0x18(%rbp), %rcx
imulq $0xe0, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movw (%rax), %ax
shrw %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x116e5d
movq -0x28(%rbp), %rax
movw (%rax), %ax
shrw %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x116e5d
movl $0x2, -0x4(%rbp)
jmp 0x116eef
movq -0x20(%rbp), %rax
movw (%rax), %ax
shrw %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x116e7d
movl $0x6, %eax
movl %eax, -0x34(%rbp)
jmp 0x116e90
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
callq 0xce7f0
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movw (%rax), %ax
shrw $0x3, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
jne 0x116ec3
movq -0x28(%rbp), %rax
movw (%rax), %ax
shrw %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x116eca
xorl %eax, %eax
movl %eax, -0x38(%rbp)
jmp 0x116ee0
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0xce7f0
addl $0x1, %eax
subl $0x6, %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
addl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ZNK10OpenSubdiv6v3_6_03Far16GregoryConverterIdE25getIrregularFacePointSizeEii:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 18h
movsxd rdx, [rbp+var_14]
imul rdx, 0E0h
add rcx, rdx
mov [rbp+var_20], rcx
add rax, 18h
movsxd rcx, [rbp+var_18]
imul rcx, 0E0h
add rax, rcx
mov [rbp+var_28], rax
mov rax, [rbp+var_20]
mov ax, [rax]
shr ax, 1
and ax, 1
movzx eax, ax
cmp eax, 0
jz short loc_116E5D
mov rax, [rbp+var_28]
mov ax, [rax]
shr ax, 1
and ax, 1
movzx eax, ax
cmp eax, 0
jz short loc_116E5D
mov [rbp+var_4], 2
jmp loc_116EEF
loc_116E5D:
mov rax, [rbp+var_20]
mov ax, [rax]
shr ax, 1
and ax, 1
movzx eax, ax
cmp eax, 0
jz short loc_116E7D
mov eax, 6
mov [rbp+var_34], eax
jmp short loc_116E90
loc_116E7D:
mov rdi, [rbp+var_20]
add rdi, 28h ; '('
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal11StackBufferIiLj40ELb1EE7GetSizeEv; OpenSubdiv::v3_6_0::Vtr::internal::StackBuffer<int,40u,true>::GetSize(void)
add eax, 1
mov [rbp+var_34], eax
loc_116E90:
mov eax, [rbp+var_34]
mov [rbp+var_2C], eax
mov rax, [rbp+var_28]
mov ax, [rax]
shr ax, 3
and ax, 1
movzx eax, ax
cmp eax, 0
jnz short loc_116EC3
mov rax, [rbp+var_28]
mov ax, [rax]
shr ax, 1
and ax, 1
movzx eax, ax
cmp eax, 0
jz short loc_116ECA
loc_116EC3:
xor eax, eax
mov [rbp+var_38], eax
jmp short loc_116EE0
loc_116ECA:
mov rdi, [rbp+var_28]
add rdi, 28h ; '('
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal11StackBufferIiLj40ELb1EE7GetSizeEv; OpenSubdiv::v3_6_0::Vtr::internal::StackBuffer<int,40u,true>::GetSize(void)
add eax, 1
sub eax, 6
mov [rbp+var_38], eax
loc_116EE0:
mov eax, [rbp+var_38]
mov [rbp+var_30], eax
mov eax, [rbp+var_2C]
add eax, [rbp+var_30]
mov [rbp+var_4], eax
loc_116EEF:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
| long long OpenSubdiv::v3_6_0::Far::GregoryConverter<double>::getIrregularFacePointSize(
long long a1,
int a2,
int a3)
{
int v4; // [rsp+8h] [rbp-38h]
int v5; // [rsp+Ch] [rbp-34h]
_WORD *v6; // [rsp+18h] [rbp-28h]
_WORD *v7; // [rsp+20h] [rbp-20h]
v7 = (_WORD *)(224LL * a2 + a1 + 24);
v6 = (_WORD *)(224LL * a3 + a1 + 24);
if ( ((*v7 >> 1) & 1) != 0 && ((*v6 >> 1) & 1) != 0 )
{
return 2;
}
else
{
if ( ((*v7 >> 1) & 1) != 0 )
v5 = 6;
else
v5 = OpenSubdiv::v3_6_0::Vtr::internal::StackBuffer<int,40u,true>::GetSize(v7 + 20) + 1;
if ( ((*v6 >> 3) & 1) != 0 || ((*v6 >> 1) & 1) != 0 )
v4 = 0;
else
v4 = OpenSubdiv::v3_6_0::Vtr::internal::StackBuffer<int,40u,true>::GetSize(v6 + 20) - 5;
return (unsigned int)(v4 + v5);
}
}
| |||
27,821 | OpenSubdiv::v3_6_0::Far::GregoryConverter<float>::getIrregularFacePointSize(int, int) const | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/catmarkPatchBuilder.cpp | int
GregoryConverter<REAL>::getIrregularFacePointSize(
int cIndexNear, int cIndexFar) const {
CornerTopology const & corner = _corners[cIndexNear];
CornerTopology const & adjCorner = _corners[cIndexFar];
if (corner.isSharp && adjCorner.isSharp) return 2;
int thisSize = corner.isSharp
? 6
: (1 + corner.ringPoints.GetSize());
int adjSize = (adjCorner.isRegular || adjCorner.isSharp)
? 0
: (1 + adjCorner.ringPoints.GetSize() - 6);
return thisSize + adjSize;
} | O1 | cpp | OpenSubdiv::v3_6_0::Far::GregoryConverter<float>::getIrregularFacePointSize(int, int) const:
movslq %esi, %rax
imulq $0xe0, %rax, %rsi
movslq %edx, %rax
imulq $0xe0, %rax, %rax
leaq (%rdi,%rax), %rcx
addq $0x18, %rcx
movzwl 0x18(%rdi,%rsi), %r8d
testb $0x2, %r8b
jne 0x528ec
leaq (%rdi,%rsi), %rax
addq $0x18, %rax
movl 0x30(%rax), %edx
incl %edx
xorl %eax, %eax
testb $0xa, (%rcx)
jne 0x528e8
movl 0x30(%rcx), %eax
addl $-0x5, %eax
addl %edx, %eax
jmp 0x52903
movl $0x2, %eax
testb $0x2, (%rcx)
jne 0x52903
movl $0x6, %edx
testb $0x2, %r8b
je 0x528ce
jmp 0x528db
retq
| _ZNK10OpenSubdiv6v3_6_03Far16GregoryConverterIdE25getIrregularFacePointSizeEii:
movsxd rax, esi
imul rsi, rax, 0E0h
movsxd rax, edx
imul rax, 0E0h
lea rcx, [rdi+rax]
add rcx, 18h
movzx r8d, word ptr [rdi+rsi+18h]
test r8b, 2
jnz short loc_528EC
loc_528CE:
lea rax, [rdi+rsi]
add rax, 18h
mov edx, [rax+30h]
inc edx
loc_528DB:
xor eax, eax
test byte ptr [rcx], 0Ah
jnz short loc_528E8
mov eax, [rcx+30h]
add eax, 0FFFFFFFBh
loc_528E8:
add eax, edx
jmp short locret_52903
loc_528EC:
mov eax, 2
test byte ptr [rcx], 2
jnz short locret_52903
mov edx, 6
test r8b, 2
jz short loc_528CE
jmp short loc_528DB
locret_52903:
retn
| long long OpenSubdiv::v3_6_0::Far::GregoryConverter<double>::getIrregularFacePointSize(
long long a1,
int a2,
int a3)
{
long long v3; // rsi
long long v4; // rcx
__int16 v5; // r8
int v6; // edx
int v7; // eax
long long result; // rax
v3 = 224LL * a2;
v4 = a1 + 224LL * a3 + 24;
v5 = *(_WORD *)(a1 + v3 + 24);
if ( (v5 & 2) == 0 )
goto LABEL_2;
result = 2LL;
if ( (*(_BYTE *)v4 & 2) != 0 )
return result;
v6 = 6;
if ( (v5 & 2) == 0 )
LABEL_2:
v6 = *(_DWORD *)(a1 + v3 + 72) + 1;
v7 = 0;
if ( (*(_BYTE *)v4 & 0xA) == 0 )
v7 = *(_DWORD *)(v4 + 48) - 5;
return (unsigned int)(v6 + v7);
}
| getIrregularFacePointSize:
MOVSXD RAX,ESI
IMUL RSI,RAX,0xe0
MOVSXD RAX,EDX
IMUL RAX,RAX,0xe0
LEA RCX,[RDI + RAX*0x1]
ADD RCX,0x18
MOVZX R8D,word ptr [RDI + RSI*0x1 + 0x18]
TEST R8B,0x2
JNZ 0x001528ec
LAB_001528ce:
LEA RAX,[RDI + RSI*0x1]
ADD RAX,0x18
MOV EDX,dword ptr [RAX + 0x30]
INC EDX
LAB_001528db:
XOR EAX,EAX
TEST byte ptr [RCX],0xa
JNZ 0x001528e8
MOV EAX,dword ptr [RCX + 0x30]
ADD EAX,-0x5
LAB_001528e8:
ADD EAX,EDX
JMP 0x00152903
LAB_001528ec:
MOV EAX,0x2
TEST byte ptr [RCX],0x2
JNZ 0x00152903
MOV EDX,0x6
TEST R8B,0x2
JZ 0x001528ce
JMP 0x001528db
LAB_00152903:
RET
|
/* OpenSubdiv::v3_6_0::Far::GregoryConverter<double>::getIrregularFacePointSize(int, int) const */
int __thiscall
OpenSubdiv::v3_6_0::Far::GregoryConverter<double>::getIrregularFacePointSize
(GregoryConverter<double> *this,int param_1,int param_2)
{
int iVar1;
int iVar2;
if ((*(ushort *)(this + (long)param_1 * 0xe0 + 0x18) & 2) != 0) {
if (((byte)this[(long)param_2 * 0xe0 + 0x18] & 2) != 0) {
return 2;
}
iVar2 = 6;
if ((*(ushort *)(this + (long)param_1 * 0xe0 + 0x18) & 2) != 0) goto LAB_001528db;
}
iVar2 = *(int *)(this + (long)param_1 * 0xe0 + 0x48) + 1;
LAB_001528db:
iVar1 = 0;
if (((byte)this[(long)param_2 * 0xe0 + 0x18] & 10) == 0) {
iVar1 = *(int *)(this + (long)param_2 * 0xe0 + 0x48) + -5;
}
return iVar1 + iVar2;
}
| |
27,822 | OpenSubdiv::v3_6_0::Far::GregoryConverter<float>::getIrregularFacePointSize(int, int) const | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/catmarkPatchBuilder.cpp | int
GregoryConverter<REAL>::getIrregularFacePointSize(
int cIndexNear, int cIndexFar) const {
CornerTopology const & corner = _corners[cIndexNear];
CornerTopology const & adjCorner = _corners[cIndexFar];
if (corner.isSharp && adjCorner.isSharp) return 2;
int thisSize = corner.isSharp
? 6
: (1 + corner.ringPoints.GetSize());
int adjSize = (adjCorner.isRegular || adjCorner.isSharp)
? 0
: (1 + adjCorner.ringPoints.GetSize() - 6);
return thisSize + adjSize;
} | O2 | cpp | OpenSubdiv::v3_6_0::Far::GregoryConverter<float>::getIrregularFacePointSize(int, int) const:
movslq %esi, %rax
imulq $0xe0, %rax, %rax
movslq %edx, %rcx
imulq $0xe0, %rcx, %rcx
addq %rdi, %rcx
addq $0x18, %rcx
testb $0x2, 0x18(%rdi,%rax)
jne 0x69879
addq %rdi, %rax
addq $0x18, %rax
movl 0x30(%rax), %edx
incl %edx
movzwl (%rcx), %esi
jmp 0x69885
movzwl (%rcx), %esi
testb $0x2, %sil
jne 0x69896
pushq $0x6
popq %rdx
xorl %eax, %eax
testb $0xa, %sil
jne 0x69893
movl 0x30(%rcx), %eax
addl $-0x5, %eax
addl %edx, %eax
retq
pushq $0x2
popq %rax
retq
| _ZNK10OpenSubdiv6v3_6_03Far16GregoryConverterIdE25getIrregularFacePointSizeEii:
movsxd rax, esi
imul rax, 0E0h
movsxd rcx, edx
imul rcx, 0E0h
add rcx, rdi
add rcx, 18h
test byte ptr [rdi+rax+18h], 2
jnz short loc_69879
add rax, rdi
add rax, 18h
mov edx, [rax+30h]
inc edx
movzx esi, word ptr [rcx]
jmp short loc_69885
loc_69879:
movzx esi, word ptr [rcx]
test sil, 2
jnz short loc_69896
push 6
pop rdx
loc_69885:
xor eax, eax
test sil, 0Ah
jnz short loc_69893
mov eax, [rcx+30h]
add eax, 0FFFFFFFBh
loc_69893:
add eax, edx
retn
loc_69896:
push 2
pop rax
retn
| long long OpenSubdiv::v3_6_0::Far::GregoryConverter<double>::getIrregularFacePointSize(
long long a1,
int a2,
int a3)
{
long long v3; // rax
long long v4; // rcx
int v5; // edx
__int16 v6; // si
int v7; // eax
v3 = 224LL * a2;
v4 = a1 + 224LL * a3 + 24;
if ( (*(_BYTE *)(a1 + v3 + 24) & 2) != 0 )
{
v6 = *(_WORD *)v4;
if ( (*(_WORD *)v4 & 2) != 0 )
return 2LL;
v5 = 6;
}
else
{
v5 = *(_DWORD *)(a1 + v3 + 72) + 1;
v6 = *(_WORD *)v4;
}
v7 = 0;
if ( (v6 & 0xA) == 0 )
v7 = *(_DWORD *)(v4 + 48) - 5;
return (unsigned int)(v5 + v7);
}
| getIrregularFacePointSize:
MOVSXD RAX,ESI
IMUL RAX,RAX,0xe0
MOVSXD RCX,EDX
IMUL RCX,RCX,0xe0
ADD RCX,RDI
ADD RCX,0x18
TEST byte ptr [RDI + RAX*0x1 + 0x18],0x2
JNZ 0x00169879
ADD RAX,RDI
ADD RAX,0x18
MOV EDX,dword ptr [RAX + 0x30]
INC EDX
MOVZX ESI,word ptr [RCX]
JMP 0x00169885
LAB_00169879:
MOVZX ESI,word ptr [RCX]
TEST SIL,0x2
JNZ 0x00169896
PUSH 0x6
POP RDX
LAB_00169885:
XOR EAX,EAX
TEST SIL,0xa
JNZ 0x00169893
MOV EAX,dword ptr [RCX + 0x30]
ADD EAX,-0x5
LAB_00169893:
ADD EAX,EDX
RET
LAB_00169896:
PUSH 0x2
POP RAX
RET
|
/* OpenSubdiv::v3_6_0::Far::GregoryConverter<double>::getIrregularFacePointSize(int, int) const */
int __thiscall
OpenSubdiv::v3_6_0::Far::GregoryConverter<double>::getIrregularFacePointSize
(GregoryConverter<double> *this,int param_1,int param_2)
{
int iVar1;
int iVar2;
ushort uVar3;
if (((byte)this[(long)param_1 * 0xe0 + 0x18] & 2) == 0) {
iVar2 = *(int *)(this + (long)param_1 * 0xe0 + 0x48) + 1;
uVar3 = *(ushort *)(this + (long)param_2 * 0xe0 + 0x18);
}
else {
uVar3 = *(ushort *)(this + (long)param_2 * 0xe0 + 0x18);
if ((uVar3 & 2) != 0) {
return 2;
}
iVar2 = 6;
}
iVar1 = 0;
if ((uVar3 & 10) == 0) {
iVar1 = *(int *)(this + (long)param_2 * 0xe0 + 0x48) + -5;
}
return iVar1 + iVar2;
}
| |
27,823 | OpenSubdiv::v3_6_0::Far::GregoryConverter<float>::getIrregularFacePointSize(int, int) const | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/catmarkPatchBuilder.cpp | int
GregoryConverter<REAL>::getIrregularFacePointSize(
int cIndexNear, int cIndexFar) const {
CornerTopology const & corner = _corners[cIndexNear];
CornerTopology const & adjCorner = _corners[cIndexFar];
if (corner.isSharp && adjCorner.isSharp) return 2;
int thisSize = corner.isSharp
? 6
: (1 + corner.ringPoints.GetSize());
int adjSize = (adjCorner.isRegular || adjCorner.isSharp)
? 0
: (1 + adjCorner.ringPoints.GetSize() - 6);
return thisSize + adjSize;
} | O3 | cpp | OpenSubdiv::v3_6_0::Far::GregoryConverter<float>::getIrregularFacePointSize(int, int) const:
movslq %esi, %rax
imulq $0xe0, %rax, %rax
movslq %edx, %rcx
imulq $0xe0, %rcx, %rcx
addq %rdi, %rcx
addq $0x18, %rcx
testb $0x2, 0x18(%rdi,%rax)
jne 0x54e05
addq %rdi, %rax
addq $0x18, %rax
movl 0x30(%rax), %edx
incl %edx
movzwl (%rcx), %esi
jmp 0x54e18
movzwl (%rcx), %esi
movl $0x2, %eax
testb $0x2, %sil
jne 0x54e28
movl $0x6, %edx
xorl %eax, %eax
testb $0xa, %sil
jne 0x54e26
movl 0x30(%rcx), %eax
addl $-0x5, %eax
addl %edx, %eax
retq
nop
| _ZNK10OpenSubdiv6v3_6_03Far16GregoryConverterIdE25getIrregularFacePointSizeEii:
movsxd rax, esi
imul rax, 0E0h
movsxd rcx, edx
imul rcx, 0E0h
add rcx, rdi
add rcx, 18h
test byte ptr [rdi+rax+18h], 2
jnz short loc_54E05
add rax, rdi
add rax, 18h
mov edx, [rax+30h]
inc edx
movzx esi, word ptr [rcx]
jmp short loc_54E18
loc_54E05:
movzx esi, word ptr [rcx]
mov eax, 2
test sil, 2
jnz short locret_54E28
mov edx, 6
loc_54E18:
xor eax, eax
test sil, 0Ah
jnz short loc_54E26
mov eax, [rcx+30h]
add eax, 0FFFFFFFBh
loc_54E26:
add eax, edx
locret_54E28:
retn
| long long OpenSubdiv::v3_6_0::Far::GregoryConverter<double>::getIrregularFacePointSize(
long long a1,
int a2,
int a3)
{
long long v3; // rax
long long v4; // rcx
int v5; // edx
__int16 v6; // si
long long result; // rax
int v8; // eax
v3 = 224LL * a2;
v4 = a1 + 224LL * a3 + 24;
if ( (*(_BYTE *)(a1 + v3 + 24) & 2) != 0 )
{
v6 = *(_WORD *)v4;
result = 2LL;
if ( (*(_WORD *)v4 & 2) != 0 )
return result;
v5 = 6;
}
else
{
v5 = *(_DWORD *)(a1 + v3 + 72) + 1;
v6 = *(_WORD *)v4;
}
v8 = 0;
if ( (v6 & 0xA) == 0 )
v8 = *(_DWORD *)(v4 + 48) - 5;
return (unsigned int)(v5 + v8);
}
| getIrregularFacePointSize:
MOVSXD RAX,ESI
IMUL RAX,RAX,0xe0
MOVSXD RCX,EDX
IMUL RCX,RCX,0xe0
ADD RCX,RDI
ADD RCX,0x18
TEST byte ptr [RDI + RAX*0x1 + 0x18],0x2
JNZ 0x00154e05
ADD RAX,RDI
ADD RAX,0x18
MOV EDX,dword ptr [RAX + 0x30]
INC EDX
MOVZX ESI,word ptr [RCX]
JMP 0x00154e18
LAB_00154e05:
MOVZX ESI,word ptr [RCX]
MOV EAX,0x2
TEST SIL,0x2
JNZ 0x00154e28
MOV EDX,0x6
LAB_00154e18:
XOR EAX,EAX
TEST SIL,0xa
JNZ 0x00154e26
MOV EAX,dword ptr [RCX + 0x30]
ADD EAX,-0x5
LAB_00154e26:
ADD EAX,EDX
LAB_00154e28:
RET
|
/* OpenSubdiv::v3_6_0::Far::GregoryConverter<double>::getIrregularFacePointSize(int, int) const */
int __thiscall
OpenSubdiv::v3_6_0::Far::GregoryConverter<double>::getIrregularFacePointSize
(GregoryConverter<double> *this,int param_1,int param_2)
{
int iVar1;
int iVar2;
ushort uVar3;
if (((byte)this[(long)param_1 * 0xe0 + 0x18] & 2) == 0) {
iVar2 = *(int *)(this + (long)param_1 * 0xe0 + 0x48) + 1;
uVar3 = *(ushort *)(this + (long)param_2 * 0xe0 + 0x18);
}
else {
uVar3 = *(ushort *)(this + (long)param_2 * 0xe0 + 0x18);
if ((uVar3 & 2) != 0) {
return 2;
}
iVar2 = 6;
}
iVar1 = 0;
if ((uVar3 & 10) == 0) {
iVar1 = *(int *)(this + (long)param_2 * 0xe0 + 0x48) + -5;
}
return iVar1 + iVar2;
}
| |
27,824 | js_free_rt | bluesky950520[P]quickjs/quickjs.c | void js_free_rt(JSRuntime *rt, void *ptr)
{
JSMallocState *s;
if (!ptr)
return;
s = &rt->malloc_state;
s->malloc_count--;
s->malloc_size -= rt->mf.js_malloc_usable_size(ptr) + MALLOC_OVERHEAD;
rt->mf.js_free(s->opaque, ptr);
} | O0 | c | js_free_rt:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x206b8
jmp 0x20711
movq 0x10(%rsp), %rax
addq $0x28, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rsp), %rdi
callq *%rax
movq %rax, %rdx
addq $0x8, %rdx
movq (%rsp), %rax
movq 0x8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rsp), %rcx
movq 0x18(%rcx), %rdi
movq 0x8(%rsp), %rsi
callq *%rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| js_free_rt:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov [rsp+18h+var_10], rsi
cmp [rsp+18h+var_10], 0
jnz short loc_206B8
jmp short loc_20711
loc_206B8:
mov rax, [rsp+18h+var_8]
add rax, 28h ; '('
mov [rsp+18h+var_18], rax
mov rax, [rsp+18h+var_18]
mov rcx, [rax]
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rax], rcx
mov rax, [rsp+18h+var_8]
mov rax, [rax+20h]
mov rdi, [rsp+18h+var_10]
call rax
mov rdx, rax
add rdx, 8
mov rax, [rsp+18h+var_18]
mov rcx, [rax+8]
sub rcx, rdx
mov [rax+8], rcx
mov rax, [rsp+18h+var_8]
mov rax, [rax+10h]
mov rcx, [rsp+18h+var_18]
mov rdi, [rcx+18h]
mov rsi, [rsp+18h+var_10]
call rax
loc_20711:
add rsp, 18h
retn
| void js_free_rt(long long a1, long long a2)
{
if ( a2 )
{
--*(_QWORD *)(a1 + 40);
*(_QWORD *)(a1 + 48) -= (*(long long ( **)(long long))(a1 + 32))(a2) + 8;
(*(void ( **)(_QWORD, long long))(a1 + 16))(*(_QWORD *)(a1 + 64), a2);
}
}
| js_free_rt:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x8],RSI
CMP qword ptr [RSP + 0x8],0x0
JNZ 0x001206b8
JMP 0x00120711
LAB_001206b8:
MOV RAX,qword ptr [RSP + 0x10]
ADD RAX,0x28
MOV qword ptr [RSP],RAX
MOV RAX,qword ptr [RSP]
MOV RCX,qword ptr [RAX]
ADD RCX,-0x1
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RAX + 0x20]
MOV RDI,qword ptr [RSP + 0x8]
CALL RAX
MOV RDX,RAX
ADD RDX,0x8
MOV RAX,qword ptr [RSP]
MOV RCX,qword ptr [RAX + 0x8]
SUB RCX,RDX
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RSP]
MOV RDI,qword ptr [RCX + 0x18]
MOV RSI,qword ptr [RSP + 0x8]
CALL RAX
LAB_00120711:
ADD RSP,0x18
RET
|
void js_free_rt(long param_1,long param_2)
{
long lVar1;
if (param_2 != 0) {
*(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + -1;
lVar1 = (**(code **)(param_1 + 0x20))(param_2);
*(long *)(param_1 + 0x30) = *(long *)(param_1 + 0x30) - (lVar1 + 8);
(**(code **)(param_1 + 0x10))(*(int8 *)(param_1 + 0x40),param_2);
}
return;
}
| |
27,825 | js_free_rt | bluesky950520[P]quickjs/quickjs.c | void js_free_rt(JSRuntime *rt, void *ptr)
{
JSMallocState *s;
if (!ptr)
return;
s = &rt->malloc_state;
s->malloc_count--;
s->malloc_size -= rt->mf.js_malloc_usable_size(ptr) + MALLOC_OVERHEAD;
rt->mf.js_free(s->opaque, ptr);
} | O1 | c | js_free_rt:
testq %rdx, %rdx
je 0x382e2
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
decq 0x28(%rdi)
movq %rdx, %rdi
callq *0x20(%r14)
movq 0x10(%r14), %rcx
movq 0x30(%r14), %rdx
subq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x30(%r14)
movq 0x40(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
retq
| js_array_buffer_free:
test rdx, rdx
jz short locret_382E2
push r14
push rbx
push rax
mov rbx, rdx
mov r14, rdi
dec qword ptr [rdi+28h]
mov rdi, rdx
call qword ptr [r14+20h]
mov rcx, [r14+10h]
mov rdx, [r14+30h]
sub rdx, rax
add rdx, 0FFFFFFFFFFFFFFF8h
mov [r14+30h], rdx
mov rdi, [r14+40h]
mov rsi, rbx
add rsp, 8
pop rbx
pop r14
jmp rcx
locret_382E2:
retn
| long long js_array_buffer_free(long long a1, long long a2, long long a3)
{
long long v4; // rax
long long ( *v5)(_QWORD, long long); // rcx
long long result; // rax
if ( a3 )
{
--*(_QWORD *)(a1 + 40);
v4 = (*(long long ( **)(long long))(a1 + 32))(a3);
v5 = *(long long ( **)(_QWORD, long long))(a1 + 16);
*(_QWORD *)(a1 + 48) = *(_QWORD *)(a1 + 48) - v4 - 8;
return v5(*(_QWORD *)(a1 + 64), a3);
}
return result;
}
| js_array_buffer_free:
TEST RDX,RDX
JZ 0x001382e2
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RDI
DEC qword ptr [RDI + 0x28]
MOV RDI,RDX
CALL qword ptr [R14 + 0x20]
MOV RCX,qword ptr [R14 + 0x10]
MOV RDX,qword ptr [R14 + 0x30]
SUB RDX,RAX
ADD RDX,-0x8
MOV qword ptr [R14 + 0x30],RDX
MOV RDI,qword ptr [R14 + 0x40]
MOV RSI,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP RCX
LAB_001382e2:
RET
|
void js_array_buffer_free(long param_1,int8 param_2,long param_3)
{
long lVar1;
if (param_3 != 0) {
*(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + -1;
lVar1 = (**(code **)(param_1 + 0x20))(param_3);
lVar1 = (*(long *)(param_1 + 0x30) - lVar1) + -8;
*(long *)(param_1 + 0x30) = lVar1;
/* WARNING: Could not recover jumptable at 0x001382e0. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(param_1 + 0x10))
(*(int8 *)(param_1 + 0x40),param_3,lVar1,*(code **)(param_1 + 0x10));
return;
}
return;
}
| |
27,826 | js_free_rt | bluesky950520[P]quickjs/quickjs.c | void js_free_rt(JSRuntime *rt, void *ptr)
{
JSMallocState *s;
if (!ptr)
return;
s = &rt->malloc_state;
s->malloc_count--;
s->malloc_size -= rt->mf.js_malloc_usable_size(ptr) + MALLOC_OVERHEAD;
rt->mf.js_free(s->opaque, ptr);
} | O3 | c | js_free_rt:
testq %rdx, %rdx
je 0x395d3
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
decq 0x28(%rdi)
movq %rdx, %rdi
callq *0x20(%r14)
movq 0x10(%r14), %rcx
movq 0x30(%r14), %rdx
subq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x30(%r14)
movq 0x40(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
retq
| js_array_buffer_free:
test rdx, rdx
jz short locret_395D3
push r14
push rbx
push rax
mov rbx, rdx
mov r14, rdi
dec qword ptr [rdi+28h]
mov rdi, rdx
call qword ptr [r14+20h]
mov rcx, [r14+10h]
mov rdx, [r14+30h]
sub rdx, rax
add rdx, 0FFFFFFFFFFFFFFF8h
mov [r14+30h], rdx
mov rdi, [r14+40h]
mov rsi, rbx
add rsp, 8
pop rbx
pop r14
jmp rcx
locret_395D3:
retn
| long long js_array_buffer_free(long long a1, long long a2, long long a3)
{
long long v4; // rax
long long ( *v5)(_QWORD, long long); // rcx
long long result; // rax
if ( a3 )
{
--*(_QWORD *)(a1 + 40);
v4 = (*(long long ( **)(long long))(a1 + 32))(a3);
v5 = *(long long ( **)(_QWORD, long long))(a1 + 16);
*(_QWORD *)(a1 + 48) = *(_QWORD *)(a1 + 48) - v4 - 8;
return v5(*(_QWORD *)(a1 + 64), a3);
}
return result;
}
| js_array_buffer_free:
TEST RDX,RDX
JZ 0x001395d3
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RDI
DEC qword ptr [RDI + 0x28]
MOV RDI,RDX
CALL qword ptr [R14 + 0x20]
MOV RCX,qword ptr [R14 + 0x10]
MOV RDX,qword ptr [R14 + 0x30]
SUB RDX,RAX
ADD RDX,-0x8
MOV qword ptr [R14 + 0x30],RDX
MOV RDI,qword ptr [R14 + 0x40]
MOV RSI,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP RCX
LAB_001395d3:
RET
|
void js_array_buffer_free(long param_1,int8 param_2,long param_3)
{
long lVar1;
if (param_3 != 0) {
*(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + -1;
lVar1 = (**(code **)(param_1 + 0x20))(param_3);
lVar1 = (*(long *)(param_1 + 0x30) - lVar1) + -8;
*(long *)(param_1 + 0x30) = lVar1;
/* WARNING: Could not recover jumptable at 0x001395d1. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(param_1 + 0x10))
(*(int8 *)(param_1 + 0x40),param_3,lVar1,*(code **)(param_1 + 0x10));
return;
}
return;
}
| |
27,827 | readMemBits | serhmarch[P]ModbusBridge/modbus/src/Modbus.cpp | StatusCode readMemBits(uint32_t offset, uint32_t count, void *values, const void *memBuff, uint32_t memBitCount, uint32_t *outCount)
{
if (static_cast<uint32_t>(offset + count) > memBitCount)
{
if (outCount && (offset < memBitCount))
count = memBitCount - offset;
else
return Status_BadIllegalDataAddress;
}
uint16_t byteOffset = offset/MB_BYTE_SZ_BITES;
uint16_t bytes = count/MB_BYTE_SZ_BITES;
uint16_t shift = offset%MB_BYTE_SZ_BITES;
const uint8_t *mem = reinterpret_cast<const uint8_t*>(memBuff);
if (shift)
{
for (uint16_t i = 0; i < bytes; i++)
{
uint16_t v = *(reinterpret_cast<const uint16_t*>(&mem[byteOffset+i])) >> shift;
reinterpret_cast<uint8_t*>(values)[i] = static_cast<uint8_t>(v);
}
if (uint16_t resid = count%MB_BYTE_SZ_BITES)
{
int8_t mask = static_cast<int8_t>(0x80);
mask = ~(mask>>(7-resid));
if ((shift+resid) > MB_BYTE_SZ_BITES)
{
uint16_t v = ((*reinterpret_cast<const uint16_t*>(&mem[byteOffset+bytes])) >> shift) & mask;
reinterpret_cast<uint8_t*>(values)[bytes] = static_cast<uint8_t>(v);
}
else
reinterpret_cast<uint8_t*>(values)[bytes] = (mem[byteOffset+bytes]>>shift) & mask;
}
}
else
{
memcpy(values, &mem[byteOffset], static_cast<size_t>(bytes));
if (uint16_t resid = count%MB_BYTE_SZ_BITES)
{
int8_t mask = static_cast<int8_t>(0x80);
mask = ~(mask>>(7-resid));
reinterpret_cast<uint8_t*>(values)[bytes] = mem[byteOffset+bytes] & mask;
}
}
if (outCount)
*outCount = count;
return Status_Good;
} | O3 | cpp | readMemBits:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %rcx, %r12
movq %rdx, %r14
movl %esi, %r15d
leal (%r15,%rdi), %eax
cmpl %r8d, %eax
jbe 0x7bf0
testq %rbx, %rbx
sete %cl
subl %edi, %r8d
setbe %dl
movl $0x1000002, %eax # imm = 0x1000002
orb %cl, %dl
jne 0x7ca9
movl %r8d, %r15d
movl %edi, %ebp
shrl $0x3, %ebp
movl %r15d, %r13d
shrl $0x3, %r13d
andl $0x7, %edi
je 0x7c56
movzwl %r13w, %eax
movl %eax, %edx
testl %eax, %eax
je 0x7c2a
movzwl %bp, %esi
addq %r12, %rsi
xorl %r8d, %r8d
movzwl (%rsi,%r8), %r9d
movl %edi, %ecx
shrl %cl, %r9d
movb %r9b, (%r14,%r8)
incq %r8
cmpq %r8, %rdx
jne 0x7c14
movl %r15d, %r8d
andl $0x7, %r8d
je 0x7c9f
movl %r8d, %ecx
xorb $0x7, %cl
movl $0x7f, %esi
shrl %cl, %esi
addl %edi, %r8d
movzwl %bp, %ecx
addq %rdx, %rcx
cmpl $0x9, %r8d
jb 0x7c90
movzwl (%r12,%rcx), %edx
jmp 0x7c95
movl $0xffff, %eax # imm = 0xFFFF
andl %eax, %ebp
leaq (%r12,%rbp), %rsi
andl %eax, %r13d
movq %r14, %rdi
movq %r13, %rdx
callq 0x52a0
movl %r15d, %ecx
andl $0x7, %ecx
je 0x7c9f
xorb $0x7, %cl
movl $0x7f, %eax
shrl %cl, %eax
movl %ebp, %ecx
addq %r13, %rcx
andb (%r12,%rcx), %al
movb %al, (%r14,%r13)
jmp 0x7c9f
movzbl (%r12,%rcx), %edx
movl %edi, %ecx
shrl %cl, %edx
andl %esi, %edx
movb %dl, (%r14,%rax)
xorl %eax, %eax
testq %rbx, %rbx
je 0x7ca9
movl %r15d, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| readMemBits:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, r9
mov r12, rcx
mov r14, rdx
mov r15d, esi
lea eax, [r15+rdi]
cmp eax, r8d
jbe short loc_7BF0
test rbx, rbx
setz cl
sub r8d, edi
setbe dl
mov eax, 1000002h
or dl, cl
jnz loc_7CA9
mov r15d, r8d
loc_7BF0:
mov ebp, edi
shr ebp, 3
mov r13d, r15d
shr r13d, 3
and edi, 7
jz short loc_7C56
movzx eax, r13w
mov edx, eax
test eax, eax
jz short loc_7C2A
movzx esi, bp
add rsi, r12
xor r8d, r8d
loc_7C14:
movzx r9d, word ptr [rsi+r8]
mov ecx, edi
shr r9d, cl
mov [r14+r8], r9b
inc r8
cmp rdx, r8
jnz short loc_7C14
loc_7C2A:
mov r8d, r15d
and r8d, 7
jz short loc_7C9F
mov ecx, r8d
xor cl, 7
mov esi, 7Fh
shr esi, cl
add r8d, edi
movzx ecx, bp
add rcx, rdx
cmp r8d, 9
jb short loc_7C90
movzx edx, word ptr [r12+rcx]
jmp short loc_7C95
loc_7C56:
mov eax, 0FFFFh
and ebp, eax
lea rsi, [r12+rbp]
and r13d, eax
mov rdi, r14
mov rdx, r13
call _memcpy
mov ecx, r15d
and ecx, 7
jz short loc_7C9F
xor cl, 7
mov eax, 7Fh
shr eax, cl
mov ecx, ebp
add rcx, r13
and al, [r12+rcx]
mov [r14+r13], al
jmp short loc_7C9F
loc_7C90:
movzx edx, byte ptr [r12+rcx]
loc_7C95:
mov ecx, edi
shr edx, cl
and edx, esi
mov [r14+rax], dl
loc_7C9F:
xor eax, eax
test rbx, rbx
jz short loc_7CA9
mov [rbx], r15d
loc_7CA9:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long readMemBits(
unsigned int a1,
unsigned int a2,
long long a3,
long long a4,
unsigned int a5,
unsigned int *a6)
{
unsigned int v9; // r15d
bool v10; // cf
unsigned int v11; // r8d
long long result; // rax
unsigned int v13; // ebp
unsigned int v14; // r13d
int v15; // edi
long long v16; // r8
int v17; // r8d
unsigned long long v18; // rcx
unsigned int v19; // edx
v9 = a2;
if ( a2 + a1 > a5 )
{
v10 = a5 < a1;
v11 = a5 - a1;
result = 16777218LL;
if ( a6 == 0LL || v10 || v11 == 0 )
return result;
v9 = v11;
}
v13 = a1 >> 3;
v14 = v9 >> 3;
v15 = a1 & 7;
if ( v15 )
{
if ( (_WORD)v14 )
{
v16 = 0LL;
do
{
*(_BYTE *)(a3 + v16) = *(unsigned __int16 *)(a4 + (unsigned __int16)v13 + v16) >> v15;
++v16;
}
while ( (unsigned __int16)v14 != v16 );
}
v17 = v9 & 7;
if ( (v9 & 7) != 0 )
{
v18 = (unsigned __int16)v14 + (unsigned long long)(unsigned __int16)v13;
if ( (unsigned int)(v15 + v17) < 9 )
v19 = *(unsigned __int8 *)(a4 + v18);
else
v19 = *(unsigned __int16 *)(a4 + v18);
*(_BYTE *)(a3 + (unsigned __int16)v14) = (0x7Fu >> (v17 ^ 7)) & (v19 >> v15);
}
}
else
{
memcpy(a3, a4 + (unsigned __int16)v13, (unsigned __int16)(v9 >> 3));
if ( (v9 & 7) != 0 )
*(_BYTE *)(a3 + (unsigned __int16)(v9 >> 3)) = *(_BYTE *)(a4
+ (unsigned __int16)(v9 >> 3)
+ (unsigned long long)(unsigned __int16)v13) & (0x7Fu >> (v9 & 7 ^ 7));
}
result = 0LL;
if ( a6 )
*a6 = v9;
return result;
}
| readMemBits:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,R9
MOV R12,RCX
MOV R14,RDX
MOV R15D,ESI
LEA EAX,[R15 + RDI*0x1]
CMP EAX,R8D
JBE 0x00107bf0
TEST RBX,RBX
SETZ CL
SUB R8D,EDI
SETBE DL
MOV EAX,0x1000002
OR DL,CL
JNZ 0x00107ca9
MOV R15D,R8D
LAB_00107bf0:
MOV EBP,EDI
SHR EBP,0x3
MOV R13D,R15D
SHR R13D,0x3
AND EDI,0x7
JZ 0x00107c56
MOVZX EAX,R13W
MOV EDX,EAX
TEST EAX,EAX
JZ 0x00107c2a
MOVZX ESI,BP
ADD RSI,R12
XOR R8D,R8D
LAB_00107c14:
MOVZX R9D,word ptr [RSI + R8*0x1]
MOV ECX,EDI
SHR R9D,CL
MOV byte ptr [R14 + R8*0x1],R9B
INC R8
CMP RDX,R8
JNZ 0x00107c14
LAB_00107c2a:
MOV R8D,R15D
AND R8D,0x7
JZ 0x00107c9f
MOV ECX,R8D
XOR CL,0x7
MOV ESI,0x7f
SHR ESI,CL
ADD R8D,EDI
MOVZX ECX,BP
ADD RCX,RDX
CMP R8D,0x9
JC 0x00107c90
MOVZX EDX,word ptr [R12 + RCX*0x1]
JMP 0x00107c95
LAB_00107c56:
MOV EAX,0xffff
AND EBP,EAX
LEA RSI,[R12 + RBP*0x1]
AND R13D,EAX
MOV RDI,R14
MOV RDX,R13
CALL 0x001052a0
MOV ECX,R15D
AND ECX,0x7
JZ 0x00107c9f
XOR CL,0x7
MOV EAX,0x7f
SHR EAX,CL
MOV ECX,EBP
ADD RCX,R13
AND AL,byte ptr [R12 + RCX*0x1]
MOV byte ptr [R14 + R13*0x1],AL
JMP 0x00107c9f
LAB_00107c90:
MOVZX EDX,byte ptr [R12 + RCX*0x1]
LAB_00107c95:
MOV ECX,EDI
SHR EDX,CL
AND EDX,ESI
MOV byte ptr [R14 + RAX*0x1],DL
LAB_00107c9f:
XOR EAX,EAX
TEST RBX,RBX
JZ 0x00107ca9
MOV dword ptr [RBX],R15D
LAB_00107ca9:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
readMemBits(uint param_1,uint param_2,void *param_3,long param_4,uint param_5,uint *param_6)
{
ulong uVar1;
long lVar2;
uint uVar3;
uint uVar4;
ulong uVar5;
ulong uVar6;
uVar6 = (ulong)param_2;
if (param_5 < param_2 + param_1) {
if ((param_5 < param_1 || param_5 - param_1 == 0) || param_6 == (uint *)0x0) {
return 0x1000002;
}
uVar6 = (ulong)(param_5 - param_1);
}
uVar3 = param_1 >> 3;
param_1 = param_1 & 7;
if (param_1 == 0) {
uVar1 = (ulong)((uint)(uVar6 >> 3) & 0xffff);
memcpy(param_3,(void *)(param_4 + (ulong)(uVar3 & 0xffff)),uVar1);
if ((uVar6 & 7) != 0) {
*(byte *)((long)param_3 + uVar1) =
(byte)(0x7f >> ((byte)uVar6 & 7 ^ 7)) & *(byte *)(param_4 + (uVar3 & 0xffff) + uVar1);
}
}
else {
uVar1 = uVar6 >> 3 & 0xffff;
if ((int)uVar1 != 0) {
uVar5 = 0;
do {
*(char *)((long)param_3 + uVar5) =
(char)(*(ushort *)((ulong)(uVar3 & 0xffff) + param_4 + uVar5) >> (sbyte)param_1);
uVar5 = uVar5 + 1;
} while (uVar1 != uVar5);
}
uVar4 = (uint)uVar6 & 7;
if ((uVar6 & 7) != 0) {
lVar2 = (uVar3 & 0xffff) + uVar1;
if (uVar4 + param_1 < 9) {
uVar3 = (uint)*(byte *)(param_4 + lVar2);
}
else {
uVar3 = (uint)*(ushort *)(param_4 + lVar2);
}
*(byte *)((long)param_3 + uVar1) =
(byte)(uVar3 >> (sbyte)param_1) & (byte)(0x7f >> ((byte)uVar4 ^ 7));
}
}
if (param_6 != (uint *)0x0) {
*param_6 = (uint)uVar6;
}
return 0;
}
| |
27,828 | minja::Parser::parseLogicalNot() | llama.cpp/common/minja/minja.hpp | std::shared_ptr<Expression> parseLogicalNot() {
static std::regex not_tok(R"(not\b)");
auto location = get_location();
if (!consumeToken(not_tok).empty()) {
auto sub = parseLogicalNot();
if (!sub) throw std::runtime_error("Expected expression after 'not' keyword");
return std::make_shared<UnaryOpExpr>(location, std::move(sub), UnaryOpExpr::Op::LogicalNot);
}
return parseLogicalCompare();
} | O3 | cpp | minja::Parser::parseLogicalNot():
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x83bfa(%rip), %rax # 0x1644f8
movb (%rax), %al
testb %al, %al
je 0xe0a1a
movq (%r15), %rax
movq %rax, 0x50(%rsp)
movq 0x8(%r15), %rax
movq %rax, 0x58(%rsp)
testq %rax, %rax
je 0xe0933
movq 0x82673(%rip), %rcx # 0x162f98
cmpb $0x0, (%rcx)
je 0xe092f
incl 0x8(%rax)
jmp 0xe0933
lock
incl 0x8(%rax)
leaq 0x58(%rsp), %rbx
movq 0x20(%r15), %rax
subq 0x10(%r15), %rax
movq %rax, 0x8(%rbx)
leaq 0x83b8d(%rip), %rdx # 0x1644d8
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
movl $0x1, %ecx
callq 0xdef6a
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
movq -0x8(%rax), %r12
cmpq %rax, %rdi
je 0xe097c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x20180
testq %r12, %r12
je 0xe09f8
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0xe08e6
cmpq $0x0, 0x28(%rsp)
je 0xe0a71
leaq 0x4c(%rsp), %r9
movl $0x2, (%r9)
leaq 0x18(%rsp), %r15
movq $0x0, -0x8(%r15)
leaq 0x10(%rsp), %rsi
leaq 0xf(%rsp), %rdx
leaq 0x50(%rsp), %rcx
leaq 0x28(%rsp), %r8
movq %r15, %rdi
callq 0xe11ea
movaps 0x10(%rsp), %xmm0
xorl %eax, %eax
movq %rax, 0x18(%rsp)
movups %xmm0, (%r14)
movq %rax, 0x10(%rsp)
movq %r15, %rdi
callq 0x70a60
leaq 0x30(%rsp), %rdi
callq 0x70a60
jmp 0xe0a03
movq %r14, %rdi
movq %r15, %rsi
callq 0xe0aea
movq %rbx, %rdi
callq 0x70a60
movq %r14, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x83ad7(%rip), %rdi # 0x1644f8
callq 0x205a0
testl %eax, %eax
je 0xe0908
leaq 0x83aa3(%rip), %rdi # 0x1644d8
leaq 0x40d6e(%rip), %rsi # 0x1217aa
movl $0x10, %edx
callq 0x6637a
leaq -0x7a627(%rip), %rdi # 0x66426
leaq 0x83a84(%rip), %rsi # 0x1644d8
leaq 0x8301d(%rip), %rdx # 0x163a78
callq 0x20ee0
leaq 0x83a91(%rip), %rdi # 0x1644f8
callq 0x20960
jmp 0xe0908
movl $0x10, %edi
callq 0x20650
movq %rax, %r15
leaq 0x40d2b(%rip), %rsi # 0x1217b0
movq %rax, %rdi
callq 0x20430
movq 0x8252c(%rip), %rsi # 0x162fc0
movq 0x824e5(%rip), %rdx # 0x162f80
movq %r15, %rdi
callq 0x20a50
movq %rax, %r14
leaq 0x83a4b(%rip), %rdi # 0x1644f8
callq 0x206d0
jmp 0xe0ae1
jmp 0xe0ac5
movq %rax, %r14
movq %r15, %rdi
callq 0x20f00
jmp 0xe0ac8
jmp 0xe0ad6
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x70a60
jmp 0xe0ad9
jmp 0xe0ad6
movq %rax, %r14
movq %rbx, %rdi
callq 0x70a60
movq %r14, %rdi
callq 0x20af0
nop
| _ZN5minja6Parser15parseLogicalNotEv:
push r15
push r14
push r12
push rbx
sub rsp, 68h
mov r15, rsi
mov r14, rdi
lea rax, _ZGVZN5minja6Parser15parseLogicalNotEvE7not_tokB5cxx11; `guard variable for'minja::Parser::parseLogicalNot(void)::not_tok
mov al, [rax]
test al, al
jz loc_E0A1A
loc_E0908:
mov rax, [r15]
mov [rsp+88h+var_38], rax
mov rax, [r15+8]
mov [rsp+88h+var_30], rax
test rax, rax
jz short loc_E0933
mov rcx, cs:_ZTISt19_Sp_make_shared_tag; `typeinfo for'std::_Sp_make_shared_tag
cmp byte ptr [rcx], 0
jz short loc_E092F
inc dword ptr [rax+8]
jmp short loc_E0933
loc_E092F:
lock inc dword ptr [rax+8]
loc_E0933:
lea rbx, [rsp+88h+var_30]
mov rax, [r15+20h]
sub rax, [r15+10h]
mov [rbx+8], rax
lea rdx, _ZZN5minja6Parser15parseLogicalNotEvE7not_tokB5cxx11; int
lea rdi, [rsp+88h+var_60]; int
mov rsi, r15; int
mov ecx, 1; int
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::basic_regex<char,std::regex_traits<char>> const&,minja::SpaceHandling)
lea rax, [rsp+88h+var_50]
mov rdi, [rax-10h]; void *
mov r12, [rax-8]
cmp rdi, rax
jz short loc_E097C
mov rsi, [rsp+88h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_E097C:
test r12, r12
jz short loc_E09F8
lea rdi, [rsp+88h+var_60]; this
mov rsi, r15
call _ZN5minja6Parser15parseLogicalNotEv; minja::Parser::parseLogicalNot(void)
cmp qword ptr [rsp+88h+var_60], 0
jz loc_E0A71
lea r9, [rsp+88h+var_3C]
mov dword ptr [r9], 2
lea r15, [rsp+88h+var_78+8]
mov qword ptr [r15-8], 0
lea rsi, [rsp+88h+var_78]
lea rdx, [rsp+88h+var_79]
lea rcx, [rsp+88h+var_38]
lea r8, [rsp+88h+var_60]
mov rdi, r15
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EEC2IN5minja11UnaryOpExprESaIvEJRNS4_8LocationESt10shared_ptrINS4_10ExpressionEENS5_2OpEEEERPT_St20_Sp_alloc_shared_tagIT0_EDpOT1_; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::__shared_count<minja::UnaryOpExpr,std::allocator<void>,minja::Location &,std::shared_ptr<minja::Expression>,minja::UnaryOpExpr::Op>(minja::UnaryOpExpr *&,std::_Sp_alloc_shared_tag<std::allocator<void>>,minja::Location &,std::shared_ptr<minja::Expression>,minja::UnaryOpExpr::Op &&)
movaps xmm0, [rsp+88h+var_78]
xor eax, eax
mov qword ptr [rsp+88h+var_78+8], rax
movups xmmword ptr [r14], xmm0
mov qword ptr [rsp+88h+var_78], rax
mov rdi, r15
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+88h+var_58]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp short loc_E0A03
loc_E09F8:
mov rdi, r14; this
mov rsi, r15
call _ZN5minja6Parser19parseLogicalCompareEv; minja::Parser::parseLogicalCompare(void)
loc_E0A03:
mov rdi, rbx
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rax, r14
add rsp, 68h
pop rbx
pop r12
pop r14
pop r15
retn
loc_E0A1A:
lea rdi, _ZGVZN5minja6Parser15parseLogicalNotEvE7not_tokB5cxx11; __guard *
call ___cxa_guard_acquire
test eax, eax
jz loc_E0908
lea rdi, _ZZN5minja6Parser15parseLogicalNotEvE7not_tokB5cxx11; minja::Parser::parseLogicalNot(void)::not_tok
lea rsi, aNotB; "not\\b"
mov edx, 10h
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2EPKcNSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex(char const*,std::regex_constants::syntax_option_type)
lea rdi, _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; lpfunc
lea rsi, _ZZN5minja6Parser15parseLogicalNotEvE7not_tokB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZN5minja6Parser15parseLogicalNotEvE7not_tokB5cxx11; __guard *
call ___cxa_guard_release
jmp loc_E0908
loc_E0A71:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rsi, aExpectedExpres_2; "Expected expression after 'not' keyword"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
mov r14, rax
lea rdi, _ZGVZN5minja6Parser15parseLogicalNotEvE7not_tokB5cxx11; __guard *
call ___cxa_guard_abort
jmp short loc_E0AE1
jmp short loc_E0AC5
mov r14, rax
mov rdi, r15; void *
call ___cxa_free_exception
jmp short loc_E0AC8
jmp short loc_E0AD6
loc_E0AC5:
mov r14, rax
loc_E0AC8:
lea rdi, [rsp+88h+var_58]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp short loc_E0AD9
jmp short $+2
loc_E0AD6:
mov r14, rax
loc_E0AD9:
mov rdi, rbx
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
loc_E0AE1:
mov rdi, r14
call __Unwind_Resume
| minja::Parser * minja::Parser::parseLogicalNot(minja::Parser *this, long long *a2)
{
volatile signed __int32 *v2; // rax
volatile signed __int32 *v3; // r12
__int128 v4; // xmm0
std::runtime_error *exception; // r15
char v7; // [rsp+Fh] [rbp-79h] BYREF
__int128 v8; // [rsp+10h] [rbp-78h] BYREF
int v9[2]; // [rsp+28h] [rbp-60h] BYREF
volatile signed __int32 *v10; // [rsp+30h] [rbp-58h] BYREF
long long v11; // [rsp+38h] [rbp-50h] BYREF
int v12; // [rsp+4Ch] [rbp-3Ch] BYREF
long long v13; // [rsp+50h] [rbp-38h] BYREF
volatile signed __int32 *v14[6]; // [rsp+58h] [rbp-30h] BYREF
if ( !(_BYTE)`guard variable for'minja::Parser::parseLogicalNot(void)::not_tok[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'minja::Parser::parseLogicalNot(void)::not_tok[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&minja::Parser::parseLogicalNot(void)::not_tok[abi:cxx11],
(long long)"not\\b",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&minja::Parser::parseLogicalNot(void)::not_tok[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'minja::Parser::parseLogicalNot(void)::not_tok[abi:cxx11]);
}
v13 = *a2;
v2 = (volatile signed __int32 *)a2[1];
v14[0] = v2;
if ( v2 )
{
if ( _libc_single_threaded )
++*((_DWORD *)v2 + 2);
else
_InterlockedIncrement(v2 + 2);
}
v14[1] = (volatile signed __int32 *)(a2[4] - a2[2]);
minja::Parser::consumeToken(v9, (long long)a2, (long long)&minja::Parser::parseLogicalNot(void)::not_tok[abi:cxx11], 1u);
v3 = v10;
if ( *(long long **)v9 != &v11 )
operator delete(*(void **)v9, v11 + 1);
if ( v3 )
{
minja::Parser::parseLogicalNot((minja::Parser *)v9);
if ( !*(_QWORD *)v9 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Expected expression after 'not' keyword");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v12 = 2;
*(_QWORD *)&v8 = 0LL;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::__shared_count<minja::UnaryOpExpr,std::allocator<void>,minja::Location &,std::shared_ptr<minja::Expression>,minja::UnaryOpExpr::Op>(
(char *)&v8 + 8,
&v8,
&v7,
&v13,
v9,
&v12);
v4 = v8;
*((_QWORD *)&v8 + 1) = 0LL;
*(_OWORD *)this = v4;
*(_QWORD *)&v8 = 0LL;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count((volatile signed __int32 **)&v8 + 1);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v10);
}
else
{
minja::Parser::parseLogicalCompare(this);
}
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(v14);
return this;
}
| parseLogicalNot:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R15,RSI
MOV R14,RDI
LEA RAX,[0x2644f8]
MOV AL,byte ptr [RAX]
TEST AL,AL
JZ 0x001e0a1a
LAB_001e0908:
MOV RAX,qword ptr [R15]
MOV qword ptr [RSP + 0x50],RAX
MOV RAX,qword ptr [R15 + 0x8]
MOV qword ptr [RSP + 0x58],RAX
TEST RAX,RAX
JZ 0x001e0933
MOV RCX,qword ptr [0x00262f98]
CMP byte ptr [RCX],0x0
JZ 0x001e092f
INC dword ptr [RAX + 0x8]
JMP 0x001e0933
LAB_001e092f:
INC.LOCK dword ptr [RAX + 0x8]
LAB_001e0933:
LEA RBX,[RSP + 0x58]
MOV RAX,qword ptr [R15 + 0x20]
SUB RAX,qword ptr [R15 + 0x10]
MOV qword ptr [RBX + 0x8],RAX
LAB_001e0944:
LEA RDX,[0x2644d8]
LEA RDI,[RSP + 0x28]
MOV RSI,R15
MOV ECX,0x1
CALL 0x001def6a
LEA RAX,[RSP + 0x38]
MOV RDI,qword ptr [RAX + -0x10]
MOV R12,qword ptr [RAX + -0x8]
CMP RDI,RAX
JZ 0x001e097c
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x00120180
LAB_001e097c:
TEST R12,R12
JZ 0x001e09f8
LAB_001e0981:
LEA RDI,[RSP + 0x28]
MOV RSI,R15
CALL 0x001e08e6
CMP qword ptr [RSP + 0x28],0x0
JZ 0x001e0a71
LEA R9,[RSP + 0x4c]
MOV dword ptr [R9],0x2
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x8],0x0
LAB_001e09b3:
LEA RSI,[RSP + 0x10]
LEA RDX,[RSP + 0xf]
LEA RCX,[RSP + 0x50]
LEA R8,[RSP + 0x28]
MOV RDI,R15
CALL 0x001e11ea
MOVAPS XMM0,xmmword ptr [RSP + 0x10]
XOR EAX,EAX
MOV qword ptr [RSP + 0x18],RAX
MOVUPS xmmword ptr [R14],XMM0
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,R15
CALL 0x00170a60
LEA RDI,[RSP + 0x30]
CALL 0x00170a60
JMP 0x001e0a03
LAB_001e09f8:
MOV RDI,R14
MOV RSI,R15
CALL 0x001e0aea
LAB_001e0a03:
MOV RDI,RBX
CALL 0x00170a60
MOV RAX,R14
ADD RSP,0x68
POP RBX
POP R12
POP R14
POP R15
RET
LAB_001e0a1a:
LEA RDI,[0x2644f8]
CALL 0x001205a0
TEST EAX,EAX
JZ 0x001e0908
LAB_001e0a2e:
LEA RDI,[0x2644d8]
LEA RSI,[0x2217aa]
MOV EDX,0x10
CALL 0x0016637a
LAB_001e0a46:
LEA RDI,[0x166426]
LEA RSI,[0x2644d8]
LEA RDX,[0x263a78]
CALL 0x00120ee0
LEA RDI,[0x2644f8]
CALL 0x00120960
JMP 0x001e0908
LAB_001e0a71:
MOV EDI,0x10
CALL 0x00120650
MOV R15,RAX
LAB_001e0a7e:
LEA RSI,[0x2217b0]
MOV RDI,RAX
CALL 0x00120430
LAB_001e0a8d:
MOV RSI,qword ptr [0x00262fc0]
MOV RDX,qword ptr [0x00262f80]
MOV RDI,R15
CALL 0x00120a50
|
/* minja::Parser::parseLogicalNot() */
void minja::Parser::parseLogicalNot(void)
{
int8 uVar1;
int iVar2;
runtime_error *this;
int8 *in_RSI;
int8 *in_RDI;
int1 local_79;
int8 local_78;
int8 auStack_70 [2];
long *local_60;
long local_58;
long local_50 [2];
int4 local_3c;
int8 local_38;
long local_30;
long local_28;
if (parseLogicalNot()::not_tok_abi_cxx11_ == '\0') {
iVar2 = __cxa_guard_acquire(&parseLogicalNot()::not_tok_abi_cxx11_);
if (iVar2 != 0) {
/* try { // try from 001e0a2e to 001e0a45 has its CatchHandler @ 001e0aa3 */
std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::basic_regex
((basic_regex<char,std::__cxx11::regex_traits<char>> *)
parseLogicalNot()::not_tok_abi_cxx11_,"not\\b",0x10);
__cxa_atexit(std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::~basic_regex,
parseLogicalNot()::not_tok_abi_cxx11_,&__dso_handle);
__cxa_guard_release(&parseLogicalNot()::not_tok_abi_cxx11_);
}
}
local_38 = *in_RSI;
local_30 = in_RSI[1];
if (local_30 != 0) {
if (*PTR___libc_single_threaded_00262f98 == '\0') {
LOCK();
*(int *)(local_30 + 8) = *(int *)(local_30 + 8) + 1;
UNLOCK();
}
else {
*(int *)(local_30 + 8) = *(int *)(local_30 + 8) + 1;
}
}
local_28 = in_RSI[4] - in_RSI[2];
/* try { // try from 001e0944 to 001e095c has its CatchHandler @ 001e0ad6 */
consumeToken(&local_60);
if (local_60 != local_50) {
operator_delete(local_60,local_50[0] + 1);
}
if (local_58 == 0) {
/* try { // try from 001e09f8 to 001e0a02 has its CatchHandler @ 001e0ac3 */
parseLogicalCompare();
}
else {
/* try { // try from 001e0981 to 001e098d has its CatchHandler @ 001e0ad4 */
parseLogicalNot();
if (local_60 == (long *)0x0) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001e0a7e to 001e0a8c has its CatchHandler @ 001e0ab6 */
std::runtime_error::runtime_error(this,"Expected expression after \'not\' keyword");
/* try { // try from 001e0a8d to 001e0aa2 has its CatchHandler @ 001e0ab4 */
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_00262fc0,PTR__runtime_error_00262f80);
}
local_3c = 2;
local_78 = 0;
/* try { // try from 001e09b3 to 001e09ce has its CatchHandler @ 001e0ac5 */
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::
__shared_count<minja::UnaryOpExpr,std::allocator<void>,minja::Location&,std::shared_ptr<minja::Expression>,minja::UnaryOpExpr::Op>
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)auStack_70,&local_78,&local_79,
&local_38,&local_60);
uVar1 = auStack_70[0];
auStack_70[0] = 0;
*in_RDI = local_78;
in_RDI[1] = uVar1;
local_78 = 0;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)auStack_70);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&local_58);
}
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&local_30);
return;
}
| |
27,829 | my_fstat | eloqsql/mysys/my_lib.c | int my_fstat(File Filedes, MY_STAT *stat_area,
myf MyFlags __attribute__((unused)))
{
DBUG_ENTER("my_fstat");
DBUG_PRINT("my",("fd: %d MyFlags: %lu", Filedes, MyFlags));
#ifdef _WIN32
DBUG_RETURN(my_win_fstat(Filedes, stat_area));
#elif defined HAVE_valgrind
{
int s= fstat(Filedes, stat_area);
if (!s)
MSAN_STAT_WORKAROUND(stat_area);
DBUG_RETURN(s);
}
#else
DBUG_RETURN(fstat(Filedes, (struct stat *) stat_area));
#endif
} | O3 | c | my_fstat:
pushq %rbp
movq %rsp, %rbp
popq %rbp
jmp 0x286f0
nopl (%rax)
| my_fstat:
push rbp
mov rbp, rsp
pop rbp
jmp _fstat64
| long long my_fstat()
{
return fstat64();
}
| my_fstat:
PUSH RBP
MOV RBP,RSP
POP RBP
JMP 0x001286f0
|
void my_fstat(int param_1,stat64 *param_2)
{
fstat64(param_1,param_2);
return;
}
| |
27,830 | list_reverse | eloqsql/libmariadb/libmariadb/ma_list.c | LIST *list_reverse(LIST *root)
{
LIST *last;
last=root;
while (root)
{
last=root;
root=root->next;
last->next=last->prev;
last->prev=root;
}
return last;
} | O0 | c | list_reverse:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x27577
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x27540
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
| list_reverse:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
loc_27540:
cmp [rbp+var_8], 0
jz short loc_27577
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov [rbp+var_8], rax
mov rax, [rbp+var_10]
mov rcx, [rax]
mov rax, [rbp+var_10]
mov [rax+8], rcx
mov rcx, [rbp+var_8]
mov rax, [rbp+var_10]
mov [rax], rcx
jmp short loc_27540
loc_27577:
mov rax, [rbp+var_10]
pop rbp
retn
| _QWORD * list_reverse(_QWORD *a1)
{
_QWORD *v2; // [rsp+0h] [rbp-10h]
_QWORD *v3; // [rsp+8h] [rbp-8h]
v3 = a1;
v2 = a1;
while ( v3 )
{
v2 = v3;
v3 = (_QWORD *)v3[1];
v2[1] = *v2;
*v2 = v3;
}
return v2;
}
| list_reverse:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
LAB_00127540:
CMP qword ptr [RBP + -0x8],0x0
JZ 0x00127577
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
JMP 0x00127540
LAB_00127577:
MOV RAX,qword ptr [RBP + -0x10]
POP RBP
RET
|
int8 * list_reverse(int8 *param_1)
{
int8 *puVar1;
int8 *local_18;
int8 *local_10;
local_18 = param_1;
local_10 = param_1;
while (local_10 != (int8 *)0x0) {
local_18 = local_10;
puVar1 = (int8 *)local_10[1];
local_10[1] = *local_10;
*local_10 = puVar1;
local_10 = puVar1;
}
return local_18;
}
| |
27,831 | list_reverse | eloqsql/libmariadb/libmariadb/ma_list.c | LIST *list_reverse(LIST *root)
{
LIST *last;
last=root;
while (root)
{
last=root;
root=root->next;
last->next=last->prev;
last->prev=root;
}
return last;
} | O3 | c | list_reverse:
testq %rdi, %rdi
je 0x1fd48
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq (%rdi), %rcx
movq 0x8(%rdi), %rdi
movq %rcx, 0x8(%rax)
movq %rdi, (%rax)
testq %rdi, %rdi
jne 0x1fd30
popq %rbp
retq
xorl %eax, %eax
retq
| list_reverse:
test rdi, rdi
jz short loc_1FD48
push rbp
mov rbp, rsp
loc_1FD30:
mov rax, rdi
mov rcx, [rdi]
mov rdi, [rdi+8]
mov [rax+8], rcx
mov [rax], rdi
test rdi, rdi
jnz short loc_1FD30
pop rbp
retn
loc_1FD48:
xor eax, eax
retn
| _QWORD * list_reverse(_QWORD *a1)
{
_QWORD *result; // rax
long long v2; // rcx
if ( !a1 )
return 0LL;
do
{
result = a1;
v2 = *a1;
a1 = (_QWORD *)a1[1];
result[1] = v2;
*result = a1;
}
while ( a1 );
return result;
}
| list_reverse:
TEST RDI,RDI
JZ 0x0011fd48
PUSH RBP
MOV RBP,RSP
LAB_0011fd30:
MOV RAX,RDI
MOV RCX,qword ptr [RDI]
MOV RDI,qword ptr [RDI + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV qword ptr [RAX],RDI
TEST RDI,RDI
JNZ 0x0011fd30
POP RBP
RET
LAB_0011fd48:
XOR EAX,EAX
RET
|
int8 * list_reverse(int8 *param_1)
{
int8 *puVar1;
int8 *puVar2;
if (param_1 == (int8 *)0x0) {
return (int8 *)0x0;
}
do {
puVar2 = param_1;
puVar1 = (int8 *)param_1[1];
param_1[1] = *param_1;
*param_1 = puVar1;
param_1 = puVar1;
} while (puVar1 != (int8 *)0x0);
return puVar2;
}
| |
27,832 | google::protobuf::DescriptorBuilder::AllocateOptions(google::protobuf::FileOptions const&, google::protobuf::FileDescriptor*, google::protobuf::internal::FlatAllocator&) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.cc | void DescriptorBuilder::AllocateOptions(const FileOptions& orig_options,
FileDescriptor* descriptor,
internal::FlatAllocator& alloc) {
std::vector<int> options_path;
options_path.push_back(FileDescriptorProto::kOptionsFieldNumber);
// We add the dummy token so that LookupSymbol does the right thing.
AllocateOptionsImpl(descriptor->package() + ".dummy", descriptor->name(),
orig_options, descriptor, options_path,
"google.protobuf.FileOptions", alloc);
} | O0 | cpp | google::protobuf::DescriptorBuilder::AllocateOptions(google::protobuf::FileOptions const&, google::protobuf::FileDescriptor*, google::protobuf::internal::FlatAllocator&):
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq %rcx, 0xc8(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0xb0(%rsp), %rdi
movq %rdi, 0x48(%rsp)
callq 0x112bb0
movq 0x48(%rsp), %rdi
movl $0x8, 0xac(%rsp)
leaq 0xac(%rsp), %rsi
callq 0x8fc80
jmp 0x255485
movq 0xd0(%rsp), %rdi
callq 0x2835a0
movq %rax, 0x38(%rsp)
jmp 0x255499
movq 0x38(%rsp), %rsi
leaq 0x19755f(%rip), %rdx # 0x3eca04
leaq 0x78(%rsp), %rdi
callq 0x95630
jmp 0x2554b1
movq 0xd0(%rsp), %rdi
callq 0x1dde00
movq %rax, 0x30(%rsp)
jmp 0x2554c5
movq 0xd8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x57(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x94520
movq 0x28(%rsp), %rdx
leaq 0x197511(%rip), %rsi # 0x3eca0b
leaq 0x58(%rsp), %rdi
callq 0x92ea0
jmp 0x255506
movq 0x20(%rsp), %r8
movq 0x18(%rsp), %rcx
movq 0x30(%rsp), %rdx
movq 0x40(%rsp), %rdi
movq 0xc8(%rsp), %rsi
movq %rsp, %rax
movq %rsi, 0x8(%rax)
leaq 0x58(%rsp), %rsi
movq %rsi, (%rax)
leaq 0x78(%rsp), %rsi
leaq 0xb0(%rsp), %r9
callq 0x284c90
jmp 0x255545
leaq 0x58(%rsp), %rdi
callq 0x921e0
leaq 0x57(%rsp), %rdi
callq 0x96fa0
leaq 0x78(%rsp), %rdi
callq 0x921e0
leaq 0xb0(%rsp), %rdi
callq 0xf7d30
addq $0xe8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x2555ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x2555e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x2555d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x921e0
leaq 0x57(%rsp), %rdi
callq 0x96fa0
leaq 0x78(%rsp), %rdi
callq 0x921e0
leaq 0xb0(%rsp), %rdi
callq 0xf7d30
movq 0xa0(%rsp), %rdi
callq 0x90db0
nopw %cs:(%rax,%rax)
| _ZN6google8protobuf17DescriptorBuilder15AllocateOptionsERKNS0_11FileOptionsEPNS0_14FileDescriptorERNS0_8internal13FlatAllocatorE:
sub rsp, 0E8h
mov [rsp+0E8h+var_8], rdi
mov [rsp+0E8h+var_10], rsi
mov [rsp+0E8h+var_18], rdx
mov [rsp+0E8h+var_20], rcx
mov rax, [rsp+0E8h+var_8]
mov [rsp+0E8h+var_A8], rax
lea rdi, [rsp+0E8h+var_38]
mov [rsp+0E8h+var_A0], rdi
call _ZNSt6vectorIiSaIiEEC2Ev; std::vector<int>::vector(void)
mov rdi, [rsp+0E8h+var_A0]
mov [rsp+0E8h+var_3C], 8
lea rsi, [rsp+0E8h+var_3C]
call __ZNSt6vectorIiSaIiEE9push_backEOi; std::vector<int>::push_back(int &&)
jmp short $+2
loc_255485:
mov rdi, [rsp+0E8h+var_18]
call _ZNK6google8protobuf14FileDescriptor7packageB5cxx11Ev; google::protobuf::FileDescriptor::package(void)
mov [rsp+0E8h+var_B0], rax
jmp short $+2
loc_255499:
mov rsi, [rsp+0E8h+var_B0]
lea rdx, aDummy; ".dummy"
lea rdi, [rsp+0E8h+var_70]
call __ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EERKS8_PKS5_; std::operator+<char>(std::string const&,char const*)
jmp short $+2
loc_2554B1:
mov rdi, [rsp+0E8h+var_18]
call _ZNK6google8protobuf14FileDescriptor4nameB5cxx11Ev; google::protobuf::FileDescriptor::name(void)
mov [rsp+0E8h+var_B8], rax
jmp short $+2
loc_2554C5:
mov rax, [rsp+0E8h+var_10]
mov [rsp+0E8h+var_D0], rax
mov rax, [rsp+0E8h+var_18]
mov [rsp+0E8h+var_C8], rax
lea rdi, [rsp+0E8h+var_91]
mov [rsp+0E8h+var_C0], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdx, [rsp+0E8h+var_C0]
lea rsi, aGoogleProtobuf_17; "google.protobuf.FileOptions"
lea rdi, [rsp+0E8h+var_90]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1EPKcRKS3_; std::string::basic_string(char const*,std::allocator<char> const&)
jmp short $+2
loc_255506:
mov r8, [rsp+0E8h+var_C8]
mov rcx, [rsp+0E8h+var_D0]
mov rdx, [rsp+0E8h+var_B8]
mov rdi, [rsp+0E8h+var_A8]
mov rsi, [rsp+0E8h+var_20]
mov rax, rsp
mov [rax+8], rsi
lea rsi, [rsp+0E8h+var_90]
mov [rax], rsi
lea rsi, [rsp+0E8h+var_70]
lea r9, [rsp+0E8h+var_38]
call _ZN6google8protobuf17DescriptorBuilder19AllocateOptionsImplINS0_14FileDescriptorEEEvRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESB_RKNT_11OptionsTypeEPSC_RKSt6vectorIiSaIiEESB_RNS0_8internal13FlatAllocatorE; google::protobuf::DescriptorBuilder::AllocateOptionsImpl<google::protobuf::FileDescriptor>(std::string const&,std::string const&,google::protobuf::FileDescriptor::OptionsType const&,google::protobuf::FileDescriptor::OptionsType*,std::vector<int> const&,std::string const&,google::protobuf::internal::FlatAllocator &)
jmp short $+2
loc_255545:
lea rdi, [rsp+0E8h+var_90]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+0E8h+var_91]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
lea rdi, [rsp+0E8h+var_70]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+0E8h+var_38]
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
add rsp, 0E8h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_98], rcx
mov [rsp+arg_94], eax
jmp short loc_2555EC
mov rcx, rax
mov eax, edx
mov [rsp+arg_98], rcx
mov [rsp+arg_94], eax
jmp short loc_2555E2
mov rcx, rax
mov eax, edx
mov [rsp+arg_98], rcx
mov [rsp+arg_94], eax
jmp short loc_2555D8
mov rcx, rax
mov eax, edx
mov [rsp+arg_98], rcx
mov [rsp+arg_94], eax
lea rdi, [rsp+arg_50]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_2555D8:
lea rdi, [rsp+arg_4F]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
loc_2555E2:
lea rdi, [rsp+arg_70]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_2555EC:
lea rdi, [rsp+arg_A8]
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rdi, [rsp+arg_98]
call __Unwind_Resume
| long long google::protobuf::DescriptorBuilder::AllocateOptions(
google::protobuf::DescriptorBuilder *this,
const google::protobuf::FileOptions *a2,
google::protobuf::FileDescriptor *a3,
google::protobuf::internal::FlatAllocator *a4)
{
long long v4; // rsi
int v5; // ecx
int v6; // r8d
int v7; // r9d
int v9; // [rsp+18h] [rbp-D0h]
int v10; // [rsp+20h] [rbp-C8h]
int v11; // [rsp+30h] [rbp-B8h]
char v12; // [rsp+57h] [rbp-91h] BYREF
_BYTE v13[32]; // [rsp+58h] [rbp-90h] BYREF
_BYTE v14[52]; // [rsp+78h] [rbp-70h] BYREF
int v15; // [rsp+ACh] [rbp-3Ch] BYREF
long long v16[3]; // [rsp+B0h] [rbp-38h] BYREF
google::protobuf::internal::FlatAllocator *v17; // [rsp+C8h] [rbp-20h]
google::protobuf::FileDescriptor *v18; // [rsp+D0h] [rbp-18h]
const google::protobuf::FileOptions *v19; // [rsp+D8h] [rbp-10h]
google::protobuf::DescriptorBuilder *v20; // [rsp+E0h] [rbp-8h]
v20 = this;
v19 = a2;
v18 = a3;
v17 = a4;
std::vector<int>::vector((long long)v16);
v15 = 8;
std::vector<int>::push_back(v16, &v15);
v4 = google::protobuf::FileDescriptor::package[abi:cxx11](v18);
std::operator+<char>((unsigned int)v14, v4, (unsigned int)".dummy", v5, v6, v7);
v11 = google::protobuf::FileDescriptor::name[abi:cxx11]((long long)v18);
v9 = (int)v19;
v10 = (int)v18;
std::allocator<char>::allocator(&v12, v4);
std::string::basic_string(v13, "google.protobuf.FileOptions", &v12);
google::protobuf::DescriptorBuilder::AllocateOptionsImpl<google::protobuf::FileDescriptor>(
(_DWORD)this,
(unsigned int)v14,
v11,
v9,
v10,
(unsigned int)v16,
(long long)v13,
(long long)v17);
std::string::~string(v13);
std::allocator<char>::~allocator(&v12);
std::string::~string(v14);
return std::vector<int>::~vector(v16);
}
| ~vector:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV RDI,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x8],RDI
MOV RAX,qword ptr [RDI]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RDI + 0x8]
MOV qword ptr [RSP + 0x18],RAX
CALL 0x002555d0
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x18]
MOV RDX,RAX
LAB_00255456:
CALL 0x002555a0
JMP 0x0025545d
LAB_0025545d:
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x002555e0
ADD RSP,0x28
RET
|
/* std::vector<google::protobuf::UnknownField, std::allocator<google::protobuf::UnknownField>
>::~vector() */
void __thiscall
std::vector<google::protobuf::UnknownField,std::allocator<google::protobuf::UnknownField>>::~vector
(vector<google::protobuf::UnknownField,std::allocator<google::protobuf::UnknownField>>
*this)
{
UnknownField *pUVar1;
UnknownField *pUVar2;
allocator *paVar3;
pUVar1 = *(UnknownField **)this;
pUVar2 = *(UnknownField **)(this + 8);
paVar3 = (allocator *)
_Vector_base<google::protobuf::UnknownField,std::allocator<google::protobuf::UnknownField>>
::_M_get_Tp_allocator
((_Vector_base<google::protobuf::UnknownField,std::allocator<google::protobuf::UnknownField>>
*)this);
/* try { // try from 00255456 to 0025545a has its CatchHandler @ 0025546c */
_Destroy<google::protobuf::UnknownField*,google::protobuf::UnknownField>(pUVar1,pUVar2,paVar3);
_Vector_base<google::protobuf::UnknownField,std::allocator<google::protobuf::UnknownField>>::
~_Vector_base((_Vector_base<google::protobuf::UnknownField,std::allocator<google::protobuf::UnknownField>>
*)this);
return;
}
| |
27,833 | google::protobuf::DescriptorBuilder::AllocateOptions(google::protobuf::FileOptions const&, google::protobuf::FileDescriptor*, google::protobuf::internal::FlatAllocator&) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.cc | void DescriptorBuilder::AllocateOptions(const FileOptions& orig_options,
FileDescriptor* descriptor,
internal::FlatAllocator& alloc) {
std::vector<int> options_path;
options_path.push_back(FileDescriptorProto::kOptionsFieldNumber);
// We add the dummy token so that LookupSymbol does the right thing.
AllocateOptionsImpl(descriptor->package() + ".dummy", descriptor->name(),
orig_options, descriptor, options_path,
"google.protobuf.FileOptions", alloc);
} | O3 | cpp | google::protobuf::DescriptorBuilder::AllocateOptions(google::protobuf::FileOptions const&, google::protobuf::FileDescriptor*, google::protobuf::internal::FlatAllocator&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rsp, %rdx
movl $0x8, (%rdx)
xorl %esi, %esi
callq 0x2ddf0
movq 0x10(%r14), %rax
leaq 0x10(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x2c640
leaq 0x9f520(%rip), %rsi # 0x16c5bb
movq %rsp, %rdi
callq 0x2e5a0
movq 0x8(%r14), %r13
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x9f50b(%rip), %rsi # 0x16c5c2
leaq 0x9f51f(%rip), %rdx # 0x16c5dd
leaq 0x20(%rsp), %rbp
movq %rbp, %rdi
callq 0x2c610
movq %rsp, %rsi
leaq 0x40(%rsp), %r9
movq %r12, %rdi
movq %r13, %rdx
movq %r15, %rcx
movq %r14, %r8
pushq %rbx
pushq %rbp
callq 0xe0a52
addq $0x10, %rsp
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0xcd0fe
callq 0x2d160
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xcd111
callq 0x2d160
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0xcd120
callq 0x2d160
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0xcd14b
callq 0x2d160
jmp 0xcd14b
movq %rax, %r14
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xcd178
jmp 0xcd16c
movq %rax, %r14
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xcd178
callq 0x2d160
jmp 0xcd178
jmp 0xcd175
movq %rax, %r14
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0xcd187
callq 0x2d160
movq %r14, %rdi
callq 0x2e220
nop
| _ZN6google8protobuf17DescriptorBuilder15AllocateOptionsERKNS0_11FileOptionsEPNS0_14FileDescriptorERNS0_8internal13FlatAllocatorE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov rbx, rcx
mov r14, rdx
mov r15, rsi
mov r12, rdi
xorps xmm0, xmm0
lea rdi, [rsp+88h+var_48]
movaps xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov rdx, rsp
mov dword ptr [rdx], 8
xor esi, esi
call __ZNSt6vectorIiSaIiEE17_M_realloc_insertIJiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_; std::vector<int>::_M_realloc_insert<int>(__gnu_cxx::__normal_iterator<int *,std::vector<int>>,int &&)
mov rax, [r14+10h]
lea rcx, [rsp+88h+var_78]
mov [rcx-10h], rcx
mov rsi, [rax]
mov rdx, [rax+8]
add rdx, rsi
mov rdi, rsp
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea rsi, aDummy; ".dummy"
mov rdi, rsp
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov r13, [r14+8]
lea rax, [rsp+88h+var_58]
mov [rax-10h], rax
lea rsi, aGoogleProtobuf_17; "google.protobuf.FileOptions"
lea rdx, aGoogleProtobuf_17+1Bh; ""
lea rbp, [rsp+88h+var_68]
mov rdi, rbp
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 rsi, rsp
lea r9, [rsp+88h+var_48]
mov rdi, r12
mov rdx, r13
mov rcx, r15
mov r8, r14
push rbx
push rbp
call _ZN6google8protobuf17DescriptorBuilder19AllocateOptionsImplINS0_14FileDescriptorEEEvRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESB_RKNT_11OptionsTypeEPSC_RKSt6vectorIiSaIiEESB_RNS0_8internal13FlatAllocatorE; google::protobuf::DescriptorBuilder::AllocateOptionsImpl<google::protobuf::FileDescriptor>(std::string const&,std::string const&,google::protobuf::FileDescriptor::OptionsType const&,google::protobuf::FileDescriptor::OptionsType*,std::vector<int> const&,std::string const&,google::protobuf::internal::FlatAllocator &)
add rsp, 10h
mov rdi, [rsp+88h+var_68]; void *
lea rax, [rsp+88h+var_58]
cmp rdi, rax
jz short loc_CD0FE
call __ZdlPv; operator delete(void *)
loc_CD0FE:
mov rdi, [rsp+88h+var_88]; void *
lea rax, [rsp+88h+var_78]
cmp rdi, rax
jz short loc_CD111
call __ZdlPv; operator delete(void *)
loc_CD111:
mov rdi, [rsp+88h+var_48]; void *
test rdi, rdi
jz short loc_CD120
call __ZdlPv; operator delete(void *)
loc_CD120:
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r14, rax
mov rdi, [rsp+arg_18]; void *
lea rax, [rsp+arg_28]
cmp rdi, rax
jz short loc_CD14B
call __ZdlPv; operator delete(void *)
jmp short loc_CD14B
mov r14, rax
loc_CD14B:
mov rdi, [rsp+0]
lea rax, [rsp+arg_8]
cmp rdi, rax
jz short loc_CD178
jmp short loc_CD16C
mov r14, rax
mov rdi, [rsp+0]; void *
lea rax, [rsp+arg_8]
cmp rdi, rax
jz short loc_CD178
loc_CD16C:
call __ZdlPv; operator delete(void *)
jmp short loc_CD178
jmp short $+2
loc_CD175:
mov r14, rax
loc_CD178:
mov rdi, [rsp+arg_38]; void *
test rdi, rdi
jz short loc_CD187
call __ZdlPv; operator delete(void *)
loc_CD187:
mov rdi, r14
call __Unwind_Resume
| void google::protobuf::DescriptorBuilder::AllocateOptions(long long a1, long long a2, long long a3, long long a4)
{
_QWORD *v6; // rax
long long v7; // r13
void *v8[2]; // [rsp+0h] [rbp-88h] BYREF
_BYTE v9[16]; // [rsp+10h] [rbp-78h] BYREF
void *v10[2]; // [rsp+20h] [rbp-68h] BYREF
_BYTE v11[16]; // [rsp+30h] [rbp-58h] BYREF
void *v12[9]; // [rsp+40h] [rbp-48h] BYREF
memset(v12, 0, 24);
LODWORD(v8[0]) = 8;
std::vector<int>::_M_realloc_insert<int>(v12, 0LL, v8);
v6 = *(_QWORD **)(a3 + 16);
v8[0] = v9;
std::string::_M_construct<char *>(v8, *v6, *v6 + v6[1]);
std::string::append(v8, ".dummy");
v7 = *(_QWORD *)(a3 + 8);
v10[0] = v11;
std::string::_M_construct<char const*>(v10, "google.protobuf.FileOptions", "");
google::protobuf::DescriptorBuilder::AllocateOptionsImpl<google::protobuf::FileDescriptor>(
a1,
v8,
v7,
a2,
a3,
v12,
v10,
a4);
if ( v10[0] != v11 )
operator delete(v10[0]);
if ( v8[0] != v9 )
operator delete(v8[0]);
if ( v12[0] )
operator delete(v12[0]);
}
| AllocateOptions:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV RBX,RCX
MOV R14,RDX
MOV R15,RSI
MOV R12,RDI
XORPS XMM0,XMM0
LEA RDI,[RSP + 0x40]
MOVAPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV RDX,RSP
MOV dword ptr [RDX],0x8
LAB_001cd06e:
XOR ESI,ESI
CALL 0x0012ddf0
MOV RAX,qword ptr [R14 + 0x10]
LEA RCX,[RSP + 0x10]
MOV qword ptr [RCX + -0x10],RCX
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
ADD RDX,RSI
LAB_001cd08c:
MOV RDI,RSP
CALL 0x0012c640
LAB_001cd094:
LEA RSI,[0x26c5bb]
MOV RDI,RSP
CALL 0x0012e5a0
MOV R13,qword ptr [R14 + 0x8]
LEA RAX,[RSP + 0x30]
MOV qword ptr [RAX + -0x10],RAX
LAB_001cd0b0:
LEA RSI,[0x26c5c2]
LEA RDX,[0x26c5dd]
LEA RBP,[RSP + 0x20]
MOV RDI,RBP
CALL 0x0012c610
LAB_001cd0cb:
MOV RSI,RSP
LEA R9,[RSP + 0x40]
MOV RDI,R12
MOV RDX,R13
MOV RCX,R15
MOV R8,R14
PUSH RBX
PUSH RBP
CALL 0x001e0a52
ADD RSP,0x10
LAB_001cd0ea:
MOV RDI,qword ptr [RSP + 0x20]
LEA RAX,[RSP + 0x30]
CMP RDI,RAX
JZ 0x001cd0fe
CALL 0x0012d160
LAB_001cd0fe:
MOV RDI,qword ptr [RSP]
LEA RAX,[RSP + 0x10]
CMP RDI,RAX
JZ 0x001cd111
CALL 0x0012d160
LAB_001cd111:
MOV RDI,qword ptr [RSP + 0x40]
TEST RDI,RDI
JZ 0x001cd120
CALL 0x0012d160
LAB_001cd120:
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* google::protobuf::DescriptorBuilder::AllocateOptions(google::protobuf::FileOptions const&,
google::protobuf::FileDescriptor*, google::protobuf::internal::FlatAllocator&) */
void __thiscall
google::protobuf::DescriptorBuilder::AllocateOptions
(DescriptorBuilder *this,FileOptions *param_1,FileDescriptor *param_2,
FlatAllocator *param_3)
{
long lVar1;
string *psVar2;
int1 *local_88 [2];
int1 local_78 [16];
int1 *local_68 [2];
int1 local_58 [16];
void *local_48;
int8 uStack_40;
int8 local_38;
local_48 = (void *)0x0;
uStack_40 = 0;
local_38 = 0;
local_88[0] = (int1 *)CONCAT44(local_88[0]._4_4_,8);
/* try { // try from 001cd06e to 001cd074 has its CatchHandler @ 001cd175 */
std::vector<int,std::allocator<int>>::_M_realloc_insert<int>
((vector<int,std::allocator<int>> *)&local_48,0);
local_88[0] = local_78;
lVar1 = **(long **)(param_2 + 0x10);
/* try { // try from 001cd08c to 001cd093 has its CatchHandler @ 001cd173 */
std::__cxx11::string::_M_construct<char*>(local_88,lVar1,(*(long **)(param_2 + 0x10))[1] + lVar1);
/* try { // try from 001cd094 to 001cd0a2 has its CatchHandler @ 001cd15b */
std::__cxx11::string::append((string *)local_88,".dummy");
psVar2 = *(string **)(param_2 + 8);
local_68[0] = local_58;
/* try { // try from 001cd0b0 to 001cd0ca has its CatchHandler @ 001cd148 */
std::__cxx11::string::_M_construct<char_const*>
((string *)local_68,"google.protobuf.FileOptions","");
/* try { // try from 001cd0cb to 001cd0e9 has its CatchHandler @ 001cd12f */
AllocateOptionsImpl<google::protobuf::FileDescriptor>
(this,(string *)local_88,psVar2,(OptionsType *)param_1,param_2,(vector *)&local_48,
(string *)local_68,param_3);
if (local_68[0] != local_58) {
operator_delete(local_68[0]);
}
if (local_88[0] != local_78) {
operator_delete(local_88[0]);
}
if (local_48 != (void *)0x0) {
operator_delete(local_48);
}
return;
}
| |
27,834 | mysql_stmt_free_result_start | eloqsql/libmariadb/libmariadb/mariadb_async.c | int STDCALL
mysql_stmt_free_result_start(my_bool *ret, MYSQL_STMT *stmt)
{
MK_ASYNC_START_BODY(
mysql_stmt_free_result,
stmt->mysql,
{
WIN_SET_NONBLOCKING(stmt->mysql)
parms.stmt= stmt;
},
TRUE,
r_my_bool,
/* If stmt->mysql==NULL then we will not block so can call directly. */
if (!stmt->mysql)
{
*ret= mysql_stmt_free_result(stmt);
return 0;
})
} | O0 | c | mysql_stmt_free_result_start:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0xa2768
movq -0x18(%rbp), %rdi
callq 0x8e730
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0xa2876
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movb $0x1, 0x14(%rax)
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
leaq 0xe2(%rip), %rsi # 0xa2880
leaq -0x30(%rbp), %rdx
callq 0xa3d80
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
movb $0x0, 0x15(%rax)
movq -0x28(%rbp), %rax
movb $0x0, 0x14(%rax)
cmpl $0x0, -0x1c(%rbp)
jle 0xa27d6
movq -0x28(%rbp), %rax
movb $0x1, 0x15(%rax)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xa2876
cmpl $0x0, -0x1c(%rbp)
jge 0xa2862
jmp 0xa27e2
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movl $0x7d8, 0x90(%rax) # imm = 0x7D8
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
addq $0x297, %rdi # imm = 0x297
leaq 0x25eb76(%rip), %rax # 0x301380
movq (%rax), %rsi
movl $0x5, %edx
callq 0x60180
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movb $0x0, 0x29c(%rax)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
addq $0x97, %rdi
leaq 0x25eb54(%rip), %rax # 0x301390
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x60180
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movb $0x0, 0x296(%rax)
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
jmp 0xa286f
movq -0x28(%rbp), %rax
movb 0x8(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
| mysql_stmt_free_result_start:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_18]
cmp qword ptr [rax+38h], 0
jnz short loc_A2768
mov rdi, [rbp+var_18]
call mysql_stmt_free_result
mov cl, al
mov rax, [rbp+var_10]
mov [rax], cl
mov [rbp+var_4], 0
jmp loc_A2876
loc_A2768:
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
mov rax, [rbp+var_28]
mov byte ptr [rax+14h], 1
mov rdi, [rbp+var_28]
add rdi, 38h ; '8'
lea rsi, mysql_stmt_free_result_start_internal
lea rdx, [rbp+var_30]
call my_context_spawn
mov [rbp+var_1C], eax
mov rax, [rbp+var_28]
mov byte ptr [rax+15h], 0
mov rax, [rbp+var_28]
mov byte ptr [rax+14h], 0
cmp [rbp+var_1C], 0
jle short loc_A27D6
mov rax, [rbp+var_28]
mov byte ptr [rax+15h], 1
mov rax, [rbp+var_28]
mov eax, [rax]
mov [rbp+var_4], eax
jmp loc_A2876
loc_A27D6:
cmp [rbp+var_1C], 0
jge loc_A2862
jmp short $+2
loc_A27E2:
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov dword ptr [rax+90h], 7D8h
mov rax, [rbp+var_18]
mov rdi, [rax+38h]
add rdi, 297h
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov byte ptr [rax+29Ch], 0
mov rax, [rbp+var_18]
mov rdi, [rax+38h]
add rdi, 97h
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov byte ptr [rax+296h], 0
mov rax, [rbp+var_10]
mov byte ptr [rax], 1
jmp short loc_A286F
loc_A2862:
mov rax, [rbp+var_28]
mov cl, [rax+8]
mov rax, [rbp+var_10]
mov [rax], cl
loc_A286F:
mov [rbp+var_4], 0
loc_A2876:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long mysql_stmt_free_result_start(_BYTE *a1, long long a2)
{
long long v3; // [rsp+0h] [rbp-30h] BYREF
_BYTE *v4; // [rsp+8h] [rbp-28h]
int v5; // [rsp+14h] [rbp-1Ch]
long long v6; // [rsp+18h] [rbp-18h]
_BYTE *v7; // [rsp+20h] [rbp-10h]
v7 = a1;
v6 = a2;
if ( *(_QWORD *)(a2 + 56) )
{
v4 = *(_BYTE **)(*(_QWORD *)(*(_QWORD *)(v6 + 56) + 1152LL) + 40LL);
v3 = v6;
v4[20] = 1;
v5 = my_context_spawn(v4 + 56, mysql_stmt_free_result_start_internal, &v3);
v4[21] = 0;
v4[20] = 0;
if ( v5 <= 0 )
{
if ( v5 >= 0 )
{
*v7 = v4[8];
}
else
{
*(_DWORD *)(*(_QWORD *)(v6 + 56) + 144LL) = 2008;
strncpy(*(_QWORD *)(v6 + 56) + 663LL, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(*(_QWORD *)(v6 + 56) + 668LL) = 0;
strncpy(*(_QWORD *)(v6 + 56) + 151LL, client_errors[8], 511LL);
*(_BYTE *)(*(_QWORD *)(v6 + 56) + 662LL) = 0;
*v7 = 1;
}
return 0;
}
else
{
v4[21] = 1;
return *(unsigned int *)v4;
}
}
else
{
*v7 = mysql_stmt_free_result(v6);
return 0;
}
}
| mysql_stmt_free_result_start:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x38],0x0
JNZ 0x001a2768
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x0018e730
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001a2876
LAB_001a2768:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x14],0x1
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x38
LEA RSI,[0x1a2880]
LEA RDX,[RBP + -0x30]
CALL 0x001a3d80
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x15],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x14],0x0
CMP dword ptr [RBP + -0x1c],0x0
JLE 0x001a27d6
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x15],0x1
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001a2876
LAB_001a27d6:
CMP dword ptr [RBP + -0x1c],0x0
JGE 0x001a2862
JMP 0x001a27e2
LAB_001a27e2:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV dword ptr [RAX + 0x90],0x7d8
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x38]
ADD RDI,0x297
LEA RAX,[0x401380]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00160180
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV byte ptr [RAX + 0x29c],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x38]
ADD RDI,0x97
LEA RAX,[0x401390]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00160180
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV byte ptr [RAX + 0x296],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],0x1
JMP 0x001a286f
LAB_001a2862:
MOV RAX,qword ptr [RBP + -0x28]
MOV CL,byte ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
LAB_001a286f:
MOV dword ptr [RBP + -0x4],0x0
LAB_001a2876:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 mysql_stmt_free_result_start(int1 *param_1,long param_2)
{
int1 uVar1;
long local_38;
int4 *local_30;
int local_24;
long local_20;
int1 *local_18;
int4 local_c;
local_20 = param_2;
local_18 = param_1;
if (*(long *)(param_2 + 0x38) == 0) {
uVar1 = mysql_stmt_free_result(param_2);
*local_18 = uVar1;
local_c = 0;
}
else {
local_30 = *(int4 **)(*(long *)(*(long *)(param_2 + 0x38) + 0x480) + 0x28);
*(int1 *)(local_30 + 5) = 1;
local_38 = param_2;
local_24 = my_context_spawn(local_30 + 0xe,mysql_stmt_free_result_start_internal,&local_38);
*(int1 *)((long)local_30 + 0x15) = 0;
*(int1 *)(local_30 + 5) = 0;
if (local_24 < 1) {
if (local_24 < 0) {
*(int4 *)(*(long *)(local_20 + 0x38) + 0x90) = 0x7d8;
strncpy((char *)(*(long *)(local_20 + 0x38) + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(*(long *)(local_20 + 0x38) + 0x29c) = 0;
strncpy((char *)(*(long *)(local_20 + 0x38) + 0x97),PTR_s_Client_run_out_of_memory_004013d0,
0x1ff);
*(int1 *)(*(long *)(local_20 + 0x38) + 0x296) = 0;
*local_18 = 1;
}
else {
*local_18 = *(int1 *)(local_30 + 2);
}
local_c = 0;
}
else {
*(int1 *)((long)local_30 + 0x15) = 1;
local_c = *local_30;
}
}
return local_c;
}
| |
27,835 | minja::ExpressionNode::do_render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const | monkey531[P]llama/common/minja.hpp | void do_render(std::ostringstream & out, const std::shared_ptr<Context> & context) const override {
if (!expr) throw std::runtime_error("ExpressionNode.expr is null");
auto result = expr->evaluate(context);
if (result.is_string()) {
out << result.get<std::string>();
} else if (result.is_boolean()) {
out << (result.get<bool>() ? "True" : "False");
} else if (!result.is_null()) {
out << result.dump();
}
} | O0 | cpp | minja::ExpressionNode::do_render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const:
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq 0xe0(%rsp), %rdi
movq %rdi, 0x28(%rsp)
addq $0x20, %rdi
callq 0x10e0b0
testb $0x1, %al
jne 0x154637
movl $0x10, %edi
callq 0x5d680
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x20(%rsp)
leaq 0xc5e75(%rip), %rsi # 0x21a46a
callq 0x5d460
jmp 0x1545fc
movq 0x20(%rsp), %rdi
movq 0x1599a8(%rip), %rsi # 0x2adfb0
movq 0x159961(%rip), %rdx # 0x2adf70
callq 0x5db00
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
callq 0x5df80
jmp 0x1547c6
movq 0x28(%rsp), %rdi
addq $0x20, %rdi
callq 0x1141e0
movq %rax, %rsi
movq 0xd0(%rsp), %rdx
leaq 0x70(%rsp), %rdi
callq 0x1141f0
leaq 0x70(%rsp), %rdi
callq 0x115f50
testb $0x1, %al
jne 0x15466a
jmp 0x1546e4
movq 0xd8(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x1165d0
jmp 0x154688
movq 0x18(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x5d540
jmp 0x154699
leaq 0x50(%rsp), %rdi
callq 0x5e548
jmp 0x1547aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
jmp 0x1547bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x5e548
jmp 0x1547bc
leaq 0x70(%rsp), %rdi
callq 0x115f30
testb $0x1, %al
jne 0x1546f4
jmp 0x154738
movq 0xd8(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x1164a0
movb %al, 0x17(%rsp)
jmp 0x154711
movq 0x8(%rsp), %rdi
movb 0x17(%rsp), %cl
leaq 0xc4d62(%rip), %rax # 0x219483
leaq 0xc4d60(%rip), %rsi # 0x219488
testb $0x1, %cl
cmovneq %rax, %rsi
callq 0x5da30
jmp 0x154736
jmp 0x1547a8
leaq 0x70(%rsp), %rdi
callq 0x115930
testb $0x1, %al
jne 0x1547a6
movq 0xd8(%rsp), %rax
movq %rax, (%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x70(%rsp), %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x114bc0
jmp 0x15476a
movq (%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x5d540
jmp 0x15477a
leaq 0x30(%rsp), %rdi
callq 0x5e548
jmp 0x1547a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5e548
jmp 0x1547bc
jmp 0x1547a8
jmp 0x1547aa
leaq 0x70(%rsp), %rdi
callq 0x114690
addq $0xe8, %rsp
retq
leaq 0x70(%rsp), %rdi
callq 0x114690
movq 0xc8(%rsp), %rdi
callq 0x5dbc0
nopw %cs:(%rax,%rax)
nopl (%rax)
| _ZNK5minja14ExpressionNode9do_renderERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEERKSt10shared_ptrINS_7ContextEE:
sub rsp, 0E8h
mov [rsp+0E8h+var_8], rdi
mov qword ptr [rsp+0E8h+var_10], rsi
mov [rsp+0E8h+var_18], rdx
mov rdi, [rsp+0E8h+var_8]
mov [rsp+0E8h+var_C0], rdi; __int64
add rdi, 20h ; ' '
call _ZNKSt12__shared_ptrIN5minja10ExpressionELN9__gnu_cxx12_Lock_policyE2EEcvbEv; std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator bool(void)
test al, 1
jnz short loc_154637
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+0E8h+var_C8], rax
lea rsi, aExpressionnode; "ExpressionNode.expr is null"
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_1545FC:
mov rdi, [rsp+0E8h+var_C8]; void *
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
mov rdi, [rsp+0E8h+var_C8]; void *
mov rcx, rax
mov eax, edx
mov [rsp+0E8h+var_20], rcx
mov [rsp+0E8h+var_24], eax
call ___cxa_free_exception
jmp loc_1547C6
loc_154637:
mov rdi, [rsp+0E8h+var_C0]
add rdi, 20h ; ' '
call _ZNKSt19__shared_ptr_accessIN5minja10ExpressionELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<minja::Expression,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rsi, rax
mov rdx, [rsp+0E8h+var_18]
lea rdi, [rsp+0E8h+var_78]
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
lea rdi, [rsp+0E8h+var_78]; this
call _ZNK5minja5Value9is_stringEv; minja::Value::is_string(void)
test al, 1
jnz short loc_15466A
jmp short loc_1546E4
loc_15466A:
mov rax, qword ptr [rsp+0E8h+var_10]
mov qword ptr [rsp+0E8h+var_D0], rax; int
lea rdi, [rsp+0E8h+var_98]; int
lea rsi, [rsp+0E8h+var_78]; int
call _ZNK5minja5Value3getINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v; minja::Value::get<std::string>(void)
jmp short $+2
loc_154688:
mov rdi, qword ptr [rsp+0E8h+var_D0]
lea rsi, [rsp+0E8h+var_98]
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
jmp short $+2
loc_154699:
lea rdi, [rsp+0E8h+var_98]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp loc_1547AA
mov rcx, rax
mov eax, edx
mov [rsp+0E8h+var_20], rcx
mov [rsp+0E8h+var_24], eax
jmp loc_1547BC
mov rcx, rax
mov eax, edx
mov [rsp+0E8h+var_20], rcx
mov [rsp+0E8h+var_24], eax
lea rdi, [rsp+0E8h+var_98]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp loc_1547BC
loc_1546E4:
lea rdi, [rsp+0E8h+var_78]; this
call _ZNK5minja5Value10is_booleanEv; minja::Value::is_boolean(void)
test al, 1
jnz short loc_1546F4
jmp short loc_154738
loc_1546F4:
mov rax, qword ptr [rsp+0E8h+var_10]
mov [rsp+0E8h+var_E0], rax
lea rdi, [rsp+0E8h+var_78]
call _ZNK5minja5Value3getIbEET_v; minja::Value::get<bool>(void)
mov [rsp+0E8h+var_D1], al
jmp short $+2
loc_154711:
mov rdi, [rsp+0E8h+var_E0]
mov cl, [rsp+0E8h+var_D1]
lea rax, aTrue_0; "True"
lea rsi, aFalse; "False"
test cl, 1
cmovnz rsi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short $+2
loc_154736:
jmp short loc_1547A8
loc_154738:
lea rdi, [rsp+0E8h+var_78]; this
call _ZNK5minja5Value7is_nullEv; minja::Value::is_null(void)
test al, 1
jnz short loc_1547A6
mov rax, qword ptr [rsp+0E8h+var_10]
mov [rsp+0E8h+var_E8], rax
lea rdi, [rsp+0E8h+var_B8]
lea rsi, [rsp+0E8h+var_78]
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
jmp short $+2
loc_15476A:
mov rdi, [rsp+0E8h+var_E8]
lea rsi, [rsp+0E8h+var_B8]
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
jmp short $+2
loc_15477A:
lea rdi, [rsp+0E8h+var_B8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_1547A6
mov rcx, rax
mov eax, edx
mov [rsp+0E8h+var_20], rcx
mov [rsp+0E8h+var_24], eax
lea rdi, [rsp+0E8h+var_B8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_1547BC
loc_1547A6:
jmp short $+2
loc_1547A8:
jmp short $+2
loc_1547AA:
lea rdi, [rsp+0E8h+var_78]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
add rsp, 0E8h
retn
loc_1547BC:
lea rdi, [rsp+0E8h+var_78]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_1547C6:
mov rdi, [rsp+0E8h+var_20]
call __Unwind_Resume
| void minja::ExpressionNode::do_render(long long a1, long long a2, long long a3)
{
void (***v3)(void); // rax
long long v4; // rdi
const char *v5; // rsi
long long v6; // [rsp+0h] [rbp-E8h]
int v7[2]; // [rsp+18h] [rbp-D0h]
std::runtime_error *exception; // [rsp+20h] [rbp-C8h]
_BYTE v9[32]; // [rsp+30h] [rbp-B8h] BYREF
int v10[8]; // [rsp+50h] [rbp-98h] BYREF
int v11[21]; // [rsp+70h] [rbp-78h] BYREF
long long v12; // [rsp+D0h] [rbp-18h]
int v13[2]; // [rsp+D8h] [rbp-10h]
long long v14; // [rsp+E0h] [rbp-8h]
v14 = a1;
*(_QWORD *)v13 = a2;
v12 = a3;
if ( !std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator bool((_QWORD *)(a1 + 32)) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "ExpressionNode.expr is null");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v3 = (void (***)(void))std::__shared_ptr_access<minja::Expression,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(a1 + 32);
minja::Expression::evaluate((long long)v11, v3);
if ( minja::Value::is_string((minja::Value *)v11) )
{
*(_QWORD *)v7 = *(_QWORD *)v13;
minja::Value::get<std::string>(v10, (minja::Value *)v11);
std::operator<<<char>(*(_QWORD *)v7, v10);
std::string::~string(v10);
}
else if ( (minja::Value::is_boolean((minja::Value *)v11) & 1) != 0 )
{
v4 = *(_QWORD *)v13;
v5 = "False";
if ( (minja::Value::get<bool>((minja::Value *)v11) & 1) != 0 )
v5 = "True";
std::operator<<<std::char_traits<char>>(v4, v5);
}
else if ( (minja::Value::is_null((minja::Value *)v11) & 1) == 0 )
{
v6 = *(_QWORD *)v13;
minja::Value::dump[abi:cxx11]((long long)v9, (long long)v11, 0xFFFFFFFF, 0);
std::operator<<<char>(v6, v9);
std::string::~string(v9);
}
minja::Value::~Value((minja::Value *)v11);
}
| |||
27,836 | minja::ExpressionNode::do_render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const | monkey531[P]llama/common/minja.hpp | void do_render(std::ostringstream & out, const std::shared_ptr<Context> & context) const override {
if (!expr) throw std::runtime_error("ExpressionNode.expr is null");
auto result = expr->evaluate(context);
if (result.is_string()) {
out << result.get<std::string>();
} else if (result.is_boolean()) {
out << (result.get<bool>() ? "True" : "False");
} else if (!result.is_null()) {
out << result.dump();
}
} | O3 | cpp | minja::ExpressionNode::do_render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const:
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq 0x20(%rdi), %rsi
testq %rsi, %rsi
je 0x9dc7b
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x85d20
movzbl 0x40(%r14), %eax
cmpl $0x4, %eax
je 0x9db6c
cmpl $0x3, %eax
jne 0x9db9b
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x87182
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x1b9c0
jmp 0x9dbdf
leaq 0x28(%rsp), %rdi
callq 0x87072
leaq 0x53f2f(%rip), %rcx # 0xf1aac
leaq 0x53f2d(%rip), %rsi # 0xf1ab1
testb %al, %al
cmovneq %rcx, %rsi
movzbl %al, %edx
xorq $0x5, %rdx
movq %rbx, %rdi
callq 0x1b9c0
jmp 0x9dbfa
testb %al, %al
jne 0x9dbb7
cmpq $0x0, 0x48(%rsp)
jne 0x9dbb7
cmpq $0x0, 0x38(%rsp)
jne 0x9dbb7
cmpq $0x0, 0x58(%rsp)
je 0x9dbfa
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x86334
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x1b9c0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9dbfa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8b0
leaq 0x68(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58644
movq %rbx, %rdi
callq 0x5db32
movq -0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x9dc1f
callq 0x6d556
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x9dc2e
callq 0x6d556
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x9dc3d
callq 0x6d556
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x9dc73
movq 0x90332(%rip), %rax # 0x12df80
cmpb $0x0, (%rax)
je 0x9dc5e
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x9dc68
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x9dc73
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x78, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x1b440
movq %rax, %r14
leaq 0x54e04(%rip), %rsi # 0xf2a93
movq %rax, %rdi
callq 0x1b320
movq 0x9034a(%rip), %rsi # 0x12dfe8
movq 0x902ab(%rip), %rdx # 0x12df50
movq %r14, %rdi
callq 0x1bef0
jmp 0x9dcb1
jmp 0x9dce0
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9dce3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8b0
jmp 0x9dce3
jmp 0x9dce0
movq %rax, %rbx
movq %r14, %rdi
callq 0x1b650
jmp 0x9dced
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x86012
movq %rbx, %rdi
callq 0x1bf70
nop
| _ZNK5minja14ExpressionNode9do_renderERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEERKSt10shared_ptrINS_7ContextEE:
push r14
push rbx
sub rsp, 78h
mov rbx, rsi
mov rsi, [rdi+20h]
test rsi, rsi
jz loc_9DC7B
lea r14, [rsp+88h+var_60]
mov rdi, r14
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
movzx eax, byte ptr [r14+40h]
cmp eax, 4
jz short loc_9DB6C
cmp eax, 3
jnz short loc_9DB9B
lea rdi, [rsp+88h+var_80]
lea rsi, [rsp+88h+var_60]
call _ZNK5minja5Value3getINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v; minja::Value::get<std::string>(void)
mov rsi, [rsp+88h+var_80]
mov rdx, [rsp+88h+var_78]
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
jmp short loc_9DBDF
loc_9DB6C:
lea rdi, [rsp+88h+var_60]
call _ZNK5minja5Value3getIbEET_v; minja::Value::get<bool>(void)
lea rcx, aTrue_0; "True"
lea rsi, aFalse; "False"
test al, al
cmovnz rsi, rcx
movzx edx, al
xor rdx, 5
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
jmp short loc_9DBFA
loc_9DB9B:
test al, al
jnz short loc_9DBB7
cmp [rsp+88h+var_40], 0
jnz short loc_9DBB7
cmp [rsp+88h+var_50], 0
jnz short loc_9DBB7
cmp [rsp+88h+var_30], 0
jz short loc_9DBFA
loc_9DBB7:
lea rdi, [rsp+88h+var_80]
lea rsi, [rsp+88h+var_60]
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
mov rsi, [rsp+88h+var_80]
mov rdx, [rsp+88h+var_78]
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
loc_9DBDF:
lea rax, [rsp+88h+var_70]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_9DBFA
mov rsi, [rsp+88h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_9DBFA:
lea rbx, [rsp+88h+var_20]
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()
mov rdi, [rbx-8]
test rdi, rdi
jz short loc_9DC1F
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9DC1F:
mov rdi, [rsp+88h+var_38]
test rdi, rdi
jz short loc_9DC2E
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9DC2E:
mov rdi, [rsp+88h+var_48]
test rdi, rdi
jz short loc_9DC3D
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9DC3D:
mov rdi, [rsp+88h+var_58]
test rdi, rdi
jz short loc_9DC73
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_9DC5E
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_9DC68
loc_9DC5E:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_9DC68:
cmp eax, 1
jnz short loc_9DC73
mov rax, [rdi]
call qword ptr [rax+18h]
loc_9DC73:
add rsp, 78h
pop rbx
pop r14
retn
loc_9DC7B:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aExpressionnode; "ExpressionNode.expr is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp short loc_9DCB1
jmp short loc_9DCE0
loc_9DCB1:
mov rbx, rax
lea rax, [rsp+88h+var_70]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_9DCE3
mov rsi, [rsp+88h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_9DCE3
jmp short loc_9DCE0
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_9DCED
loc_9DCE0:
mov rbx, rax
loc_9DCE3:
lea rdi, [rsp+88h+var_60]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_9DCED:
mov rdi, rbx
call __Unwind_Resume
| long long minja::ExpressionNode::do_render(long long a1, long long a2)
{
void (***v3)(void); // rsi
unsigned __int8 v4; // al
const char *v5; // rsi
long long result; // rax
long long v7; // rdi
std::runtime_error *exception; // r14
long long *v9; // [rsp+8h] [rbp-80h] BYREF
long long v10; // [rsp+10h] [rbp-78h]
long long v11; // [rsp+18h] [rbp-70h] BYREF
long long v12; // [rsp+28h] [rbp-60h] BYREF
long long v13; // [rsp+30h] [rbp-58h]
long long v14; // [rsp+38h] [rbp-50h]
volatile signed __int32 *v15; // [rsp+40h] [rbp-48h]
long long v16; // [rsp+48h] [rbp-40h]
volatile signed __int32 *v17; // [rsp+50h] [rbp-38h]
long long v18; // [rsp+58h] [rbp-30h]
volatile signed __int32 *v19; // [rsp+60h] [rbp-28h]
char v20[32]; // [rsp+68h] [rbp-20h] BYREF
v3 = *(void (****)(void))(a1 + 32);
if ( !v3 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "ExpressionNode.expr is null");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::Expression::evaluate((long long)&v12, v3);
if ( v20[0] == 4 )
{
v4 = minja::Value::get<bool>(&v12);
v5 = "False";
if ( v4 )
v5 = "True";
std::__ostream_insert<char,std::char_traits<char>>(a2, v5, v4 ^ 5LL);
}
else
{
if ( v20[0] == 3 )
{
minja::Value::get<std::string>((long long)&v9, &v12);
std::__ostream_insert<char,std::char_traits<char>>(a2, v9, v10);
}
else
{
if ( !v20[0] && !v16 && !v14 && !v18 )
goto LABEL_15;
minja::Value::dump[abi:cxx11]((long long)&v9, (long long)&v12, 0xFFFFFFFF, 0);
std::__ostream_insert<char,std::char_traits<char>>(a2, v9, v10);
}
if ( v9 != &v11 )
operator delete(v9, v11 + 1);
}
LABEL_15:
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(v20);
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>::data::~data(v20);
if ( v19 )
result = std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v19);
if ( v17 )
result = std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v17);
if ( v15 )
result = std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v15);
v7 = v13;
if ( v13 )
{
if ( _libc_single_threaded )
{
result = *(unsigned int *)(v13 + 12);
*(_DWORD *)(v13 + 12) = result - 1;
}
else
{
result = (unsigned int)_InterlockedExchangeAdd((volatile signed __int32 *)(v13 + 12), 0xFFFFFFFF);
}
if ( (_DWORD)result == 1 )
return (*(long long ( **)(long long, _QWORD))(*(_QWORD *)v7 + 24LL))(v7, 0LL);
}
return result;
}
| do_render:
PUSH R14
PUSH RBX
SUB RSP,0x78
MOV RBX,RSI
MOV RSI,qword ptr [RDI + 0x20]
TEST RSI,RSI
JZ 0x0019dc7b
LEA R14,[RSP + 0x28]
MOV RDI,R14
CALL 0x00185d20
MOVZX EAX,byte ptr [R14 + 0x40]
CMP EAX,0x4
JZ 0x0019db6c
CMP EAX,0x3
JNZ 0x0019db9b
LAB_0019db49:
LEA RDI,[RSP + 0x8]
LEA RSI,[RSP + 0x28]
CALL 0x00187182
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
LAB_0019db62:
MOV RDI,RBX
CALL 0x0011b9c0
JMP 0x0019dbdf
LAB_0019db6c:
LEA RDI,[RSP + 0x28]
CALL 0x00187072
LEA RCX,[0x1f1aac]
LEA RSI,[0x1f1ab1]
TEST AL,AL
CMOVNZ RSI,RCX
MOVZX EDX,AL
XOR RDX,0x5
MOV RDI,RBX
CALL 0x0011b9c0
JMP 0x0019dbfa
LAB_0019db9b:
TEST AL,AL
JNZ 0x0019dbb7
CMP qword ptr [RSP + 0x48],0x0
JNZ 0x0019dbb7
CMP qword ptr [RSP + 0x38],0x0
JNZ 0x0019dbb7
CMP qword ptr [RSP + 0x58],0x0
JZ 0x0019dbfa
LAB_0019dbb7:
LEA RDI,[RSP + 0x8]
LEA RSI,[RSP + 0x28]
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x00186334
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
LAB_0019dbd7:
MOV RDI,RBX
CALL 0x0011b9c0
LAB_0019dbdf:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0019dbfa
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011b8b0
LAB_0019dbfa:
LEA RBX,[RSP + 0x68]
MOV RDI,RBX
XOR ESI,ESI
CALL 0x00158644
MOV RDI,RBX
CALL 0x0015db32
MOV RDI,qword ptr [RBX + -0x8]
TEST RDI,RDI
JZ 0x0019dc1f
CALL 0x0016d556
LAB_0019dc1f:
MOV RDI,qword ptr [RSP + 0x50]
TEST RDI,RDI
JZ 0x0019dc2e
CALL 0x0016d556
LAB_0019dc2e:
MOV RDI,qword ptr [RSP + 0x40]
TEST RDI,RDI
JZ 0x0019dc3d
CALL 0x0016d556
LAB_0019dc3d:
MOV RDI,qword ptr [RSP + 0x30]
TEST RDI,RDI
JZ 0x0019dc73
MOV RAX,qword ptr [0x0022df80]
CMP byte ptr [RAX],0x0
JZ 0x0019dc5e
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x0019dc68
LAB_0019dc5e:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_0019dc68:
CMP EAX,0x1
JNZ 0x0019dc73
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_0019dc73:
ADD RSP,0x78
POP RBX
POP R14
RET
LAB_0019dc7b:
MOV EDI,0x10
CALL 0x0011b440
MOV R14,RAX
LAB_0019dc88:
LEA RSI,[0x1f2a93]
MOV RDI,RAX
CALL 0x0011b320
LAB_0019dc97:
MOV RSI,qword ptr [0x0022dfe8]
MOV RDX,qword ptr [0x0022df50]
MOV RDI,R14
CALL 0x0011bef0
|
/* minja::ExpressionNode::do_render(std::__cxx11::ostringstream&, std::shared_ptr<minja::Context>
const&) const */
void minja::ExpressionNode::do_render(ostringstream *param_1,shared_ptr *param_2)
{
int *piVar1;
bool bVar2;
int iVar3;
runtime_error *this;
char *pcVar4;
long *local_80;
long local_78;
long local_70 [2];
Expression local_60 [8];
long *local_58;
long local_50;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_48;
long local_40;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_38;
long local_30;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_28;
data local_20 [16];
if (*(shared_ptr **)(param_1 + 0x20) == (shared_ptr *)0x0) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0019dc88 to 0019dc96 has its CatchHandler @ 0019dcd3 */
std::runtime_error::runtime_error(this,"ExpressionNode.expr is null");
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_0022dfe8,PTR__runtime_error_0022df50);
}
Expression::evaluate(local_60,*(shared_ptr **)(param_1 + 0x20));
if (local_20[0] == (data)0x4) {
/* try { // try from 0019db6c to 0019db98 has its CatchHandler @ 0019dce0 */
bVar2 = Value::get<bool>((Value *)local_60);
pcVar4 = "False";
if (bVar2) {
pcVar4 = "True";
}
std::__ostream_insert<char,std::char_traits<char>>((ostream *)param_2,pcVar4,(ulong)bVar2 ^ 5);
}
else {
if (local_20[0] == (data)0x3) {
/* try { // try from 0019db49 to 0019db57 has its CatchHandler @ 0019dcd1 */
Value::get<std::__cxx11::string>();
/* try { // try from 0019db62 to 0019db69 has its CatchHandler @ 0019dcb1 */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)param_2,(char *)local_80,local_78);
}
else {
if ((((local_20[0] == (data)0x0) && (local_40 == 0)) && (local_50 == 0)) && (local_30 == 0))
goto LAB_0019dbfa;
/* try { // try from 0019dbb7 to 0019dbcc has its CatchHandler @ 0019dcaf */
Value::dump_abi_cxx11_((int)&local_80,SUB81(local_60,0));
/* try { // try from 0019dbd7 to 0019dbde has its CatchHandler @ 0019dcad */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)param_2,(char *)local_80,local_78);
}
if (local_80 != local_70) {
operator_delete(local_80,local_70[0] + 1);
}
}
LAB_0019dbfa:
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_20,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_20);
if (local_28 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_28);
}
if (local_38 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_38);
}
if (local_48 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_48);
}
if (local_58 != (long *)0x0) {
if (*PTR___libc_single_threaded_0022df80 == '\0') {
LOCK();
piVar1 = (int *)((long)local_58 + 0xc);
iVar3 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar3 = *(int *)((long)local_58 + 0xc);
*(int *)((long)local_58 + 0xc) = iVar3 + -1;
}
if (iVar3 == 1) {
(**(code **)(*local_58 + 0x18))();
}
}
return;
}
| |
27,837 | my_readlink | eloqsql/mysys/my_symlink.c | int my_readlink(char *to, const char *filename, myf MyFlags)
{
#ifndef HAVE_READLINK
strmov(to,filename);
return 1;
#else
int result=0;
int length;
DBUG_ENTER("my_readlink");
if ((length=readlink(filename, to, FN_REFLEN-1)) < 0)
{
/* Don't give an error if this wasn't a symlink */
if ((my_errno=errno) == EINVAL)
{
result= 1;
strmov(to,filename);
}
else
{
if (MyFlags & MY_WME)
my_error(EE_CANT_READLINK, MYF(0), filename, errno);
result= -1;
}
}
else
to[length]=0;
DBUG_PRINT("exit" ,("result: %d", result));
DBUG_RETURN(result);
#endif /* HAVE_READLINK */
} | O3 | c | my_readlink:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1ff, %edx # imm = 0x1FF
movq %rsi, %rdi
movq %r14, %rsi
callq 0x29260
testl %eax, %eax
js 0xa1c2e
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
movb $0x0, (%r14,%rax)
xorl %r14d, %r14d
jmp 0xa1c7b
callq 0x297b0
movq %rax, %r12
movl (%rax), %r13d
callq 0xa2a4e
movl %r13d, (%rax)
cmpl $0x16, %r13d
jne 0xa1c5a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x29360
movl $0x1, %r14d
jmp 0xa1c7b
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
testb $0x10, %r15b
je 0xa1c7b
movl (%r12), %ecx
movl $0x18, %edi
xorl %esi, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x9f103
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_readlink:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rdx
mov rbx, rsi
mov r14, rdi
mov edx, 1FFh
mov rdi, rsi
mov rsi, r14
call _readlink
test eax, eax
js short loc_A1C2E
and eax, 7FFFFFFFh
mov byte ptr [r14+rax], 0
xor r14d, r14d
jmp short loc_A1C7B
loc_A1C2E:
call ___errno_location
mov r12, rax
mov r13d, [rax]
call _my_thread_var
mov [rax], r13d
cmp r13d, 16h
jnz short loc_A1C5A
mov rdi, r14
mov rsi, rbx
call _strcpy
mov r14d, 1
jmp short loc_A1C7B
loc_A1C5A:
mov r14d, 0FFFFFFFFh
test r15b, 10h
jz short loc_A1C7B
mov ecx, [r12]
mov edi, 18h
xor esi, esi
mov rdx, rbx
xor eax, eax
call my_error
loc_A1C7B:
mov eax, r14d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_readlink(const char *a1, long long a2, char a3)
{
int v4; // eax
unsigned int v5; // r14d
unsigned int *v6; // r12
unsigned int v7; // r13d
v4 = readlink(a2, a1, 511LL);
if ( v4 < 0 )
{
v6 = (unsigned int *)__errno_location(a2);
v7 = *v6;
*(_DWORD *)my_thread_var(a2, a1) = v7;
if ( v7 == 22 )
{
strcpy(a1, a2);
return 1;
}
else
{
v5 = -1;
if ( (a3 & 0x10) != 0 )
my_error(0x18u, 0LL, a2, *v6);
}
}
else
{
a1[v4 & 0x7FFFFFFF] = 0;
return 0;
}
return v5;
}
| my_readlink:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RDX
MOV RBX,RSI
MOV R14,RDI
MOV EDX,0x1ff
MOV RDI,RSI
MOV RSI,R14
CALL 0x00129260
TEST EAX,EAX
JS 0x001a1c2e
AND EAX,0x7fffffff
MOV byte ptr [R14 + RAX*0x1],0x0
XOR R14D,R14D
JMP 0x001a1c7b
LAB_001a1c2e:
CALL 0x001297b0
MOV R12,RAX
MOV R13D,dword ptr [RAX]
CALL 0x001a2a4e
MOV dword ptr [RAX],R13D
CMP R13D,0x16
JNZ 0x001a1c5a
MOV RDI,R14
MOV RSI,RBX
CALL 0x00129360
MOV R14D,0x1
JMP 0x001a1c7b
LAB_001a1c5a:
MOV R14D,0xffffffff
TEST R15B,0x10
JZ 0x001a1c7b
MOV ECX,dword ptr [R12]
MOV EDI,0x18
XOR ESI,ESI
MOV RDX,RBX
XOR EAX,EAX
CALL 0x0019f103
LAB_001a1c7b:
MOV EAX,R14D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 my_readlink(char *param_1,char *param_2,ulong param_3)
{
int iVar1;
ssize_t sVar2;
int *piVar3;
int *piVar4;
int8 uVar5;
sVar2 = readlink(param_2,param_1,0x1ff);
if ((int)(uint)sVar2 < 0) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar4 = (int *)_my_thread_var();
*piVar4 = iVar1;
if (iVar1 == 0x16) {
strcpy(param_1,param_2);
uVar5 = 1;
}
else {
uVar5 = 0xffffffff;
if ((param_3 & 0x10) != 0) {
my_error(0x18,0,param_2,*piVar3);
}
}
}
else {
param_1[(uint)sVar2 & 0x7fffffff] = '\0';
uVar5 = 0;
}
return uVar5;
}
| |
27,838 | eth_get_account_value | corpus-core[P]colibri-stateless/src/chains/eth/verifier/eth_account.c | void eth_get_account_value(ssz_ob_t account, eth_account_field_t field, bytes32_t value) {
bytes_t last_value = get_last_value(ssz_get(&account, "accountProof"));
if (!last_value.data) return;
if (rlp_decode(&last_value, 0, &last_value) != RLP_LIST) return;
if (rlp_decode(&last_value, field - 1, &last_value) != RLP_ITEM) return;
if (last_value.len > 32) return;
memcpy(value + 32 - last_value.len, last_value.data, last_value.len);
} | O2 | c | eth_get_account_value:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x47fc2(%rip), %rdx # 0x73751
leaq 0x28(%rsp), %r14
leaq 0x60(%rsp), %rsi
movq %r14, %rdi
callq 0x4c201
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
callq 0x2b6c7
movl %eax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
testq %rdx, %rdx
je 0x2b80d
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
movq %rdi, %rdx
callq 0x2cf5c
cmpl $0x2, %eax
jne 0x2b80d
decl %ebp
leaq 0x18(%rsp), %rdi
movl %ebp, %esi
movq %rdi, %rdx
callq 0x2cf5c
cmpl $0x1, %eax
jne 0x2b80d
movl 0x18(%rsp), %edx
cmpq $0x20, %rdx
ja 0x2b80d
subq %rdx, %rbx
addq $0x20, %rbx
movq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x221a0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| eth_get_account_value:
push rbp
push r14
push rbx
sub rsp, 40h
mov rbx, rsi
mov ebp, edi
lea rdx, aAccountproof; "accountProof"
lea r14, [rsp+58h+var_30]
lea rsi, [rsp+58h+arg_0]
mov rdi, r14
call ssz_get
mov rax, [r14+10h]
mov [rsp+58h+var_48], rax
movups xmm0, xmmword ptr [r14]
movups [rsp+58h+var_58], xmm0
call get_last_value
mov [rsp+58h+var_40], eax
mov [rsp+58h+var_38], rdx
test rdx, rdx
jz short loc_2B80D
lea rdi, [rsp+58h+var_40]
xor esi, esi
mov rdx, rdi
call rlp_decode
cmp eax, 2
jnz short loc_2B80D
dec ebp
lea rdi, [rsp+58h+var_40]
mov esi, ebp
mov rdx, rdi
call rlp_decode
cmp eax, 1
jnz short loc_2B80D
mov edx, [rsp+58h+var_40]
cmp rdx, 20h ; ' '
ja short loc_2B80D
sub rbx, rdx
add rbx, 20h ; ' '
mov rsi, [rsp+58h+var_38]
mov rdi, rbx
call _memcpy
loc_2B80D:
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
| long long eth_get_account_value(int a1, long long a2, _DWORD a3, _DWORD a4, _DWORD a5, _DWORD a6, char a7)
{
int v7; // edx
int v8; // ecx
int v9; // r8d
int v10; // r9d
long long result; // rax
long long v12; // rdx
long long v13; // rcx
unsigned int v14; // [rsp+18h] [rbp-40h] BYREF
long long v15; // [rsp+20h] [rbp-38h]
__int128 v16; // [rsp+28h] [rbp-30h] BYREF
long long v17; // [rsp+38h] [rbp-20h]
ssz_get(&v16, &a7);
result = get_last_value((int)&v16, (int)&a7, v7, v8, v9, v10, v16, v17);
v14 = result;
v15 = v12;
if ( v12 )
{
result = rlp_decode(&v14, 0LL, &v14);
if ( (_DWORD)result == 2 )
{
result = rlp_decode(&v14, (unsigned int)(a1 - 1), &v14);
if ( (_DWORD)result == 1 && v14 <= 0x20uLL )
return memcpy(a2 - v14 + 32, v15, v14, v13);
}
}
return result;
}
| eth_get_account_value:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV RBX,RSI
MOV EBP,EDI
LEA RDX,[0x173751]
LEA R14,[RSP + 0x28]
LEA RSI,[RSP + 0x60]
MOV RDI,R14
CALL 0x0014c201
MOV RAX,qword ptr [R14 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R14]
MOVUPS xmmword ptr [RSP],XMM0
CALL 0x0012b6c7
MOV dword ptr [RSP + 0x18],EAX
MOV qword ptr [RSP + 0x20],RDX
TEST RDX,RDX
JZ 0x0012b80d
LEA RDI,[RSP + 0x18]
XOR ESI,ESI
MOV RDX,RDI
CALL 0x0012cf5c
CMP EAX,0x2
JNZ 0x0012b80d
DEC EBP
LEA RDI,[RSP + 0x18]
MOV ESI,EBP
MOV RDX,RDI
CALL 0x0012cf5c
CMP EAX,0x1
JNZ 0x0012b80d
MOV EDX,dword ptr [RSP + 0x18]
CMP RDX,0x20
JA 0x0012b80d
SUB RBX,RDX
ADD RBX,0x20
MOV RSI,qword ptr [RSP + 0x20]
MOV RDI,RBX
CALL 0x001221a0
LAB_0012b80d:
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
|
void eth_get_account_value(int param_1,long param_2)
{
int iVar1;
void *extraout_RDX;
ulong __n;
uint local_40 [2];
void *local_38;
int1 local_30 [24];
ssz_get(local_30,&stack0x00000008,"accountProof");
local_40[0] = get_last_value();
if (extraout_RDX != (void *)0x0) {
local_38 = extraout_RDX;
iVar1 = rlp_decode(local_40,0,local_40);
if (iVar1 == 2) {
iVar1 = rlp_decode(local_40,param_1 + -1,local_40);
if ((iVar1 == 1) && (__n = (ulong)local_40[0], __n < 0x21)) {
memcpy((void *)((param_2 - __n) + 0x20),local_38,__n);
}
}
}
return;
}
| |
27,839 | find_type_with_warning | eloqsql/mysys/typelib.c | int find_type_with_warning(const char *x, TYPELIB *typelib, const char *option)
{
int res;
const char **ptr;
if ((res= find_type((char *) x, typelib, FIND_TYPE_BASIC)) <= 0)
{
ptr= typelib->type_names;
if (!*x)
fprintf(stderr, "No option given to %s\n", option);
else
fprintf(stderr, "Unknown option to %s: %s\n", option, x);
fprintf(stderr, "Alternatives are: '%s'", *ptr);
while (*++ptr)
fprintf(stderr, ",'%s'", *ptr);
fprintf(stderr, "\n");
}
return res;
} | O3 | c | find_type_with_warning:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leaq -0x30(%rbp), %rbx
movq %rdi, (%rbx)
callq 0x3a4c0
leaq (%rax,%r15), %rcx
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x8674d
movl %eax, %ebx
testl %eax, %eax
jg 0x866f8
movq 0x10(%r12), %r12
cmpb $0x0, (%r15)
movq 0x2e5966(%rip), %r13 # 0x36bfc0
movq (%r13), %rdi
je 0x8667b
leaq 0x3ac37(%rip), %rdx # 0xc129e
movl $0x1, %esi
movq %r14, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x3a2f0
jmp 0x86691
leaq 0x3ac05(%rip), %rdx # 0xc1287
movl $0x1, %esi
movq %r14, %rcx
xorl %eax, %eax
callq 0x3a2f0
movq (%r13), %rdi
movq (%r12), %rcx
leaq 0x3ac18(%rip), %rdx # 0xc12b8
movl $0x1, %esi
xorl %eax, %eax
callq 0x3a2f0
movq 0x8(%r12), %rcx
testq %rcx, %rcx
je 0x866e1
addq $0x10, %r12
leaq 0x3ac0e(%rip), %r14 # 0xc12cf
movq (%r13), %rdi
movl $0x1, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3a2f0
movq (%r12), %rcx
addq $0x8, %r12
testq %rcx, %rcx
jne 0x866c1
movq (%r13), %rdi
leaq 0x3c8b1(%rip), %rdx # 0xc2f9d
movl $0x1, %esi
xorl %eax, %eax
callq 0x3a2f0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| find_type_with_warning:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rdx
mov r12, rsi
mov r15, rdi
lea rbx, [rbp+var_30]
mov [rbx], rdi
call _strlen
lea rcx, [rax+r15]
mov rdi, rbx
mov rsi, r12
xor edx, edx
call find_type_eol
mov ebx, eax
test eax, eax
jg loc_866F8
mov r12, [r12+10h]
cmp byte ptr [r15], 0
mov r13, cs:stderr_ptr
mov rdi, [r13+0]
jz short loc_8667B
lea rdx, aUnknownOptionT; "Unknown option to %s: %s\n"
mov esi, 1
mov rcx, r14
mov r8, r15
xor eax, eax
call ___fprintf_chk
jmp short loc_86691
loc_8667B:
lea rdx, aNoOptionGivenT; "No option given to %s\n"
mov esi, 1
mov rcx, r14
xor eax, eax
call ___fprintf_chk
loc_86691:
mov rdi, [r13+0]
mov rcx, [r12]
lea rdx, aAlternativesAr; "Alternatives are: '%s'"
mov esi, 1
xor eax, eax
call ___fprintf_chk
mov rcx, [r12+8]
test rcx, rcx
jz short loc_866E1
add r12, 10h
lea r14, aS_5; ",'%s'"
loc_866C1:
mov rdi, [r13+0]
mov esi, 1
mov rdx, r14
xor eax, eax
call ___fprintf_chk
mov rcx, [r12]
add r12, 8
test rcx, rcx
jnz short loc_866C1
loc_866E1:
mov rdi, [r13+0]
lea rdx, asc_C2F9A+3; "\n"
mov esi, 1
xor eax, eax
call ___fprintf_chk
loc_866F8:
mov eax, ebx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long find_type_with_warning(const char *a1, long long a2, const char *a3)
{
long long v4; // rax
int type_eol; // ebx
const char **v6; // r12
const char *v7; // rcx
const char **v8; // r12
const char *v10; // [rsp+0h] [rbp-30h] BYREF
v10 = a1;
v4 = strlen(a1);
type_eol = find_type_eol(&v10, a2, 0LL, &a1[v4]);
if ( type_eol <= 0 )
{
v6 = *(const char ***)(a2 + 16);
if ( *a1 )
__fprintf_chk(stderr, 1LL, "Unknown option to %s: %s\n", a3, a1);
else
__fprintf_chk(stderr, 1LL, "No option given to %s\n", a3);
__fprintf_chk(stderr, 1LL, "Alternatives are: '%s'", *v6);
v7 = v6[1];
if ( v7 )
{
v8 = v6 + 2;
do
{
__fprintf_chk(stderr, 1LL, ",'%s'", v7);
v7 = *v8++;
}
while ( v7 );
}
__fprintf_chk(stderr, 1LL, "\n");
}
return (unsigned int)type_eol;
}
| find_type_with_warning:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV R12,RSI
MOV R15,RDI
LEA RBX,[RBP + -0x30]
MOV qword ptr [RBX],RDI
CALL 0x0013a4c0
LEA RCX,[RAX + R15*0x1]
MOV RDI,RBX
MOV RSI,R12
XOR EDX,EDX
CALL 0x0018674d
MOV EBX,EAX
TEST EAX,EAX
JG 0x001866f8
MOV R12,qword ptr [R12 + 0x10]
CMP byte ptr [R15],0x0
MOV R13,qword ptr [0x0046bfc0]
MOV RDI,qword ptr [R13]
JZ 0x0018667b
LEA RDX,[0x1c129e]
MOV ESI,0x1
MOV RCX,R14
MOV R8,R15
XOR EAX,EAX
CALL 0x0013a2f0
JMP 0x00186691
LAB_0018667b:
LEA RDX,[0x1c1287]
MOV ESI,0x1
MOV RCX,R14
XOR EAX,EAX
CALL 0x0013a2f0
LAB_00186691:
MOV RDI,qword ptr [R13]
MOV RCX,qword ptr [R12]
LEA RDX,[0x1c12b8]
MOV ESI,0x1
XOR EAX,EAX
CALL 0x0013a2f0
MOV RCX,qword ptr [R12 + 0x8]
TEST RCX,RCX
JZ 0x001866e1
ADD R12,0x10
LEA R14,[0x1c12cf]
LAB_001866c1:
MOV RDI,qword ptr [R13]
MOV ESI,0x1
MOV RDX,R14
XOR EAX,EAX
CALL 0x0013a2f0
MOV RCX,qword ptr [R12]
ADD R12,0x8
TEST RCX,RCX
JNZ 0x001866c1
LAB_001866e1:
MOV RDI,qword ptr [R13]
LEA RDX,[0x1c2f9d]
MOV ESI,0x1
XOR EAX,EAX
CALL 0x0013a2f0
LAB_001866f8:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int find_type_with_warning(char *param_1,long param_2,int8 param_3)
{
int8 *puVar1;
long lVar2;
int *puVar3;
int iVar4;
size_t sVar5;
long *plVar6;
char *local_38;
local_38 = param_1;
sVar5 = strlen(param_1);
iVar4 = find_type_eol(&local_38,param_2,0,param_1 + sVar5);
puVar3 = PTR_stderr_0046bfc0;
if (iVar4 < 1) {
puVar1 = *(int8 **)(param_2 + 0x10);
if (*param_1 == '\0') {
__fprintf_chk(*(int8 *)PTR_stderr_0046bfc0,1,"No option given to %s\n",param_3);
}
else {
__fprintf_chk(*(int8 *)PTR_stderr_0046bfc0,1,"Unknown option to %s: %s\n",param_3,
param_1);
}
__fprintf_chk(*(int8 *)puVar3,1,"Alternatives are: \'%s\'",*puVar1);
if (puVar1[1] != 0) {
plVar6 = puVar1 + 2;
do {
__fprintf_chk(*(int8 *)puVar3,1,",\'%s\'");
lVar2 = *plVar6;
plVar6 = plVar6 + 1;
} while (lVar2 != 0);
}
__fprintf_chk(*(int8 *)puVar3,1,&DAT_001c2f9d);
}
return iVar4;
}
| |
27,840 | optional_chain_test | bluesky950520[P]quickjs/quickjs.c | static void optional_chain_test(JSParseState *s, int *poptional_chaining_label,
int drop_count)
{
int label_next, i;
if (*poptional_chaining_label < 0)
*poptional_chaining_label = new_label(s);
/* XXX: could be more efficient with a specific opcode */
emit_op(s, OP_dup);
emit_op(s, OP_is_undefined_or_null);
label_next = emit_goto(s, OP_if_false, -1);
for(i = 0; i < drop_count; i++)
emit_op(s, OP_drop);
emit_op(s, OP_undefined);
emit_goto(s, OP_goto, *poptional_chaining_label);
emit_label(s, label_next);
} | O2 | c | optional_chain_test:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, (%rsi)
jns 0x59ef2
movq %rbx, %rdi
callq 0x5604b
movl %eax, (%r14)
pushq $0x11
popq %rsi
movq %rbx, %rdi
callq 0x4fa1b
movq %rbx, %rdi
movl $0xb0, %esi
callq 0x4fa1b
pushq $0x69
popq %rsi
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x5605a
movl %eax, %ebp
xorl %r12d, %r12d
testl %r15d, %r15d
cmovgl %r15d, %r12d
pushq $0xe
popq %r15
subl $0x1, %r12d
jb 0x59f3b
movq %rbx, %rdi
movl %r15d, %esi
callq 0x4fa1b
jmp 0x59f28
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0x4fa1b
movl (%r14), %edx
pushq $0x6b
popq %rsi
movq %rbx, %rdi
callq 0x5605a
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5617c
| optional_chain_test:
push rbp
push r15
push r14
push r12
push rbx
mov r15d, edx
mov r14, rsi
mov rbx, rdi
cmp dword ptr [rsi], 0
jns short loc_59EF2
mov rdi, rbx
call new_label
mov [r14], eax
loc_59EF2:
push 11h
pop rsi
mov rdi, rbx
call emit_op
mov rdi, rbx
mov esi, 0B0h
call emit_op
push 69h ; 'i'
pop rsi
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rdi, rbx
call emit_goto
mov ebp, eax
xor r12d, r12d
test r15d, r15d
cmovg r12d, r15d
push 0Eh
pop r15
loc_59F28:
sub r12d, 1
jb short loc_59F3B
mov rdi, rbx
mov esi, r15d
call emit_op
jmp short loc_59F28
loc_59F3B:
push 6
pop rsi
mov rdi, rbx
call emit_op
mov edx, [r14]
push 6Bh ; 'k'
pop rsi
mov rdi, rbx
call emit_goto
mov rdi, rbx
mov esi, ebp
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp emit_label
| long long optional_chain_test(long long a1, int *a2, int a3)
{
int v4; // ebp
int v5; // r12d
if ( *a2 < 0 )
*a2 = new_label(a1);
emit_op(a1, 17);
emit_op(a1, 176);
v4 = emit_goto(a1, 105, -1);
v5 = 0;
if ( a3 > 0 )
v5 = a3;
while ( v5-- != 0 )
emit_op(a1, 14);
emit_op(a1, 6);
emit_goto(a1, 107, *a2);
return emit_label(a1, v4);
}
| optional_chain_test:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R15D,EDX
MOV R14,RSI
MOV RBX,RDI
CMP dword ptr [RSI],0x0
JNS 0x00159ef2
MOV RDI,RBX
CALL 0x0015604b
MOV dword ptr [R14],EAX
LAB_00159ef2:
PUSH 0x11
POP RSI
MOV RDI,RBX
CALL 0x0014fa1b
MOV RDI,RBX
MOV ESI,0xb0
CALL 0x0014fa1b
PUSH 0x69
POP RSI
PUSH -0x1
POP RDX
MOV RDI,RBX
CALL 0x0015605a
MOV EBP,EAX
XOR R12D,R12D
TEST R15D,R15D
CMOVG R12D,R15D
PUSH 0xe
POP R15
LAB_00159f28:
SUB R12D,0x1
JC 0x00159f3b
MOV RDI,RBX
MOV ESI,R15D
CALL 0x0014fa1b
JMP 0x00159f28
LAB_00159f3b:
PUSH 0x6
POP RSI
MOV RDI,RBX
CALL 0x0014fa1b
MOV EDX,dword ptr [R14]
PUSH 0x6b
POP RSI
MOV RDI,RBX
CALL 0x0015605a
MOV RDI,RBX
MOV ESI,EBP
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x0015617c
|
void optional_chain_test(int8 param_1,int *param_2,int param_3)
{
int iVar1;
int4 uVar2;
if (*param_2 < 0) {
iVar1 = new_label(param_1);
*param_2 = iVar1;
}
emit_op(param_1,0x11);
emit_op(param_1,0xb0);
uVar2 = emit_goto(param_1,0x69,0xffffffffffffffff);
iVar1 = 0;
if (0 < param_3) {
iVar1 = param_3;
}
while (iVar1 != 0) {
emit_op(param_1,0xe);
iVar1 = iVar1 + -1;
}
emit_op(param_1,6);
emit_goto(param_1,0x6b,*param_2);
emit_label(param_1,uVar2);
return;
}
| |
27,841 | google::protobuf::internal::WireFormat::InternalSerializeMessageSetItem(google::protobuf::FieldDescriptor const*, google::protobuf::Message const&, unsigned char*, google::protobuf::io::EpsCopyOutputStream*) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/wire_format.cc | uint8_t* WireFormat::InternalSerializeMessageSetItem(
const FieldDescriptor* field, const Message& message, uint8_t* target,
io::EpsCopyOutputStream* stream) {
const Reflection* message_reflection = message.GetReflection();
target = stream->EnsureSpace(target);
// Start group.
target = io::CodedOutputStream::WriteTagToArray(
WireFormatLite::kMessageSetItemStartTag, target);
// Write type ID.
target = WireFormatLite::WriteUInt32ToArray(
WireFormatLite::kMessageSetTypeIdNumber, field->number(), target);
// Write message.
auto& msg = message_reflection->GetMessage(message, field);
target = WireFormatLite::InternalWriteMessage(
WireFormatLite::kMessageSetMessageNumber, msg, msg.GetCachedSize(),
target, stream);
// End group.
target = stream->EnsureSpace(target);
target = io::CodedOutputStream::WriteTagToArray(
WireFormatLite::kMessageSetItemEndTag, target);
return target;
} | O0 | cpp | google::protobuf::internal::WireFormat::InternalSerializeMessageSetItem(google::protobuf::FieldDescriptor const*, google::protobuf::Message const&, unsigned char*, google::protobuf::io::EpsCopyOutputStream*):
subq $0x98, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0x7a410
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x22890
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movl $0xb, 0x54(%rsp)
movq %rax, 0x48(%rsp)
movl 0x54(%rsp), %edi
movq 0x48(%rsp), %rsi
callq 0x22990
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0x73db0
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl $0x2, 0x64(%rsp)
movl %ecx, 0x60(%rsp)
movq %rax, 0x58(%rsp)
movl 0x64(%rsp), %ecx
movq 0x58(%rsp), %rax
movl %ecx, 0x74(%rsp)
movl $0x0, 0x70(%rsp)
movq %rax, 0x68(%rsp)
movl 0x74(%rsp), %edi
movl 0x70(%rsp), %esi
callq 0xde2e0
movl %eax, %ecx
movq 0x68(%rsp), %rax
movl %ecx, 0x84(%rsp)
movq %rax, 0x78(%rsp)
movl 0x84(%rsp), %edi
movq 0x78(%rsp), %rsi
callq 0x22990
movq %rax, 0x58(%rsp)
movl 0x60(%rsp), %ecx
movq 0x58(%rsp), %rax
movl %ecx, 0x94(%rsp)
movq %rax, 0x88(%rsp)
movl 0x94(%rsp), %edi
movq 0x88(%rsp), %rsi
callq 0x22990
movq %rax, 0x20(%rsp)
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x111b40
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movq (%rsp), %rsi
movl %eax, %edx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
movl $0x3, %edi
callq 0x1d88f0
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x22890
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movl $0xc, 0x44(%rsp)
movq %rax, 0x38(%rsp)
movl 0x44(%rsp), %edi
movq 0x38(%rsp), %rsi
callq 0x22990
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x98, %rsp
retq
nopl (%rax)
| _ZN6google8protobuf8internal10WireFormat31InternalSerializeMessageSetItemEPKNS0_15FieldDescriptorERKNS0_7MessageEPhPNS0_2io19EpsCopyOutputStreamE:
sub rsp, 98h
mov [rsp+98h+var_68], rdi
mov [rsp+98h+var_70], rsi
mov [rsp+98h+var_78], rdx
mov [rsp+98h+var_80], rcx
mov rdi, [rsp+98h+var_70]; this
call _ZNK6google8protobuf7Message13GetReflectionEv; google::protobuf::Message::GetReflection(void)
mov [rsp+98h+var_88], rax
mov rdi, [rsp+98h+var_80]; this
mov rsi, [rsp+98h+var_78]; unsigned __int8 *
call _ZN6google8protobuf2io19EpsCopyOutputStream11EnsureSpaceEPh; google::protobuf::io::EpsCopyOutputStream::EnsureSpace(uchar *)
mov [rsp+98h+var_78], rax
mov rax, [rsp+98h+var_78]
mov dword ptr [rsp+98h+var_44], 0Bh
mov [rsp+98h+var_54+4], rax
mov edi, dword ptr [rsp+98h+var_44]; this
mov rsi, [rsp+98h+var_54+4]; unsigned int
call _ZN6google8protobuf2io17CodedOutputStream20WriteVarint32ToArrayEjPh; google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(uint,uchar *)
mov [rsp+98h+var_78], rax
mov rdi, [rsp+98h+var_68]; this
call _ZNK6google8protobuf15FieldDescriptor6numberEv; google::protobuf::FieldDescriptor::number(void)
mov ecx, eax
mov rax, [rsp+98h+var_78]
mov [rsp+98h+var_34], 2
mov [rsp+98h+var_38], ecx
mov [rsp+98h+var_44+4], rax
mov ecx, [rsp+98h+var_34]
mov rax, [rsp+98h+var_44+4]
mov [rsp+98h+var_24], ecx
mov [rsp+98h+var_28], 0
mov [rsp+98h+var_30], rax
mov edi, [rsp+98h+var_24]
mov esi, [rsp+98h+var_28]
call _ZN6google8protobuf8internal14WireFormatLite7MakeTagEiNS2_8WireTypeE; google::protobuf::internal::WireFormatLite::MakeTag(int,google::protobuf::internal::WireFormatLite::WireType)
mov ecx, eax
mov rax, [rsp+98h+var_30]
mov dword ptr [rsp+98h+var_14], ecx
mov qword ptr [rsp+98h+var_20], rax
mov edi, dword ptr [rsp+98h+var_14]; this
mov rsi, qword ptr [rsp+98h+var_20]; unsigned int
call _ZN6google8protobuf2io17CodedOutputStream20WriteVarint32ToArrayEjPh; google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(uint,uchar *)
mov [rsp+98h+var_44+4], rax
mov ecx, [rsp+98h+var_38]
mov rax, [rsp+98h+var_44+4]
mov [rsp+98h+var_4], ecx
mov [rsp+98h+var_14+4], rax
mov edi, [rsp+98h+var_4]; this
mov rsi, [rsp+98h+var_14+4]; unsigned int
call _ZN6google8protobuf2io17CodedOutputStream20WriteVarint32ToArrayEjPh; google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(uint,uchar *)
mov [rsp+98h+var_78], rax
mov rdi, [rsp+98h+var_88]; this
mov rsi, [rsp+98h+var_70]; google::protobuf::Message *
mov rdx, [rsp+98h+var_68]; google::protobuf::FieldDescriptor *
xor eax, eax
mov ecx, eax; google::protobuf::MessageFactory *
call _ZNK6google8protobuf10Reflection10GetMessageERKNS0_7MessageEPKNS0_15FieldDescriptorEPNS0_14MessageFactoryE; google::protobuf::Reflection::GetMessage(google::protobuf::Message const&,google::protobuf::FieldDescriptor const*,google::protobuf::MessageFactory *)
mov [rsp+98h+var_90], rax
mov rax, [rsp+98h+var_90]
mov qword ptr [rsp+98h+var_98], rax
mov rdi, [rsp+98h+var_90]
mov rax, [rdi]
call qword ptr [rax+48h]
mov rsi, qword ptr [rsp+98h+var_98]; int
mov edx, eax; google::protobuf::MessageLite *
mov rcx, [rsp+98h+var_78]; int
mov r8, [rsp+98h+var_80]; unsigned __int8 *
mov edi, (offset dword_0+3); this
call _ZN6google8protobuf8internal14WireFormatLite20InternalWriteMessageEiRKNS0_11MessageLiteEiPhPNS0_2io19EpsCopyOutputStreamE; google::protobuf::internal::WireFormatLite::InternalWriteMessage(int,google::protobuf::MessageLite const&,int,uchar *,google::protobuf::io::EpsCopyOutputStream *)
mov [rsp+98h+var_78], rax
mov rdi, [rsp+98h+var_80]; this
mov rsi, [rsp+98h+var_78]; unsigned __int8 *
call _ZN6google8protobuf2io19EpsCopyOutputStream11EnsureSpaceEPh; google::protobuf::io::EpsCopyOutputStream::EnsureSpace(uchar *)
mov [rsp+98h+var_78], rax
mov rax, [rsp+98h+var_78]
mov dword ptr [rsp+98h+var_54], 0Ch
mov qword ptr [rsp+98h+var_60], rax
mov edi, dword ptr [rsp+98h+var_54]; this
mov rsi, qword ptr [rsp+98h+var_60]; unsigned int
call _ZN6google8protobuf2io17CodedOutputStream20WriteVarint32ToArrayEjPh; google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(uint,uchar *)
mov [rsp+98h+var_78], rax
mov rax, [rsp+98h+var_78]
add rsp, 98h
retn
| _BYTE * google::protobuf::internal::WireFormat::InternalSerializeMessageSetItem(
google::protobuf::internal::WireFormat *this,
const google::protobuf::FieldDescriptor *a2,
const google::protobuf::Message *a3,
google::protobuf::io::EpsCopyOutputStream *a4,
google::protobuf::io::EpsCopyOutputStream *a5)
{
unsigned __int8 *v5; // rdx
unsigned __int8 *v6; // rdx
unsigned __int8 *v7; // rdx
unsigned int v8; // eax
google::protobuf::io::EpsCopyOutputStream *v9; // r9
unsigned __int8 *v10; // rax
unsigned __int8 *v11; // rdx
long long Message; // [rsp+0h] [rbp-98h]
google::protobuf::_anonymous_namespace_ **Reflection; // [rsp+10h] [rbp-88h]
unsigned __int8 *v17; // [rsp+20h] [rbp-78h]
unsigned __int8 *v18; // [rsp+38h] [rbp-60h]
unsigned __int8 *v19; // [rsp+48h] [rbp-50h]
unsigned int v20; // [rsp+60h] [rbp-38h]
unsigned int Tag; // [rsp+84h] [rbp-14h]
google::protobuf::io::CodedOutputStream *v22; // [rsp+88h] [rbp-10h]
Reflection = (google::protobuf::_anonymous_namespace_ **)google::protobuf::Message::GetReflection(a2);
v19 = google::protobuf::io::EpsCopyOutputStream::EnsureSpace(a4, (unsigned __int8 *)a3);
v17 = google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
(google::protobuf::io::CodedOutputStream *)&byte_9[2],
v19,
v5);
v20 = google::protobuf::FieldDescriptor::number(this);
Tag = google::protobuf::internal::WireFormatLite::MakeTag(2, 0);
v22 = (google::protobuf::io::CodedOutputStream *)google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
(google::protobuf::io::CodedOutputStream *)Tag,
v17,
v6);
LODWORD(v17) = (unsigned int)google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
(google::protobuf::io::CodedOutputStream *)v20,
v22,
v7);
Message = google::protobuf::Reflection::GetMessage(Reflection, a2, this, 0LL);
v8 = (*(long long ( **)(long long))(*(_QWORD *)Message + 72LL))(Message);
v10 = (unsigned __int8 *)google::protobuf::internal::WireFormatLite::InternalWriteMessage(
(google::protobuf::internal::WireFormatLite *)((char *)&dword_0 + 3),
Message,
(const google::protobuf::MessageLite *)v8,
(int)v17,
(unsigned __int8 *)a4,
v9);
v18 = google::protobuf::io::EpsCopyOutputStream::EnsureSpace(a4, v10);
return google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
(google::protobuf::io::CodedOutputStream *)&byte_9[3],
v18,
v11);
}
| field_count:
MOV qword ptr [RSP + -0x8],RDI
MOV RAX,qword ptr [RSP + -0x8]
MOV EAX,dword ptr [RAX + 0x4]
RET
|
/* google::protobuf::Descriptor::field_count() const */
int4 __thiscall google::protobuf::Descriptor::field_count(Descriptor *this)
{
return *(int4 *)(this + 4);
}
| |
27,842 | inline_mysql_file_open | eloqsql/include/mysql/psi/mysql_file.h | static inline File
inline_mysql_file_open(
#ifdef HAVE_PSI_FILE_INTERFACE
PSI_file_key key, const char *src_file, uint src_line,
#endif
const char *filename, int flags, myf myFlags)
{
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_OPEN, filename,
&locker);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_open_wait)(locker, src_file, src_line);
file= my_open(filename, flags, myFlags);
PSI_FILE_CALL(end_file_open_wait_and_bind_to_descriptor)(locker, file);
return file;
}
#endif
file= my_open(filename, flags, myFlags);
return file;
} | O0 | c | inline_mysql_file_open:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
leaq 0x1a2ce8(%rip), %rax # 0x1cc810
movq (%rax), %rax
movq 0x148(%rax), %rax
movl -0x8(%rbp), %esi
movq -0x20(%rbp), %rcx
leaq -0x88(%rbp), %rdi
movl $0x2, %edx
leaq -0x40(%rbp), %r8
callq *%rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x29bc2
leaq 0x1a2c9a(%rip), %rax # 0x1cc810
movq (%rax), %rax
movq 0x1f0(%rax), %rax
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq *%rax
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x30(%rbp), %rdx
callq 0x2de60
movl %eax, -0x34(%rbp)
leaq 0x1a2c69(%rip), %rax # 0x1cc810
movq (%rax), %rax
movq 0x200(%rax), %rax
movq -0x40(%rbp), %rdi
movl -0x34(%rbp), %esi
callq *%rax
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x29bdb
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x30(%rbp), %rdx
callq 0x2de60
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| inline_mysql_file_open:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_8], edi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_20], rcx
mov [rbp+var_24], r8d
mov [rbp+var_30], r9
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+148h]
mov esi, [rbp+var_8]
mov rcx, [rbp+var_20]
lea rdi, [rbp+var_88]
mov edx, 2
lea r8, [rbp+var_40]
call rax
mov [rbp+var_40], rax
cmp [rbp+var_40], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_29BC2
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1F0h]
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_10]
mov edx, [rbp+var_14]
call rax
mov rdi, [rbp+var_20]
mov esi, [rbp+var_24]
mov rdx, [rbp+var_30]
call my_open
mov [rbp+var_34], eax
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+200h]
mov rdi, [rbp+var_40]
mov esi, [rbp+var_34]
call rax
mov eax, [rbp+var_34]
mov [rbp+var_4], eax
jmp short loc_29BDB
loc_29BC2:
mov rdi, [rbp+var_20]
mov esi, [rbp+var_24]
mov rdx, [rbp+var_30]
call my_open
mov [rbp+var_34], eax
mov eax, [rbp+var_34]
mov [rbp+var_4], eax
loc_29BDB:
mov eax, [rbp+var_4]
add rsp, 90h
pop rbp
retn
| long long inline_mysql_file_open(
unsigned int a1,
long long a2,
unsigned int a3,
long long a4,
unsigned int a5,
long long a6)
{
_BYTE v7[72]; // [rsp+8h] [rbp-88h] BYREF
long long v8; // [rsp+50h] [rbp-40h] BYREF
unsigned int v9; // [rsp+5Ch] [rbp-34h]
long long v10; // [rsp+60h] [rbp-30h]
unsigned int v11; // [rsp+6Ch] [rbp-24h]
long long v12; // [rsp+70h] [rbp-20h]
unsigned int v13; // [rsp+7Ch] [rbp-14h]
long long v14; // [rsp+80h] [rbp-10h]
unsigned int v15; // [rsp+88h] [rbp-8h]
v15 = a1;
v14 = a2;
v13 = a3;
v12 = a4;
v11 = a5;
v10 = a6;
v8 = (*((long long ( **)(_BYTE *, _QWORD, long long, long long, long long *))PSI_server[0] + 41))(
v7,
a1,
2LL,
a4,
&v8);
if ( v8 )
{
(*((void ( **)(long long, long long, _QWORD))PSI_server[0] + 62))(v8, v14, v13);
v9 = my_open(v12, v11, v10);
(*((void ( **)(long long, _QWORD))PSI_server[0] + 64))(v8, v9);
}
else
{
return (unsigned int)my_open(v12, v11, v10);
}
return v9;
}
| inline_mysql_file_open:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV dword ptr [RBP + -0x8],EDI
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 qword ptr [RBP + -0x30],R9
LEA RAX,[0x2cc810]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x148]
MOV ESI,dword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x20]
LEA RDI,[RBP + -0x88]
MOV EDX,0x2
LEA R8,[RBP + -0x40]
CALL RAX
MOV qword ptr [RBP + -0x40],RAX
CMP qword ptr [RBP + -0x40],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x00129bc2
LEA RAX,[0x2cc810]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1f0]
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x14]
CALL RAX
MOV RDI,qword ptr [RBP + -0x20]
MOV ESI,dword ptr [RBP + -0x24]
MOV RDX,qword ptr [RBP + -0x30]
CALL 0x0012de60
MOV dword ptr [RBP + -0x34],EAX
LEA RAX,[0x2cc810]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x200]
MOV RDI,qword ptr [RBP + -0x40]
MOV ESI,dword ptr [RBP + -0x34]
CALL RAX
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00129bdb
LAB_00129bc2:
MOV RDI,qword ptr [RBP + -0x20]
MOV ESI,dword ptr [RBP + -0x24]
MOV RDX,qword ptr [RBP + -0x30]
CALL 0x0012de60
MOV dword ptr [RBP + -0x34],EAX
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x4],EAX
LAB_00129bdb:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x90
POP RBP
RET
|
int4
inline_mysql_file_open
(int4 param_1,int8 param_2,int4 param_3,int8 param_4,
int4 param_5,int8 param_6)
{
int1 local_90 [72];
long local_48;
int4 local_3c;
int8 local_38;
int4 local_2c;
int8 local_28;
int4 local_1c;
int8 local_18;
int4 local_10;
int4 local_c;
local_38 = param_6;
local_2c = param_5;
local_28 = param_4;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
local_48 = (**(code **)(PSI_server + 0x148))(local_90,param_1,2,param_4,&local_48);
if (local_48 == 0) {
local_c = my_open(local_28,local_2c,local_38);
}
else {
(**(code **)(PSI_server + 0x1f0))(local_48,local_18,local_1c);
local_3c = my_open(local_28,local_2c,local_38);
(**(code **)(PSI_server + 0x200))(local_48,local_3c);
local_c = local_3c;
}
return local_c;
}
| |
27,843 | bf_integer_from_radix | bluesky950520[P]quickjs/libbf.c | static int bf_integer_from_radix(bf_t *r, const limb_t *tab,
limb_t n, limb_t radix)
{
bf_context_t *s = r->ctx;
int pow_tab_len, i, ret;
limb_t radixl;
bf_t *pow_tab;
radixl = get_limb_radix(radix);
pow_tab_len = ceil_log2(n) + 2; /* XXX: check */
pow_tab = bf_malloc(s, sizeof(pow_tab[0]) * pow_tab_len);
if (!pow_tab)
return -1;
for(i = 0; i < pow_tab_len; i++)
bf_init(r->ctx, &pow_tab[i]);
ret = bf_integer_from_radix_rec(r, tab, n, 0, n, radixl, pow_tab);
for(i = 0; i < pow_tab_len; i++) {
bf_delete(&pow_tab[i]);
}
bf_free(s, pow_tab);
return ret;
} | O3 | c | bf_integer_from_radix:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, 0x8(%rsp)
movq %rdi, %r15
movslq %ecx, %rax
leal -0x2(%rax), %ecx
movslq %ecx, %rcx
leaq 0x11c72(%rip), %rdx # 0xa47a0
movzbl (%rcx,%rdx), %ecx
cmpb $0x3, %cl
movl $0x2, %edx
cmovael %ecx, %edx
movq (%rdi), %r8
movzbl %dl, %ecx
decl %ecx
movq %rax, %r12
imulq %rax, %r12
decl %ecx
jne 0x92b48
movq %rbx, %rax
decq %rax
je 0x92b62
bsrq %rax, %rax
xorq $0x3f, %rax
jmp 0x92b67
movl $0x40, %eax
movl $0x42, %ecx
subl %eax, %ecx
cmpq $0x2, %rbx
movl $0x2, %r14d
cmovael %ecx, %r14d
leal (,%r14,8), %ebp
leal (%rbp,%rbp,4), %edx
movq (%r8), %rdi
xorl %esi, %esi
movq %r8, 0x10(%rsp)
callq *0x8(%r8)
testq %rax, %rax
je 0x92c3d
movq %rax, %r13
leaq (,%rbp,4), %rax
addq %rbp, %rax
xorl %ecx, %ecx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorps %xmm0, %xmm0
movq (%r15), %rsi
movq %rsi, (%r13,%rcx)
movl $0x0, 0x8(%r13,%rcx)
movq %rdx, 0x10(%r13,%rcx)
movups %xmm0, 0x18(%r13,%rcx)
addq $0x28, %rcx
cmpq %rcx, %rax
jne 0x92bbc
movq %r13, (%rsp)
movq %r15, %rdi
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
movq %rbx, %r8
movq %r12, %r9
callq 0x92c53
movl %eax, %ebx
movl %r14d, %r14d
movq %r13, %r15
addq $0x20, %r15
movq -0x20(%r15), %rax
testq %rax, %rax
je 0x92c22
movq (%r15), %rsi
testq %rsi, %rsi
je 0x92c22
movq (%rax), %rdi
xorl %edx, %edx
callq *0x8(%rax)
addq $0x28, %r15
decq %r14
jne 0x92c09
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq %r13, %rsi
xorl %edx, %edx
callq *0x8(%rax)
jmp 0x92c42
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| bf_integer_from_radix:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdx
mov [rsp+48h+var_40], rsi
mov r15, rdi
movsxd rax, ecx
lea ecx, [rax-2]
movsxd rcx, ecx
lea rdx, digits_per_limb_table
movzx ecx, byte ptr [rcx+rdx]
cmp cl, 3
mov edx, 2
cmovnb edx, ecx
mov r8, [rdi]
movzx ecx, dl
dec ecx
mov r12, rax
loc_92B48:
imul r12, rax
dec ecx
jnz short loc_92B48
mov rax, rbx
dec rax
jz short loc_92B62
bsr rax, rax
xor rax, 3Fh
jmp short loc_92B67
loc_92B62:
mov eax, 40h ; '@'
loc_92B67:
mov ecx, 42h ; 'B'
sub ecx, eax
cmp rbx, 2
mov r14d, 2
cmovnb r14d, ecx
lea ebp, ds:0[r14*8]
lea edx, [rbp+rbp*4+0]
mov rdi, [r8]
xor esi, esi
mov [rsp+48h+var_38], r8
call qword ptr [r8+8]
test rax, rax
jz loc_92C3D
mov r13, rax
lea rax, ds:0[rbp*4]
add rax, rbp
xor ecx, ecx
mov rdx, 8000000000000000h
xorps xmm0, xmm0
loc_92BBC:
mov rsi, [r15]
mov [r13+rcx+0], rsi
mov dword ptr [r13+rcx+8], 0
mov [r13+rcx+10h], rdx
movups xmmword ptr [r13+rcx+18h], xmm0
add rcx, 28h ; '('
cmp rax, rcx
jnz short loc_92BBC
mov [rsp+48h+var_48], r13
mov rdi, r15
mov rsi, [rsp+48h+var_40]
mov rdx, rbx
xor ecx, ecx
mov r8, rbx
mov r9, r12
call bf_integer_from_radix_rec
mov ebx, eax
mov r14d, r14d
mov r15, r13
add r15, 20h ; ' '
loc_92C09:
mov rax, [r15-20h]
test rax, rax
jz short loc_92C22
mov rsi, [r15]
test rsi, rsi
jz short loc_92C22
mov rdi, [rax]
xor edx, edx
call qword ptr [rax+8]
loc_92C22:
add r15, 28h ; '('
dec r14
jnz short loc_92C09
mov rax, [rsp+48h+var_38]
mov rdi, [rax]
mov rsi, r13
xor edx, edx
call qword ptr [rax+8]
jmp short loc_92C42
loc_92C3D:
mov ebx, 0FFFFFFFFh
loc_92C42:
mov eax, ebx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long bf_integer_from_radix(_QWORD **a1, int a2, unsigned long long a3, int a4)
{
unsigned __int8 v6; // cl
unsigned __int8 v7; // dl
int v8; // ecx
int v9; // r12d
unsigned long long v10; // rax
int v11; // eax
long long v12; // r14
long long v13; // rax
long long v14; // r13
long long v15; // rcx
unsigned int v16; // ebx
_QWORD *v17; // r15
long long v18; // rax
_QWORD *v20; // [rsp+10h] [rbp-38h]
v6 = digits_per_limb_table[a4 - 2];
v7 = 2;
if ( v6 >= 3u )
v7 = v6;
v8 = v7 - 1;
v9 = a4;
do
{
v9 *= a4;
--v8;
}
while ( v8 );
if ( a3 == 1 )
{
v11 = 64;
}
else
{
_BitScanReverse64(&v10, a3 - 1);
v11 = v10 ^ 0x3F;
}
LODWORD(v12) = 2;
if ( a3 >= 2 )
LODWORD(v12) = 66 - v11;
v20 = *a1;
v13 = ((long long ( *)(_QWORD, _QWORD, _QWORD))(*a1)[1])(**a1, 0LL, (unsigned int)(40 * v12));
if ( v13 )
{
v14 = v13;
v15 = 0LL;
do
{
*(_QWORD *)(v13 + v15) = *a1;
*(_DWORD *)(v13 + v15 + 8) = 0;
*(_QWORD *)(v13 + v15 + 16) = 0x8000000000000000LL;
*(_OWORD *)(v13 + v15 + 24) = 0LL;
v15 += 40LL;
}
while ( 5LL * (unsigned int)(8 * v12) != v15 );
v16 = bf_integer_from_radix_rec((_DWORD)a1, a2, a3, 0, a3, v9, v13);
v12 = (unsigned int)v12;
v17 = (_QWORD *)(v14 + 32);
do
{
v18 = *(v17 - 4);
if ( v18 && *v17 )
(*(void ( **)(_QWORD, _QWORD, _QWORD, double))(v18 + 8))(*(_QWORD *)v18, *v17, 0LL, 0.0);
v17 += 5;
--v12;
}
while ( v12 );
((void ( *)(_QWORD, long long, _QWORD, double))v20[1])(*v20, v14, 0LL, 0.0);
}
else
{
return (unsigned int)-1;
}
return v16;
}
| bf_integer_from_radix:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDX
MOV qword ptr [RSP + 0x8],RSI
MOV R15,RDI
MOVSXD RAX,ECX
LEA ECX,[RAX + -0x2]
MOVSXD RCX,ECX
LEA RDX,[0x1a47a0]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
CMP CL,0x3
MOV EDX,0x2
CMOVNC EDX,ECX
MOV R8,qword ptr [RDI]
MOVZX ECX,DL
DEC ECX
MOV R12,RAX
LAB_00192b48:
IMUL R12,RAX
DEC ECX
JNZ 0x00192b48
MOV RAX,RBX
DEC RAX
JZ 0x00192b62
BSR RAX,RAX
XOR RAX,0x3f
JMP 0x00192b67
LAB_00192b62:
MOV EAX,0x40
LAB_00192b67:
MOV ECX,0x42
SUB ECX,EAX
CMP RBX,0x2
MOV R14D,0x2
CMOVNC R14D,ECX
LEA EBP,[R14*0x8]
LEA EDX,[RBP + RBP*0x4]
MOV RDI,qword ptr [R8]
XOR ESI,ESI
MOV qword ptr [RSP + 0x10],R8
CALL qword ptr [R8 + 0x8]
TEST RAX,RAX
JZ 0x00192c3d
MOV R13,RAX
LEA RAX,[RBP*0x4]
ADD RAX,RBP
XOR ECX,ECX
MOV RDX,-0x8000000000000000
XORPS XMM0,XMM0
LAB_00192bbc:
MOV RSI,qword ptr [R15]
MOV qword ptr [R13 + RCX*0x1],RSI
MOV dword ptr [R13 + RCX*0x1 + 0x8],0x0
MOV qword ptr [R13 + RCX*0x1 + 0x10],RDX
MOVUPS xmmword ptr [R13 + RCX*0x1 + 0x18],XMM0
ADD RCX,0x28
CMP RAX,RCX
JNZ 0x00192bbc
MOV qword ptr [RSP],R13
MOV RDI,R15
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,RBX
XOR ECX,ECX
MOV R8,RBX
MOV R9,R12
CALL 0x00192c53
MOV EBX,EAX
MOV R14D,R14D
MOV R15,R13
ADD R15,0x20
LAB_00192c09:
MOV RAX,qword ptr [R15 + -0x20]
TEST RAX,RAX
JZ 0x00192c22
MOV RSI,qword ptr [R15]
TEST RSI,RSI
JZ 0x00192c22
MOV RDI,qword ptr [RAX]
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
LAB_00192c22:
ADD R15,0x28
DEC R14
JNZ 0x00192c09
MOV RAX,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RAX]
MOV RSI,R13
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
JMP 0x00192c42
LAB_00192c3d:
MOV EBX,0xffffffff
LAB_00192c42:
MOV EAX,EBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int4 bf_integer_from_radix(long *param_1,int8 param_2,ulong param_3,int param_4)
{
int8 *puVar1;
int8 *puVar2;
uint uVar3;
int4 uVar4;
ulong uVar5;
long lVar6;
int iVar7;
long lVar8;
byte bVar9;
long lVar10;
uint uVar11;
long *plVar12;
bVar9 = 2;
if (2 < (byte)digits_per_limb_table[param_4 + -2]) {
bVar9 = digits_per_limb_table[param_4 + -2];
}
puVar2 = (int8 *)*param_1;
iVar7 = bVar9 - 1;
lVar10 = (long)param_4;
do {
lVar10 = lVar10 * param_4;
iVar7 = iVar7 + -1;
} while (iVar7 != 0);
uVar5 = param_3 - 1;
if (uVar5 == 0) {
uVar3 = 0x40;
}
else {
lVar6 = 0x3f;
if (uVar5 != 0) {
for (; uVar5 >> lVar6 == 0; lVar6 = lVar6 + -1) {
}
}
uVar3 = (uint)lVar6 ^ 0x3f;
}
uVar11 = 2;
if (1 < param_3) {
uVar11 = 0x42 - uVar3;
}
lVar6 = (*(code *)puVar2[1])(*puVar2,0,uVar11 * 0x28);
if (lVar6 == 0) {
uVar4 = 0xffffffff;
}
else {
lVar8 = 0;
do {
*(long *)(lVar6 + lVar8) = *param_1;
*(int4 *)(lVar6 + 8 + lVar8) = 0;
*(int8 *)(lVar6 + 0x10 + lVar8) = 0x8000000000000000;
puVar1 = (int8 *)(lVar6 + 0x18 + lVar8);
*puVar1 = 0;
puVar1[1] = 0;
lVar8 = lVar8 + 0x28;
} while ((ulong)(uVar11 * 8) * 5 != lVar8);
uVar4 = bf_integer_from_radix_rec(param_1,param_2,param_3,0,param_3,lVar10,lVar6);
uVar5 = (ulong)uVar11;
plVar12 = (long *)(lVar6 + 0x20);
do {
puVar1 = (int8 *)plVar12[-4];
if ((puVar1 != (int8 *)0x0) && (*plVar12 != 0)) {
(*(code *)puVar1[1])(*puVar1,*plVar12,0);
}
plVar12 = plVar12 + 5;
uVar5 = uVar5 - 1;
} while (uVar5 != 0);
(*(code *)puVar2[1])(*puVar2,lVar6,0);
}
return uVar4;
}
| |
27,844 | bool httplib::detail::write_content<httplib::Server::write_content_with_provider(httplib::Stream&, httplib::Request const&, httplib::Response&, 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&)::'lambda'()>(httplib::Stream&, std::function<bool (unsigned long, unsigned long, httplib::DataSink&)> const&, unsigned long, unsigned long, httplib::Server::write_content_with_provider(httplib::Stream&, httplib::Request const&, httplib::Response&, 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&)::'lambda'(), httplib::Error&) | nickolajgrishuk[P]metricz-cpp/build_O0/_deps/httplib-src/httplib.h | inline bool write_content(Stream &strm, const ContentProvider &content_provider,
size_t offset, size_t length, T is_shutting_down,
Error &error) {
size_t end_offset = offset + length;
auto ok = true;
DataSink data_sink;
data_sink.write = [&](const char *d, size_t l) -> bool {
if (ok) {
if (strm.is_writable() && write_data(strm, d, l)) {
offset += l;
} else {
ok = false;
}
}
return ok;
};
while (offset < end_offset && !is_shutting_down()) {
if (!strm.is_writable()) {
error = Error::Write;
return false;
} else if (!content_provider(offset, end_offset - offset, data_sink)) {
error = Error::Canceled;
return false;
} else if (!ok) {
error = Error::Write;
return false;
}
}
error = Error::Success;
return true;
} | O0 | c | bool httplib::detail::write_content<httplib::Server::write_content_with_provider(httplib::Stream&, httplib::Request const&, httplib::Response&, 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&)::'lambda'()>(httplib::Stream&, std::function<bool (unsigned long, unsigned long, httplib::DataSink&)> const&, unsigned long, unsigned long, httplib::Server::write_content_with_provider(httplib::Stream&, httplib::Request const&, httplib::Response&, 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&)::'lambda'(), httplib::Error&):
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp # imm = 0x220
movq %r8, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movb $0x1, -0x41(%rbp)
leaq -0x1e0(%rbp), %rdi
movq %rdi, -0x210(%rbp)
callq 0x47400
movq -0x210(%rbp), %rdi
leaq -0x41(%rbp), %rax
movq %rax, -0x1f8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x1f0(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x1e8(%rbp)
leaq -0x1f8(%rbp), %rsi
callq 0x474b0
jmp 0x4729f
jmp 0x472a1
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x211(%rbp)
jae 0x472d2
leaq -0x10(%rbp), %rdi
callq 0x47500
movb %al, -0x212(%rbp)
jmp 0x472c4
movb -0x212(%rbp), %al
xorb $-0x1, %al
movb %al, -0x211(%rbp)
movb -0x211(%rbp), %al
testb $0x1, %al
jne 0x472e1
jmp 0x473b4
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movb %al, -0x213(%rbp)
jmp 0x472f6
movb -0x213(%rbp), %al
testb $0x1, %al
jne 0x47342
jmp 0x47302
movq -0x38(%rbp), %rax
movl $0x5, (%rax)
movb $0x0, -0x1(%rbp)
movl $0x1, -0x208(%rbp)
jmp 0x473cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x200(%rbp)
movl %eax, -0x204(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x47580
jmp 0x473e6
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x40(%rbp), %rdx
subq %rsi, %rdx
leaq -0x1e0(%rbp), %rcx
callq 0x47530
movb %al, -0x214(%rbp)
jmp 0x47365
movb -0x214(%rbp), %al
testb $0x1, %al
jne 0x4738b
jmp 0x47371
movq -0x38(%rbp), %rax
movl $0x7, (%rax)
movb $0x0, -0x1(%rbp)
movl $0x1, -0x208(%rbp)
jmp 0x473cc
testb $0x1, -0x41(%rbp)
jne 0x473ab
movq -0x38(%rbp), %rax
movl $0x5, (%rax)
movb $0x0, -0x1(%rbp)
movl $0x1, -0x208(%rbp)
jmp 0x473cc
jmp 0x473ad
jmp 0x473af
jmp 0x472a1
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
movb $0x1, -0x1(%rbp)
movl $0x1, -0x208(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x47580
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x220, %rsp # imm = 0x220
popq %rbp
retq
movq -0x200(%rbp), %rdi
callq 0xa850
nopw %cs:(%rax,%rax)
nopl (%rax)
| _ZN7httplib6detail13write_contentIZNS_6Server27write_content_with_providerERNS_6StreamERKNS_7RequestERNS_8ResponseERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESH_EUlvE_EEbS4_RKSt8functionIFbmmRNS_8DataSinkEEEmmT_RNS_5ErrorE:
push rbp
mov rbp, rsp
sub rsp, 220h
mov [rbp+var_10], r8
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_28], rdx
mov [rbp+var_30], rcx
mov [rbp+var_38], r9
mov rax, [rbp+var_28]
mov rcx, [rbp+var_30]
add rax, rcx
mov [rbp+var_40], rax
mov [rbp+var_41], 1
lea rdi, [rbp+var_1E0]; this
mov [rbp+var_210], rdi
call _ZN7httplib8DataSinkC2Ev; httplib::DataSink::DataSink(void)
mov rdi, [rbp+var_210]
lea rax, [rbp+var_41]
mov [rbp+var_1F8], rax
mov rax, [rbp+var_18]
mov [rbp+var_1F0], rax
lea rax, [rbp+var_28]
mov [rbp+var_1E8], rax
lea rsi, [rbp+var_1F8]
call _ZNSt8functionIFbPKcmEEaSIZN7httplib6detail13write_contentIZNS5_6Server27write_content_with_providerERNS5_6StreamERKNS5_7RequestERNS5_8ResponseERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESN_EUlvE_EEbSA_RKS_IFbmmRNS5_8DataSinkEEEmmT_RNS5_5ErrorEEUlS1_mE_EENSt9enable_ifIXsrNS3_9_CallableISV_NSZ_IXntsr7is_sameINSt9remove_cvINSt16remove_referenceISV_E4typeEE4typeES3_EE5valueESt5decayISV_EE4type4typeESt15__invoke_resultIRS1B_JS1_mEEEE5valueERS3_E4typeEOSV_
jmp short $+2
loc_4729F:
jmp short $+2
loc_472A1:
mov rcx, [rbp+var_28]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_211], al
jnb short loc_472D2
lea rdi, [rbp+var_10]
call _ZZN7httplib6Server27write_content_with_providerERNS_6StreamERKNS_7RequestERNS_8ResponseERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESF_ENKUlvE_clEv; httplib::Server::write_content_with_provider(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&)::{lambda(void)#1}::operator()(void)
mov [rbp+var_212], al
jmp short $+2
loc_472C4:
mov al, [rbp+var_212]
xor al, 0FFh
mov [rbp+var_211], al
loc_472D2:
mov al, [rbp+var_211]
test al, 1
jnz short loc_472E1
jmp loc_473B4
loc_472E1:
mov rdi, [rbp+var_18]
mov rax, [rdi]
mov rax, [rax+18h]
call rax
mov [rbp+var_213], al
jmp short $+2
loc_472F6:
mov al, [rbp+var_213]
test al, 1
jnz short loc_47342
jmp short $+2
loc_47302:
mov rax, [rbp+var_38]
mov dword ptr [rax], 5
mov [rbp+var_1], 0
mov [rbp+var_208], 1
jmp loc_473CC
mov rcx, rax
mov eax, edx
mov [rbp+var_200], rcx
mov [rbp+var_204], eax
lea rdi, [rbp+var_1E0]; this
call _ZN7httplib8DataSinkD2Ev; httplib::DataSink::~DataSink()
jmp loc_473E6
loc_47342:
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_40]
sub rdx, rsi
lea rcx, [rbp+var_1E0]
call _ZNKSt8functionIFbmmRN7httplib8DataSinkEEEclEmmS2_; std::function<bool ()(ulong,ulong,httplib::DataSink &)>::operator()(ulong,ulong,httplib::DataSink &)
mov [rbp+var_214], al
jmp short $+2
loc_47365:
mov al, [rbp+var_214]
test al, 1
jnz short loc_4738B
jmp short $+2
loc_47371:
mov rax, [rbp+var_38]
mov dword ptr [rax], 7
mov [rbp+var_1], 0
mov [rbp+var_208], 1
jmp short loc_473CC
loc_4738B:
test [rbp+var_41], 1
jnz short loc_473AB
mov rax, [rbp+var_38]
mov dword ptr [rax], 5
mov [rbp+var_1], 0
mov [rbp+var_208], 1
jmp short loc_473CC
loc_473AB:
jmp short $+2
loc_473AD:
jmp short $+2
loc_473AF:
jmp loc_472A1
loc_473B4:
mov rax, [rbp+var_38]
mov dword ptr [rax], 0
mov [rbp+var_1], 1
mov [rbp+var_208], 1
loc_473CC:
lea rdi, [rbp+var_1E0]; this
call _ZN7httplib8DataSinkD2Ev; httplib::DataSink::~DataSink()
mov al, [rbp+var_1]
and al, 1
add rsp, 220h
pop rbp
retn
loc_473E6:
mov rdi, [rbp+var_200]
call __Unwind_Resume
| char httplib::detail::write_content<httplib::Server::write_content_with_provider(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&)::{lambda(void)#1}>(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
long long a5,
_DWORD *a6)
{
char v7; // [rsp+Fh] [rbp-211h]
_QWORD v8[3]; // [rsp+28h] [rbp-1F8h] BYREF
_BYTE v9[415]; // [rsp+40h] [rbp-1E0h] BYREF
char v10; // [rsp+1DFh] [rbp-41h] BYREF
unsigned long long v11; // [rsp+1E0h] [rbp-40h]
_DWORD *v12; // [rsp+1E8h] [rbp-38h]
long long v13; // [rsp+1F0h] [rbp-30h]
unsigned long long v14; // [rsp+1F8h] [rbp-28h] BYREF
long long v15; // [rsp+200h] [rbp-20h]
long long v16; // [rsp+208h] [rbp-18h]
long long v17; // [rsp+210h] [rbp-10h] BYREF
char v18; // [rsp+21Fh] [rbp-1h]
v17 = a5;
v16 = a1;
v15 = a2;
v14 = a3;
v13 = a4;
v12 = a6;
v11 = a4 + a3;
v10 = 1;
httplib::DataSink::DataSink((httplib::DataSink *)v9);
v8[0] = &v10;
v8[1] = v16;
v8[2] = &v14;
std::function<bool ()(char const*,unsigned long)>::operator=<bool httplib::detail::write_content<httplib::Server::write_content_with_provider(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&)::{lambda(void)#1}>(httplib::Stream &,std::function const&<bool ()(unsigned long,unsigned long,httplib::DataSink &)>,unsigned long,unsigned long,httplib::Server::write_content_with_provider(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&)::{lambda(void)#1},httplib::Error &)::{lambda(char const*,unsigned long)#1}>(
v9,
v8);
while ( 1 )
{
v7 = 0;
if ( v14 < v11 )
v7 = ~(unsigned __int8)httplib::Server::write_content_with_provider(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&)::{lambda(void)#1}::operator()(&v17);
if ( (v7 & 1) == 0 )
break;
if ( ((*(long long ( **)(long long))(*(_QWORD *)v16 + 24LL))(v16) & 1) == 0 )
{
*v12 = 5;
v18 = 0;
goto LABEL_13;
}
if ( (std::function<bool ()(unsigned long,unsigned long,httplib::DataSink &)>::operator()(v15, v14, v11 - v14, v9) & 1) == 0 )
{
*v12 = 7;
v18 = 0;
goto LABEL_13;
}
if ( (v10 & 1) == 0 )
{
*v12 = 5;
v18 = 0;
goto LABEL_13;
}
}
*v12 = 0;
v18 = 1;
LABEL_13:
httplib::DataSink::~DataSink((httplib::DataSink *)v9);
return v18 & 1;
}
| write_content<httplib::Server::write_content_with_provider(httplib::Stream&,httplib::Request_const&,httplib::Response&,std::__cxx11::string_const&,std::__cxx11::string_const&)::{lambda()#1}>:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x220
MOV qword ptr [RBP + -0x10],R8
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
MOV qword ptr [RBP + -0x30],RCX
MOV qword ptr [RBP + -0x38],R9
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
ADD RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
MOV byte ptr [RBP + -0x41],0x1
LEA RDI,[RBP + -0x1e0]
MOV qword ptr [RBP + -0x210],RDI
CALL 0x00147400
MOV RDI,qword ptr [RBP + -0x210]
LEA RAX,[RBP + -0x41]
MOV qword ptr [RBP + -0x1f8],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x1f0],RAX
LEA RAX,[RBP + -0x28]
MOV qword ptr [RBP + -0x1e8],RAX
LAB_00147291:
LEA RSI,[RBP + -0x1f8]
CALL 0x001474b0
JMP 0x0014729f
LAB_0014729f:
JMP 0x001472a1
LAB_001472a1:
MOV RCX,qword ptr [RBP + -0x28]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x211],AL
JNC 0x001472d2
LEA RDI,[RBP + -0x10]
CALL 0x00147500
MOV byte ptr [RBP + -0x212],AL
JMP 0x001472c4
LAB_001472c4:
MOV AL,byte ptr [RBP + -0x212]
XOR AL,0xff
MOV byte ptr [RBP + -0x211],AL
LAB_001472d2:
MOV AL,byte ptr [RBP + -0x211]
TEST AL,0x1
JNZ 0x001472e1
JMP 0x001473b4
LAB_001472e1:
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x18]
CALL RAX
MOV byte ptr [RBP + -0x213],AL
JMP 0x001472f6
LAB_001472f6:
MOV AL,byte ptr [RBP + -0x213]
TEST AL,0x1
JNZ 0x00147342
JMP 0x00147302
LAB_00147302:
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x5
MOV byte ptr [RBP + -0x1],0x0
MOV dword ptr [RBP + -0x208],0x1
JMP 0x001473cc
LAB_00147342:
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x40]
SUB RDX,RSI
LEA RCX,[RBP + -0x1e0]
CALL 0x00147530
LAB_0014735d:
MOV byte ptr [RBP + -0x214],AL
JMP 0x00147365
LAB_00147365:
MOV AL,byte ptr [RBP + -0x214]
TEST AL,0x1
JNZ 0x0014738b
JMP 0x00147371
LAB_00147371:
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x7
MOV byte ptr [RBP + -0x1],0x0
MOV dword ptr [RBP + -0x208],0x1
JMP 0x001473cc
LAB_0014738b:
TEST byte ptr [RBP + -0x41],0x1
JNZ 0x001473ab
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x5
MOV byte ptr [RBP + -0x1],0x0
MOV dword ptr [RBP + -0x208],0x1
JMP 0x001473cc
LAB_001473ab:
JMP 0x001473ad
LAB_001473ad:
JMP 0x001473af
LAB_001473af:
JMP 0x001472a1
LAB_001473b4:
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x0
MOV byte ptr [RBP + -0x1],0x1
MOV dword ptr [RBP + -0x208],0x1
LAB_001473cc:
LEA RDI,[RBP + -0x1e0]
CALL 0x00147580
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0x220
POP RBP
RET
|
/* bool
httplib::detail::write_content<httplib::Server::write_content_with_provider(httplib::Stream&,
httplib::Request const&, httplib::Response&, std::__cxx11::string const&, std::__cxx11::string
const&)::{lambda()#1}>(httplib::Stream&, std::function<bool (unsigned long, unsigned long,
httplib::DataSink&)> const&, unsigned long, unsigned long,
httplib::Server::write_content_with_provider(httplib::Stream&, httplib::Request const&,
httplib::Response&, std::__cxx11::string const&, std::__cxx11::string const&)::{lambda()#1},
httplib::Error&) */
bool httplib::detail::
write_content<httplib::Server::write_content_with_provider(httplib::Stream&,httplib::Request_const&,httplib::Response&,std::__cxx11::string_const&,std::__cxx11::string_const&)::_lambda()_1_>
(long *param_1,
function<bool(unsigned_long,unsigned_long,httplib::DataSink&)> *param_2,ulong param_3
,long param_4,int8 param_5,int4 *param_6)
{
byte bVar1;
byte local_219;
byte *local_200;
long *local_1f8;
ulong *local_1f0;
DataSink local_1e8 [415];
byte local_49;
ulong local_48;
int4 *local_40;
long local_38;
ulong local_30;
function<bool(unsigned_long,unsigned_long,httplib::DataSink&)> *local_28;
long *local_20;
int8 local_18;
byte local_9;
local_48 = param_3 + param_4;
local_49 = 1;
local_40 = param_6;
local_38 = param_4;
local_30 = param_3;
local_28 = param_2;
local_20 = param_1;
local_18 = param_5;
DataSink::DataSink(local_1e8);
local_200 = &local_49;
local_1f8 = local_20;
local_1f0 = &local_30;
/* try { // try from 00147291 to 0014735c has its CatchHandler @ 0014731f */
std::function<bool(char_const*,unsigned_long)>::operator=
((function<bool(char_const*,unsigned_long)> *)local_1e8,
(_lambda_char_const__unsigned_long__1_ *)&local_200);
do {
local_219 = 0;
if (local_30 < local_48) {
local_219 = Server::
write_content_with_provider(httplib::Stream&,httplib::Request_const&,httplib::Response&,std::__cxx11::string_const&,std::__cxx11::string_const&)
::{lambda()#1}::operator()((_lambda___1_ *)&local_18);
local_219 = local_219 ^ 0xff;
}
if ((local_219 & 1) == 0) {
*local_40 = 0;
local_9 = 1;
goto LAB_001473cc;
}
bVar1 = (**(code **)(*local_20 + 0x18))();
if ((bVar1 & 1) == 0) {
*local_40 = 5;
local_9 = 0;
goto LAB_001473cc;
}
bVar1 = std::function<bool(unsigned_long,unsigned_long,httplib::DataSink&)>::operator()
(local_28,local_30,local_48 - local_30,local_1e8);
if ((bVar1 & 1) == 0) {
*local_40 = 7;
local_9 = 0;
goto LAB_001473cc;
}
} while ((local_49 & 1) != 0);
*local_40 = 5;
local_9 = 0;
LAB_001473cc:
DataSink::~DataSink(local_1e8);
return (bool)(local_9 & 1);
}
| |
27,845 | mi_ft_segiterator_init | eloqsql/storage/myisam/ft_update.c | void _mi_ft_segiterator_init(MI_INFO *info, uint keynr, const uchar *record,
FT_SEG_ITERATOR *ftsi)
{
DBUG_ENTER("_mi_ft_segiterator_init");
ftsi->num=info->s->keyinfo[keynr].keysegs;
ftsi->seg=info->s->keyinfo[keynr].seg;
ftsi->rec=record;
ftsi->pos= 0; /* Avoid warnings from gcc */
ftsi->len= 0; /* Avoid warnings from gcc */
DBUG_VOID_RETURN;
} | O3 | c | mi_ft_segiterator_init:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq 0x218(%rax), %rax
movl %esi, %esi
imulq $0x70, %rsi, %rsi
movzwl 0x8(%rax,%rsi), %eax
movl %eax, (%rcx)
movq (%rdi), %rax
movq 0x218(%rax), %rax
movq 0x28(%rax,%rsi), %rax
movq %rax, 0x8(%rcx)
movq %rdx, 0x10(%rcx)
movq $0x0, 0x18(%rcx)
movl $0x0, 0x4(%rcx)
popq %rbp
retq
| _mi_ft_segiterator_init:
push rbp
mov rbp, rsp
mov rax, [rdi]
mov rax, [rax+218h]
mov esi, esi
imul rsi, 70h ; 'p'
movzx eax, word ptr [rax+rsi+8]
mov [rcx], eax
mov rax, [rdi]
mov rax, [rax+218h]
mov rax, [rax+rsi+28h]
mov [rcx+8], rax
mov [rcx+10h], rdx
mov qword ptr [rcx+18h], 0
mov dword ptr [rcx+4], 0
pop rbp
retn
| long long mi_ft_segiterator_init(long long a1, unsigned int a2, long long a3, long long a4)
{
long long v4; // rsi
long long result; // rax
v4 = 112LL * a2;
*(_DWORD *)a4 = *(unsigned __int16 *)(*(_QWORD *)(*(_QWORD *)a1 + 536LL) + v4 + 8);
result = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 536LL) + v4 + 40);
*(_QWORD *)(a4 + 8) = result;
*(_QWORD *)(a4 + 16) = a3;
*(_QWORD *)(a4 + 24) = 0LL;
*(_DWORD *)(a4 + 4) = 0;
return result;
}
| _mi_ft_segiterator_init:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x218]
MOV ESI,ESI
IMUL RSI,RSI,0x70
MOVZX EAX,word ptr [RAX + RSI*0x1 + 0x8]
MOV dword ptr [RCX],EAX
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x218]
MOV RAX,qword ptr [RAX + RSI*0x1 + 0x28]
MOV qword ptr [RCX + 0x8],RAX
MOV qword ptr [RCX + 0x10],RDX
MOV qword ptr [RCX + 0x18],0x0
MOV dword ptr [RCX + 0x4],0x0
POP RBP
RET
|
void _mi_ft_segiterator_init(long *param_1,uint param_2,int8 param_3,uint *param_4)
{
*param_4 = (uint)*(ushort *)(*(long *)(*param_1 + 0x218) + 8 + (ulong)param_2 * 0x70);
*(int8 *)(param_4 + 2) =
*(int8 *)(*(long *)(*param_1 + 0x218) + 0x28 + (ulong)param_2 * 0x70);
*(int8 *)(param_4 + 4) = param_3;
param_4[6] = 0;
param_4[7] = 0;
param_4[1] = 0;
return;
}
| |
27,846 | mysql_stmt_store_result_start | eloqsql/libmariadb/libmariadb/mariadb_async.c | int STDCALL
mysql_stmt_store_result_start(int *ret, MYSQL_STMT *stmt)
{
MK_ASYNC_START_BODY(
mysql_stmt_store_result,
stmt->mysql,
{
WIN_SET_NONBLOCKING(stmt->mysql)
parms.stmt= stmt;
},
1,
r_int,
/* If stmt->mysql==NULL then we will not block so can call directly. */
if (!stmt->mysql)
{
*ret= mysql_stmt_store_result(stmt);
return 0;
})
} | O3 | c | mysql_stmt_store_result_start:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rsi), %rax
testq %rax, %rax
je 0x4ff87
movq 0x480(%rax), %rax
movq 0x28(%rax), %r15
leaq -0x20(%rbp), %rdx
movq %r14, (%rdx)
movb $0x1, 0x14(%r15)
leaq 0x38(%r15), %rdi
leaq 0xa2(%rip), %rsi # 0x5000f
callq 0x51490
movw $0x0, 0x14(%r15)
testl %eax, %eax
jle 0x4ff91
movb $0x1, 0x15(%r15)
movl (%r15), %eax
jmp 0x50004
movq %r14, %rdi
callq 0x44e5e
jmp 0x50000
js 0x4ff99
movl 0x8(%r15), %eax
jmp 0x50000
movq 0x38(%r14), %rax
movl $0x7d8, 0x90(%rax) # imm = 0x7D8
movl $0x297, %edi # imm = 0x297
addq 0x38(%r14), %rdi
leaq 0x2e9df9(%rip), %rax # 0x339db0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x36130
movq 0x38(%r14), %rax
xorl %r15d, %r15d
movb %r15b, 0x29c(%rax)
movl $0x97, %edi
addq 0x38(%r14), %rdi
leaq 0x2e9dde(%rip), %rax # 0x339dc0
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x36130
movq 0x38(%r14), %rax
movb %r15b, 0x296(%rax)
movl $0x1, %eax
movl %eax, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| mysql_stmt_store_result_start:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov rax, [rsi+38h]
test rax, rax
jz short loc_4FF87
mov rax, [rax+480h]
mov r15, [rax+28h]
lea rdx, [rbp+var_20]
mov [rdx], r14
mov byte ptr [r15+14h], 1
lea rdi, [r15+38h]
lea rsi, mysql_stmt_store_result_start_internal
call my_context_spawn
mov word ptr [r15+14h], 0
test eax, eax
jle short loc_4FF91
mov byte ptr [r15+15h], 1
mov eax, [r15]
jmp short loc_50004
loc_4FF87:
mov rdi, r14
call mysql_stmt_store_result
jmp short loc_50000
loc_4FF91:
js short loc_4FF99
mov eax, [r15+8]
jmp short loc_50000
loc_4FF99:
mov rax, [r14+38h]
mov dword ptr [rax+90h], 7D8h
mov edi, 297h
add rdi, [r14+38h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [r14+38h]
xor r15d, r15d
mov [rax+29Ch], r15b
mov edi, 97h
add rdi, [r14+38h]
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
mov rax, [r14+38h]
mov [rax+296h], r15b
mov eax, 1
loc_50000:
mov [rbx], eax
xor eax, eax
loc_50004:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long mysql_stmt_store_result_start(int *a1, long long a2)
{
long long v2; // rax
long long v3; // rax
unsigned int *v4; // r15
int v5; // eax
int v7; // eax
long long v8[4]; // [rsp+0h] [rbp-20h] BYREF
v8[0] = v2;
v3 = *(_QWORD *)(a2 + 56);
if ( v3 )
{
v4 = *(unsigned int **)(*(_QWORD *)(v3 + 1152) + 40LL);
v8[0] = a2;
*((_BYTE *)v4 + 20) = 1;
v5 = my_context_spawn(v4 + 14, mysql_stmt_store_result_start_internal, v8);
*((_WORD *)v4 + 10) = 0;
if ( v5 > 0 )
{
*((_BYTE *)v4 + 21) = 1;
return *v4;
}
if ( v5 < 0 )
{
*(_DWORD *)(*(_QWORD *)(a2 + 56) + 144LL) = 2008;
strncpy(*(_QWORD *)(a2 + 56) + 663LL, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 668LL) = 0;
strncpy(*(_QWORD *)(a2 + 56) + 151LL, client_errors[8], 511LL);
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 662LL) = 0;
v7 = 1;
}
else
{
v7 = v4[2];
}
}
else
{
v7 = mysql_stmt_store_result(a2);
}
*a1 = v7;
return 0LL;
}
| mysql_stmt_store_result_start:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RSI + 0x38]
TEST RAX,RAX
JZ 0x0014ff87
MOV RAX,qword ptr [RAX + 0x480]
MOV R15,qword ptr [RAX + 0x28]
LEA RDX,[RBP + -0x20]
MOV qword ptr [RDX],R14
MOV byte ptr [R15 + 0x14],0x1
LEA RDI,[R15 + 0x38]
LEA RSI,[0x15000f]
CALL 0x00151490
MOV word ptr [R15 + 0x14],0x0
TEST EAX,EAX
JLE 0x0014ff91
MOV byte ptr [R15 + 0x15],0x1
MOV EAX,dword ptr [R15]
JMP 0x00150004
LAB_0014ff87:
MOV RDI,R14
CALL 0x00144e5e
JMP 0x00150000
LAB_0014ff91:
JS 0x0014ff99
MOV EAX,dword ptr [R15 + 0x8]
JMP 0x00150000
LAB_0014ff99:
MOV RAX,qword ptr [R14 + 0x38]
MOV dword ptr [RAX + 0x90],0x7d8
MOV EDI,0x297
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x439db0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00136130
MOV RAX,qword ptr [R14 + 0x38]
XOR R15D,R15D
MOV byte ptr [RAX + 0x29c],R15B
MOV EDI,0x97
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x439dc0]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00136130
MOV RAX,qword ptr [R14 + 0x38]
MOV byte ptr [RAX + 0x296],R15B
MOV EAX,0x1
LAB_00150000:
MOV dword ptr [RBX],EAX
XOR EAX,EAX
LAB_00150004:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4 mysql_stmt_store_result_start(int4 *param_1,long param_2)
{
int4 *puVar1;
int iVar2;
int4 uVar3;
if (*(long *)(param_2 + 0x38) == 0) {
uVar3 = mysql_stmt_store_result(param_2);
}
else {
puVar1 = *(int4 **)(*(long *)(*(long *)(param_2 + 0x38) + 0x480) + 0x28);
*(int1 *)(puVar1 + 5) = 1;
iVar2 = my_context_spawn(puVar1 + 0xe,mysql_stmt_store_result_start_internal);
*(int2 *)(puVar1 + 5) = 0;
if (0 < iVar2) {
*(int1 *)((long)puVar1 + 0x15) = 1;
return *puVar1;
}
if (iVar2 < 0) {
*(int4 *)(*(long *)(param_2 + 0x38) + 0x90) = 0x7d8;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(*(long *)(param_2 + 0x38) + 0x29c) = 0;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x97),PTR_s_Client_run_out_of_memory_00439e00,
0x1ff);
*(int1 *)(*(long *)(param_2 + 0x38) + 0x296) = 0;
uVar3 = 1;
}
else {
uVar3 = puVar1[2];
}
}
*param_1 = uVar3;
return 0;
}
| |
27,847 | wait_for_free_space | eloqsql/mysys/errors.c | void wait_for_free_space(const char *filename, int errors)
{
if (errors == 0)
my_error(EE_DISK_FULL,MYF(ME_BELL | ME_ERROR_LOG | ME_WARNING),
filename,my_errno,MY_WAIT_FOR_USER_TO_FIX_PANIC);
if (!(errors % MY_WAIT_GIVE_USER_A_MESSAGE))
my_printf_error(EE_DISK_FULL,
"Retry in %d secs. Message reprinted in %d secs",
MYF(ME_BELL | ME_ERROR_LOG | ME_WARNING),
MY_WAIT_FOR_USER_TO_FIX_PANIC,
MY_WAIT_GIVE_USER_A_MESSAGE * MY_WAIT_FOR_USER_TO_FIX_PANIC );
(void) sleep(MY_WAIT_FOR_USER_TO_FIX_PANIC);
} | O3 | c | wait_for_free_space:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testl %esi, %esi
je 0x31ee5
imull $0xcccccccd, %esi, %eax # imm = 0xCCCCCCCD
movl $0x19999998, %ecx # imm = 0x19999998
addl %ecx, %eax
rorl %eax
cmpl %ecx, %eax
ja 0x31f2c
jmp 0x31f09
movq %rdi, %rbx
callq 0x2df82
movl (%rax), %ecx
movl $0x844, %esi # imm = 0x844
movl $0x14, %edi
movq %rbx, %rdx
movl $0x3c, %r8d
xorl %eax, %eax
callq 0x295ff
leaq 0x33485(%rip), %rsi # 0x65395
movl $0x844, %edx # imm = 0x844
movl $0x14, %edi
movl $0x3c, %ecx
movl $0x258, %r8d # imm = 0x258
xorl %eax, %eax
callq 0x29719
movl $0x3c, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x24250
| wait_for_free_space:
push rbp
mov rbp, rsp
push rbx
push rax
test esi, esi
jz short loc_31EE5
imul eax, esi, 0CCCCCCCDh
mov ecx, 19999998h
add eax, ecx
ror eax, 1
cmp eax, ecx
ja short loc_31F2C
jmp short loc_31F09
loc_31EE5:
mov rbx, rdi
call _my_thread_var
mov ecx, [rax]
mov esi, 844h
mov edi, 14h
mov rdx, rbx
mov r8d, 3Ch ; '<'
xor eax, eax
call my_error
loc_31F09:
lea rsi, aRetryInDSecsMe; "Retry in %d secs. Message reprinted in "...
mov edx, 844h
mov edi, 14h
mov ecx, 3Ch ; '<'
mov r8d, 258h
xor eax, eax
call my_printf_error
loc_31F2C:
mov edi, 3Ch ; '<'
add rsp, 8
pop rbx
pop rbp
jmp _sleep
| long long wait_for_free_space(
long long a1,
int a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
long long a11,
long long a12,
long long a13,
long long a14)
{
char v14; // al
unsigned int *v15; // rax
char v17; // [rsp-8h] [rbp-10h]
v17 = v14;
if ( !a2 )
{
v15 = (unsigned int *)my_thread_var();
my_error(0x14u, 2116LL, a1, *v15, 60LL);
LABEL_5:
my_printf_error(
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
20LL,
(long long)"Retry in %d secs. Message reprinted in %d secs",
2116LL,
60LL,
600LL,
a14,
v17);
return sleep(60LL);
}
if ( __ROR4__(-858993459 * a2 + 429496728, 1) <= 0x19999998u )
goto LABEL_5;
return sleep(60LL);
}
| wait_for_free_space:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
TEST ESI,ESI
JZ 0x00131ee5
IMUL EAX,ESI,-0x33333333
MOV ECX,0x19999998
ADD EAX,ECX
ROR EAX,0x1
CMP EAX,ECX
JA 0x00131f2c
JMP 0x00131f09
LAB_00131ee5:
MOV RBX,RDI
CALL 0x0012df82
MOV ECX,dword ptr [RAX]
MOV ESI,0x844
MOV EDI,0x14
MOV RDX,RBX
MOV R8D,0x3c
XOR EAX,EAX
CALL 0x001295ff
LAB_00131f09:
LEA RSI,[0x165395]
MOV EDX,0x844
MOV EDI,0x14
MOV ECX,0x3c
MOV R8D,0x258
XOR EAX,EAX
CALL 0x00129719
LAB_00131f2c:
MOV EDI,0x3c
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x00124250
|
void wait_for_free_space(int8 param_1,int param_2)
{
uint uVar1;
int4 *puVar2;
if (param_2 == 0) {
puVar2 = (int4 *)_my_thread_var();
my_error(0x14,0x844,param_1,*puVar2,0x3c);
}
else {
uVar1 = param_2 * -0x33333333 + 0x19999998;
if (0x19999998 < (uVar1 >> 1 | (uint)((uVar1 & 1) != 0) << 0x1f)) goto LAB_00131f2c;
}
my_printf_error(0x14,"Retry in %d secs. Message reprinted in %d secs",0x844,0x3c,600);
LAB_00131f2c:
sleep(0x3c);
return;
}
| |
27,848 | minja::Parser::parseConstant() | monkey531[P]llama/common/minja.hpp | std::shared_ptr<Value> parseConstant() {
auto start = it;
consumeSpaces();
if (it == end) return nullptr;
if (*it == '"' || *it == '\'') {
auto str = parseString();
if (str) return std::make_shared<Value>(*str);
}
static std::regex prim_tok(R"(true\b|True\b|false\b|False\b|None\b)");
auto token = consumeToken(prim_tok);
if (!token.empty()) {
if (token == "true" || token == "True") return std::make_shared<Value>(true);
if (token == "false" || token == "False") return std::make_shared<Value>(false);
if (token == "None") return std::make_shared<Value>(nullptr);
throw std::runtime_error("Unknown constant token: " + token);
}
auto number = parseNumber(it, end);
if (!number.is_null()) return std::make_shared<Value>(number);
it = start;
return nullptr;
} | O3 | cpp | minja::Parser::parseConstant():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x20(%rsi), %r14
movq 0x18(%rsi), %r12
movq 0x20(%rsi), %r13
movq %r13, %rbp
cmpq %r12, %r13
je 0x8a107
movq %r13, %rbp
movsbl (%rbp), %edi
callq 0x1b0c0
testl %eax, %eax
je 0x8a107
incq %rbp
movq %rbp, (%r14)
cmpq %r12, %rbp
jne 0x8a0ef
cmpq %r12, %rbp
je 0x8a15d
movzbl (%rbp), %eax
cmpl $0x27, %eax
je 0x8a11a
cmpl $0x22, %eax
jne 0x8a168
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x8b4ac
movq (%r12), %rdx
testq %rdx, %rdx
je 0x8a168
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x8bb00
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x8a2c5
leaq 0x8(%rsp), %rdi
callq 0x8bd20
jmp 0x8a2c5
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x8a2c5
leaq 0xa5001(%rip), %rax # 0x12f170
movb (%rax), %al
testb %al, %al
je 0x8a2d7
leaq 0xa4fd0(%rip), %rdx # 0x12f150
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movl $0x1, %ecx
callq 0x837d2
cmpq $0x0, 0x8(%r12)
je 0x8a244
leaq 0x5e832(%rip), %rsi # 0xe89da
leaq 0x8(%rsp), %rdi
callq 0x1b220
testl %eax, %eax
je 0x8a22d
leaq 0x678ef(%rip), %rsi # 0xf1aac
leaq 0x8(%rsp), %rdi
callq 0x1b220
testl %eax, %eax
je 0x8a22d
leaq 0x614f1(%rip), %rsi # 0xeb6c3
leaq 0x8(%rsp), %rdi
callq 0x1b220
testl %eax, %eax
je 0x8a273
leaq 0x678c6(%rip), %rsi # 0xf1ab1
leaq 0x8(%rsp), %rdi
callq 0x1b220
testl %eax, %eax
je 0x8a273
leaq 0x67ccc(%rip), %rsi # 0xf1ecc
leaq 0x8(%rsp), %rdi
callq 0x1b220
testl %eax, %eax
jne 0x8a32e
leaq 0x28(%rsp), %rdx
movq $0x0, (%rdx)
leaq 0x7(%rsp), %rsi
movq %rbx, %rdi
callq 0x8be40
jmp 0x8a2aa
leaq 0x7(%rsp), %rdx
movb $0x1, (%rdx)
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x8bd4e
jmp 0x8a2aa
leaq 0x18(%r15), %rcx
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x8b52c
cmpb $0x0, 0x28(%rsp)
je 0x8a28a
leaq 0x7(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x8c054
jmp 0x8a293
leaq 0x7(%rsp), %rdx
movb $0x0, (%rdx)
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x8bd4e
jmp 0x8a2aa
movq %r13, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
leaq 0x28(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x58644
movq %r14, %rdi
callq 0x5db32
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8a2c5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8b0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa4e92(%rip), %rdi # 0x12f170
callq 0x1bfd0
testl %eax, %eax
je 0x8a179
leaq 0xa4e5e(%rip), %rdi # 0x12f150
leaq 0x67bae(%rip), %rsi # 0xf1ea7
movl $0x10, %edx
callq 0x624e4
leaq -0x27b22(%rip), %rdi # 0x627e8
leaq 0xa4e3f(%rip), %rsi # 0x12f150
leaq 0xa45b0(%rip), %rdx # 0x12e8c8
callq 0x1b790
leaq 0xa4e4c(%rip), %rdi # 0x12f170
callq 0x1b5a0
jmp 0x8a179
movl $0x10, %edi
callq 0x1b440
movq %rax, %r14
leaq 0x67b8f(%rip), %rsi # 0xf1ed1
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x540d1
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x1be00
xorl %ebp, %ebp
movq 0xa3c7e(%rip), %rsi # 0x12dfe8
movq 0xa3bdf(%rip), %rdx # 0x12df50
movq %r14, %rdi
callq 0x1bef0
movq %rax, %rbx
leaq 0xa4ded(%rip), %rdi # 0x12f170
callq 0x1b590
jmp 0x8a418
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8a3ab
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1b8b0
testb %bpl, %bpl
jne 0x8a3b5
jmp 0x8a3e4
movq %rax, %rbx
movq %r14, %rdi
callq 0x1b650
jmp 0x8a3e4
jmp 0x8a3e1
jmp 0x8a3e1
movq %rax, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x58644
movq %r14, %rdi
callq 0x5db32
jmp 0x8a3e4
jmp 0x8a3e1
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8a418
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8b0
jmp 0x8a418
movq %rax, %rbx
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x8a418
leaq 0x8(%rsp), %rdi
callq 0x8bd20
movq %rbx, %rdi
callq 0x1bf70
| _ZN5minja6Parser13parseConstantEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r15, rsi
mov rbx, rdi
lea r14, [rsi+20h]
mov r12, [rsi+18h]
mov r13, [rsi+20h]
mov rbp, r13
cmp r13, r12
jz short loc_8A107
mov rbp, r13
loc_8A0EF:
movsx edi, byte ptr [rbp+0]
call _isspace
test eax, eax
jz short loc_8A107
inc rbp
mov [r14], rbp
cmp rbp, r12
jnz short loc_8A0EF
loc_8A107:
cmp rbp, r12
jz short loc_8A15D
movzx eax, byte ptr [rbp+0]
cmp eax, 27h ; '''
jz short loc_8A11A
cmp eax, 22h ; '"'
jnz short loc_8A168
loc_8A11A:
lea r12, [rsp+78h+var_70]
mov rdi, r12; int
mov rsi, r15; void *
call _ZN5minja6Parser11parseStringB5cxx11Ev; minja::Parser::parseString(void)
mov rdx, [r12]
test rdx, rdx
jz short loc_8A168
lea rsi, [rsp+78h+var_50]
mov rdi, rbx
call _ZNSt12__shared_ptrIN5minja5ValueELN9__gnu_cxx12_Lock_policyE2EEC2ISaIS1_EJRNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEESt20_Sp_alloc_shared_tagIT_EDpOT0_; std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<minja::Value>,std::string &>(std::_Sp_alloc_shared_tag<std::allocator<minja::Value>>,std::string &)
mov rsi, qword ptr [rsp+78h+var_70]
test rsi, rsi
jz loc_8A2C5
lea rdi, [rsp+78h+var_70]
call _ZNKSt14default_deleteINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclEPS5_; std::default_delete<std::string>::operator()(std::string*)
jmp loc_8A2C5
loc_8A15D:
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
jmp loc_8A2C5
loc_8A168:
lea rax, _ZGVZN5minja6Parser13parseConstantEvE8prim_tokB5cxx11; `guard variable for'minja::Parser::parseConstant(void)::prim_tok
mov al, [rax]
test al, al
jz loc_8A2D7
loc_8A179:
lea rdx, _ZZN5minja6Parser13parseConstantEvE8prim_tokB5cxx11; minja::Parser::parseConstant(void)::prim_tok
lea r12, [rsp+78h+var_70]
mov rdi, r12
mov rsi, r15
mov ecx, 1
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::basic_regex<char,std::regex_traits<char>> const&,minja::SpaceHandling)
cmp qword ptr [r12+8], 0
jz loc_8A244
lea rsi, aTrue; "true"
lea rdi, [rsp+78h+var_70]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_8A22D
lea rsi, aTrue_0; "True"
lea rdi, [rsp+78h+var_70]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_8A22D
lea rsi, aAdvancedOption+0ABh; "false"
lea rdi, [rsp+78h+var_70]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz loc_8A273
lea rsi, aFalse; "False"
lea rdi, [rsp+78h+var_70]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_8A273
lea rsi, aNone_0; "None"
lea rdi, [rsp+78h+var_70]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jnz loc_8A32E
lea rdx, [rsp+78h+var_50]
mov qword ptr [rdx], 0
lea rsi, [rsp+78h+var_71]
mov rdi, rbx
call _ZNSt12__shared_ptrIN5minja5ValueELN9__gnu_cxx12_Lock_policyE2EEC2ISaIS1_EJDnEEESt20_Sp_alloc_shared_tagIT_EDpOT0_; std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<minja::Value>,decltype(nullptr)>(std::_Sp_alloc_shared_tag<std::allocator<minja::Value>>,decltype(nullptr) &&)
jmp short loc_8A2AA
loc_8A22D:
lea rdx, [rsp+78h+var_71]
mov byte ptr [rdx], 1
lea rsi, [rsp+78h+var_50]
mov rdi, rbx
call _ZNSt12__shared_ptrIN5minja5ValueELN9__gnu_cxx12_Lock_policyE2EEC2ISaIS1_EJbEEESt20_Sp_alloc_shared_tagIT_EDpOT0_; std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<minja::Value>,bool>(std::_Sp_alloc_shared_tag<std::allocator<minja::Value>>,bool &&)
jmp short loc_8A2AA
loc_8A244:
lea rcx, [r15+18h]
lea rdi, [rsp+78h+var_50]
mov rsi, r15
mov rdx, r14
call _ZN5minja6Parser11parseNumberERN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEERKSB_; minja::Parser::parseNumber(__gnu_cxx::__normal_iterator<char const*,std::string> &,__gnu_cxx::__normal_iterator<char const*,std::string> const&)
cmp [rsp+78h+var_50], 0
jz short loc_8A28A
lea rsi, [rsp+78h+var_71]
lea rdx, [rsp+78h+var_50]
mov rdi, rbx
call _ZNSt12__shared_ptrIN5minja5ValueELN9__gnu_cxx12_Lock_policyE2EEC2ISaIS1_EJRN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS8_14adl_serializerESB_IhSaIhEEvEEEEESt20_Sp_alloc_shared_tagIT_EDpOT0_; std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<minja::Value>,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::_Sp_alloc_shared_tag<std::allocator<minja::Value>>,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> &)
jmp short loc_8A293
loc_8A273:
lea rdx, [rsp+78h+var_71]
mov byte ptr [rdx], 0
lea rsi, [rsp+78h+var_50]
mov rdi, rbx
call _ZNSt12__shared_ptrIN5minja5ValueELN9__gnu_cxx12_Lock_policyE2EEC2ISaIS1_EJbEEESt20_Sp_alloc_shared_tagIT_EDpOT0_; std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<minja::Value>,bool>(std::_Sp_alloc_shared_tag<std::allocator<minja::Value>>,bool &&)
jmp short loc_8A2AA
loc_8A28A:
mov [r14], r13
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
loc_8A293:
lea r14, [rsp+78h+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_8A2AA:
lea rax, [rsp+78h+var_60]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_8A2C5
mov rsi, [rsp+78h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_8A2C5:
mov rax, rbx
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_8A2D7:
lea rdi, _ZGVZN5minja6Parser13parseConstantEvE8prim_tokB5cxx11; __guard *
call ___cxa_guard_acquire
test eax, eax
jz loc_8A179
lea rdi, _ZZN5minja6Parser13parseConstantEvE8prim_tokB5cxx11; minja::Parser::parseConstant(void)::prim_tok
lea rsi, aTrueBTrueBFals; "true\\b|True\\b|false\\b|False\\b|None"...
mov edx, 10h
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2EPKcNSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex(char const*,std::regex_constants::syntax_option_type)
lea rdi, _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; lpfunc
lea rsi, _ZZN5minja6Parser13parseConstantEvE8prim_tokB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZN5minja6Parser13parseConstantEvE8prim_tokB5cxx11; __guard *
call ___cxa_guard_release
jmp loc_8A179
loc_8A32E:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aUnknownConstan; "Unknown constant token: "
lea rdi, [rsp+78h+var_50]
lea rdx, [rsp+78h+var_70]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
mov bpl, 1
lea rsi, [rsp+78h+var_50]
mov rdi, r14
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
mov rbx, rax
lea rdi, _ZGVZN5minja6Parser13parseConstantEvE8prim_tokB5cxx11; __guard *
call ___cxa_guard_abort
jmp loc_8A418
mov rbx, rax
lea rax, [rsp+78h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_8A3AB
mov rsi, [rsp+78h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_8A3AB:
test bpl, bpl
jnz short loc_8A3B5
jmp short loc_8A3E4
mov rbx, rax
loc_8A3B5:
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_8A3E4
jmp short loc_8A3E1
jmp short loc_8A3E1
mov rbx, rax
lea r14, [rsp+78h+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()
jmp short loc_8A3E4
jmp short $+2
loc_8A3E1:
mov rbx, rax
loc_8A3E4:
lea rax, [rsp+78h+var_60]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_8A418
mov rsi, [rsp+78h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_8A418
mov rbx, rax
mov rsi, qword ptr [rsp+78h+var_70]
test rsi, rsi
jz short loc_8A418
lea rdi, [rsp+78h+var_70]
call _ZNKSt14default_deleteINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclEPS5_; std::default_delete<std::string>::operator()(std::string*)
loc_8A418:
mov rdi, rbx
call __Unwind_Resume
| minja::Parser * minja::Parser::parseConstant(minja::Parser *this, unsigned __int8 **a2)
{
unsigned __int8 **v2; // r14
char *v3; // r12
unsigned __int8 *v4; // r13
unsigned __int8 *v5; // rbp
int v6; // eax
void *exception; // r14
char v9; // [rsp+7h] [rbp-71h] BYREF
int v10[2]; // [rsp+8h] [rbp-70h] BYREF
long long v11; // [rsp+10h] [rbp-68h]
long long v12; // [rsp+18h] [rbp-60h] BYREF
_QWORD v13[2]; // [rsp+28h] [rbp-50h] BYREF
v2 = a2 + 4;
v3 = (char *)a2[3];
v4 = a2[4];
v5 = v4;
if ( v4 != (unsigned __int8 *)v3 )
{
v5 = a2[4];
do
{
if ( !(unsigned int)isspace((unsigned int)(char)*v5) )
break;
*v2 = ++v5;
}
while ( v5 != (unsigned __int8 *)v3 );
}
if ( v5 == (unsigned __int8 *)v3 )
{
*(_OWORD *)this = 0LL;
}
else
{
v6 = *v5;
if ( (v6 == 39 || v6 == 34) && (minja::Parser::parseString[abi:cxx11]((int)v10, a2), *(_QWORD *)v10) )
{
std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<minja::Value>,std::string &>(
this,
v13);
if ( *(_QWORD *)v10 )
std::default_delete<std::string>::operator()(v10);
}
else
{
if ( !(_BYTE)`guard variable for'minja::Parser::parseConstant(void)::prim_tok[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'minja::Parser::parseConstant(void)::prim_tok[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&minja::Parser::parseConstant(void)::prim_tok[abi:cxx11],
(long long)"true\\b|True\\b|false\\b|False\\b|None\\b",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&minja::Parser::parseConstant(void)::prim_tok[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'minja::Parser::parseConstant(void)::prim_tok[abi:cxx11]);
}
minja::Parser::consumeToken(
(long long)v10,
(long long)a2,
(long long)&minja::Parser::parseConstant(void)::prim_tok[abi:cxx11],
1u);
if ( v11 )
{
if ( !(unsigned int)std::string::compare(v10, "true") || !(unsigned int)std::string::compare(v10, "True") )
{
v9 = 1;
std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<minja::Value>,bool>(
this,
v13,
&v9);
}
else if ( !(unsigned int)std::string::compare(v10, "false") || !(unsigned int)std::string::compare(v10, "False") )
{
v9 = 0;
std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<minja::Value>,bool>(
this,
v13,
&v9);
}
else
{
if ( (unsigned int)std::string::compare(v10, "None") )
{
exception = __cxa_allocate_exception(0x10uLL);
std::operator+<char>((long long)v13, (long long)"Unknown constant token: ", v10);
std::runtime_error::runtime_error(exception, v13);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v13[0] = 0LL;
std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<minja::Value>,decltype(nullptr)>(
this,
&v9,
v13);
}
}
else
{
minja::Parser::parseNumber(v13, a2, v2, a2 + 3);
if ( LOBYTE(v13[0]) )
{
std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<minja::Value>,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> &>(
this,
&v9,
v13);
}
else
{
*v2 = v4;
*(_OWORD *)this = 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>::assert_invariant((char *)v13);
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(v13);
}
if ( *(long long **)v10 != &v12 )
operator delete(*(void **)v10, v12 + 1);
}
}
return this;
}
| parseConstant:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R15,RSI
MOV RBX,RDI
LEA R14,[RSI + 0x20]
MOV R12,qword ptr [RSI + 0x18]
MOV R13,qword ptr [RSI + 0x20]
MOV RBP,R13
CMP R13,R12
JZ 0x0018a107
MOV RBP,R13
LAB_0018a0ef:
MOVSX EDI,byte ptr [RBP]
CALL 0x0011b0c0
TEST EAX,EAX
JZ 0x0018a107
INC RBP
MOV qword ptr [R14],RBP
CMP RBP,R12
JNZ 0x0018a0ef
LAB_0018a107:
CMP RBP,R12
JZ 0x0018a15d
MOVZX EAX,byte ptr [RBP]
CMP EAX,0x27
JZ 0x0018a11a
CMP EAX,0x22
JNZ 0x0018a168
LAB_0018a11a:
LEA R12,[RSP + 0x8]
MOV RDI,R12
MOV RSI,R15
CALL 0x0018b4ac
MOV RDX,qword ptr [R12]
TEST RDX,RDX
JZ 0x0018a168
LAB_0018a133:
LEA RSI,[RSP + 0x28]
MOV RDI,RBX
CALL 0x0018bb00
LAB_0018a140:
MOV RSI,qword ptr [RSP + 0x8]
TEST RSI,RSI
JZ 0x0018a2c5
LEA RDI,[RSP + 0x8]
CALL 0x0018bd20
JMP 0x0018a2c5
LAB_0018a15d:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
JMP 0x0018a2c5
LAB_0018a168:
LEA RAX,[0x22f170]
MOV AL,byte ptr [RAX]
TEST AL,AL
JZ 0x0018a2d7
LAB_0018a179:
LEA RDX,[0x22f150]
LEA R12,[RSP + 0x8]
MOV RDI,R12
MOV RSI,R15
MOV ECX,0x1
CALL 0x001837d2
CMP qword ptr [R12 + 0x8],0x0
JZ 0x0018a244
LEA RSI,[0x1e89da]
LEA RDI,[RSP + 0x8]
CALL 0x0011b220
TEST EAX,EAX
JZ 0x0018a22d
LEA RSI,[0x1f1aac]
LEA RDI,[RSP + 0x8]
CALL 0x0011b220
TEST EAX,EAX
JZ 0x0018a22d
LEA RSI,[0x1eb6c3]
LEA RDI,[RSP + 0x8]
CALL 0x0011b220
TEST EAX,EAX
JZ 0x0018a273
LEA RSI,[0x1f1ab1]
LEA RDI,[RSP + 0x8]
CALL 0x0011b220
TEST EAX,EAX
JZ 0x0018a273
LEA RSI,[0x1f1ecc]
LEA RDI,[RSP + 0x8]
CALL 0x0011b220
TEST EAX,EAX
JNZ 0x0018a32e
LEA RDX,[RSP + 0x28]
MOV qword ptr [RDX],0x0
LAB_0018a21e:
LEA RSI,[RSP + 0x7]
MOV RDI,RBX
CALL 0x0018be40
JMP 0x0018a2aa
LAB_0018a22d:
LEA RDX,[RSP + 0x7]
MOV byte ptr [RDX],0x1
LAB_0018a235:
LEA RSI,[RSP + 0x28]
MOV RDI,RBX
CALL 0x0018bd4e
JMP 0x0018a2aa
LAB_0018a244:
LEA RCX,[R15 + 0x18]
LEA RDI,[RSP + 0x28]
MOV RSI,R15
MOV RDX,R14
CALL 0x0018b52c
CMP byte ptr [RSP + 0x28],0x0
JZ 0x0018a28a
LAB_0018a25f:
LEA RSI,[RSP + 0x7]
LEA RDX,[RSP + 0x28]
MOV RDI,RBX
CALL 0x0018c054
JMP 0x0018a293
LAB_0018a273:
LEA RDX,[RSP + 0x7]
MOV byte ptr [RDX],0x0
LAB_0018a27b:
LEA RSI,[RSP + 0x28]
MOV RDI,RBX
CALL 0x0018bd4e
JMP 0x0018a2aa
LAB_0018a28a:
MOV qword ptr [R14],R13
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
LAB_0018a293:
LEA R14,[RSP + 0x28]
MOV RDI,R14
XOR ESI,ESI
CALL 0x00158644
MOV RDI,R14
CALL 0x0015db32
LAB_0018a2aa:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0018a2c5
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011b8b0
LAB_0018a2c5:
MOV RAX,RBX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0018a2d7:
LEA RDI,[0x22f170]
CALL 0x0011bfd0
TEST EAX,EAX
JZ 0x0018a179
LAB_0018a2eb:
LEA RDI,[0x22f150]
LEA RSI,[0x1f1ea7]
MOV EDX,0x10
CALL 0x001624e4
LAB_0018a303:
LEA RDI,[0x1627e8]
LEA RSI,[0x22f150]
LEA RDX,[0x22e8c8]
CALL 0x0011b790
LEA RDI,[0x22f170]
CALL 0x0011b5a0
JMP 0x0018a179
LAB_0018a32e:
MOV EDI,0x10
CALL 0x0011b440
MOV R14,RAX
LAB_0018a33b:
LEA RSI,[0x1f1ed1]
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x8]
CALL 0x001540d1
MOV BPL,0x1
LAB_0018a354:
LEA RSI,[RSP + 0x28]
MOV RDI,R14
CALL 0x0011be00
XOR EBP,EBP
MOV RSI,qword ptr [0x0022dfe8]
MOV RDX,qword ptr [0x0022df50]
MOV RDI,R14
CALL 0x0011bef0
|
/* minja::Parser::parseConstant() */
void minja::Parser::parseConstant(void)
{
char *pcVar1;
char *pcVar2;
int iVar3;
runtime_error *this;
char *pcVar4;
__normal_iterator *in_RSI;
int8 *in_RDI;
string *local_70;
long local_68;
long local_60 [2];
int8 local_50 [4];
pcVar1 = *(char **)(in_RSI + 0x18);
pcVar2 = *(char **)(in_RSI + 0x20);
pcVar4 = pcVar2;
while ((pcVar4 != pcVar1 && (iVar3 = isspace((int)*pcVar4), iVar3 != 0))) {
pcVar4 = pcVar4 + 1;
*(char **)(in_RSI + 0x20) = pcVar4;
}
if (pcVar4 == pcVar1) {
*in_RDI = 0;
in_RDI[1] = 0;
}
else if (((*pcVar4 == '\'') || (*pcVar4 == '\"')) &&
(parseString_abi_cxx11_(), local_70 != (string *)0x0)) {
/* try { // try from 0018a133 to 0018a13f has its CatchHandler @ 0018a401 */
std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::
__shared_ptr<std::allocator<minja::Value>,std::__cxx11::string&>();
if (local_70 != (string *)0x0) {
std::default_delete<std::__cxx11::string>::operator()
((default_delete<std::__cxx11::string> *)&local_70,local_70);
}
}
else {
if ((parseConstant()::prim_tok_abi_cxx11_ == '\0') &&
(iVar3 = __cxa_guard_acquire(&parseConstant()::prim_tok_abi_cxx11_), iVar3 != 0)) {
/* try { // try from 0018a2eb to 0018a302 has its CatchHandler @ 0018a379 */
std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::basic_regex
((basic_regex<char,std::__cxx11::regex_traits<char>> *)
parseConstant()::prim_tok_abi_cxx11_,"true\\b|True\\b|false\\b|False\\b|None\\b",
0x10);
__cxa_atexit(std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::~basic_regex,
parseConstant()::prim_tok_abi_cxx11_,&__dso_handle);
__cxa_guard_release(&parseConstant()::prim_tok_abi_cxx11_);
}
consumeToken(&local_70);
if (local_68 == 0) {
/* try { // try from 0018a244 to 0018a257 has its CatchHandler @ 0018a3df */
parseNumber((__normal_iterator *)local_50,in_RSI);
if (local_50[0]._0_1_ == (data)0x0) {
*(char **)(in_RSI + 0x20) = pcVar2;
*in_RDI = 0;
in_RDI[1] = 0;
}
else {
/* try { // try from 0018a25f to 0018a270 has its CatchHandler @ 0018a3c3 */
std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::
__shared_ptr<std::allocator<minja::Value>,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::
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);
}
else {
iVar3 = std::__cxx11::string::compare((char *)&local_70);
if ((iVar3 == 0) || (iVar3 = std::__cxx11::string::compare((char *)&local_70), iVar3 == 0)) {
/* try { // try from 0018a235 to 0018a241 has its CatchHandler @ 0018a3e1 */
std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::
__shared_ptr<std::allocator<minja::Value>,bool>();
}
else {
iVar3 = std::__cxx11::string::compare((char *)&local_70);
if ((iVar3 == 0) || (iVar3 = std::__cxx11::string::compare((char *)&local_70), iVar3 == 0))
{
/* try { // try from 0018a27b to 0018a287 has its CatchHandler @ 0018a3c1 */
std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::
__shared_ptr<std::allocator<minja::Value>,bool>();
}
else {
iVar3 = std::__cxx11::string::compare((char *)&local_70);
if (iVar3 != 0) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0018a33b to 0018a350 has its CatchHandler @ 0018a3b2 */
std::operator+((char *)local_50,(string *)"Unknown constant token: ");
/* try { // try from 0018a354 to 0018a378 has its CatchHandler @ 0018a38d */
std::runtime_error::runtime_error(this,(string *)local_50);
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_0022dfe8,PTR__runtime_error_0022df50);
}
local_50[0] = 0;
/* try { // try from 0018a21e to 0018a22a has its CatchHandler @ 0018a3bf */
std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::
__shared_ptr<std::allocator<minja::Value>,decltype(nullptr)>();
}
}
}
if (local_70 != (string *)local_60) {
operator_delete(local_70,local_60[0] + 1);
}
}
return;
}
| |
27,849 | common_model_params_to_llama(common_params&) | monkey531[P]llama/common/common.cpp | struct llama_model_params common_model_params_to_llama(common_params & params) {
auto mparams = llama_model_default_params();
if (!params.devices.empty()) {
mparams.devices = params.devices.data();
}
if (params.n_gpu_layers != -1) {
mparams.n_gpu_layers = params.n_gpu_layers;
}
mparams.main_gpu = params.main_gpu;
mparams.split_mode = params.split_mode;
mparams.tensor_split = params.tensor_split;
mparams.use_mmap = params.use_mmap;
mparams.use_mlock = params.use_mlock;
mparams.check_tensors = params.check_tensors;
if (params.kv_overrides.empty()) {
mparams.kv_overrides = NULL;
} else {
GGML_ASSERT(params.kv_overrides.back().key[0] == 0 && "KV overrides not terminated with empty key");
mparams.kv_overrides = params.kv_overrides.data();
}
return mparams;
} | O2 | cpp | common_model_params_to_llama(common_params&):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x23ea0
movq 0x50(%r14), %rax
cmpq 0x58(%r14), %rax
je 0x553bf
movq %rax, (%rbx)
movl 0x68(%r14), %eax
cmpl $-0x1, %eax
je 0x553cb
movl %eax, 0x8(%rbx)
movl 0x6c(%r14), %eax
movl %eax, 0x10(%rbx)
movl 0x270(%r14), %eax
movl %eax, 0xc(%rbx)
leaq 0x70(%r14), %rax
movq %rax, 0x18(%rbx)
movb 0xfe9(%r14), %al
movb %al, 0x39(%rbx)
movb 0xfea(%r14), %al
movb %al, 0x3a(%rbx)
movb 0xff0(%r14), %al
movb %al, 0x3b(%rbx)
movq 0xf48(%r14), %rax
movq 0xf50(%r14), %rcx
cmpq %rcx, %rax
je 0x5543f
cmpb $0x0, -0x104(%rcx)
je 0x55441
leaq 0x5c74c(%rip), %rdi # 0xb1b71
leaq 0x59a14(%rip), %rdx # 0xaee40
leaq 0x5cc43(%rip), %rcx # 0xb2076
movl $0x44b, %esi # imm = 0x44B
xorl %eax, %eax
callq 0x23ed0
xorl %eax, %eax
movq %rax, 0x30(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| _Z28common_model_params_to_llamaR13common_params:
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
call _llama_model_default_params
mov rax, [r14+50h]
cmp rax, [r14+58h]
jz short loc_553BF
mov [rbx], rax
loc_553BF:
mov eax, [r14+68h]
cmp eax, 0FFFFFFFFh
jz short loc_553CB
mov [rbx+8], eax
loc_553CB:
mov eax, [r14+6Ch]
mov [rbx+10h], eax
mov eax, [r14+270h]
mov [rbx+0Ch], eax
lea rax, [r14+70h]
mov [rbx+18h], rax
mov al, [r14+0FE9h]
mov [rbx+39h], al
mov al, [r14+0FEAh]
mov [rbx+3Ah], al
mov al, [r14+0FF0h]
mov [rbx+3Bh], al
mov rax, [r14+0F48h]
mov rcx, [r14+0F50h]
cmp rax, rcx
jz short loc_5543F
cmp byte ptr [rcx-104h], 0
jz short loc_55441
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aParamsKvOverri; "params.kv_overrides.back().key[0] == 0 "...
mov esi, 44Bh
xor eax, eax
call _ggml_abort
loc_5543F:
xor eax, eax
loc_55441:
mov [rbx+30h], rax
mov rax, rbx
add rsp, 8
pop rbx
pop r14
retn
| common_params * common_model_params_to_llama(common_params *a1, long long a2)
{
long long v2; // rax
int v3; // eax
long long v4; // rax
long long v5; // rcx
llama_model_default_params(a1);
v2 = *(_QWORD *)(a2 + 80);
if ( v2 != *(_QWORD *)(a2 + 88) )
*(_QWORD *)a1 = v2;
v3 = *(_DWORD *)(a2 + 104);
if ( v3 != -1 )
*((_DWORD *)a1 + 2) = v3;
*((_DWORD *)a1 + 4) = *(_DWORD *)(a2 + 108);
*((_DWORD *)a1 + 3) = *(_DWORD *)(a2 + 624);
*((_QWORD *)a1 + 3) = a2 + 112;
*((_BYTE *)a1 + 57) = *(_BYTE *)(a2 + 4073);
*((_BYTE *)a1 + 58) = *(_BYTE *)(a2 + 4074);
*((_BYTE *)a1 + 59) = *(_BYTE *)(a2 + 4080);
v4 = *(_QWORD *)(a2 + 3912);
v5 = *(_QWORD *)(a2 + 3920);
if ( v4 == v5 )
goto LABEL_8;
if ( *(_BYTE *)(v5 - 260) )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",
1099LL,
"GGML_ASSERT(%s) failed",
"params.kv_overrides.back().key[0] == 0 && \"KV overrides not terminated with empty key\"");
LABEL_8:
v4 = 0LL;
}
*((_QWORD *)a1 + 6) = v4;
return a1;
}
| common_model_params_to_llama:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
CALL 0x00123ea0
MOV RAX,qword ptr [R14 + 0x50]
CMP RAX,qword ptr [R14 + 0x58]
JZ 0x001553bf
MOV qword ptr [RBX],RAX
LAB_001553bf:
MOV EAX,dword ptr [R14 + 0x68]
CMP EAX,-0x1
JZ 0x001553cb
MOV dword ptr [RBX + 0x8],EAX
LAB_001553cb:
MOV EAX,dword ptr [R14 + 0x6c]
MOV dword ptr [RBX + 0x10],EAX
MOV EAX,dword ptr [R14 + 0x270]
MOV dword ptr [RBX + 0xc],EAX
LEA RAX,[R14 + 0x70]
MOV qword ptr [RBX + 0x18],RAX
MOV AL,byte ptr [R14 + 0xfe9]
MOV byte ptr [RBX + 0x39],AL
MOV AL,byte ptr [R14 + 0xfea]
MOV byte ptr [RBX + 0x3a],AL
MOV AL,byte ptr [R14 + 0xff0]
MOV byte ptr [RBX + 0x3b],AL
MOV RAX,qword ptr [R14 + 0xf48]
MOV RCX,qword ptr [R14 + 0xf50]
CMP RAX,RCX
JZ 0x0015543f
CMP byte ptr [RCX + -0x104],0x0
JZ 0x00155441
LEA RDI,[0x1b1b71]
LEA RDX,[0x1aee40]
LEA RCX,[0x1b2076]
MOV ESI,0x44b
XOR EAX,EAX
CALL 0x00123ed0
LAB_0015543f:
XOR EAX,EAX
LAB_00155441:
MOV qword ptr [RBX + 0x30],RAX
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* common_model_params_to_llama(common_params&) */
common_params * common_model_params_to_llama(common_params *param_1)
{
long lVar1;
long in_RSI;
llama_model_default_params();
if (*(long *)(in_RSI + 0x50) != *(long *)(in_RSI + 0x58)) {
*(long *)param_1 = *(long *)(in_RSI + 0x50);
}
if (*(int *)(in_RSI + 0x68) != -1) {
*(int *)(param_1 + 8) = *(int *)(in_RSI + 0x68);
}
*(int4 *)(param_1 + 0x10) = *(int4 *)(in_RSI + 0x6c);
*(int4 *)(param_1 + 0xc) = *(int4 *)(in_RSI + 0x270);
*(long *)(param_1 + 0x18) = in_RSI + 0x70;
param_1[0x39] = *(common_params *)(in_RSI + 0xfe9);
param_1[0x3a] = *(common_params *)(in_RSI + 0xfea);
param_1[0x3b] = *(common_params *)(in_RSI + 0xff0);
lVar1 = *(long *)(in_RSI + 0xf48);
if (lVar1 == *(long *)(in_RSI + 0xf50)) {
lVar1 = 0;
}
else if (*(char *)(*(long *)(in_RSI + 0xf50) + -0x104) != '\0') {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",1099,
"GGML_ASSERT(%s) failed",
"params.kv_overrides.back().key[0] == 0 && \"KV overrides not terminated with empty key\""
);
}
*(long *)(param_1 + 0x30) = lVar1;
return param_1;
}
| |
27,850 | minja::Value& 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::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>, minja::Value, std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<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, minja::Value>>>::operator[]<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 0>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | llama.cpp/common/json.hpp | T & operator[](KeyType && key)
{
return emplace(std::forward<KeyType>(key), T{}).first->second;
} | O3 | cpp | minja::Value& 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::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>, minja::Value, std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<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, minja::Value>>>::operator[]<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 0>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x40(%rsp), %r14
movq $0x0, 0x8(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%r14)
movaps %xmm0, -0x30(%r14)
movaps %xmm0, -0x20(%r14)
movaps %xmm0, -0x10(%r14)
movb $0x0, (%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x886ee
movq %r14, %rdi
movl $0x1, %esi
callq 0x886ee
movq %rsp, %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0xc0cb0
movq %rax, %rbx
movq %r14, %rdi
xorl %esi, %esi
callq 0x886ee
movq %r14, %rdi
callq 0x8ce08
leaq 0x38(%rsp), %rdi
callq 0x74104
leaq 0x28(%rsp), %rdi
callq 0x74104
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x74104
movq -0x10(%r14), %rdi
testq %rdi, %rdi
je 0xc0a3a
movq 0xa557b(%rip), %rax # 0x165f90
cmpb $0x0, (%rax)
je 0xc0a25
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0xc0a2f
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0xc0a3a
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x10, %rbx
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xb9610
movq %rbx, %rdi
callq 0x21c10
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEEixIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OST_:
push r15
push r14
push rbx
sub rsp, 50h
mov rbx, rsi
mov r15, rdi
lea r14, [rsp+68h+var_28]
mov qword ptr [r14+8], 0
xorps xmm0, xmm0
movaps xmmword ptr [r14-40h], xmm0
movaps xmmword ptr [r14-30h], xmm0
movaps xmmword ptr [r14-20h], xmm0
movaps xmmword ptr [r14-10h], xmm0
mov byte ptr [r14], 0
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdx, rsp
mov rdi, r15
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE7emplaceIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEESI_IN9__gnu_cxx17__normal_iteratorIPSK_S3_ISK_SL_EEEbEOST_OSF_
mov rbx, rax
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()
lea rdi, [rsp+68h+var_30]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+68h+var_40]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea r14, [rsp+68h+var_50]
mov rdi, r14
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, [r14-10h]
test rdi, rdi
jz short loc_C0A3A
mov rax, cs:_ZTISt19_Sp_make_shared_tag; `typeinfo for'std::_Sp_make_shared_tag
cmp byte ptr [rax], 0
jz short loc_C0A25
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_C0A2F
loc_C0A25:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_C0A2F:
cmp eax, 1
jnz short loc_C0A3A
mov rax, [rdi]
call qword ptr [rax+18h]
loc_C0A3A:
add rbx, 10h
mov rax, rbx
add rsp, 50h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
mov rdi, rsp; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rdi, rbx
call __Unwind_Resume
| long long ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEEixIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OST_(
long long a1,
long long a2)
{
long long v2; // rbx
long long v3; // rdi
signed __int32 v4; // eax
__int128 v6; // [rsp+0h] [rbp-68h] BYREF
__int128 v7; // [rsp+10h] [rbp-58h] BYREF
__int128 v8; // [rsp+20h] [rbp-48h] BYREF
__int128 v9; // [rsp+30h] [rbp-38h] BYREF
char v10[8]; // [rsp+40h] [rbp-28h] BYREF
long long v11; // [rsp+48h] [rbp-20h]
v11 = 0LL;
v6 = 0LL;
v7 = 0LL;
v8 = 0LL;
v9 = 0LL;
v10[0] = 0;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v10);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v10);
v2 = ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE7emplaceIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEESI_IN9__gnu_cxx17__normal_iteratorIPSK_S3_ISK_SL_EEEbEOST_OSF_(
a1,
a2,
&v6);
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(v10);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v10);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count((volatile signed __int32 **)&v9 + 1);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count((volatile signed __int32 **)&v8 + 1);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count((volatile signed __int32 **)&v7 + 1);
v3 = *((_QWORD *)&v6 + 1);
if ( *((_QWORD *)&v6 + 1) )
{
if ( _libc_single_threaded )
{
v4 = *(_DWORD *)(*((_QWORD *)&v6 + 1) + 12LL);
*(_DWORD *)(*((_QWORD *)&v6 + 1) + 12LL) = v4 - 1;
}
else
{
v4 = _InterlockedExchangeAdd((volatile signed __int32 *)(*((_QWORD *)&v6 + 1) + 12LL), 0xFFFFFFFF);
}
if ( v4 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v3 + 24LL))(v3, 0LL);
}
return v2 + 16;
}
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEEixIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OST_:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV RBX,RSI
MOV R15,RDI
LEA R14,[RSP + 0x40]
MOV qword ptr [R14 + 0x8],0x0
XORPS XMM0,XMM0
MOVAPS xmmword ptr [R14 + -0x40],XMM0
MOVAPS xmmword ptr [R14 + -0x30],XMM0
MOVAPS xmmword ptr [R14 + -0x20],XMM0
MOVAPS xmmword ptr [R14 + -0x10],XMM0
MOV byte ptr [R14],0x0
MOV RDI,R14
MOV ESI,0x1
CALL 0x001886ee
MOV RDI,R14
MOV ESI,0x1
CALL 0x001886ee
LAB_001c09c1:
MOV RDX,RSP
MOV RDI,R15
MOV RSI,RBX
CALL 0x001c0cb0
LAB_001c09cf:
MOV RBX,RAX
MOV RDI,R14
XOR ESI,ESI
CALL 0x001886ee
MOV RDI,R14
CALL 0x0018ce08
LEA RDI,[RSP + 0x38]
CALL 0x00174104
LEA RDI,[RSP + 0x28]
CALL 0x00174104
LEA R14,[RSP + 0x18]
MOV RDI,R14
CALL 0x00174104
MOV RDI,qword ptr [R14 + -0x10]
TEST RDI,RDI
JZ 0x001c0a3a
MOV RAX,qword ptr [0x00265f90]
CMP byte ptr [RAX],0x0
JZ 0x001c0a25
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x001c0a2f
LAB_001c0a25:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_001c0a2f:
CMP EAX,0x1
JNZ 0x001c0a3a
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_001c0a3a:
ADD RBX,0x10
MOV RAX,RBX
ADD RSP,0x50
POP RBX
POP R14
POP R15
RET
|
long _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEEixIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OST_
(int8 param_1,int8 param_2)
{
int *piVar1;
int iVar2;
long lVar3;
bool bVar4;
int8 local_68;
long *plStack_60;
int8 local_58;
int8 uStack_50;
int8 local_48;
int8 uStack_40;
int8 local_38;
int8 uStack_30;
data local_28 [8];
int8 local_20;
local_20 = 0;
local_68 = 0;
plStack_60 = (long *)0x0;
local_58 = 0;
uStack_50 = 0;
local_48 = 0;
uStack_40 = 0;
local_38 = 0;
uStack_30 = 0;
local_28[0] = (data)0x0;
bVar4 = SUB81(local_28,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>
::assert_invariant(bVar4);
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(bVar4);
/* try { // try from 001c09c1 to 001c09ce has its CatchHandler @ 001c0a4b */
lVar3 = _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE7emplaceIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEESI_IN9__gnu_cxx17__normal_iteratorIPSK_S3_ISK_SL_EEEbEOST_OSF_
(param_1,param_2,&local_68);
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(bVar4);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_28);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&uStack_30);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&uStack_40);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&uStack_50);
if (plStack_60 != (long *)0x0) {
if (*PTR___libc_single_threaded_00265f90 == '\0') {
LOCK();
piVar1 = (int *)((long)plStack_60 + 0xc);
iVar2 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar2 = *(int *)((long)plStack_60 + 0xc);
*(int *)((long)plStack_60 + 0xc) = iVar2 + -1;
}
if (iVar2 == 1) {
(**(code **)(*plStack_60 + 0x18))();
}
}
return lVar3 + 0x10;
}
| |
27,851 | flux::parser::OpExpr::clone() const | kvthweatt[P]FluxLang/src/parser/ast.cpp | std::unique_ptr<Expr> OpExpr::clone() const {
return std::make_unique<OpExpr>(
left->clone(),
operatorName,
right->clone(),
range);
} | O0 | cpp | flux::parser::OpExpr::clone() const:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x28, %rdi
callq 0x1d600
movq %rax, %rsi
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq -0x20(%rbp), %rdi
callq *%rax
movq -0x48(%rbp), %rdi
movq %rdi, %rax
addq $0x30, %rax
movq %rax, -0x40(%rbp)
addq $0x40, %rdi
callq 0x1d600
movq %rax, %rsi
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq -0x28(%rbp), %rdi
callq *%rax
jmp 0x1d1e6
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %r8
addq $0x8, %r8
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rcx
callq 0x23510
jmp 0x1d205
movq -0x58(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x23620
leaq -0x18(%rbp), %rdi
callq 0x23670
leaq -0x28(%rbp), %rdi
callq 0x1d6d0
leaq -0x20(%rbp), %rdi
callq 0x1d6d0
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x1d25a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1d6d0
leaq -0x20(%rbp), %rdi
callq 0x1d6d0
movq -0x30(%rbp), %rdi
callq 0x75a0
nopl (%rax)
| _ZNK4flux6parser6OpExpr5cloneEv:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_58], rdi
mov rax, rdi
mov [rbp+var_50], rax
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rdi, [rbp+var_10]
mov [rbp+var_48], rdi
add rdi, 28h ; '('
call _ZNKSt10unique_ptrIN4flux6parser4ExprESt14default_deleteIS2_EEptEv; std::unique_ptr<flux::parser::Expr>::operator->(void)
mov rsi, rax
mov rax, [rsi]
mov rax, [rax+18h]
lea rdi, [rbp+var_20]
call rax
mov rdi, [rbp+var_48]
mov rax, rdi
add rax, 30h ; '0'
mov [rbp+var_40], rax
add rdi, 40h ; '@'
call _ZNKSt10unique_ptrIN4flux6parser4ExprESt14default_deleteIS2_EEptEv; std::unique_ptr<flux::parser::Expr>::operator->(void)
mov rsi, rax
mov rax, [rsi]
mov rax, [rax+18h]
lea rdi, [rbp+var_28]
call rax
jmp short $+2
loc_1D1E6:
mov rdx, [rbp+var_40]
mov r8, [rbp+var_48]
add r8, 8
lea rdi, [rbp+var_18]
lea rsi, [rbp+var_20]
lea rcx, [rbp+var_28]
call _ZSt11make_uniqueIN4flux6parser6OpExprEJSt10unique_ptrINS1_4ExprESt14default_deleteIS4_EERKSt17basic_string_viewIcSt11char_traitsIcEES7_RKNS0_6common11SourceRangeEEENSt9_MakeUniqIT_E15__single_objectEDpOT0_; std::make_unique<flux::parser::OpExpr,std::unique_ptr<flux::parser::Expr>,std::string_view const&,std::unique_ptr<flux::parser::Expr>,flux::common::SourceRange const&>(std::unique_ptr<flux::parser::Expr>,std::string_view const&,std::unique_ptr<flux::parser::Expr>,flux::common::SourceRange const&)
jmp short $+2
loc_1D205:
mov rdi, [rbp+var_58]
lea rsi, [rbp+var_18]
call _ZNSt10unique_ptrIN4flux6parser4ExprESt14default_deleteIS2_EEC2INS1_6OpExprES3_IS7_EvEEOS_IT_T0_E; std::unique_ptr<flux::parser::Expr>::unique_ptr<flux::parser::OpExpr,std::default_delete<flux::parser::OpExpr>,void>(std::unique_ptr&&<flux::parser::OpExpr,std::default_delete<flux::parser::OpExpr>>)
lea rdi, [rbp+var_18]
call _ZNSt10unique_ptrIN4flux6parser6OpExprESt14default_deleteIS2_EED2Ev; std::unique_ptr<flux::parser::OpExpr>::~unique_ptr()
lea rdi, [rbp+var_28]
call _ZNSt10unique_ptrIN4flux6parser4ExprESt14default_deleteIS2_EED2Ev; std::unique_ptr<flux::parser::Expr>::~unique_ptr()
lea rdi, [rbp+var_20]
call _ZNSt10unique_ptrIN4flux6parser4ExprESt14default_deleteIS2_EED2Ev; std::unique_ptr<flux::parser::Expr>::~unique_ptr()
mov rax, [rbp+var_50]
add rsp, 60h
pop rbp
retn
mov rcx, rax
mov eax, edx
mov [rbp+var_30], rcx
mov [rbp+var_34], eax
jmp short loc_1D25A
mov rcx, rax
mov eax, edx
mov [rbp+var_30], rcx
mov [rbp+var_34], eax
lea rdi, [rbp+var_28]
call _ZNSt10unique_ptrIN4flux6parser4ExprESt14default_deleteIS2_EED2Ev; std::unique_ptr<flux::parser::Expr>::~unique_ptr()
loc_1D25A:
lea rdi, [rbp+var_20]
call _ZNSt10unique_ptrIN4flux6parser4ExprESt14default_deleteIS2_EED2Ev; std::unique_ptr<flux::parser::Expr>::~unique_ptr()
mov rdi, [rbp+var_30]
call __Unwind_Resume
| flux::parser::OpExpr * flux::parser::OpExpr::clone(flux::parser::OpExpr *this, long long a2)
{
long long v2; // rax
long long v3; // rsi
long long v6; // [rsp+20h] [rbp-40h]
_BYTE v7[8]; // [rsp+38h] [rbp-28h] BYREF
_BYTE v8[8]; // [rsp+40h] [rbp-20h] BYREF
_BYTE v9[8]; // [rsp+48h] [rbp-18h] BYREF
long long v10; // [rsp+50h] [rbp-10h]
flux::parser::OpExpr *v11; // [rsp+58h] [rbp-8h]
v11 = this;
v10 = a2;
v2 = std::unique_ptr<flux::parser::Expr>::operator->(a2 + 40);
(*(void ( **)(_BYTE *))(*(_QWORD *)v2 + 24LL))(v8);
v6 = a2 + 48;
v3 = std::unique_ptr<flux::parser::Expr>::operator->(a2 + 64);
(*(void ( **)(_BYTE *))(*(_QWORD *)v3 + 24LL))(v7);
std::make_unique<flux::parser::OpExpr,std::unique_ptr<flux::parser::Expr>,std::string_view const&,std::unique_ptr<flux::parser::Expr>,flux::common::SourceRange const&>(
v9,
v8,
v6,
v7,
a2 + 8);
std::unique_ptr<flux::parser::Expr>::unique_ptr<flux::parser::OpExpr,std::default_delete<flux::parser::OpExpr>,void>(
this,
v9);
std::unique_ptr<flux::parser::OpExpr>::~unique_ptr(v9);
std::unique_ptr<flux::parser::Expr>::~unique_ptr(v7);
std::unique_ptr<flux::parser::Expr>::~unique_ptr(v8);
return this;
}
| clone:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x58],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0x50],RAX
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RDI,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x48],RDI
ADD RDI,0x28
CALL 0x0011d600
MOV RSI,RAX
MOV RAX,qword ptr [RSI]
MOV RAX,qword ptr [RAX + 0x18]
LEA RDI,[RBP + -0x20]
CALL RAX
MOV RDI,qword ptr [RBP + -0x48]
MOV RAX,RDI
ADD RAX,0x30
MOV qword ptr [RBP + -0x40],RAX
ADD RDI,0x40
CALL 0x0011d600
MOV RSI,RAX
MOV RAX,qword ptr [RSI]
MOV RAX,qword ptr [RAX + 0x18]
LAB_0011d1de:
LEA RDI,[RBP + -0x28]
CALL RAX
JMP 0x0011d1e6
LAB_0011d1e6:
MOV RDX,qword ptr [RBP + -0x40]
MOV R8,qword ptr [RBP + -0x48]
ADD R8,0x8
LAB_0011d1f2:
LEA RDI,[RBP + -0x18]
LEA RSI,[RBP + -0x20]
LEA RCX,[RBP + -0x28]
CALL 0x00123510
LAB_0011d203:
JMP 0x0011d205
LAB_0011d205:
MOV RDI,qword ptr [RBP + -0x58]
LEA RSI,[RBP + -0x18]
CALL 0x00123620
LEA RDI,[RBP + -0x18]
CALL 0x00123670
LEA RDI,[RBP + -0x28]
CALL 0x0011d6d0
LEA RDI,[RBP + -0x20]
CALL 0x0011d6d0
MOV RAX,qword ptr [RBP + -0x50]
ADD RSP,0x60
POP RBP
RET
|
/* flux::parser::OpExpr::clone() const */
unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>> *
flux::parser::OpExpr::clone(void)
{
long *plVar1;
long in_RSI;
unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>> *in_RDI;
SourceRange local_30 [8];
unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>> local_28 [8];
unique_ptr local_20 [24];
plVar1 = (long *)std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>::
operator->((unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>
*)(in_RSI + 0x28));
(**(code **)(*plVar1 + 0x18))(local_28);
plVar1 = (long *)std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>::
operator->((unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>
*)(in_RSI + 0x40));
/* try { // try from 0011d1de to 0011d1e3 has its CatchHandler @ 0011d237 */
(**(code **)(*plVar1 + 0x18))(local_30);
/* try { // try from 0011d1f2 to 0011d202 has its CatchHandler @ 0011d245 */
std::
make_unique<flux::parser::OpExpr,std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>,std::basic_string_view<char,std::char_traits<char>>const&,std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>,flux::common::SourceRange_const&>
(local_20,local_28,(unique_ptr *)(in_RSI + 0x30),local_30);
std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>::
unique_ptr<flux::parser::OpExpr,std::default_delete<flux::parser::OpExpr>,void>(in_RDI,local_20);
std::unique_ptr<flux::parser::OpExpr,std::default_delete<flux::parser::OpExpr>>::~unique_ptr
((unique_ptr<flux::parser::OpExpr,std::default_delete<flux::parser::OpExpr>> *)local_20)
;
std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>::~unique_ptr
((unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>> *)local_30);
std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>::~unique_ptr(local_28)
;
return in_RDI;
}
| |
27,852 | flux::parser::OpExpr::clone() const | kvthweatt[P]FluxLang/src/parser/ast.cpp | std::unique_ptr<Expr> OpExpr::clone() const {
return std::make_unique<OpExpr>(
left->clone(),
operatorName,
right->clone(),
range);
} | O1 | cpp | flux::parser::OpExpr::clone() const:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rsi), %rsi
movq (%rsi), %rax
leaq 0x10(%rsp), %rdi
callq *0x18(%rax)
movq 0x40(%r14), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x18(%rax)
movl $0x48, %edi
callq 0x6270
movq 0x10(%rsp), %rcx
xorl %edx, %edx
movq %rdx, 0x10(%rsp)
movups 0x30(%r14), %xmm0
movq 0x8(%rsp), %rsi
movq %rdx, 0x8(%rsp)
leaq 0x2a85f(%rip), %rdx # 0x3ac60
movq %rdx, (%rax)
movups 0x8(%r14), %xmm1
movups 0x18(%r14), %xmm2
movups %xmm1, 0x8(%rax)
movups %xmm2, 0x18(%rax)
leaq 0x29ad3(%rip), %rdx # 0x39ef0
movq %rdx, (%rax)
movq %rcx, 0x28(%rax)
movups %xmm0, 0x30(%rax)
movq %rsi, 0x40(%rax)
movq %rax, (%rbx)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1043f
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1044f
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1046d
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
jmp 0x1047b
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1048b
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x6440
nop
| _ZNK4flux6parser6OpExpr5cloneEv:
push r14
push rbx
sub rsp, 18h
mov r14, rsi
mov rbx, rdi
mov rsi, [rsi+28h]
mov rax, [rsi]
lea rdi, [rsp+28h+var_18]
call qword ptr [rax+18h]
mov rsi, [r14+40h]
mov rax, [rsi]
lea rdi, [rsp+28h+var_20]
call qword ptr [rax+18h]
mov edi, 48h ; 'H'; unsigned __int64
call __Znwm; operator new(ulong)
mov rcx, [rsp+28h+var_18]
xor edx, edx
mov [rsp+28h+var_18], rdx
movups xmm0, xmmword ptr [r14+30h]
mov rsi, [rsp+28h+var_20]
mov [rsp+28h+var_20], rdx
lea rdx, off_3AC60
mov [rax], rdx
movups xmm1, xmmword ptr [r14+8]
movups xmm2, xmmword ptr [r14+18h]
movups xmmword ptr [rax+8], xmm1
movups xmmword ptr [rax+18h], xmm2
lea rdx, off_39EF0
mov [rax], rdx
mov [rax+28h], rcx
movups xmmword ptr [rax+30h], xmm0
mov [rax+40h], rsi
mov [rbx], rax
mov rdi, [rsp+28h+var_20]
test rdi, rdi
jz short loc_1043F
mov rax, [rdi]
call qword ptr [rax+8]
loc_1043F:
mov rdi, [rsp+28h+var_18]
test rdi, rdi
jz short loc_1044F
mov rax, [rdi]
call qword ptr [rax+8]
loc_1044F:
mov rax, rbx
add rsp, 18h
pop rbx
pop r14
retn
mov rbx, rax
mov rdi, [rsp+arg_0]
test rdi, rdi
jz short loc_1046D
mov rax, [rdi]
call qword ptr [rax+8]
loc_1046D:
mov [rsp+arg_0], 0
jmp short loc_1047B
mov rbx, rax
loc_1047B:
mov rdi, [rsp+arg_8]
test rdi, rdi
jz short loc_1048B
mov rax, [rdi]
call qword ptr [rax+8]
loc_1048B:
mov rdi, rbx
call __Unwind_Resume
| flux::parser::OpExpr * flux::parser::OpExpr::clone(flux::parser::OpExpr *this, long long a2)
{
long long v3; // rax
long long v4; // rcx
__int128 v5; // xmm0
long long v6; // rsi
__int128 v7; // xmm2
long long v9; // [rsp+8h] [rbp-20h] BYREF
_QWORD v10[3]; // [rsp+10h] [rbp-18h] BYREF
(*(void ( **)(_QWORD *))(**(_QWORD **)(a2 + 40) + 24LL))(v10);
(*(void ( **)(long long *))(**(_QWORD **)(a2 + 64) + 24LL))(&v9);
v3 = operator new(0x48uLL);
v4 = v10[0];
v10[0] = 0LL;
v5 = *(_OWORD *)(a2 + 48);
v6 = v9;
v9 = 0LL;
*(_QWORD *)v3 = &off_3AC60;
v7 = *(_OWORD *)(a2 + 24);
*(_OWORD *)(v3 + 8) = *(_OWORD *)(a2 + 8);
*(_OWORD *)(v3 + 24) = v7;
*(_QWORD *)v3 = off_39EF0;
*(_QWORD *)(v3 + 40) = v4;
*(_OWORD *)(v3 + 48) = v5;
*(_QWORD *)(v3 + 64) = v6;
*(_QWORD *)this = v3;
if ( v9 )
(*(void ( **)(long long))(*(_QWORD *)v9 + 8LL))(v9);
if ( v10[0] )
(*(void ( **)(_QWORD))(*(_QWORD *)v10[0] + 8LL))(v10[0]);
return this;
}
| clone:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV R14,RSI
MOV RBX,RDI
MOV RSI,qword ptr [RSI + 0x28]
MOV RAX,qword ptr [RSI]
LEA RDI,[RSP + 0x10]
CALL qword ptr [RAX + 0x18]
MOV RSI,qword ptr [R14 + 0x40]
MOV RAX,qword ptr [RSI]
LAB_001103cd:
LEA RDI,[RSP + 0x8]
CALL qword ptr [RAX + 0x18]
LAB_001103d5:
MOV EDI,0x48
CALL 0x00106270
LAB_001103df:
MOV RCX,qword ptr [RSP + 0x10]
XOR EDX,EDX
MOV qword ptr [RSP + 0x10],RDX
MOVUPS XMM0,xmmword ptr [R14 + 0x30]
MOV RSI,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x8],RDX
LEA RDX,[0x13ac60]
MOV qword ptr [RAX],RDX
MOVUPS XMM1,xmmword ptr [R14 + 0x8]
MOVUPS XMM2,xmmword ptr [R14 + 0x18]
MOVUPS xmmword ptr [RAX + 0x8],XMM1
MOVUPS xmmword ptr [RAX + 0x18],XMM2
LEA RDX,[0x139ef0]
MOV qword ptr [RAX],RDX
MOV qword ptr [RAX + 0x28],RCX
MOVUPS xmmword ptr [RAX + 0x30],XMM0
MOV qword ptr [RAX + 0x40],RSI
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x0011043f
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0011043f:
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x0011044f
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0011044f:
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R14
RET
|
/* WARNING: Removing unreachable block (ram,0x00110439) */
/* WARNING: Removing unreachable block (ram,0x00110449) */
/* flux::parser::OpExpr::clone() const */
void flux::parser::OpExpr::clone(void)
{
int4 uVar1;
int4 uVar2;
int4 uVar3;
int4 uVar4;
int4 uVar5;
int4 uVar6;
int4 uVar7;
int4 uVar8;
int4 uVar9;
int4 uVar10;
int4 uVar11;
int8 *puVar12;
long in_RSI;
int8 *in_RDI;
int8 local_20;
int8 local_18;
(**(code **)(**(long **)(in_RSI + 0x28) + 0x18))(&local_18);
/* try { // try from 001103cd to 001103d4 has its CatchHandler @ 00110478 */
(**(code **)(**(long **)(in_RSI + 0x40) + 0x18))(&local_20);
/* try { // try from 001103d5 to 001103de has its CatchHandler @ 0011045a */
puVar12 = (int8 *)operator_new(0x48);
uVar1 = *(int4 *)(in_RSI + 0x30);
uVar2 = *(int4 *)(in_RSI + 0x34);
uVar3 = *(int4 *)(in_RSI + 0x38);
uVar4 = *(int4 *)(in_RSI + 0x3c);
*puVar12 = &PTR__Expr_0013ac60;
uVar5 = *(int4 *)(in_RSI + 0xc);
uVar6 = *(int4 *)(in_RSI + 0x10);
uVar7 = *(int4 *)(in_RSI + 0x14);
uVar8 = *(int4 *)(in_RSI + 0x18);
uVar9 = *(int4 *)(in_RSI + 0x1c);
uVar10 = *(int4 *)(in_RSI + 0x20);
uVar11 = *(int4 *)(in_RSI + 0x24);
*(int4 *)(puVar12 + 1) = *(int4 *)(in_RSI + 8);
*(int4 *)((long)puVar12 + 0xc) = uVar5;
*(int4 *)(puVar12 + 2) = uVar6;
*(int4 *)((long)puVar12 + 0x14) = uVar7;
*(int4 *)(puVar12 + 3) = uVar8;
*(int4 *)((long)puVar12 + 0x1c) = uVar9;
*(int4 *)(puVar12 + 4) = uVar10;
*(int4 *)((long)puVar12 + 0x24) = uVar11;
*puVar12 = &PTR__OpExpr_00139ef0;
puVar12[5] = local_18;
*(int4 *)(puVar12 + 6) = uVar1;
*(int4 *)((long)puVar12 + 0x34) = uVar2;
*(int4 *)(puVar12 + 7) = uVar3;
*(int4 *)((long)puVar12 + 0x3c) = uVar4;
puVar12[8] = local_20;
*in_RDI = puVar12;
return;
}
| |
27,853 | copy_not_changed_fields | eloqsql/storage/maria/ma_blockrec.c | void copy_not_changed_fields(MARIA_HA *info, MY_BITMAP *changed_fields,
uchar *to, uchar *from)
{
MARIA_COLUMNDEF *column, *end_column;
uchar *bitmap= (uchar*) changed_fields->bitmap;
MARIA_SHARE *share= info->s;
uint bit= 1;
for (column= share->columndef, end_column= column+ share->base.fields;
column < end_column; column++)
{
if (!(*bitmap & bit))
{
uint field_length= column->length;
if (column->type == FIELD_VARCHAR)
{
if (column->fill_length == 1)
field_length= (uint) from[column->offset] + 1;
else
field_length= uint2korr(from + column->offset) + 2;
}
memcpy(to + column->offset, from + column->offset, field_length);
}
if ((bit= (bit << 1)) == 256)
{
bitmap++;
bit= 1;
}
}
} | O3 | c | copy_not_changed_fields:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, -0x30(%rbp)
movq (%rdi), %rax
movl 0x3c8(%rax), %ecx
testq %rcx, %rcx
je 0x4d56d
movq 0x588(%rax), %r15
imulq $0x38, %rcx, %r12
addq %r15, %r12
movq (%rsi), %r13
movl $0x1, %ecx
movl $0x1, %r14d
movzbl (%r13), %eax
testl %eax, %r14d
jne 0x4d54e
movl 0x4(%r15), %esi
cmpl $0x8, (%r15)
jne 0x4d52a
cmpw $0x1, 0xc(%r15)
jne 0x4d531
movzbl (%rbx,%rsi), %edx
incq %rdx
jmp 0x4d539
movzwl 0x8(%r15), %edx
jmp 0x4d539
movzwl (%rbx,%rsi), %edx
addq $0x2, %rdx
movq -0x30(%rbp), %rax
leaq (%rax,%rsi), %rdi
addq %rbx, %rsi
callq 0x2a0a0
movl $0x1, %ecx
addl %r14d, %r14d
xorl %eax, %eax
cmpl $0x100, %r14d # imm = 0x100
cmovel %ecx, %r14d
sete %al
addq %rax, %r13
addq $0x38, %r15
cmpq %r12, %r15
jb 0x4d505
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| copy_not_changed_fields:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rcx
mov [rbp+var_30], rdx
mov rax, [rdi]
mov ecx, [rax+3C8h]
test rcx, rcx
jz loc_4D56D
mov r15, [rax+588h]
imul r12, rcx, 38h ; '8'
add r12, r15
mov r13, [rsi]
mov ecx, 1
mov r14d, 1
loc_4D505:
movzx eax, byte ptr [r13+0]
test r14d, eax
jnz short loc_4D54E
mov esi, [r15+4]
cmp dword ptr [r15], 8
jnz short loc_4D52A
cmp word ptr [r15+0Ch], 1
jnz short loc_4D531
movzx edx, byte ptr [rbx+rsi]
inc rdx
jmp short loc_4D539
loc_4D52A:
movzx edx, word ptr [r15+8]
jmp short loc_4D539
loc_4D531:
movzx edx, word ptr [rbx+rsi]
add rdx, 2
loc_4D539:
mov rax, [rbp+var_30]
lea rdi, [rax+rsi]
add rsi, rbx
call _memcpy
mov ecx, 1
loc_4D54E:
add r14d, r14d
xor eax, eax
cmp r14d, 100h
cmovz r14d, ecx
setz al
add r13, rax
add r15, 38h ; '8'
cmp r15, r12
jb short loc_4D505
loc_4D56D:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| char copy_not_changed_fields(long long *a1, _BYTE **a2, long long a3, long long a4)
{
long long v5; // rax
unsigned long long v6; // r15
unsigned long long v7; // r12
_BYTE *v8; // r13
int v9; // r14d
long long v10; // rsi
long long v11; // rdx
bool v12; // zf
v5 = *a1;
if ( *(_DWORD *)(*a1 + 968) )
{
v6 = *(_QWORD *)(v5 + 1416);
v7 = v6 + 56LL * *(unsigned int *)(*a1 + 968);
v8 = *a2;
v9 = 1;
do
{
if ( (*v8 & (unsigned __int8)v9) == 0 )
{
v10 = *(unsigned int *)(v6 + 4);
if ( *(_DWORD *)v6 == 8 )
{
if ( *(_WORD *)(v6 + 12) == 1 )
v11 = *(unsigned __int8 *)(a4 + v10) + 1LL;
else
v11 = *(unsigned __int16 *)(a4 + v10) + 2LL;
}
else
{
v11 = *(unsigned __int16 *)(v6 + 8);
}
memcpy(a3 + v10, a4 + v10, v11);
}
v9 *= 2;
v5 = 0LL;
v12 = v9 == 256;
if ( v9 == 256 )
v9 = 1;
LOBYTE(v5) = v12;
v8 += v5;
v6 += 56LL;
}
while ( v6 < v7 );
}
return v5;
}
| copy_not_changed_fields:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV qword ptr [RBP + -0x30],RDX
MOV RAX,qword ptr [RDI]
MOV ECX,dword ptr [RAX + 0x3c8]
TEST RCX,RCX
JZ 0x0014d56d
MOV R15,qword ptr [RAX + 0x588]
IMUL R12,RCX,0x38
ADD R12,R15
MOV R13,qword ptr [RSI]
MOV ECX,0x1
MOV R14D,0x1
LAB_0014d505:
MOVZX EAX,byte ptr [R13]
TEST R14D,EAX
JNZ 0x0014d54e
MOV ESI,dword ptr [R15 + 0x4]
CMP dword ptr [R15],0x8
JNZ 0x0014d52a
CMP word ptr [R15 + 0xc],0x1
JNZ 0x0014d531
MOVZX EDX,byte ptr [RBX + RSI*0x1]
INC RDX
JMP 0x0014d539
LAB_0014d52a:
MOVZX EDX,word ptr [R15 + 0x8]
JMP 0x0014d539
LAB_0014d531:
MOVZX EDX,word ptr [RBX + RSI*0x1]
ADD RDX,0x2
LAB_0014d539:
MOV RAX,qword ptr [RBP + -0x30]
LEA RDI,[RAX + RSI*0x1]
ADD RSI,RBX
CALL 0x0012a0a0
MOV ECX,0x1
LAB_0014d54e:
ADD R14D,R14D
XOR EAX,EAX
CMP R14D,0x100
CMOVZ R14D,ECX
SETZ AL
ADD R13,RAX
ADD R15,0x38
CMP R15,R12
JC 0x0014d505
LAB_0014d56d:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void copy_not_changed_fields(long *param_1,int8 *param_2,long param_3,long param_4)
{
ulong uVar1;
size_t __n;
int *piVar2;
byte *pbVar3;
uint uVar4;
int *piVar5;
bool bVar6;
uVar1 = (ulong)*(uint *)(*param_1 + 0x3c8);
if (uVar1 != 0) {
piVar5 = *(int **)(*param_1 + 0x588);
piVar2 = piVar5 + uVar1 * 0xe;
pbVar3 = (byte *)*param_2;
uVar4 = 1;
do {
if ((uVar4 & *pbVar3) == 0) {
uVar1 = (ulong)(uint)piVar5[1];
if (*piVar5 == 8) {
if ((short)piVar5[3] == 1) {
__n = (ulong)*(byte *)(param_4 + uVar1) + 1;
}
else {
__n = (ulong)*(ushort *)(param_4 + uVar1) + 2;
}
}
else {
__n = (size_t)*(ushort *)(piVar5 + 2);
}
memcpy((void *)(param_3 + uVar1),(void *)(uVar1 + param_4),__n);
}
uVar4 = uVar4 * 2;
bVar6 = uVar4 == 0x100;
if (bVar6) {
uVar4 = 1;
}
pbVar3 = pbVar3 + bVar6;
piVar5 = piVar5 + 0xe;
} while (piVar5 < piVar2);
}
return;
}
| |
27,854 | mi_check_status | eloqsql/storage/myisam/mi_locking.c | my_bool mi_check_status(void *param)
{
MI_INFO *info=(MI_INFO*) param;
DBUG_ENTER("mi_check_status");
DBUG_PRINT("info",("dellink: %ld r_locks: %u w_locks: %u",
(long) info->s->state.dellink, (uint) info->s->r_locks,
(uint) info->s->w_locks));
/*
The test for w_locks == 1 is here because this thread has already done an
external lock (in other words: w_locks == 1 means no other threads has
a write lock)
*/
DBUG_RETURN((my_bool) !(info->s->state.dellink == HA_OFFSET_ERROR ||
(myisam_concurrent_insert == 2 && info->s->r_locks &&
info->s->w_locks == 1)));
} | O3 | c | mi_check_status:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rcx
cmpq $-0x1, 0x58(%rcx)
je 0x835fb
leaq 0x30f712(%rip), %rdx # 0x392cf0
movb $0x1, %al
cmpq $0x2, (%rdx)
jne 0x835fd
cmpl $0x0, 0x364(%rcx)
je 0x835fd
cmpl $0x1, 0x360(%rcx)
setne %al
jmp 0x835fd
xorl %eax, %eax
popq %rbp
retq
| mi_check_status:
push rbp
mov rbp, rsp
mov rcx, [rdi]
cmp qword ptr [rcx+58h], 0FFFFFFFFFFFFFFFFh
jz short loc_835FB
lea rdx, myisam_concurrent_insert
mov al, 1
cmp qword ptr [rdx], 2
jnz short loc_835FD
cmp dword ptr [rcx+364h], 0
jz short loc_835FD
cmp dword ptr [rcx+360h], 1
setnz al
jmp short loc_835FD
loc_835FB:
xor eax, eax
loc_835FD:
pop rbp
retn
| bool mi_check_status(long long *a1)
{
long long v1; // rcx
bool result; // al
v1 = *a1;
if ( *(_QWORD *)(*a1 + 88) == -1LL )
return 0;
result = 1;
if ( myisam_concurrent_insert == 2LL )
{
if ( *(_DWORD *)(v1 + 868) )
return *(_DWORD *)(v1 + 864) != 1;
}
return result;
}
| mi_check_status:
PUSH RBP
MOV RBP,RSP
MOV RCX,qword ptr [RDI]
CMP qword ptr [RCX + 0x58],-0x1
JZ 0x001835fb
LEA RDX,[0x492cf0]
MOV AL,0x1
CMP qword ptr [RDX],0x2
JNZ 0x001835fd
CMP dword ptr [RCX + 0x364],0x0
JZ 0x001835fd
CMP dword ptr [RCX + 0x360],0x1
SETNZ AL
JMP 0x001835fd
LAB_001835fb:
XOR EAX,EAX
LAB_001835fd:
POP RBP
RET
|
bool mi_check_status(long *param_1)
{
long lVar1;
bool bVar2;
lVar1 = *param_1;
if (*(long *)(lVar1 + 0x58) == -1) {
bVar2 = false;
}
else {
bVar2 = true;
if ((myisam_concurrent_insert == 2) && (*(int *)(lVar1 + 0x364) != 0)) {
bVar2 = *(int *)(lVar1 + 0x360) != 1;
}
}
return bVar2;
}
| |
27,855 | lre_canonicalize | bluesky950520[P]quickjs/libunicode.c | int lre_canonicalize(uint32_t c, BOOL is_unicode)
{
if (c < 128) {
/* fast case */
if (is_unicode) {
if (c >= 'A' && c <= 'Z') {
c = c - 'A' + 'a';
}
} else {
if (c >= 'a' && c <= 'z') {
c = c - 'a' + 'A';
}
}
} else {
uint32_t v, code, len;
int idx, idx_min, idx_max;
idx_min = 0;
idx_max = countof(case_conv_table1) - 1;
while (idx_min <= idx_max) {
idx = (unsigned)(idx_max + idx_min) / 2;
v = case_conv_table1[idx];
code = v >> (32 - 17);
len = (v >> (32 - 17 - 7)) & 0x7f;
if (c < code) {
idx_max = idx - 1;
} else if (c >= code + len) {
idx_min = idx + 1;
} else {
return lre_case_folding_entry(c, idx, v, is_unicode);
}
}
}
return c;
} | O1 | c | lre_canonicalize:
movl %esi, %ecx
cmpl $0x80, %edi
jae 0x977fb
testl %ecx, %ecx
je 0x97846
leal -0x41(%rdi), %eax
movl %edi, %ecx
orl $0x20, %ecx
jmp 0x9784c
xorl %r9d, %r9d
movl $0x179, %r8d # imm = 0x179
leaq 0xa935(%rip), %rax # 0xa2140
leal (%r8,%r9), %esi
shrl %esi
movl (%rax,%rsi,4), %edx
movl %edx, %r10d
shrl $0xf, %r10d
cmpl %edi, %r10d
jbe 0x97827
decl %esi
movl %esi, %r8d
jmp 0x9783f
movl %edx, %r9d
shrl $0x8, %r9d
andl $0x7f, %r9d
addl %r10d, %r9d
cmpl %edi, %r9d
ja 0x97857
incl %esi
movl %esi, %r9d
cmpl %r8d, %r9d
jle 0x9780b
jmp 0x97854
leal -0x61(%rdi), %eax
leal -0x20(%rdi), %ecx
cmpl $0x1a, %eax
cmovael %edi, %ecx
movl %ecx, %edi
movl %edi, %eax
retq
jmp 0x97859
| lre_canonicalize:
mov ecx, esi
cmp edi, 80h
jnb short loc_977FB
test ecx, ecx
jz short loc_97846
lea eax, [rdi-41h]
mov ecx, edi
or ecx, 20h
jmp short loc_9784C
loc_977FB:
xor r9d, r9d
mov r8d, 179h
lea rax, case_conv_table1
loc_9780B:
lea esi, [r8+r9]
shr esi, 1
mov edx, [rax+rsi*4]
mov r10d, edx
shr r10d, 0Fh
cmp r10d, edi
jbe short loc_97827
dec esi
mov r8d, esi
jmp short loc_9783F
loc_97827:
mov r9d, edx
shr r9d, 8
and r9d, 7Fh
add r9d, r10d
cmp r9d, edi
ja short loc_97857
inc esi
mov r9d, esi
loc_9783F:
cmp r9d, r8d
jle short loc_9780B
jmp short loc_97854
loc_97846:
lea eax, [rdi-61h]
lea ecx, [rdi-20h]
loc_9784C:
cmp eax, 1Ah
cmovnb ecx, edi
mov edi, ecx
loc_97854:
mov eax, edi
retn
loc_97857:
jmp short $+2
| long long lre_canonicalize(long long a1, unsigned int a2)
{
long long v2; // rcx
unsigned int v3; // eax
int v4; // ecx
int v5; // r9d
int v6; // r8d
long long v7; // rsi
long long v8; // rdx
unsigned int v9; // r10d
v2 = a2;
if ( (unsigned int)a1 >= 0x80 )
{
v5 = 0;
v6 = 377;
while ( 1 )
{
v7 = (unsigned int)(v6 + v5) >> 1;
v8 = (unsigned int)case_conv_table1[v7];
v9 = case_conv_table1[v7] >> 15;
if ( v9 <= (unsigned int)a1 )
{
if ( v9 + (((unsigned int)v8 >> 8) & 0x7F) > (unsigned int)a1 )
return lre_case_folding_entry(a1, v7, v8, v2);
v5 = v7 + 1;
}
else
{
v6 = v7 - 1;
}
if ( v5 > v6 )
return (unsigned int)a1;
}
}
if ( a2 )
{
v3 = a1 - 65;
v4 = a1 | 0x20;
}
else
{
v3 = a1 - 97;
v4 = a1 - 32;
}
if ( v3 >= 0x1A )
v4 = a1;
LODWORD(a1) = v4;
return (unsigned int)a1;
}
| lre_canonicalize:
MOV ECX,ESI
CMP EDI,0x80
JNC 0x001977fb
TEST ECX,ECX
JZ 0x00197846
LEA EAX,[RDI + -0x41]
MOV ECX,EDI
OR ECX,0x20
JMP 0x0019784c
LAB_001977fb:
XOR R9D,R9D
MOV R8D,0x179
LEA RAX,[0x1a2140]
LAB_0019780b:
LEA ESI,[R8 + R9*0x1]
SHR ESI,0x1
MOV EDX,dword ptr [RAX + RSI*0x4]
MOV R10D,EDX
SHR R10D,0xf
CMP R10D,EDI
JBE 0x00197827
DEC ESI
MOV R8D,ESI
JMP 0x0019783f
LAB_00197827:
MOV R9D,EDX
SHR R9D,0x8
AND R9D,0x7f
ADD R9D,R10D
CMP R9D,EDI
JA 0x00197857
INC ESI
MOV R9D,ESI
LAB_0019783f:
CMP R9D,R8D
JLE 0x0019780b
JMP 0x00197854
LAB_00197846:
LEA EAX,[RDI + -0x61]
LEA ECX,[RDI + -0x20]
LAB_0019784c:
CMP EAX,0x1a
CMOVNC ECX,EDI
MOV EDI,ECX
LAB_00197854:
MOV EAX,EDI
RET
LAB_00197857:
JMP 0x00197859
|
ulong lre_canonicalize(uint param_1,int param_2)
{
uint uVar1;
ulong uVar2;
uint uVar3;
int iVar4;
int iVar5;
if (param_1 < 0x80) {
if (param_2 == 0) {
uVar1 = param_1 - 0x61;
uVar3 = param_1 - 0x20;
}
else {
uVar1 = param_1 - 0x41;
uVar3 = param_1 | 0x20;
}
if (0x19 < uVar1) {
uVar3 = param_1;
}
}
else {
iVar5 = 0;
iVar4 = 0x179;
do {
uVar3 = (uint)(iVar4 + iVar5) >> 1;
uVar1 = (uint)(&case_conv_table1)[uVar3] >> 0xf;
if (param_1 < uVar1) {
iVar4 = uVar3 - 1;
}
else {
if (param_1 < ((uint)(&case_conv_table1)[uVar3] >> 8 & 0x7f) + uVar1) {
uVar2 = lre_case_folding_entry();
return uVar2;
}
iVar5 = uVar3 + 1;
}
uVar3 = param_1;
} while (iVar5 <= iVar4);
}
return (ulong)uVar3;
}
| |
27,856 | lre_canonicalize | bluesky950520[P]quickjs/libunicode.c | int lre_canonicalize(uint32_t c, BOOL is_unicode)
{
if (c < 128) {
/* fast case */
if (is_unicode) {
if (c >= 'A' && c <= 'Z') {
c = c - 'A' + 'a';
}
} else {
if (c >= 'a' && c <= 'z') {
c = c - 'a' + 'A';
}
}
} else {
uint32_t v, code, len;
int idx, idx_min, idx_max;
idx_min = 0;
idx_max = countof(case_conv_table1) - 1;
while (idx_min <= idx_max) {
idx = (unsigned)(idx_max + idx_min) / 2;
v = case_conv_table1[idx];
code = v >> (32 - 17);
len = (v >> (32 - 17 - 7)) & 0x7f;
if (c < code) {
idx_max = idx - 1;
} else if (c >= code + len) {
idx_min = idx + 1;
} else {
return lre_case_folding_entry(c, idx, v, is_unicode);
}
}
}
return c;
} | O3 | c | lre_canonicalize:
movl %esi, %ecx
cmpl $0x80, %edi
jae 0x9a0d6
testl %ecx, %ecx
je 0x9a121
leal -0x41(%rdi), %eax
movl %edi, %ecx
orl $0x20, %ecx
jmp 0x9a127
xorl %r9d, %r9d
movl $0x179, %r8d # imm = 0x179
leaq 0xb00a(%rip), %rax # 0xa50f0
leal (%r8,%r9), %esi
shrl %esi
movl (%rax,%rsi,4), %edx
movl %edx, %r10d
shrl $0xf, %r10d
cmpl %edi, %r10d
jbe 0x9a102
decl %esi
movl %esi, %r8d
jmp 0x9a11a
movl %edx, %r9d
shrl $0x8, %r9d
andl $0x7f, %r9d
addl %r10d, %r9d
cmpl %edi, %r9d
ja 0x9a132
incl %esi
movl %esi, %r9d
cmpl %r8d, %r9d
jle 0x9a0e6
jmp 0x9a12f
leal -0x61(%rdi), %eax
leal -0x20(%rdi), %ecx
cmpl $0x1a, %eax
cmovael %edi, %ecx
movl %ecx, %edi
movl %edi, %eax
retq
jmp 0x9a134
| lre_canonicalize:
mov ecx, esi
cmp edi, 80h
jnb short loc_9A0D6
test ecx, ecx
jz short loc_9A121
lea eax, [rdi-41h]
mov ecx, edi
or ecx, 20h
jmp short loc_9A127
loc_9A0D6:
xor r9d, r9d
mov r8d, 179h
lea rax, case_conv_table1
loc_9A0E6:
lea esi, [r8+r9]
shr esi, 1
mov edx, [rax+rsi*4]
mov r10d, edx
shr r10d, 0Fh
cmp r10d, edi
jbe short loc_9A102
dec esi
mov r8d, esi
jmp short loc_9A11A
loc_9A102:
mov r9d, edx
shr r9d, 8
and r9d, 7Fh
add r9d, r10d
cmp r9d, edi
ja short loc_9A132
inc esi
mov r9d, esi
loc_9A11A:
cmp r9d, r8d
jle short loc_9A0E6
jmp short loc_9A12F
loc_9A121:
lea eax, [rdi-61h]
lea ecx, [rdi-20h]
loc_9A127:
cmp eax, 1Ah
cmovnb ecx, edi
mov edi, ecx
loc_9A12F:
mov eax, edi
retn
loc_9A132:
jmp short $+2
| long long lre_canonicalize(long long a1, unsigned int a2)
{
long long v2; // rcx
unsigned int v3; // eax
int v4; // ecx
int v5; // r9d
int v6; // r8d
long long v7; // rsi
long long v8; // rdx
unsigned int v9; // r10d
v2 = a2;
if ( (unsigned int)a1 >= 0x80 )
{
v5 = 0;
v6 = 377;
while ( 1 )
{
v7 = (unsigned int)(v6 + v5) >> 1;
v8 = (unsigned int)case_conv_table1[v7];
v9 = case_conv_table1[v7] >> 15;
if ( v9 <= (unsigned int)a1 )
{
if ( v9 + (((unsigned int)v8 >> 8) & 0x7F) > (unsigned int)a1 )
return lre_case_folding_entry(a1, v7, v8, v2);
v5 = v7 + 1;
}
else
{
v6 = v7 - 1;
}
if ( v5 > v6 )
return (unsigned int)a1;
}
}
if ( a2 )
{
v3 = a1 - 65;
v4 = a1 | 0x20;
}
else
{
v3 = a1 - 97;
v4 = a1 - 32;
}
if ( v3 >= 0x1A )
v4 = a1;
LODWORD(a1) = v4;
return (unsigned int)a1;
}
| lre_canonicalize:
MOV ECX,ESI
CMP EDI,0x80
JNC 0x0019a0d6
TEST ECX,ECX
JZ 0x0019a121
LEA EAX,[RDI + -0x41]
MOV ECX,EDI
OR ECX,0x20
JMP 0x0019a127
LAB_0019a0d6:
XOR R9D,R9D
MOV R8D,0x179
LEA RAX,[0x1a50f0]
LAB_0019a0e6:
LEA ESI,[R8 + R9*0x1]
SHR ESI,0x1
MOV EDX,dword ptr [RAX + RSI*0x4]
MOV R10D,EDX
SHR R10D,0xf
CMP R10D,EDI
JBE 0x0019a102
DEC ESI
MOV R8D,ESI
JMP 0x0019a11a
LAB_0019a102:
MOV R9D,EDX
SHR R9D,0x8
AND R9D,0x7f
ADD R9D,R10D
CMP R9D,EDI
JA 0x0019a132
INC ESI
MOV R9D,ESI
LAB_0019a11a:
CMP R9D,R8D
JLE 0x0019a0e6
JMP 0x0019a12f
LAB_0019a121:
LEA EAX,[RDI + -0x61]
LEA ECX,[RDI + -0x20]
LAB_0019a127:
CMP EAX,0x1a
CMOVNC ECX,EDI
MOV EDI,ECX
LAB_0019a12f:
MOV EAX,EDI
RET
LAB_0019a132:
JMP 0x0019a134
|
ulong lre_canonicalize(uint param_1,int param_2)
{
uint uVar1;
ulong uVar2;
uint uVar3;
int iVar4;
int iVar5;
if (param_1 < 0x80) {
if (param_2 == 0) {
uVar1 = param_1 - 0x61;
uVar3 = param_1 - 0x20;
}
else {
uVar1 = param_1 - 0x41;
uVar3 = param_1 | 0x20;
}
if (0x19 < uVar1) {
uVar3 = param_1;
}
}
else {
iVar5 = 0;
iVar4 = 0x179;
do {
uVar3 = (uint)(iVar4 + iVar5) >> 1;
uVar1 = (uint)(&case_conv_table1)[uVar3] >> 0xf;
if (param_1 < uVar1) {
iVar4 = uVar3 - 1;
}
else {
if (param_1 < ((uint)(&case_conv_table1)[uVar3] >> 8 & 0x7f) + uVar1) {
uVar2 = lre_case_folding_entry();
return uVar2;
}
iVar5 = uVar3 + 1;
}
uVar3 = param_1;
} while (iVar5 <= iVar4);
}
return (ulong)uVar3;
}
| |
27,857 | minja::Parser::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, minja::Options const&) | monkey531[P]llama/common/minja.hpp | static std::shared_ptr<TemplateNode> parse(const std::string& template_str, const Options & options) {
Parser parser(std::make_shared<std::string>(normalize_newlines(template_str)), options);
auto tokens = parser.tokenize();
TemplateTokenIterator begin = tokens.begin();
auto it = begin;
TemplateTokenIterator end = tokens.end();
return parser.parseTemplate(begin, it, end, /* full= */ true);
} | O2 | cpp | minja::Parser::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, minja::Options const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x27120
movq %rsp, %rdi
movq %r15, %rsi
callq 0x796e0
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
movq %r14, %rdx
callq 0x796fe
leaq 0x8(%rsp), %rdi
callq 0x4dd26
leaq 0x10(%rsp), %rdi
callq 0x27998
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x797a6
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rsi
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0x38(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x30(%rsp), %r8
movq %rsi, (%r8)
leaq 0x40(%rsp), %rsi
pushq $0x1
popq %r9
movq %rbx, %rdi
callq 0x7b546
leaq 0x10(%rsp), %rdi
callq 0x7c466
leaq 0x48(%rsp), %rdi
callq 0x4dd26
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x7c466
jmp 0x78c1e
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x4dd26
jmp 0x78c46
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4dd26
jmp 0x78c3c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x27998
movq %rbx, %rdi
callq 0x27660
| _ZN5minja6Parser5parseERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_7OptionsE:
push r15
push r14
push rbx
sub rsp, 70h
mov r14, rdx
mov rbx, rdi
lea r15, [rsp+88h+var_78]
mov rdi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
mov rdi, rsp
mov rsi, r15
call _ZSt11make_sharedINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJS5_EESt10shared_ptrIT_EDpOT0_; std::make_shared<std::string,std::string>(std::string &&)
lea rdi, [rsp+88h+var_48]
mov rsi, rsp
mov rdx, r14
call _ZN5minja6ParserC2ERKSt10shared_ptrINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEERKNS_7OptionsE; minja::Parser::Parser(std::shared_ptr<std::string> const&,minja::Options const&)
lea rdi, [rsp+88h+var_80]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+88h+var_78]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+88h+var_78]; this
lea rsi, [rsp+88h+var_48]
call _ZN5minja6Parser8tokenizeEv; minja::Parser::tokenize(void)
mov rax, [rsp+88h+var_78]
mov rsi, [rsp+88h+var_70]
mov rdx, rsp
mov [rdx], rax
lea rcx, [rsp+88h+var_50]
mov [rcx], rax
lea r8, [rsp+88h+var_58]
mov [r8], rsi
lea rsi, [rsp+88h+var_48]
push 1
pop r9
mov rdi, rbx
call _ZNK5minja6Parser13parseTemplateERKN9__gnu_cxx17__normal_iteratorIPKSt10unique_ptrINS_13TemplateTokenESt14default_deleteIS4_EESt6vectorIS7_SaIS7_EEEERSD_SF_b; minja::Parser::parseTemplate(__gnu_cxx::__normal_iterator<std::unique_ptr<minja::TemplateToken> const*,std::vector<std::unique_ptr<minja::TemplateToken>>> const&,__gnu_cxx::__normal_iterator<std::unique_ptr<minja::TemplateToken> const*,std::vector<std::unique_ptr<minja::TemplateToken>>>&,__gnu_cxx::__normal_iterator<std::unique_ptr<minja::TemplateToken> const*,std::vector<std::unique_ptr<minja::TemplateToken>>> const&,bool)
lea rdi, [rsp+88h+var_78]
call _ZNSt6vectorISt10unique_ptrIN5minja13TemplateTokenESt14default_deleteIS2_EESaIS5_EED2Ev; std::vector<std::unique_ptr<minja::TemplateToken>>::~vector()
lea rdi, [rsp+88h+var_40]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rax, rbx
add rsp, 70h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+arg_8]
call _ZNSt6vectorISt10unique_ptrIN5minja13TemplateTokenESt14default_deleteIS2_EESaIS5_EED2Ev; std::vector<std::unique_ptr<minja::TemplateToken>>::~vector()
jmp short loc_78C1E
mov rbx, rax
loc_78C1E:
lea rdi, [rsp+arg_40]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp short loc_78C46
mov rbx, rax
lea rdi, [rsp+arg_0]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp short loc_78C3C
mov rbx, rax
loc_78C3C:
lea rdi, [rsp+arg_8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_78C46:
mov rdi, rbx
call __Unwind_Resume
| long long minja::Parser::parse(long long a1, long long a2, long long a3)
{
long long v5; // [rsp+0h] [rbp-88h] BYREF
long long v6; // [rsp+8h] [rbp-80h] BYREF
_QWORD v7[4]; // [rsp+10h] [rbp-78h] BYREF
long long v8; // [rsp+30h] [rbp-58h] BYREF
long long v9; // [rsp+38h] [rbp-50h] BYREF
_BYTE v10[8]; // [rsp+40h] [rbp-48h] BYREF
_QWORD v11[8]; // [rsp+48h] [rbp-40h] BYREF
std::string::basic_string(v7, a2);
std::make_shared<std::string,std::string>(&v5, v7);
minja::Parser::Parser(v10, &v5, a3);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v6);
std::string::~string(v7);
minja::Parser::tokenize((minja::Parser *)v7);
v5 = v7[0];
v9 = v7[0];
v8 = v7[1];
((void ( *)(long long, _BYTE *, long long *, long long *, long long *, long long))minja::Parser::parseTemplate)(
a1,
v10,
&v5,
&v9,
&v8,
1LL);
std::vector<std::unique_ptr<minja::TemplateToken>>::~vector(v7);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(v11);
return a1;
}
| parse:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x70
MOV R14,RDX
MOV RBX,RDI
LEA R15,[RSP + 0x10]
MOV RDI,R15
CALL 0x00127120
LAB_00178b7c:
MOV RDI,RSP
MOV RSI,R15
CALL 0x001796e0
LAB_00178b87:
LEA RDI,[RSP + 0x40]
MOV RSI,RSP
MOV RDX,R14
CALL 0x001796fe
LEA RDI,[RSP + 0x8]
CALL 0x0014dd26
LEA RDI,[RSP + 0x10]
CALL 0x00127998
LAB_00178bab:
LEA RDI,[RSP + 0x10]
LEA RSI,[RSP + 0x40]
CALL 0x001797a6
MOV RAX,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x18]
MOV RDX,RSP
MOV qword ptr [RDX],RAX
LEA RCX,[RSP + 0x38]
MOV qword ptr [RCX],RAX
LEA R8,[RSP + 0x30]
MOV qword ptr [R8],RSI
LAB_00178bda:
LEA RSI,[RSP + 0x40]
PUSH 0x1
POP R9
MOV RDI,RBX
CALL 0x0017b546
LAB_00178beb:
LEA RDI,[RSP + 0x10]
CALL 0x0017c466
LEA RDI,[RSP + 0x48]
CALL 0x0014dd26
MOV RAX,RBX
ADD RSP,0x70
POP RBX
POP R14
POP R15
RET
|
/* minja::Parser::parse(std::__cxx11::string const&, minja::Options const&) */
Parser * __thiscall minja::Parser::parse(Parser *this,string *param_1,Options *param_2)
{
int8 local_88;
__shared_count<(__gnu_cxx::_Lock_policy)2> local_80 [8];
int8 local_78;
int8 local_70;
int8 local_58;
int8 local_50;
Parser local_48 [8];
__shared_count<(__gnu_cxx::_Lock_policy)2> local_40 [40];
std::__cxx11::string::string((string *)&local_78,param_1);
/* try { // try from 00178b7c to 00178b86 has its CatchHandler @ 00178c39 */
std::make_shared<std::__cxx11::string,std::__cxx11::string>((string *)&local_88);
/* try { // try from 00178b87 to 00178b96 has its CatchHandler @ 00178c2a */
Parser(local_48,(shared_ptr *)&local_88,param_2);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_80);
std::__cxx11::string::~string((string *)&local_78);
/* try { // try from 00178bab to 00178bb9 has its CatchHandler @ 00178c1b */
tokenize();
local_88 = local_78;
local_50 = local_78;
local_58 = local_70;
/* try { // try from 00178bda to 00178bea has its CatchHandler @ 00178c0c */
parseTemplate(this,local_48,(__normal_iterator *)&local_88,SUB81(&local_50,0));
std::
vector<std::unique_ptr<minja::TemplateToken,std::default_delete<minja::TemplateToken>>,std::allocator<std::unique_ptr<minja::TemplateToken,std::default_delete<minja::TemplateToken>>>>
::~vector((vector<std::unique_ptr<minja::TemplateToken,std::default_delete<minja::TemplateToken>>,std::allocator<std::unique_ptr<minja::TemplateToken,std::default_delete<minja::TemplateToken>>>>
*)&local_78);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_40);
return this;
}
| |
27,858 | ma_seq_search | eloqsql/storage/maria/ma_search.c | int _ma_seq_search(const MARIA_KEY *key, const MARIA_PAGE *ma_page,
uint32 comp_flag, uchar **ret_pos,
uchar *buff, my_bool *last_key)
{
int UNINIT_VAR(flag);
uint page_flag, nod_flag, UNINIT_VAR(length), not_used[2];
uchar t_buff[MARIA_MAX_KEY_BUFF], *end;
uchar *page;
MARIA_KEYDEF *keyinfo= key->keyinfo;
MARIA_SHARE *share= keyinfo->share;
MARIA_KEY tmp_key;
DBUG_ENTER("_ma_seq_search");
page_flag= ma_page->flag;
nod_flag= ma_page->node;
page= ma_page->buff;
end= page + ma_page->size;
page+= share->keypage_header + nod_flag;
*ret_pos= page;
t_buff[0]=0; /* Avoid bugs */
tmp_key.data= t_buff;
tmp_key.keyinfo= keyinfo;
while (page < end)
{
length=(*keyinfo->get_key)(&tmp_key, page_flag, nod_flag, &page);
if (length == 0 || page > end)
{
_ma_set_fatal_error_with_share(share, HA_ERR_CRASHED);
DBUG_PRINT("error",
("Found wrong key: length: %u page: %p end: %p",
length, page, end));
DBUG_RETURN(MARIA_FOUND_WRONG_KEY);
}
if ((flag= ha_key_cmp(keyinfo->seg, t_buff, key->data,
key->data_length + key->ref_length,
comp_flag | tmp_key.flag,
not_used)) >= 0)
break;
DBUG_PRINT("loop_extra",("page:%p key: '%s' flag: %d",
page, t_buff, flag));
memcpy(buff,t_buff,length);
*ret_pos=page;
}
if (flag == 0)
memcpy(buff,t_buff,length); /* Result is first key */
*last_key= page == end;
DBUG_PRINT("exit",("flag: %d ret_pos: %p", flag, *ret_pos));
DBUG_RETURN(flag);
} | O3 | c | ma_seq_search:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa58, %rsp # imm = 0xA58
movq %r9, -0xa48(%rbp)
movq %r8, -0xa38(%rbp)
movl %edx, -0xa24(%rbp)
movq %rdi, %r13
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq 0x8(%rdi), %r14
movq (%r14), %rdx
movl 0x2c(%rsi), %eax
movl %eax, -0xa2c(%rbp)
movl 0x28(%rsi), %edi
movq 0x10(%rsi), %rax
movl 0x20(%rsi), %esi
movq %rsi, %r8
addq %rax, %r8
movq %r8, -0xa20(%rbp)
movq %rdx, -0xa40(%rbp)
movl 0x744(%rdx), %edx
movl %edi, -0xa28(%rbp)
addl %edi, %edx
addq %rdx, %rax
movq %rax, -0xa18(%rbp)
movq %rcx, -0xa50(%rbp)
movq %rax, (%rcx)
leaq -0xa10(%rbp), %rax
movb $0x0, (%rax)
movq %rax, -0xa70(%rbp)
movq %r14, -0xa68(%rbp)
cmpl %esi, %edx
jae 0x5767a
leaq -0xa10(%rbp), %r12
leaq -0xa70(%rbp), %rdi
movl -0xa2c(%rbp), %esi
movl -0xa28(%rbp), %edx
leaq -0xa18(%rbp), %rcx
callq *0xe0(%r14)
testl %eax, %eax
je 0x57648
movl %eax, %r15d
movq -0xa20(%rbp), %rax
cmpq %rax, -0xa18(%rbp)
ja 0x57648
movq 0xc0(%r14), %rdi
movq (%r13), %rdx
movl 0x14(%r13), %ecx
addl 0x10(%r13), %ecx
movl -0xa58(%rbp), %r8d
orl -0xa24(%rbp), %r8d
movq %r12, %rsi
leaq -0xa78(%rbp), %r9
callq 0x9f74e
movl %eax, %ebx
testl %eax, %eax
jns 0x57660
movl %r15d, %edx
movq -0xa38(%rbp), %rdi
movq %r12, %rsi
callq 0x29080
movq -0xa18(%rbp), %rax
movq -0xa50(%rbp), %rcx
movq %rax, (%rcx)
cmpq -0xa20(%rbp), %rax
jb 0x575a8
jmp 0x5767a
movq -0xa40(%rbp), %rdi
movl $0x7e, %esi
callq 0x379ae
movl $0x7fffffff, %ebx # imm = 0x7FFFFFFF
jmp 0x57692
jne 0x5767a
movl %r15d, %edx
leaq -0xa10(%rbp), %rsi
movq -0xa38(%rbp), %rdi
callq 0x29080
xorl %ebx, %ebx
movq -0xa20(%rbp), %rax
cmpq %rax, -0xa18(%rbp)
movq -0xa48(%rbp), %rax
sete (%rax)
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x576b5
movl %ebx, %eax
addq $0xa58, %rsp # imm = 0xA58
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x29270
| _ma_seq_search:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0A58h
mov [rbp+var_A48], r9
mov [rbp+var_A38], r8
mov [rbp+var_A24], edx
mov r13, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov r14, [rdi+8]
mov rdx, [r14]
mov eax, [rsi+2Ch]
mov [rbp+var_A2C], eax
mov edi, [rsi+28h]
mov rax, [rsi+10h]
mov esi, [rsi+20h]
mov r8, rsi
add r8, rax
mov [rbp+var_A20], r8
mov [rbp+var_A40], rdx
mov edx, [rdx+744h]
mov [rbp+var_A28], edi
add edx, edi
add rax, rdx
mov [rbp+var_A18], rax
mov [rbp+var_A50], rcx
mov [rcx], rax
lea rax, [rbp+var_A10]
mov byte ptr [rax], 0
mov [rbp+var_A70], rax
mov [rbp+var_A68], r14
cmp edx, esi
jnb loc_5767A
lea r12, [rbp+var_A10]
loc_575A8:
lea rdi, [rbp+var_A70]
mov esi, [rbp+var_A2C]
mov edx, [rbp+var_A28]
lea rcx, [rbp+var_A18]
call qword ptr [r14+0E0h]
test eax, eax
jz short loc_57648
mov r15d, eax
mov rax, [rbp+var_A20]
cmp [rbp+var_A18], rax
ja short loc_57648
mov rdi, [r14+0C0h]
mov rdx, [r13+0]
mov ecx, [r13+14h]
add ecx, [r13+10h]
mov r8d, [rbp+var_A58]
or r8d, [rbp+var_A24]
mov rsi, r12
lea r9, [rbp+var_A78]
call ha_key_cmp
mov ebx, eax
test eax, eax
jns short loc_57660
mov edx, r15d
mov rdi, [rbp+var_A38]
mov rsi, r12
call _memcpy
mov rax, [rbp+var_A18]
mov rcx, [rbp+var_A50]
mov [rcx], rax
cmp rax, [rbp+var_A20]
jb loc_575A8
jmp short loc_5767A
loc_57648:
mov rdi, [rbp+var_A40]
mov esi, 7Eh ; '~'
call _ma_set_fatal_error_with_share
mov ebx, 7FFFFFFFh
jmp short loc_57692
loc_57660:
jnz short loc_5767A
mov edx, r15d
lea rsi, [rbp+var_A10]
mov rdi, [rbp+var_A38]
call _memcpy
xor ebx, ebx
loc_5767A:
mov rax, [rbp+var_A20]
cmp [rbp+var_A18], rax
mov rax, [rbp+var_A48]
setz byte ptr [rax]
loc_57692:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_576B5
mov eax, ebx
add rsp, 0A58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_576B5:
call ___stack_chk_fail
| long long ma_seq_search(long long a1, long long a2, int a3, unsigned long long *a4, long long a5, bool *a6)
{
unsigned int v6; // ebx
long long v8; // r14
long long v9; // rdx
unsigned int v10; // edi
long long v11; // rax
long long v12; // rsi
long long v13; // rdx
unsigned int v14; // eax
long long v15; // rdx
long long v16; // rcx
long long v17; // r8
int v18; // r9d
unsigned int v19; // r15d
int v20; // eax
unsigned long long v21; // rax
char v23[8]; // [rsp+8h] [rbp-A78h] BYREF
_QWORD v24[3]; // [rsp+10h] [rbp-A70h] BYREF
unsigned int v25; // [rsp+28h] [rbp-A58h]
unsigned long long *v26; // [rsp+30h] [rbp-A50h]
bool *v27; // [rsp+38h] [rbp-A48h]
long long v28; // [rsp+40h] [rbp-A40h]
long long v29; // [rsp+48h] [rbp-A38h]
unsigned int v30; // [rsp+54h] [rbp-A2Ch]
unsigned int v31; // [rsp+58h] [rbp-A28h]
int v32; // [rsp+5Ch] [rbp-A24h]
unsigned long long v33; // [rsp+60h] [rbp-A20h]
unsigned long long v34; // [rsp+68h] [rbp-A18h] BYREF
_BYTE v35[2528]; // [rsp+70h] [rbp-A10h] BYREF
unsigned long long v36; // [rsp+A50h] [rbp-30h]
v27 = a6;
v29 = a5;
v32 = a3;
v36 = __readfsqword(0x28u);
v8 = *(_QWORD *)(a1 + 8);
v9 = *(_QWORD *)v8;
v30 = *(_DWORD *)(a2 + 44);
v10 = *(_DWORD *)(a2 + 40);
v11 = *(_QWORD *)(a2 + 16);
v12 = *(unsigned int *)(a2 + 32);
v33 = v11 + v12;
v28 = v9;
LODWORD(v9) = *(_DWORD *)(v9 + 1860);
v31 = v10;
v13 = v10 + (unsigned int)v9;
v34 = v13 + v11;
v26 = a4;
*a4 = v13 + v11;
v35[0] = 0;
v24[0] = v35;
v24[1] = v8;
if ( (unsigned int)v13 < (unsigned int)v12 )
{
while ( 1 )
{
v14 = (*(long long ( **)(_QWORD *, _QWORD, _QWORD, unsigned long long *))(v8 + 224))(v24, v30, v31, &v34);
if ( !v14 || (v19 = v14, v34 > v33) )
{
ma_set_fatal_error_with_share(v28, 126, v15, v16, v17, v18);
return 0x7FFFFFFF;
}
v20 = ha_key_cmp(
*(_QWORD *)(v8 + 192),
v35,
*(_QWORD *)a1,
(unsigned int)(*(_DWORD *)(a1 + 16) + *(_DWORD *)(a1 + 20)),
v32 | v25,
v23);
v6 = v20;
if ( v20 >= 0 )
break;
memcpy(v29, v35, v19);
v21 = v34;
*v26 = v34;
if ( v21 >= v33 )
goto LABEL_10;
}
if ( !v20 )
{
memcpy(v29, v35, v19);
v6 = 0;
}
}
LABEL_10:
*v27 = v34 == v33;
return v6;
}
| _ma_seq_search:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xa58
MOV qword ptr [RBP + -0xa48],R9
MOV qword ptr [RBP + -0xa38],R8
MOV dword ptr [RBP + -0xa24],EDX
MOV R13,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV R14,qword ptr [RDI + 0x8]
MOV RDX,qword ptr [R14]
MOV EAX,dword ptr [RSI + 0x2c]
MOV dword ptr [RBP + -0xa2c],EAX
MOV EDI,dword ptr [RSI + 0x28]
MOV RAX,qword ptr [RSI + 0x10]
MOV ESI,dword ptr [RSI + 0x20]
MOV R8,RSI
ADD R8,RAX
MOV qword ptr [RBP + -0xa20],R8
MOV qword ptr [RBP + -0xa40],RDX
MOV EDX,dword ptr [RDX + 0x744]
MOV dword ptr [RBP + -0xa28],EDI
ADD EDX,EDI
ADD RAX,RDX
MOV qword ptr [RBP + -0xa18],RAX
MOV qword ptr [RBP + -0xa50],RCX
MOV qword ptr [RCX],RAX
LEA RAX,[RBP + -0xa10]
MOV byte ptr [RAX],0x0
MOV qword ptr [RBP + -0xa70],RAX
MOV qword ptr [RBP + -0xa68],R14
CMP EDX,ESI
JNC 0x0015767a
LEA R12,[RBP + -0xa10]
LAB_001575a8:
LEA RDI,[RBP + -0xa70]
MOV ESI,dword ptr [RBP + -0xa2c]
MOV EDX,dword ptr [RBP + -0xa28]
LEA RCX,[RBP + -0xa18]
CALL qword ptr [R14 + 0xe0]
TEST EAX,EAX
JZ 0x00157648
MOV R15D,EAX
MOV RAX,qword ptr [RBP + -0xa20]
CMP qword ptr [RBP + -0xa18],RAX
JA 0x00157648
MOV RDI,qword ptr [R14 + 0xc0]
MOV RDX,qword ptr [R13]
MOV ECX,dword ptr [R13 + 0x14]
ADD ECX,dword ptr [R13 + 0x10]
MOV R8D,dword ptr [RBP + -0xa58]
OR R8D,dword ptr [RBP + -0xa24]
MOV RSI,R12
LEA R9,[RBP + -0xa78]
CALL 0x0019f74e
MOV EBX,EAX
TEST EAX,EAX
JNS 0x00157660
MOV EDX,R15D
MOV RDI,qword ptr [RBP + -0xa38]
MOV RSI,R12
CALL 0x00129080
MOV RAX,qword ptr [RBP + -0xa18]
MOV RCX,qword ptr [RBP + -0xa50]
MOV qword ptr [RCX],RAX
CMP RAX,qword ptr [RBP + -0xa20]
JC 0x001575a8
JMP 0x0015767a
LAB_00157648:
MOV RDI,qword ptr [RBP + -0xa40]
MOV ESI,0x7e
CALL 0x001379ae
MOV EBX,0x7fffffff
JMP 0x00157692
LAB_00157660:
JNZ 0x0015767a
MOV EDX,R15D
LEA RSI,[RBP + -0xa10]
MOV RDI,qword ptr [RBP + -0xa38]
CALL 0x00129080
XOR EBX,EBX
LAB_0015767a:
MOV RAX,qword ptr [RBP + -0xa20]
CMP qword ptr [RBP + -0xa18],RAX
MOV RAX,qword ptr [RBP + -0xa48]
SETZ byte ptr [RAX]
LAB_00157692:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001576b5
MOV EAX,EBX
ADD RSP,0xa58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001576b5:
CALL 0x00129270
|
int _ma_seq_search(int8 *param_1,long param_2,uint param_3,ulong *param_4,void *param_5,
int8 param_6)
{
long *plVar1;
uint uVar2;
uint uVar3;
int unaff_EBX;
long in_FS_OFFSET;
int1 local_a80 [8];
int1 *local_a78;
long *local_a70;
uint local_a60;
ulong *local_a58;
int8 local_a50;
long local_a48;
void *local_a40;
int4 local_a34;
int local_a30;
uint local_a2c;
ulong local_a28;
ulong local_a20;
int1 local_a18 [2528];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
plVar1 = (long *)param_1[1];
local_a48 = *plVar1;
local_a34 = *(int4 *)(param_2 + 0x2c);
local_a30 = *(int *)(param_2 + 0x28);
uVar2 = *(uint *)(param_2 + 0x20);
local_a28 = (ulong)uVar2 + *(long *)(param_2 + 0x10);
uVar3 = *(int *)(local_a48 + 0x744) + local_a30;
local_a20 = *(long *)(param_2 + 0x10) + (ulong)uVar3;
*param_4 = local_a20;
local_a78 = local_a18;
local_a18[0] = 0;
local_a70 = plVar1;
local_a58 = param_4;
local_a50 = param_6;
local_a40 = param_5;
local_a2c = param_3;
if (uVar3 < uVar2) {
do {
uVar2 = (*(code *)plVar1[0x1c])(&local_a78,local_a34,local_a30,&local_a20);
if ((uVar2 == 0) || (local_a28 < local_a20)) {
_ma_set_fatal_error_with_share(local_a48,0x7e);
unaff_EBX = 0x7fffffff;
goto LAB_00157692;
}
unaff_EBX = ha_key_cmp(plVar1[0x18],local_a18,*param_1,
*(int *)((long)param_1 + 0x14) + *(int *)(param_1 + 2),
local_a60 | local_a2c,local_a80);
if (-1 < unaff_EBX) {
if (unaff_EBX == 0) {
memcpy(local_a40,local_a18,(ulong)uVar2);
unaff_EBX = 0;
}
break;
}
memcpy(local_a40,local_a18,(ulong)uVar2);
*local_a58 = local_a20;
} while (local_a20 < local_a28);
}
*(bool *)local_a50 = local_a20 == local_a28;
LAB_00157692:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return unaff_EBX;
}
| |
27,859 | ma_bitmap_create_missing_into_pagecache | eloqsql/storage/maria/ma_bitmap.c | static my_bool
_ma_bitmap_create_missing_into_pagecache(MARIA_SHARE *share,
MARIA_FILE_BITMAP *bitmap,
pgcache_page_no_t from,
pgcache_page_no_t to,
uchar *zeroes)
{
pgcache_page_no_t i;
/*
We do not use my_chsize() because there can be a race between when it
reads the physical size and when it writes (assume data_file_length is 10,
physical length is 8 and two data pages are in cache, and here we do a
my_chsize: my_chsize sees physical length is 8, then the two data pages go
to disk then my_chsize writes from page 8 and so overwrites the two data
pages, wrongly).
We instead rely on the filesystem filling gaps with zeroes.
*/
for (i= from; i <= to; i+= bitmap->pages_covered)
{
/**
No need to keep them pinned, they are new so flushable.
@todo but we may want to keep them pinned, as an optimization: if they
are not pinned they may go to disk before the data pages go (so, the
physical pages would be in non-ascending "sparse" order on disk), or the
filesystem may fill gaps with zeroes physically which is a waste of
time.
*/
if (pagecache_write(share->pagecache,
&bitmap->file, i, 0,
zeroes, PAGECACHE_PLAIN_PAGE,
PAGECACHE_LOCK_LEFT_UNLOCKED,
PAGECACHE_PIN_LEFT_UNPINNED,
PAGECACHE_WRITE_DELAY, 0, LSN_IMPOSSIBLE))
goto err;
}
/*
Data pages after data_file_length are full of zeroes but that is allowed
as they are marked empty in the bitmap.
*/
return FALSE;
err:
_ma_set_fatal_error_with_share(share, my_errno);
return TRUE;
} | O3 | c | ma_bitmap_create_missing_into_pagecache:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
xorl %r14d, %r14d
cmpq %rcx, %rdx
ja 0x43006
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbx
leaq 0x40(%rsi), %r15
movq -0x30(%rbp), %rax
movq 0x600(%rax), %rdi
movl 0x80(%rdi), %eax
movl %eax, 0x30(%rsp)
movl %r14d, 0x28(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsp)
movl %r14d, 0x10(%rsp)
movl %r14d, (%rsp)
movl $0x1, 0x8(%rsp)
movq %r15, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
movq -0x38(%rbp), %r8
movl $0x1, %r9d
callq 0x349ca
testb %al, %al
jne 0x42ff3
addq 0x138(%rbx), %r13
cmpq %r12, %r13
jbe 0x42f94
xorl %r14d, %r14d
jmp 0x43006
callq 0xa2a4e
movl (%rax), %esi
movq -0x30(%rbp), %rdi
callq 0x379ae
movb $0x1, %r14b
movl %r14d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ma_bitmap_create_missing_into_pagecache:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov [rbp+var_38], r8
mov [rbp+var_30], rdi
xor r14d, r14d
cmp rdx, rcx
ja short loc_43006
mov r12, rcx
mov r13, rdx
mov rbx, rsi
lea r15, [rsi+40h]
loc_42F94:
mov rax, [rbp+var_30]
mov rdi, [rax+600h]
mov eax, [rdi+80h]
mov [rsp+70h+var_40], eax
mov [rsp+70h+var_48], r14d
xorps xmm0, xmm0
movups [rsp+70h+var_58], xmm0
mov [rsp+70h+var_60], r14d
mov [rsp+70h+var_70], r14d
mov [rsp+70h+var_68], 1
mov rsi, r15
mov rdx, r13
xor ecx, ecx
mov r8, [rbp+var_38]
mov r9d, 1
call pagecache_write_part
test al, al
jnz short loc_42FF3
add r13, [rbx+138h]
cmp r13, r12
jbe short loc_42F94
xor r14d, r14d
jmp short loc_43006
loc_42FF3:
call _my_thread_var
mov esi, [rax]
mov rdi, [rbp+var_30]
call _ma_set_fatal_error_with_share
mov r14b, 1
loc_43006:
mov eax, r14d
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ma_bitmap_create_missing_into_pagecache(
long long a1,
long long a2,
unsigned long long a3,
unsigned long long a4,
char *a5)
{
unsigned int v5; // r14d
unsigned long long v7; // r13
char *v8; // r15
__m128i *v9; // rdi
long long v10; // rdx
long long v11; // rcx
long long v12; // r8
int *v13; // rax
long long v14; // rdx
long long v15; // rcx
long long v16; // r8
int v17; // r9d
v5 = 0;
if ( a3 <= a4 )
{
v7 = a3;
v8 = (char *)(a2 + 64);
while ( 1 )
{
v9 = *(__m128i **)(a1 + 1536);
if ( (unsigned __int8)pagecache_write_part(v9, v8, v7, 0, a5, 1, 0, 1u, 0, 0LL, 0LL, 0, v9[8].m128i_u32[0]) )
break;
v7 += *(_QWORD *)(a2 + 312);
if ( v7 > a4 )
return 0;
}
v13 = (int *)my_thread_var(v9, v8, v10, v11, v12);
ma_set_fatal_error_with_share(a1, *v13, v14, v15, v16, v17);
LOBYTE(v5) = 1;
}
return v5;
}
| _ma_bitmap_create_missing_into_pagecache:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x38],R8
MOV qword ptr [RBP + -0x30],RDI
XOR R14D,R14D
CMP RDX,RCX
JA 0x00143006
MOV R12,RCX
MOV R13,RDX
MOV RBX,RSI
LEA R15,[RSI + 0x40]
LAB_00142f94:
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RAX + 0x600]
MOV EAX,dword ptr [RDI + 0x80]
MOV dword ptr [RSP + 0x30],EAX
MOV dword ptr [RSP + 0x28],R14D
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSP + 0x18],XMM0
MOV dword ptr [RSP + 0x10],R14D
MOV dword ptr [RSP],R14D
MOV dword ptr [RSP + 0x8],0x1
MOV RSI,R15
MOV RDX,R13
XOR ECX,ECX
MOV R8,qword ptr [RBP + -0x38]
MOV R9D,0x1
CALL 0x001349ca
TEST AL,AL
JNZ 0x00142ff3
ADD R13,qword ptr [RBX + 0x138]
CMP R13,R12
JBE 0x00142f94
XOR R14D,R14D
JMP 0x00143006
LAB_00142ff3:
CALL 0x001a2a4e
MOV ESI,dword ptr [RAX]
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x001379ae
MOV R14B,0x1
LAB_00143006:
MOV EAX,R14D
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
_ma_bitmap_create_missing_into_pagecache
(long param_1,long param_2,ulong param_3,ulong param_4,int8 param_5)
{
char cVar1;
int4 *puVar2;
if (param_3 <= param_4) {
do {
cVar1 = pagecache_write_part
(*(long *)(param_1 + 0x600),param_2 + 0x40,param_3,0,param_5,1,0,1,0,0,0,0,
*(int4 *)(*(long *)(param_1 + 0x600) + 0x80));
if (cVar1 != '\0') {
puVar2 = (int4 *)_my_thread_var();
_ma_set_fatal_error_with_share(param_1,*puVar2);
return 1;
}
param_3 = param_3 + *(long *)(param_2 + 0x138);
} while (param_3 <= param_4);
}
return 0;
}
| |
27,860 | iq2_find_best_neighbour | monkey531[P]llama/ggml/src/ggml-quants.c | static int iq2_find_best_neighbour(const uint16_t * restrict neighbours, const uint64_t * restrict grid,
const float * restrict xval, const float * restrict weight, float scale, int8_t * restrict L) {
int num_neighbors = neighbours[0];
GGML_ASSERT(num_neighbors > 0);
float best_d2 = FLT_MAX;
int grid_index = -1;
for (int j = 1; j <= num_neighbors; ++j) {
const int8_t * pg = (const int8_t *)(grid + neighbours[j]);
float d2 = 0;
for (int i = 0; i < 8; ++i) {
float q = pg[i];
float diff = scale*q - xval[i];
d2 += weight[i]*diff*diff;
}
if (d2 < best_d2) {
best_d2 = d2; grid_index = neighbours[j];
}
}
GGML_ASSERT(grid_index >= 0);
const int8_t * pg = (const int8_t *)(grid + grid_index);
for (int i = 0; i < 8; ++i) L[i] = (pg[i] - 1)/2;
return grid_index;
} | O0 | c | iq2_find_best_neighbour:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movss %xmm0, 0x44(%rsp)
movq %r8, 0x38(%rsp)
movq 0x60(%rsp), %rax
movzwl (%rax), %eax
movl %eax, 0x34(%rsp)
cmpl $0x0, 0x34(%rsp)
jg 0x8b907
leaq 0x377e3(%rip), %rdi # 0xc30d0
movl $0xb75, %esi # imm = 0xB75
leaq 0x28d08(%rip), %rdx # 0xb4601
leaq 0x37b21(%rip), %rcx # 0xc3421
movb $0x0, %al
callq 0x46770
movss 0x2cd9d(%rip), %xmm0 # 0xb86ac
movss %xmm0, 0x30(%rsp)
movl $0xffffffff, 0x2c(%rsp) # imm = 0xFFFFFFFF
movl $0x1, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x34(%rsp), %eax
jg 0x8ba3f
movq 0x58(%rsp), %rax
movq 0x60(%rsp), %rcx
movslq 0x28(%rsp), %rdx
movzwl (%rcx,%rdx,2), %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
cmpl $0x8, 0x18(%rsp)
jge 0x8b9fe
movq 0x20(%rsp), %rax
movslq 0x18(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, 0x14(%rsp)
movss 0x44(%rsp), %xmm0
movss 0x14(%rsp), %xmm2
movq 0x50(%rsp), %rax
movslq 0x18(%rsp), %rcx
movss (%rax,%rcx,4), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax # imm = 0x80000000
movd %eax, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x10(%rsp)
movq 0x48(%rsp), %rax
movslq 0x18(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
mulss 0x10(%rsp), %xmm0
movss 0x10(%rsp), %xmm2
movss 0x1c(%rsp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x1c(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x8b966
movss 0x1c(%rsp), %xmm1
movss 0x30(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x8ba2d
movss 0x1c(%rsp), %xmm0
movss %xmm0, 0x30(%rsp)
movq 0x60(%rsp), %rax
movslq 0x28(%rsp), %rcx
movzwl (%rax,%rcx,2), %eax
movl %eax, 0x2c(%rsp)
jmp 0x8ba2f
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x8b925
cmpl $0x0, 0x2c(%rsp)
jge 0x8ba67
leaq 0x37683(%rip), %rdi # 0xc30d0
movl $0xb84, %esi # imm = 0xB84
leaq 0x28ba8(%rip), %rdx # 0xb4601
leaq 0x379d3(%rip), %rcx # 0xc3433
movb $0x0, %al
callq 0x46770
movq 0x58(%rsp), %rax
movslq 0x2c(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpl $0x8, 0x4(%rsp)
jge 0x8bac1
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movsbl (%rax,%rcx), %eax
subl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movb %al, %dl
movq 0x38(%rsp), %rax
movslq 0x4(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x8ba85
movl 0x2c(%rsp), %eax
addq $0x68, %rsp
retq
nopw (%rax,%rax)
| iq2_find_best_neighbour:
sub rsp, 68h
mov [rsp+68h+var_8], rdi
mov [rsp+68h+var_10], rsi
mov [rsp+68h+var_18], rdx
mov [rsp+68h+var_20], rcx
movss [rsp+68h+var_24], xmm0
mov [rsp+68h+var_30], r8
mov rax, [rsp+68h+var_8]
movzx eax, word ptr [rax]
mov [rsp+68h+var_34], eax
cmp [rsp+68h+var_34], 0
jg short loc_8B907
lea rdi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
mov esi, 0B75h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aNumNeighbors0; "num_neighbors > 0"
mov al, 0
call _ggml_abort
loc_8B907:
movss xmm0, cs:dword_B86AC
movss [rsp+68h+var_38], xmm0
mov [rsp+68h+var_3C], 0FFFFFFFFh
mov [rsp+68h+var_40], 1
loc_8B925:
mov eax, [rsp+68h+var_40]
cmp eax, [rsp+68h+var_34]
jg loc_8BA3F
mov rax, [rsp+68h+var_10]
mov rcx, [rsp+68h+var_8]
movsxd rdx, [rsp+68h+var_40]
movzx ecx, word ptr [rcx+rdx*2]
movsxd rcx, ecx
shl rcx, 3
add rax, rcx
mov [rsp+68h+var_48], rax
xorps xmm0, xmm0
movss [rsp+68h+var_4C], xmm0
mov [rsp+68h+var_50], 0
loc_8B966:
cmp [rsp+68h+var_50], 8
jge loc_8B9FE
mov rax, [rsp+68h+var_48]
movsxd rcx, [rsp+68h+var_50]
movsx eax, byte ptr [rax+rcx]
cvtsi2ss xmm0, eax
movss [rsp+68h+var_54], xmm0
movss xmm0, [rsp+68h+var_24]
movss xmm2, [rsp+68h+var_54]
mov rax, [rsp+68h+var_18]
movsxd rcx, [rsp+68h+var_50]
movss xmm1, dword ptr [rax+rcx*4]
movd eax, xmm1
xor eax, 80000000h
movd xmm1, eax
mulss xmm0, xmm2
addss xmm0, xmm1
movss [rsp+68h+var_58], xmm0
mov rax, [rsp+68h+var_20]
movsxd rcx, [rsp+68h+var_50]
movss xmm0, dword ptr [rax+rcx*4]
mulss xmm0, [rsp+68h+var_58]
movss xmm2, [rsp+68h+var_58]
movss xmm1, [rsp+68h+var_4C]
mulss xmm0, xmm2
addss xmm0, xmm1
movss [rsp+68h+var_4C], xmm0
mov eax, [rsp+68h+var_50]
add eax, 1
mov [rsp+68h+var_50], eax
jmp loc_8B966
loc_8B9FE:
movss xmm1, [rsp+68h+var_4C]
movss xmm0, [rsp+68h+var_38]
ucomiss xmm0, xmm1
jbe short loc_8BA2D
movss xmm0, [rsp+68h+var_4C]
movss [rsp+68h+var_38], xmm0
mov rax, [rsp+68h+var_8]
movsxd rcx, [rsp+68h+var_40]
movzx eax, word ptr [rax+rcx*2]
mov [rsp+68h+var_3C], eax
loc_8BA2D:
jmp short $+2
loc_8BA2F:
mov eax, [rsp+68h+var_40]
add eax, 1
mov [rsp+68h+var_40], eax
jmp loc_8B925
loc_8BA3F:
cmp [rsp+68h+var_3C], 0
jge short loc_8BA67
lea rdi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
mov esi, 0B84h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGridIndex0; "grid_index >= 0"
mov al, 0
call _ggml_abort
loc_8BA67:
mov rax, [rsp+68h+var_10]
movsxd rcx, [rsp+68h+var_3C]
shl rcx, 3
add rax, rcx
mov [rsp+68h+var_60], rax
mov [rsp+68h+var_64], 0
loc_8BA85:
cmp [rsp+68h+var_64], 8
jge short loc_8BAC1
mov rax, [rsp+68h+var_60]
movsxd rcx, [rsp+68h+var_64]
movsx eax, byte ptr [rax+rcx]
sub eax, 1
mov ecx, 2
cdq
idiv ecx
mov dl, al
mov rax, [rsp+68h+var_30]
movsxd rcx, [rsp+68h+var_64]
mov [rax+rcx], dl
mov eax, [rsp+68h+var_64]
add eax, 1
mov [rsp+68h+var_64], eax
jmp short loc_8BA85
loc_8BAC1:
mov eax, [rsp+68h+var_3C]
add rsp, 68h
retn
| long long iq2_find_best_neighbour(_WORD *a1, long long a2, long long a3, long long a4, long long a5, float a6)
{
int k; // [rsp+4h] [rbp-64h]
float v8; // [rsp+10h] [rbp-58h]
int j; // [rsp+18h] [rbp-50h]
float v10; // [rsp+1Ch] [rbp-4Ch]
int i; // [rsp+28h] [rbp-40h]
int v12; // [rsp+2Ch] [rbp-3Ch]
float v13; // [rsp+30h] [rbp-38h]
if ( !*a1 )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml-quants.c",
2933,
(long long)"GGML_ASSERT(%s) failed",
"num_neighbors > 0");
v13 = 3.4028235e38;
v12 = -1;
for ( i = 1; i <= (unsigned __int16)*a1; ++i )
{
v10 = 0.0;
for ( j = 0; j < 8; ++j )
{
v8 = (float)(a6 * (float)*(char *)(8LL * (unsigned __int16)a1[i] + a2 + j))
+ COERCE_FLOAT(_mm_cvtsi128_si32((__m128i)*(unsigned int *)(a3 + 4LL * j)) ^ 0x80000000);
v10 = (float)((float)(*(float *)(a4 + 4LL * j) * v8) * v8) + v10;
}
if ( v13 > v10 )
{
v13 = v10;
v12 = (unsigned __int16)a1[i];
}
}
if ( v12 < 0 )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml-quants.c",
2948,
(long long)"GGML_ASSERT(%s) failed",
"grid_index >= 0");
for ( k = 0; k < 8; ++k )
*(_BYTE *)(a5 + k) = (*(char *)(8LL * v12 + a2 + k) - 1) / 2;
return (unsigned int)v12;
}
| iq2_find_best_neighbour:
SUB RSP,0x68
MOV qword ptr [RSP + 0x60],RDI
MOV qword ptr [RSP + 0x58],RSI
MOV qword ptr [RSP + 0x50],RDX
MOV qword ptr [RSP + 0x48],RCX
MOVSS dword ptr [RSP + 0x44],XMM0
MOV qword ptr [RSP + 0x38],R8
MOV RAX,qword ptr [RSP + 0x60]
MOVZX EAX,word ptr [RAX]
MOV dword ptr [RSP + 0x34],EAX
CMP dword ptr [RSP + 0x34],0x0
JG 0x0018b907
LEA RDI,[0x1c30d0]
MOV ESI,0xb75
LEA RDX,[0x1b4601]
LEA RCX,[0x1c3421]
MOV AL,0x0
CALL 0x00146770
LAB_0018b907:
MOVSS XMM0,dword ptr [0x001b86ac]
MOVSS dword ptr [RSP + 0x30],XMM0
MOV dword ptr [RSP + 0x2c],0xffffffff
MOV dword ptr [RSP + 0x28],0x1
LAB_0018b925:
MOV EAX,dword ptr [RSP + 0x28]
CMP EAX,dword ptr [RSP + 0x34]
JG 0x0018ba3f
MOV RAX,qword ptr [RSP + 0x58]
MOV RCX,qword ptr [RSP + 0x60]
MOVSXD RDX,dword ptr [RSP + 0x28]
MOVZX ECX,word ptr [RCX + RDX*0x2]
MOVSXD RCX,ECX
SHL RCX,0x3
ADD RAX,RCX
MOV qword ptr [RSP + 0x20],RAX
XORPS XMM0,XMM0
MOVSS dword ptr [RSP + 0x1c],XMM0
MOV dword ptr [RSP + 0x18],0x0
LAB_0018b966:
CMP dword ptr [RSP + 0x18],0x8
JGE 0x0018b9fe
MOV RAX,qword ptr [RSP + 0x20]
MOVSXD RCX,dword ptr [RSP + 0x18]
MOVSX EAX,byte ptr [RAX + RCX*0x1]
CVTSI2SS XMM0,EAX
MOVSS dword ptr [RSP + 0x14],XMM0
MOVSS XMM0,dword ptr [RSP + 0x44]
MOVSS XMM2,dword ptr [RSP + 0x14]
MOV RAX,qword ptr [RSP + 0x50]
MOVSXD RCX,dword ptr [RSP + 0x18]
MOVSS XMM1,dword ptr [RAX + RCX*0x4]
MOVD EAX,XMM1
XOR EAX,0x80000000
MOVD XMM1,EAX
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOVSS dword ptr [RSP + 0x10],XMM0
MOV RAX,qword ptr [RSP + 0x48]
MOVSXD RCX,dword ptr [RSP + 0x18]
MOVSS XMM0,dword ptr [RAX + RCX*0x4]
MULSS XMM0,dword ptr [RSP + 0x10]
MOVSS XMM2,dword ptr [RSP + 0x10]
MOVSS XMM1,dword ptr [RSP + 0x1c]
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOVSS dword ptr [RSP + 0x1c],XMM0
MOV EAX,dword ptr [RSP + 0x18]
ADD EAX,0x1
MOV dword ptr [RSP + 0x18],EAX
JMP 0x0018b966
LAB_0018b9fe:
MOVSS XMM1,dword ptr [RSP + 0x1c]
MOVSS XMM0,dword ptr [RSP + 0x30]
UCOMISS XMM0,XMM1
JBE 0x0018ba2d
MOVSS XMM0,dword ptr [RSP + 0x1c]
MOVSS dword ptr [RSP + 0x30],XMM0
MOV RAX,qword ptr [RSP + 0x60]
MOVSXD RCX,dword ptr [RSP + 0x28]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RSP + 0x2c],EAX
LAB_0018ba2d:
JMP 0x0018ba2f
LAB_0018ba2f:
MOV EAX,dword ptr [RSP + 0x28]
ADD EAX,0x1
MOV dword ptr [RSP + 0x28],EAX
JMP 0x0018b925
LAB_0018ba3f:
CMP dword ptr [RSP + 0x2c],0x0
JGE 0x0018ba67
LEA RDI,[0x1c30d0]
MOV ESI,0xb84
LEA RDX,[0x1b4601]
LEA RCX,[0x1c3433]
MOV AL,0x0
CALL 0x00146770
LAB_0018ba67:
MOV RAX,qword ptr [RSP + 0x58]
MOVSXD RCX,dword ptr [RSP + 0x2c]
SHL RCX,0x3
ADD RAX,RCX
MOV qword ptr [RSP + 0x8],RAX
MOV dword ptr [RSP + 0x4],0x0
LAB_0018ba85:
CMP dword ptr [RSP + 0x4],0x8
JGE 0x0018bac1
MOV RAX,qword ptr [RSP + 0x8]
MOVSXD RCX,dword ptr [RSP + 0x4]
MOVSX EAX,byte ptr [RAX + RCX*0x1]
SUB EAX,0x1
MOV ECX,0x2
CDQ
IDIV ECX
MOV DL,AL
MOV RAX,qword ptr [RSP + 0x38]
MOVSXD RCX,dword ptr [RSP + 0x4]
MOV byte ptr [RAX + RCX*0x1],DL
MOV EAX,dword ptr [RSP + 0x4]
ADD EAX,0x1
MOV dword ptr [RSP + 0x4],EAX
JMP 0x0018ba85
LAB_0018bac1:
MOV EAX,dword ptr [RSP + 0x2c]
ADD RSP,0x68
RET
|
uint iq2_find_best_neighbour
(float param_1,ushort *param_2,long param_3,long param_4,long param_5,long param_6)
{
ushort uVar1;
float fVar2;
int local_64;
int local_50;
float local_4c;
int local_40;
uint local_3c;
float local_38;
uVar1 = *param_2;
if (uVar1 == 0) {
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml-quants.c",
0xb75,"GGML_ASSERT(%s) failed","num_neighbors > 0");
}
local_38 = DAT_001b86ac;
local_3c = 0xffffffff;
for (local_40 = 1; local_40 <= (int)(uint)uVar1; local_40 = local_40 + 1) {
local_4c = 0.0;
for (local_50 = 0; local_50 < 8; local_50 = local_50 + 1) {
fVar2 = param_1 * (float)(int)*(char *)(param_3 + (long)(int)(uint)param_2[local_40] * 8 +
(long)local_50) +
-*(float *)(param_4 + (long)local_50 * 4);
local_4c = *(float *)(param_5 + (long)local_50 * 4) * fVar2 * fVar2 + local_4c;
}
if (local_4c < local_38) {
local_38 = local_4c;
local_3c = (uint)param_2[local_40];
}
}
if ((int)local_3c < 0) {
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml-quants.c",
0xb84,"GGML_ASSERT(%s) failed","grid_index >= 0");
}
for (local_64 = 0; local_64 < 8; local_64 = local_64 + 1) {
*(char *)(param_6 + local_64) =
(char)((long)(*(char *)(param_3 + (long)(int)local_3c * 8 + (long)local_64) + -1) / 2);
}
return local_3c;
}
| |
27,861 | google::protobuf::Message::~Message() | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/message.h | class PROTOBUF_EXPORT Message : public MessageLite {
public:
constexpr Message() {}
// Basic Operations ------------------------------------------------
// Construct a new instance of the same type. Ownership is passed to the
// caller. (This is also defined in MessageLite, but is defined again here
// for return-type covariance.)
Message* New() const { return New(nullptr); }
// Construct a new instance on the arena. Ownership is passed to the caller
// if arena is a nullptr.
Message* New(Arena* arena) const override = 0;
// Make this message into a copy of the given message. The given message
// must have the same descriptor, but need not necessarily be the same class.
// By default this is just implemented as "Clear(); MergeFrom(from);".
void CopyFrom(const Message& from);
// Merge the fields from the given message into this message. Singular
// fields will be overwritten, if specified in from, except for embedded
// messages which will be merged. Repeated fields will be concatenated.
// The given message must be of the same type as this message (i.e. the
// exact same class).
virtual void MergeFrom(const Message& from);
// Verifies that IsInitialized() returns true. GOOGLE_CHECK-fails otherwise, with
// a nice error message.
void CheckInitialized() const;
// Slowly build a list of all required fields that are not set.
// This is much, much slower than IsInitialized() as it is implemented
// purely via reflection. Generally, you should not call this unless you
// have already determined that an error exists by calling IsInitialized().
void FindInitializationErrors(std::vector<std::string>* errors) const;
// Like FindInitializationErrors, but joins all the strings, delimited by
// commas, and returns them.
std::string InitializationErrorString() const override;
// Clears all unknown fields from this message and all embedded messages.
// Normally, if unknown tag numbers are encountered when parsing a message,
// the tag and value are stored in the message's UnknownFieldSet and
// then written back out when the message is serialized. This allows servers
// which simply route messages to other servers to pass through messages
// that have new field definitions which they don't yet know about. However,
// this behavior can have security implications. To avoid it, call this
// method after parsing.
//
// See Reflection::GetUnknownFields() for more on unknown fields.
void DiscardUnknownFields();
// Computes (an estimate of) the total number of bytes currently used for
// storing the message in memory. The default implementation calls the
// Reflection object's SpaceUsed() method.
//
// SpaceUsed() is noticeably slower than ByteSize(), as it is implemented
// using reflection (rather than the generated code implementation for
// ByteSize()). Like ByteSize(), its CPU time is linear in the number of
// fields defined for the proto.
virtual size_t SpaceUsedLong() const;
PROTOBUF_DEPRECATED_MSG("Please use SpaceUsedLong() instead")
int SpaceUsed() const { return internal::ToIntSize(SpaceUsedLong()); }
// Debugging & Testing----------------------------------------------
// Generates a human-readable form of this message for debugging purposes.
// Note that the format and content of a debug string is not guaranteed, may
// change without notice, and should not be depended on. Code that does
// anything except display a string to assist in debugging should use
// TextFormat instead.
std::string DebugString() const;
// Like DebugString(), but with less whitespace.
std::string ShortDebugString() const;
// Like DebugString(), but do not escape UTF-8 byte sequences.
std::string Utf8DebugString() const;
// Convenience function useful in GDB. Prints DebugString() to stdout.
void PrintDebugString() const;
// Reflection-based methods ----------------------------------------
// These methods are pure-virtual in MessageLite, but Message provides
// reflection-based default implementations.
std::string GetTypeName() const override;
void Clear() override;
// Returns whether all required fields have been set. Note that required
// fields no longer exist starting in proto3.
bool IsInitialized() const override;
void CheckTypeAndMergeFrom(const MessageLite& other) override;
// Reflective parser
const char* _InternalParse(const char* ptr,
internal::ParseContext* ctx) override;
size_t ByteSizeLong() const override;
uint8_t* _InternalSerialize(uint8_t* target,
io::EpsCopyOutputStream* stream) const override;
private:
// This is called only by the default implementation of ByteSize(), to
// update the cached size. If you override ByteSize(), you do not need
// to override this. If you do not override ByteSize(), you MUST override
// this; the default implementation will crash.
//
// The method is private because subclasses should never call it; only
// override it. Yes, C++ lets you do that. Crazy, huh?
virtual void SetCachedSize(int size) const;
public:
// Introspection ---------------------------------------------------
// Get a non-owning pointer to a Descriptor for this message's type. This
// describes what fields the message contains, the types of those fields, etc.
// This object remains property of the Message.
const Descriptor* GetDescriptor() const { return GetMetadata().descriptor; } | O0 | c | google::protobuf::Message::~Message():
movq %rdi, -0x8(%rsp)
ud2
nopw (%rax,%rax)
| _ZN6google8protobuf7MessageD0Ev:
mov [rsp+var_8], rdi
ud2
| void __noreturn google::protobuf::Message::~Message(google::protobuf::Message *this)
{
BUG();
}
| __get_helper<0ul,aimrt_mujoco_sim::mujoco_sim_module::publisher::JointSensorPublisher*,std::default_delete<aimrt_mujoco_sim::mujoco_sim_module::publisher::JointSensorPublisher>>:
PUSH RAX
MOV qword ptr [RSP],RDI
MOV RDI,qword ptr [RSP]
CALL 0x001dd180
POP RCX
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* aimrt_mujoco_sim::mujoco_sim_module::publisher::JointSensorPublisher*& std::__get_helper<0ul,
aimrt_mujoco_sim::mujoco_sim_module::publisher::JointSensorPublisher*,
std::default_delete<aimrt_mujoco_sim::mujoco_sim_module::publisher::JointSensorPublisher>
>(std::_Tuple_impl<0ul, aimrt_mujoco_sim::mujoco_sim_module::publisher::JointSensorPublisher*,
std::default_delete<aimrt_mujoco_sim::mujoco_sim_module::publisher::JointSensorPublisher> >&) */
JointSensorPublisher **
std::
__get_helper<0ul,aimrt_mujoco_sim::mujoco_sim_module::publisher::JointSensorPublisher*,std::default_delete<aimrt_mujoco_sim::mujoco_sim_module::publisher::JointSensorPublisher>>
(_Tuple_impl *param_1)
{
JointSensorPublisher **ppJVar1;
ppJVar1 = (JointSensorPublisher **)
_Tuple_impl<0ul,aimrt_mujoco_sim::mujoco_sim_module::publisher::JointSensorPublisher*,std::default_delete<aimrt_mujoco_sim::mujoco_sim_module::publisher::JointSensorPublisher>>
::_M_head(param_1);
return ppJVar1;
}
| |
27,862 | FileWriterJson::writeFileContents(std::filesystem::__cxx11::path const&, std::filesystem::__cxx11::path const&) | shubhamoy[P]dir2txt/src/FileWriterJson.cpp | void FileWriterJson::writeFileContents(const std::filesystem::path& filePath,
const std::filesystem::path& rootPath) {
std::string relPath = std::filesystem::relative(filePath, rootPath).string();
std::vector<std::string> lines;
if (stripComments) {
lines = CommentStripper::strip(filePath);
} else {
std::ifstream file(filePath);
if (!file) {
j["files"][relPath]["error"] = "Unable to read file";
return;
}
std::string line;
while (std::getline(file, line)) {
lines.push_back(line);
}
}
j["files"][relPath]["content"] = lines;
} | O1 | cpp | FileWriterJson::writeFileContents(std::filesystem::__cxx11::path const&, std::filesystem::__cxx11::path const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2c8, %rsp # imm = 0x2C8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc0(%rsp), %r15
movq %r15, %rdi
callq 0x8320
movq (%r15), %rsi
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x9a84
leaq 0xc0(%rsp), %rdi
callq 0x9990
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
cmpb $0x1, 0x260(%rbx)
jne 0x286bf
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
callq 0x33dd8
xorps %xmm0, %xmm0
leaq 0xc0(%rsp), %rdi
movaps %xmm0, (%rdi)
movaps (%rsp), %xmm0
movq 0x10(%rsp), %rax
leaq 0x50(%rsp), %r14
movups (%r14), %xmm1
movaps %xmm1, (%rsp)
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rsp)
movaps (%rdi), %xmm1
movaps %xmm0, (%rdi)
movq %rax, 0x10(%rdi)
movups %xmm1, (%r14)
movq $0x0, 0x10(%r14)
callq 0xc2b2
movq %r14, %rdi
callq 0xc2b2
jmp 0x28833
movq (%r14), %rsi
leaq 0xc0(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x8600
movq 0xc0(%rsp), %rax
movq -0x18(%rax), %rax
movl 0xe0(%rsp,%rax), %ebp
testb $0x5, %bpl
je 0x287a0
leaq 0xea3c(%rip), %rsi # 0x37137
leaq 0x70(%rsp), %rdi
callq 0x2974a
leaq 0x8(%rbx), %rdi
leaq 0xd081(%rip), %rsi # 0x35791
callq 0x28e32
movq %rax, %r14
leaq 0xb0(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq %rsi, %rdx
leaq 0xa0(%rsp), %rdi
callq 0x9eca
leaq 0xa0(%rsp), %rsi
movq %r14, %rdi
callq 0x29784
leaq 0xed86(%rip), %rsi # 0x374db
movq %rax, %rdi
callq 0x28e32
leaq 0x70(%rsp), %rsi
movq %rax, %rdi
callq 0x28ea8
movq 0xa0(%rsp), %rdi
cmpq %r15, %rdi
je 0x28787
movq 0xb0(%rsp), %rsi
incq %rsi
callq 0x8380
leaq 0x70(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x29abe
movq %r14, %rdi
callq 0x29b94
jmp 0x2881c
leaq 0x60(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
leaq 0x50(%rsp), %r15
movq %rsp, %r12
movq 0xc0(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x8350
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x8620
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x28800
movq %r12, %rdi
movq %r15, %rsi
callq 0x15cac
jmp 0x287be
movq 0x50(%rsp), %rdi
cmpq %r13, %rdi
je 0x28817
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x8380
leaq 0x30(%rsp), %r12
leaq 0xc0(%rsp), %rdi
callq 0x80a0
testb $0x5, %bpl
jne 0x288dc
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0x2989c
addq $0x8, %rbx
leaq 0xcf46(%rip), %rsi # 0x35791
movq %rbx, %rdi
callq 0x28e32
movq %rax, %rbx
leaq 0x90(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq %rsi, %rdx
leaq 0x80(%rsp), %rdi
callq 0x9eca
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
callq 0x29784
leaq 0xe8b8(%rip), %rsi # 0x3714b
movq %rax, %rdi
callq 0x28e32
leaq 0x40(%rsp), %rsi
movq %rax, %rdi
callq 0x28ea8
movq 0x80(%rsp), %rdi
cmpq %r14, %rdi
je 0x288c5
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x8380
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x29abe
movq %rbx, %rdi
callq 0x29b94
movq %rsp, %rdi
callq 0xc2b2
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x288fb
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x8380
addq $0x2c8, %rsp # imm = 0x2C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x289c9
jmp 0x28957
jmp 0x28957
movq %rax, %rbx
movq 0xa0(%rsp), %rdi
cmpq %r15, %rdi
je 0x2893e
movq 0xb0(%rsp), %rsi
incq %rsi
callq 0x8380
jmp 0x2893e
movq %rax, %rbx
leaq 0x70(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x29abe
movq %r14, %rdi
callq 0x29b94
jmp 0x289c9
movq %rax, %rbx
jmp 0x289d6
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0x9990
jmp 0x289fa
movq %rax, %rbx
movq 0x80(%rsp), %rdi
cmpq %r14, %rdi
je 0x28996
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x8380
jmp 0x28996
movq %rax, %rbx
leaq 0x40(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x29abe
movq %r14, %rdi
callq 0x29b94
jmp 0x289d6
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r13, %rdi
je 0x289c9
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x8380
leaq 0xc0(%rsp), %rdi
callq 0x80a0
movq %rsp, %rdi
callq 0xc2b2
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x289fa
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x8380
movq %rbx, %rdi
callq 0x85d0
| _ZN14FileWriterJson17writeFileContentsERKNSt10filesystem7__cxx114pathES4_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 2C8h
mov r14, rsi
mov rbx, rdi
lea r15, [rsp+2F8h+var_238]
mov rdi, r15; this
call __ZNSt10filesystem8relativeERKNS_7__cxx114pathES3_; std::filesystem::relative(std::filesystem::__cxx11::path const&,std::filesystem::__cxx11::path const&)
mov rsi, [r15]
lea r12, [rsp+2F8h+var_2C8]
mov [r12-10h], r12
mov rdx, [r15+8]
add rdx, rsi
lea rdi, [rsp+2F8h+var_2D8]
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+2F8h+var_238]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
xorps xmm0, xmm0
movaps [rsp+2F8h+var_2F8], xmm0
mov [rsp+2F8h+var_2E8], 0
cmp byte ptr [rbx+260h], 1
jnz short loc_286BF
lea rdi, [rsp+2F8h+var_2A8]; this
mov rsi, r14; std::filesystem::__cxx11::path *
call _ZN15CommentStripper5stripERKNSt10filesystem7__cxx114pathE; CommentStripper::strip(std::filesystem::__cxx11::path const&)
xorps xmm0, xmm0
lea rdi, [rsp+2F8h+var_238]
movaps xmmword ptr [rdi], xmm0
movaps xmm0, [rsp+2F8h+var_2F8]
mov rax, [rsp+2F8h+var_2E8]
lea r14, [rsp+2F8h+var_2A8]
movups xmm1, xmmword ptr [r14]
movaps [rsp+2F8h+var_2F8], xmm1
mov rcx, [r14+10h]
mov [rsp+2F8h+var_2E8], rcx
movaps xmm1, xmmword ptr [rdi]
movaps xmmword ptr [rdi], xmm0
mov [rdi+10h], rax
movups xmmword ptr [r14], xmm1
mov qword ptr [r14+10h], 0
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, r14
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
jmp loc_28833
loc_286BF:
mov rsi, [r14]
lea r14, [rsp+2F8h+var_238]
mov rdi, r14
mov edx, 8
call __ZNSt14basic_ifstreamIcSt11char_traitsIcEEC1EPKcSt13_Ios_Openmode; std::ifstream::basic_ifstream(char const*,std::_Ios_Openmode)
mov rax, [rsp+2F8h+var_238]
mov rax, [rax-18h]
mov ebp, [rsp+rax+2F8h+var_218]
test bpl, 5
jz loc_287A0
lea rsi, aUnableToReadFi_0; "Unable to read file"
lea rdi, [rsp+2F8h+var_288]
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRA20_KcA20_cTnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SK_EE5valueEiE4typeELi0EEEOT_
lea rdi, [rbx+8]
lea rsi, aStripCommentsF+1Bh; "files"
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixIKcEERSD_PT_; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::operator[]<char const>(char const *)
mov r14, rax
lea r15, [rsp+2F8h+var_248]
mov [r15-10h], r15
mov rsi, [rsp+2F8h+var_2D8]
mov rdx, [rsp+2F8h+var_2D0]
add rdx, rsi
lea rdi, [rsp+2F8h+var_258]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea rsi, [rsp+2F8h+var_258]
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixES9_; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::operator[](std::string)
lea rsi, aTypeError+5; "error"
mov rdi, rax
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixIKcEERSD_PT_; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::operator[]<char const>(char const *)
lea rsi, [rsp+2F8h+var_288]
mov rdi, rax
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>)
mov rdi, [rsp+2F8h+var_258]; void *
cmp rdi, r15
jz short loc_28787
mov rsi, [rsp+2F8h+var_248]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_28787:
lea r14, [rsp+2F8h+var_288]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp short loc_2881C
loc_287A0:
lea r13, [rsp+2F8h+var_298]
mov [r13-10h], r13
mov qword ptr [r13-8], 0
mov byte ptr [r13+0], 0
lea r15, [rsp+2F8h+var_2A8]
mov r12, rsp
loc_287BE:
mov rax, [rsp+2F8h+var_238]
mov rdi, [rax-18h]
add rdi, r14
mov esi, 0Ah
call __ZNKSt9basic_iosIcSt11char_traitsIcEE5widenEc; std::ios::widen(char)
movsx edx, al
mov rdi, r14
mov rsi, r15
call __ZSt7getlineIcSt11char_traitsIcESaIcEERSt13basic_istreamIT_T0_ES7_RNSt7__cxx1112basic_stringIS4_S5_T1_EES4_; std::getline<char,std::char_traits<char>,std::allocator<char>>(std::istream &,std::string &,char)
mov rcx, [rax]
mov rcx, [rcx-18h]
test byte ptr [rax+rcx+20h], 5
jnz short loc_28800
mov rdi, r12
mov rsi, r15
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE9push_backERKS5_; std::vector<std::string>::push_back(std::string const&)
jmp short loc_287BE
loc_28800:
mov rdi, [rsp+2F8h+var_2A8]; void *
cmp rdi, r13
jz short loc_28817
mov rsi, [rsp+2F8h+var_298]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_28817:
lea r12, [rsp+2F8h+var_2C8]
loc_2881C:
lea rdi, [rsp+2F8h+var_238]
call __ZNSt14basic_ifstreamIcSt11char_traitsIcEED1Ev; std::ifstream::~ifstream()
test bpl, 5
jnz loc_288DC
loc_28833:
lea rdi, [rsp+2F8h+var_2B8]
mov rsi, rsp
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS3_IS9_SaIS9_EESG_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SJ_EE5valueEiE4typeELi0EEEOT_
add rbx, 8
lea rsi, aStripCommentsF+1Bh; "files"
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixIKcEERSD_PT_; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::operator[]<char const>(char const *)
mov rbx, rax
lea r14, [rsp+2F8h+var_268]
mov [r14-10h], r14
mov rsi, [rsp+2F8h+var_2D8]
mov rdx, [rsp+2F8h+var_2D0]
add rdx, rsi
lea rdi, [rsp+2F8h+var_278]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea rsi, [rsp+2F8h+var_278]
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixES9_; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::operator[](std::string)
lea rsi, aContent; "content"
mov rdi, rax
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixIKcEERSD_PT_; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::operator[]<char const>(char const *)
lea rsi, [rsp+2F8h+var_2B8]
mov rdi, rax
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>)
mov rdi, [rsp+2F8h+var_278]; void *
cmp rdi, r14
jz short loc_288C5
mov rsi, [rsp+2F8h+var_268]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_288C5:
lea rbx, [rsp+2F8h+var_2B8]
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_288DC:
mov rdi, rsp
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, [rsp+2F8h+var_2D8]; void *
cmp rdi, r12
jz short loc_288FB
mov rsi, [rsp+2F8h+var_2C8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_288FB:
add rsp, 2C8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
jmp loc_289C9
jmp short loc_28957
jmp short loc_28957
mov rbx, rax
mov rdi, [rsp+arg_98]; void *
cmp rdi, r15
jz short loc_2893E
mov rsi, [rsp+arg_A8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_2893E
mov rbx, rax
loc_2893E:
lea r14, [rsp+arg_68]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp short loc_289C9
loc_28957:
mov rbx, rax
jmp short loc_289D6
mov rbx, rax
lea rdi, [rsp+arg_B8]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
jmp loc_289FA
mov rbx, rax
mov rdi, [rsp+arg_78]; void *
cmp rdi, r14
jz short loc_28996
mov rsi, [rsp+arg_88]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_28996
mov rbx, rax
loc_28996:
lea r14, [rsp+arg_38]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp short loc_289D6
mov rbx, rax
mov rdi, [rsp+arg_48]; void *
cmp rdi, r13
jz short loc_289C9
mov rsi, [rsp+arg_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_289C9:
lea rdi, [rsp+arg_B8]
call __ZNSt14basic_ifstreamIcSt11char_traitsIcEED1Ev; std::ifstream::~ifstream()
loc_289D6:
mov rdi, rsp
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, [rsp+arg_18]; void *
lea rax, [rsp+arg_28]
cmp rdi, rax
jz short loc_289FA
mov rsi, [rsp+arg_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_289FA:
mov rdi, rbx
call __Unwind_Resume
| void FileWriterJson::writeFileContents(
FileWriterJson *this,
const std::filesystem::__cxx11::path *a2,
const std::filesystem::__cxx11::path *a3)
{
__int128 v3; // xmm0
long long v4; // rax
int v5; // ebp
int v6; // edx
int v7; // ecx
int v8; // r8d
int v9; // r9d
long long v10; // r14
int v11; // eax
int v12; // edx
int v13; // ecx
int v14; // r8d
int v15; // r9d
long long v16; // rax
char v17; // al
_QWORD *v18; // rax
int v19; // edx
int v20; // ecx
int v21; // r8d
int v22; // r9d
long long v23; // rbx
int v24; // eax
int v25; // edx
int v26; // ecx
int v27; // r8d
int v28; // r9d
long long v29; // rax
__int128 v30; // [rsp+0h] [rbp-2F8h] BYREF
long long v31; // [rsp+10h] [rbp-2E8h]
void *v32; // [rsp+20h] [rbp-2D8h] BYREF
long long v33; // [rsp+28h] [rbp-2D0h]
_QWORD v34[2]; // [rsp+30h] [rbp-2C8h] BYREF
_BYTE v35[16]; // [rsp+40h] [rbp-2B8h] BYREF
__int128 v36; // [rsp+50h] [rbp-2A8h] BYREF
_QWORD v37[2]; // [rsp+60h] [rbp-298h] BYREF
_BYTE v38[16]; // [rsp+70h] [rbp-288h] BYREF
void *v39[2]; // [rsp+80h] [rbp-278h] BYREF
_QWORD v40[2]; // [rsp+90h] [rbp-268h] BYREF
void *v41[2]; // [rsp+A0h] [rbp-258h] BYREF
_QWORD v42[2]; // [rsp+B0h] [rbp-248h] BYREF
__int128 v43; // [rsp+C0h] [rbp-238h] BYREF
long long v44; // [rsp+D0h] [rbp-228h]
_DWORD v45[134]; // [rsp+E0h] [rbp-218h]
std::filesystem::relative((std::filesystem *)&v43, a2, a3);
v32 = v34;
std::string::_M_construct<char const*>(&v32, (_BYTE *)v43, v43 + *((_QWORD *)&v43 + 1));
std::filesystem::__cxx11::path::~path((std::filesystem::__cxx11::path *)&v43);
v30 = 0LL;
v31 = 0LL;
if ( *((_BYTE *)this + 608) == 1 )
{
CommentStripper::strip((CommentStripper *)&v36, a2);
v3 = v30;
v4 = v31;
v30 = v36;
v31 = v37[0];
v43 = v3;
v44 = v4;
v36 = 0LL;
v37[0] = 0LL;
std::vector<std::string>::~vector(&v43);
std::vector<std::string>::~vector(&v36);
LABEL_13:
ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS3_IS9_SaIS9_EESG_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SJ_EE5valueEiE4typeELi0EEEOT_(
v35,
&v30);
v23 = nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::operator[]<char const>(
(int)this + 8,
(unsigned int)"files",
v19,
v20,
v21,
v22);
v39[0] = v40;
std::string::_M_construct<char *>((long long *)v39, v32, (long long)v32 + v33);
v24 = nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::operator[](
v23,
v39);
v29 = nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::operator[]<char const>(
v24,
(unsigned int)"content",
v25,
v26,
v27,
v28);
nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::operator=(
v29,
v35);
if ( v39[0] != v40 )
operator delete(v39[0], v40[0] + 1LL);
nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
v35,
0LL);
nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::data::~data(v35);
goto LABEL_16;
}
std::ifstream::basic_ifstream(&v43, *(_QWORD *)a2, 8LL);
v5 = *(_DWORD *)((char *)v45 + *(_QWORD *)(v43 - 24));
if ( (v5 & 5) != 0 )
{
ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRA20_KcA20_cTnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SK_EE5valueEiE4typeELi0EEEOT_(
v38,
"Unable to read file");
v10 = nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::operator[]<char const>(
(int)this + 8,
(unsigned int)"files",
v6,
v7,
v8,
v9);
v41[0] = v42;
std::string::_M_construct<char *>((long long *)v41, v32, (long long)v32 + v33);
v11 = nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::operator[](
v10,
v41);
v16 = nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::operator[]<char const>(
v11,
(unsigned int)"error",
v12,
v13,
v14,
v15);
nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::operator=(
v16,
v38);
if ( v41[0] != v42 )
operator delete(v41[0], v42[0] + 1LL);
nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
v38,
0LL);
nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::data::~data(v38);
}
else
{
*(_QWORD *)&v36 = v37;
*((_QWORD *)&v36 + 1) = 0LL;
LOBYTE(v37[0]) = 0;
while ( 1 )
{
v17 = std::ios::widen((char *)&v43 + *(_QWORD *)(v43 - 24), 10LL);
v18 = (_QWORD *)std::getline<char,std::char_traits<char>,std::allocator<char>>(&v43, &v36, (unsigned int)v17);
if ( (*((_BYTE *)v18 + *(_QWORD *)(*v18 - 24LL) + 32) & 5) != 0 )
break;
std::vector<std::string>::push_back((long long)&v30, (long long)&v36);
}
if ( (_QWORD *)v36 != v37 )
operator delete((void *)v36, v37[0] + 1LL);
}
std::ifstream::~ifstream(&v43);
if ( (v5 & 5) == 0 )
goto LABEL_13;
LABEL_16:
std::vector<std::string>::~vector(&v30);
if ( v32 != v34 )
operator delete(v32, v34[0] + 1LL);
}
| writeFileContents:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x2c8
MOV R14,RSI
MOV RBX,RDI
LEA R15,[RSP + 0xc0]
MOV RDI,R15
CALL 0x00108320
MOV RSI,qword ptr [R15]
LEA R12,[RSP + 0x30]
MOV qword ptr [R12 + -0x10],R12
MOV RDX,qword ptr [R15 + 0x8]
ADD RDX,RSI
LAB_0012862d:
LEA RDI,[RSP + 0x20]
CALL 0x00109a84
LEA RDI,[RSP + 0xc0]
CALL 0x00109990
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x10],0x0
CMP byte ptr [RBX + 0x260],0x1
JNZ 0x001286bf
LAB_0012865d:
LEA RDI,[RSP + 0x50]
MOV RSI,R14
CALL 0x00133dd8
XORPS XMM0,XMM0
LEA RDI,[RSP + 0xc0]
MOVAPS xmmword ptr [RDI],XMM0
MOVAPS XMM0,xmmword ptr [RSP]
MOV RAX,qword ptr [RSP + 0x10]
LEA R14,[RSP + 0x50]
MOVUPS XMM1,xmmword ptr [R14]
MOVAPS xmmword ptr [RSP],XMM1
MOV RCX,qword ptr [R14 + 0x10]
MOV qword ptr [RSP + 0x10],RCX
MOVAPS XMM1,xmmword ptr [RDI]
MOVAPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],RAX
MOVUPS xmmword ptr [R14],XMM1
MOV qword ptr [R14 + 0x10],0x0
CALL 0x0010c2b2
MOV RDI,R14
CALL 0x0010c2b2
JMP 0x00128833
LAB_001286bf:
MOV RSI,qword ptr [R14]
LAB_001286c2:
LEA R14,[RSP + 0xc0]
MOV RDI,R14
MOV EDX,0x8
CALL 0x00108600
MOV RAX,qword ptr [RSP + 0xc0]
MOV RAX,qword ptr [RAX + -0x18]
MOV EBP,dword ptr [RSP + RAX*0x1 + 0xe0]
TEST BPL,0x5
JZ 0x001287a0
LAB_001286f4:
LEA RSI,[0x137137]
LEA RDI,[RSP + 0x70]
CALL 0x0012974a
LEA RDI,[RBX + 0x8]
LAB_00128709:
LEA RSI,[0x135791]
CALL 0x00128e32
MOV R14,RAX
LEA R15,[RSP + 0xb0]
MOV qword ptr [R15 + -0x10],R15
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
ADD RDX,RSI
LEA RDI,[RSP + 0xa0]
CALL 0x00109eca
LAB_0012873e:
LEA RSI,[RSP + 0xa0]
MOV RDI,R14
CALL 0x00129784
LEA RSI,[0x1374db]
MOV RDI,RAX
CALL 0x00128e32
LEA RSI,[RSP + 0x70]
MOV RDI,RAX
CALL 0x00128ea8
MOV RDI,qword ptr [RSP + 0xa0]
CMP RDI,R15
JZ 0x00128787
MOV RSI,qword ptr [RSP + 0xb0]
INC RSI
CALL 0x00108380
LAB_00128787:
LEA R14,[RSP + 0x70]
MOV RDI,R14
XOR ESI,ESI
CALL 0x00129abe
MOV RDI,R14
CALL 0x00129b94
JMP 0x0012881c
LAB_001287a0:
LEA R13,[RSP + 0x60]
MOV qword ptr [R13 + -0x10],R13
MOV qword ptr [R13 + -0x8],0x0
MOV byte ptr [R13],0x0
LEA R15,[RSP + 0x50]
MOV R12,RSP
LAB_001287be:
MOV RAX,qword ptr [RSP + 0xc0]
MOV RDI,qword ptr [RAX + -0x18]
ADD RDI,R14
LAB_001287cd:
MOV ESI,0xa
CALL 0x00108350
MOVSX EDX,AL
MOV RDI,R14
MOV RSI,R15
CALL 0x00108620
MOV RCX,qword ptr [RAX]
MOV RCX,qword ptr [RCX + -0x18]
TEST byte ptr [RAX + RCX*0x1 + 0x20],0x5
JNZ 0x00128800
MOV RDI,R12
MOV RSI,R15
CALL 0x00115cac
JMP 0x001287be
LAB_00128800:
MOV RDI,qword ptr [RSP + 0x50]
CMP RDI,R13
JZ 0x00128817
MOV RSI,qword ptr [RSP + 0x60]
INC RSI
CALL 0x00108380
LAB_00128817:
LEA R12,[RSP + 0x30]
LAB_0012881c:
LEA RDI,[RSP + 0xc0]
CALL 0x001080a0
TEST BPL,0x5
JNZ 0x001288dc
LAB_00128833:
LEA RDI,[RSP + 0x40]
MOV RSI,RSP
CALL 0x0012989c
ADD RBX,0x8
LAB_00128844:
LEA RSI,[0x135791]
MOV RDI,RBX
CALL 0x00128e32
MOV RBX,RAX
LEA R14,[RSP + 0x90]
MOV qword ptr [R14 + -0x10],R14
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
ADD RDX,RSI
LEA RDI,[RSP + 0x80]
CALL 0x00109eca
LAB_0012887c:
LEA RSI,[RSP + 0x80]
MOV RDI,RBX
CALL 0x00129784
LEA RSI,[0x13714b]
MOV RDI,RAX
CALL 0x00128e32
LAB_0012889b:
LEA RSI,[RSP + 0x40]
MOV RDI,RAX
CALL 0x00128ea8
MOV RDI,qword ptr [RSP + 0x80]
CMP RDI,R14
JZ 0x001288c5
MOV RSI,qword ptr [RSP + 0x90]
INC RSI
CALL 0x00108380
LAB_001288c5:
LEA RBX,[RSP + 0x40]
MOV RDI,RBX
XOR ESI,ESI
CALL 0x00129abe
MOV RDI,RBX
CALL 0x00129b94
LAB_001288dc:
MOV RDI,RSP
CALL 0x0010c2b2
MOV RDI,qword ptr [RSP + 0x20]
CMP RDI,R12
JZ 0x001288fb
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x00108380
LAB_001288fb:
ADD RSP,0x2c8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* FileWriterJson::writeFileContents(std::filesystem::__cxx11::path const&,
std::filesystem::__cxx11::path const&) */
void FileWriterJson::writeFileContents(path *param_1,path *param_2)
{
uint uVar1;
char cVar2;
istream *piVar3;
basic_json *pbVar4;
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*pbVar5;
ulong *local_2f8;
long lStack_2f0;
ulong local_2e8;
long *local_2d8;
long local_2d0;
long local_2c8 [2];
data local_2b8 [16];
ulong *local_2a8;
long lStack_2a0;
ulong local_298 [2];
data local_288 [16];
long *local_278 [2];
long local_268 [2];
long *local_258 [2];
long local_248 [2];
ulong *local_238;
long lStack_230;
ulong local_228;
uint auStack_218 [122];
std::filesystem::relative((path *)&local_238,param_2);
local_2d8 = local_2c8;
/* try { // try from 0012862d to 00128636 has its CatchHandler @ 0012895c */
std::__cxx11::string::_M_construct<char_const*>(&local_2d8,local_238,lStack_230 + (long)local_238)
;
std::filesystem::__cxx11::path::~path((path *)&local_238);
local_2f8 = (ulong *)0x0;
lStack_2f0 = 0;
local_2e8 = 0;
if (param_1[0x260] == (path)0x1) {
/* try { // try from 0012865d to 00128669 has its CatchHandler @ 00128917 */
CommentStripper::strip((CommentStripper *)&local_2a8,param_2);
local_228 = local_2e8;
lStack_230 = lStack_2f0;
local_238 = local_2f8;
local_2f8 = local_2a8;
lStack_2f0 = lStack_2a0;
local_2e8 = local_298[0];
local_2a8 = (ulong *)0x0;
lStack_2a0 = 0;
local_298[0] = 0;
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)&local_238);
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)&local_2a8);
}
else {
/* try { // try from 001286c2 to 001286d6 has its CatchHandler @ 00128915 */
std::ifstream::ifstream((ifstream *)&local_238,*(int8 *)param_2,8);
uVar1 = *(uint *)((long)auStack_218 + local_238[-3]);
if ((uVar1 & 5) == 0) {
lStack_2a0 = 0;
local_298[0] = local_298[0] & 0xffffffffffffff00;
local_2a8 = local_298;
while( true ) {
/* try { // try from 001287cd to 001287fd has its CatchHandler @ 001289af */
cVar2 = std::ios::widen((char)local_238[-3] + (char)(istream *)&local_238);
piVar3 = std::getline<char,std::char_traits<char>,std::allocator<char>>
((istream *)&local_238,(string *)&local_2a8,cVar2);
if (((byte)piVar3[*(long *)(*(long *)piVar3 + -0x18) + 0x20] & 5) != 0) break;
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::push_back
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)&local_2f8,
(string *)&local_2a8);
}
if (local_2a8 != local_298) {
operator_delete(local_2a8,local_298[0] + 1);
}
}
else {
/* try { // try from 001286f4 to 00128704 has its CatchHandler @ 0012890d */
_ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRA20_KcA20_cTnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SK_EE5valueEiE4typeELi0EEEOT_
(local_288,"Unable to read file");
/* try { // try from 00128709 to 0012873d has its CatchHandler @ 0012893b */
pbVar4 = nlohmann::json_abi_v3_12_0::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator[]<char_const>
((basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)(param_1 + 8),"files");
local_258[0] = local_248;
std::__cxx11::string::_M_construct<char*>(local_258,local_2d8,local_2d0 + (long)local_2d8);
/* try { // try from 0012873e to 0012875c has its CatchHandler @ 00128919 */
pbVar5 = (basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)nlohmann::json_abi_v3_12_0::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator[]((basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)pbVar4,local_258);
pbVar4 = nlohmann::json_abi_v3_12_0::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator[]<char_const>(pbVar5,"error");
nlohmann::json_abi_v3_12_0::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=((basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)pbVar4,local_288);
if (local_258[0] != local_248) {
operator_delete(local_258[0],local_248[0] + 1);
}
nlohmann::json_abi_v3_12_0::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_288,0));
nlohmann::json_abi_v3_12_0::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_288);
}
std::ifstream::~ifstream((ifstream *)&local_238);
if ((uVar1 & 5) != 0) goto LAB_001288dc;
}
/* try { // try from 00128833 to 0012883f has its CatchHandler @ 00128957 */
_ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS3_IS9_SaIS9_EESG_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SJ_EE5valueEiE4typeELi0EEEOT_
(local_2b8,&local_2f8);
/* try { // try from 00128844 to 0012887b has its CatchHandler @ 00128993 */
pbVar4 = nlohmann::json_abi_v3_12_0::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator[]<char_const>
((basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)(param_1 + 8),"files");
local_278[0] = local_268;
std::__cxx11::string::_M_construct<char*>(local_278,local_2d8,local_2d0 + (long)local_2d8);
/* try { // try from 0012887c to 0012889a has its CatchHandler @ 00128971 */
pbVar5 = (basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)nlohmann::json_abi_v3_12_0::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator[]((basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)pbVar4,local_278);
pbVar4 = nlohmann::json_abi_v3_12_0::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator[]<char_const>(pbVar5,"content");
nlohmann::json_abi_v3_12_0::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=((basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)pbVar4,local_2b8);
if (local_278[0] != local_268) {
operator_delete(local_278[0],local_268[0] + 1);
}
nlohmann::json_abi_v3_12_0::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_2b8,0));
nlohmann::json_abi_v3_12_0::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_2b8);
LAB_001288dc:
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)&local_2f8);
if (local_2d8 != local_2c8) {
operator_delete(local_2d8,local_2c8[0] + 1);
}
return;
}
| |
27,863 | bytes_remove_leading_zeros | corpus-core[P]colibri-stateless/src/util/bytes.c | bytes_t bytes_remove_leading_zeros(bytes_t data) {
while (data.len > 1 && data.data[0] == 0) {
data.len--;
data.data++;
}
return data;
} | O0 | c | bytes_remove_leading_zeros:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
xorl %eax, %eax
cmpl $0x1, -0x20(%rbp)
movb %al, -0x21(%rbp)
jbe 0x9f4c6
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x9f4cf
jmp 0x9f4e6
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x9f4ab
movups -0x20(%rbp), %xmm0
movaps %xmm0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
popq %rbp
retq
nopw (%rax,%rax)
| bytes_remove_leading_zeros:
push rbp
mov rbp, rsp
mov dword ptr [rbp+var_20], edi
mov qword ptr [rbp+var_20+8], rsi
loc_9F4AB:
xor eax, eax
cmp dword ptr [rbp+var_20], 1
mov [rbp+var_21], al
jbe short loc_9F4C6
mov rax, qword ptr [rbp+var_20+8]
movzx eax, byte ptr [rax]
cmp eax, 0
setz al
mov [rbp+var_21], al
loc_9F4C6:
mov al, [rbp+var_21]
test al, 1
jnz short loc_9F4CF
jmp short loc_9F4E6
loc_9F4CF:
mov eax, dword ptr [rbp+var_20]
add eax, 0FFFFFFFFh
mov dword ptr [rbp+var_20], eax
mov rax, qword ptr [rbp+var_20+8]
add rax, 1
mov qword ptr [rbp+var_20+8], rax
jmp short loc_9F4AB
loc_9F4E6:
movups xmm0, [rbp+var_20]
movaps [rbp+var_10], xmm0
mov eax, dword ptr [rbp+var_10]
mov rdx, qword ptr [rbp+var_10+8]
pop rbp
retn
| long long bytes_remove_leading_zeros(unsigned int a1, _BYTE *a2)
{
bool v3; // [rsp+1h] [rbp-21h]
while ( 1 )
{
v3 = 0;
if ( a1 > 1 )
v3 = *a2 == 0;
if ( !v3 )
break;
--a1;
++a2;
}
return a1;
}
| bytes_remove_leading_zeros:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x20],EDI
MOV qword ptr [RBP + -0x18],RSI
LAB_0019f4ab:
XOR EAX,EAX
CMP dword ptr [RBP + -0x20],0x1
MOV byte ptr [RBP + -0x21],AL
JBE 0x0019f4c6
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x0
SETZ AL
MOV byte ptr [RBP + -0x21],AL
LAB_0019f4c6:
MOV AL,byte ptr [RBP + -0x21]
TEST AL,0x1
JNZ 0x0019f4cf
JMP 0x0019f4e6
LAB_0019f4cf:
MOV EAX,dword ptr [RBP + -0x20]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x20],EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0019f4ab
LAB_0019f4e6:
MOVUPS XMM0,xmmword ptr [RBP + -0x20]
MOVAPS xmmword ptr [RBP + -0x10],XMM0
MOV EAX,dword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
POP RBP
RET
|
int1 [16] bytes_remove_leading_zeros(uint param_1,char *param_2)
{
bool bVar1;
int1 auVar2 [16];
uint local_28;
char *pcStack_20;
local_28 = param_1;
pcStack_20 = param_2;
while( true ) {
bVar1 = false;
if (1 < local_28) {
bVar1 = *pcStack_20 == '\0';
}
if (!bVar1) break;
local_28 = local_28 - 1;
pcStack_20 = pcStack_20 + 1;
}
auVar2._4_4_ = 0;
auVar2._0_4_ = local_28;
auVar2._8_8_ = pcStack_20;
return auVar2;
}
| |
27,864 | bytes_remove_leading_zeros | corpus-core[P]colibri-stateless/src/util/bytes.c | bytes_t bytes_remove_leading_zeros(bytes_t data) {
while (data.len > 1 && data.data[0] == 0) {
data.len--;
data.data++;
}
return data;
} | O3 | c | bytes_remove_leading_zeros:
movl %edi, %eax
cmpl $0x2, %edi
jb 0x53c45
leal -0x2(%rax), %ecx
leaq (%rsi,%rcx), %rdx
incq %rdx
cmpb $0x0, (%rsi)
jne 0x53c45
decl %eax
incq %rsi
cmpl $0x1, %eax
ja 0x53c30
movl $0x1, %eax
retq
movq %rsi, %rdx
retq
| bytes_remove_leading_zeros:
mov eax, edi
cmp edi, 2
jb short loc_53C45
lea ecx, [rax-2]
lea rdx, [rsi+rcx]
inc rdx
loc_53C30:
cmp byte ptr [rsi], 0
jnz short loc_53C45
dec eax
inc rsi
cmp eax, 1
ja short loc_53C30
mov eax, 1
retn
loc_53C45:
mov rdx, rsi
retn
| long long bytes_remove_leading_zeros(unsigned int a1, _BYTE *a2)
{
long long result; // rax
result = a1;
if ( a1 >= 2 )
{
while ( !*a2 )
{
result = (unsigned int)(result - 1);
++a2;
if ( (unsigned int)result <= 1 )
return 1LL;
}
}
return result;
}
| bytes_remove_leading_zeros:
MOV EAX,EDI
CMP EDI,0x2
JC 0x00153c45
LEA ECX,[RAX + -0x2]
LEA RDX,[RSI + RCX*0x1]
INC RDX
LAB_00153c30:
CMP byte ptr [RSI],0x0
JNZ 0x00153c45
DEC EAX
INC RSI
CMP EAX,0x1
JA 0x00153c30
MOV EAX,0x1
RET
LAB_00153c45:
MOV RDX,RSI
RET
|
int1 [16] bytes_remove_leading_zeros(uint param_1,char *param_2)
{
uint uVar1;
ulong uVar2;
int1 auVar3 [16];
int1 auVar4 [16];
uVar2 = (ulong)param_1;
if (1 < param_1) {
auVar3._8_8_ = param_2 + (ulong)(param_1 - 2) + 1;
while (*param_2 == '\0') {
uVar1 = (int)uVar2 - 1;
uVar2 = (ulong)uVar1;
param_2 = param_2 + 1;
if (uVar1 < 2) {
auVar3._0_8_ = 1;
return auVar3;
}
}
}
auVar4._8_8_ = param_2;
auVar4._0_8_ = uVar2;
return auVar4;
}
| |
27,865 | JS_VALUE_IS_NAN | bluesky950520[P]quickjs/quickjs.h | static inline JS_BOOL JS_VALUE_IS_NAN(JSValue v)
{
union {
double d;
uint64_t u64;
} u;
if (v.tag != JS_TAG_FLOAT64)
return 0;
u.d = v.u.float64;
return (u.u64 & 0x7fffffffffffffff) > 0x7ff0000000000000;
} | O0 | c | JS_VALUE_IS_NAN:
movq %rdi, -0x18(%rsp)
movq %rsi, -0x10(%rsp)
cmpq $0x7, -0x10(%rsp)
je 0x61bcc
movl $0x0, -0x4(%rsp)
jmp 0x61c00
movsd -0x18(%rsp), %xmm0
movsd %xmm0, -0x20(%rsp)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
andq -0x20(%rsp), %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
| JS_VALUE_IS_NAN:
mov [rsp+var_18], rdi
mov [rsp+var_10], rsi
cmp [rsp+var_10], 7
jz short loc_61BCC
mov [rsp+var_4], 0
jmp short loc_61C00
loc_61BCC:
movsd xmm0, [rsp+var_18]
movsd [rsp+var_20], xmm0
mov rax, 7FFFFFFFFFFFFFFFh
and rax, [rsp+var_20]
mov rcx, 7FF0000000000000h
cmp rax, rcx
setnbe al
and al, 1
movzx eax, al
mov [rsp+var_4], eax
loc_61C00:
mov eax, [rsp+var_4]
retn
| _BOOL8 JS_VALUE_IS_NAN(long long a1, long long a2)
{
return a2 == 7 && (a1 & 0x7FFFFFFFFFFFFFFFuLL) > 0x7FF0000000000000LL;
}
| JS_VALUE_IS_NAN:
MOV qword ptr [RSP + -0x18],RDI
MOV qword ptr [RSP + -0x10],RSI
CMP qword ptr [RSP + -0x10],0x7
JZ 0x00161bcc
MOV dword ptr [RSP + -0x4],0x0
JMP 0x00161c00
LAB_00161bcc:
MOVSD XMM0,qword ptr [RSP + -0x18]
MOVSD qword ptr [RSP + -0x20],XMM0
MOV RAX,0x7fffffffffffffff
AND RAX,qword ptr [RSP + -0x20]
MOV RCX,0x7ff0000000000000
CMP RAX,RCX
SETA AL
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RSP + -0x4],EAX
LAB_00161c00:
MOV EAX,dword ptr [RSP + -0x4]
RET
|
bool JS_VALUE_IS_NAN(ulong param_1,long param_2)
{
return param_2 == 7 && 0x7ff0000000000000 < (param_1 & 0x7fffffffffffffff);
}
| |
27,866 | mariadb_compress_alloc | eloqsql/libmariadb/libmariadb/ma_compress.c | unsigned char *_mariadb_compress_alloc(NET *net, const unsigned char *packet, size_t *len, size_t *complen)
{
unsigned char *compbuf;
*complen = *len * 120 / 100 + 12;
if (!(compbuf = (unsigned char *) malloc(*complen)))
return 0; /* Not enough memory */
if (compression_plugin(net)->compress(compression_ctx(net), (void *)compbuf, complen, (void *)packet, *len))
{
free(compbuf);
return 0;
}
if (*complen >= *len)
{
*complen=0;
free(compbuf);
return 0;
}
swap(size_t,*len,*complen); /* *len is now packet length */
return compbuf;
} | O3 | c | mariadb_compress_alloc:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
imulq $0x78, (%rdx), %rax
shrq $0x2, %rax
movabsq $0x28f5c28f5c28f5c3, %rcx # imm = 0x28F5C28F5C28F5C3
mulq %rcx
shrq $0x2, %rdx
leaq 0xc(%rdx), %rdi
movq %rdi, (%rbx)
callq 0x5faf0
testq %rax, %rax
je 0x7b804
movq %rax, %r14
movq 0x2a0(%r13), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rax
movq (%r15), %r8
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq *0x68(%rax)
testb %al, %al
jne 0x7b7fc
movq (%rbx), %rax
movq (%r15), %rcx
cmpq %rcx, %rax
jae 0x7b7f5
movq %rax, (%r15)
movq %rcx, (%rbx)
jmp 0x7b807
movq $0x0, (%rbx)
movq %r14, %rdi
callq 0x5f1d0
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _mariadb_compress_alloc:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rcx
mov r15, rdx
mov r12, rsi
mov r13, rdi
imul rax, [rdx], 78h ; 'x'
shr rax, 2
mov rcx, 28F5C28F5C28F5C3h
mul rcx
shr rdx, 2
lea rdi, [rdx+0Ch]
mov [rbx], rdi
call _malloc
test rax, rax
jz short loc_7B804
mov r14, rax
mov rax, [r13+2A0h]
mov rdi, [rax+8]
mov rax, [rax+10h]
mov r8, [r15]
mov rsi, r14
mov rdx, rbx
mov rcx, r12
call qword ptr [rax+68h]
test al, al
jnz short loc_7B7FC
mov rax, [rbx]
mov rcx, [r15]
cmp rax, rcx
jnb short loc_7B7F5
mov [r15], rax
mov [rbx], rcx
jmp short loc_7B807
loc_7B7F5:
mov qword ptr [rbx], 0
loc_7B7FC:
mov rdi, r14
call _free
loc_7B804:
xor r14d, r14d
loc_7B807:
mov rax, r14
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long mariadb_compress_alloc(long long a1, long long a2, unsigned long long *a3, unsigned long long *a4)
{
unsigned long long v7; // rdi
long long v8; // rax
long long v9; // r14
unsigned long long v10; // rcx
v7 = 120 * *a3 / 0x64 + 12;
*a4 = v7;
v8 = malloc(v7);
if ( !v8 )
return 0LL;
v9 = v8;
if ( (*(unsigned __int8 ( **)(_QWORD, long long, unsigned long long *, long long, unsigned long long))(*(_QWORD *)(*(_QWORD *)(a1 + 672) + 16LL) + 104LL))(
*(_QWORD *)(*(_QWORD *)(a1 + 672) + 8LL),
v8,
a4,
a2,
*a3) )
{
LABEL_6:
free(v9);
return 0LL;
}
v10 = *a3;
if ( *a4 >= *a3 )
{
*a4 = 0LL;
goto LABEL_6;
}
*a3 = *a4;
*a4 = v10;
return v9;
}
| _mariadb_compress_alloc:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R15,RDX
MOV R12,RSI
MOV R13,RDI
IMUL RAX,qword ptr [RDX],0x78
SHR RAX,0x2
MOV RCX,0x28f5c28f5c28f5c3
MUL RCX
SHR RDX,0x2
LEA RDI,[RDX + 0xc]
MOV qword ptr [RBX],RDI
CALL 0x0015faf0
TEST RAX,RAX
JZ 0x0017b804
MOV R14,RAX
MOV RAX,qword ptr [R13 + 0x2a0]
MOV RDI,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV R8,qword ptr [R15]
MOV RSI,R14
MOV RDX,RBX
MOV RCX,R12
CALL qword ptr [RAX + 0x68]
TEST AL,AL
JNZ 0x0017b7fc
MOV RAX,qword ptr [RBX]
MOV RCX,qword ptr [R15]
CMP RAX,RCX
JNC 0x0017b7f5
MOV qword ptr [R15],RAX
MOV qword ptr [RBX],RCX
JMP 0x0017b807
LAB_0017b7f5:
MOV qword ptr [RBX],0x0
LAB_0017b7fc:
MOV RDI,R14
CALL 0x0015f1d0
LAB_0017b804:
XOR R14D,R14D
LAB_0017b807:
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void * _mariadb_compress_alloc(long param_1,int8 param_2,ulong *param_3,size_t *param_4)
{
size_t __size;
ulong uVar1;
char cVar2;
void *__ptr;
__size = (*param_3 * 0x78) / 100 + 0xc;
*param_4 = __size;
__ptr = malloc(__size);
if (__ptr != (void *)0x0) {
cVar2 = (**(code **)(*(long *)(*(long *)(param_1 + 0x2a0) + 0x10) + 0x68))
(*(int8 *)(*(long *)(param_1 + 0x2a0) + 8),__ptr,param_4,param_2,
*param_3);
if (cVar2 == '\0') {
uVar1 = *param_3;
if (*param_4 < uVar1) {
*param_3 = *param_4;
*param_4 = uVar1;
return __ptr;
}
*param_4 = 0;
}
free(__ptr);
}
return (void *)0x0;
}
| |
27,867 | translog_write_variable_record_1group | eloqsql/storage/maria/ma_loghandler.c | static my_bool
translog_write_variable_record_1group(LSN *lsn,
enum translog_record_type type,
MARIA_HA *tbl_info,
SHORT_TRANSACTION_ID short_trid,
struct st_translog_parts *parts,
struct st_translog_buffer
*buffer_to_flush, uint16 header_length,
TRN *trn, void *hook_arg)
{
TRANSLOG_ADDRESS horizon;
struct st_buffer_cursor cursor;
int rc= 0;
uint i;
translog_size_t record_rest, full_pages, first_page;
uint additional_chunk3_page= 0;
uchar chunk0_header[1 + 2 + 5 + 2];
DBUG_ENTER("translog_write_variable_record_1group");
translog_lock_assert_owner();
if (buffer_to_flush)
translog_buffer_lock_assert_owner(buffer_to_flush);
set_lsn(lsn, horizon= log_descriptor.horizon);
if (translog_set_lsn_for_files(LSN_FILE_NO(*lsn), LSN_FILE_NO(*lsn),
*lsn, TRUE) ||
(log_record_type_descriptor[type].inwrite_hook &&
(*log_record_type_descriptor[type].inwrite_hook)(type, trn, tbl_info,
lsn, hook_arg)))
{
translog_unlock();
if (buffer_to_flush != NULL)
{
translog_buffer_flush(buffer_to_flush);
translog_buffer_unlock(buffer_to_flush);
}
DBUG_RETURN(1);
}
cursor= log_descriptor.bc;
cursor.chaser= 1;
/* Advance pointer to be able unlock the loghandler */
first_page= translog_get_current_page_rest();
record_rest= parts->record_length - (first_page - header_length);
full_pages= record_rest / log_descriptor.page_capacity_chunk_2;
record_rest= (record_rest % log_descriptor.page_capacity_chunk_2);
if (record_rest + 1 == log_descriptor.page_capacity_chunk_2)
{
DBUG_PRINT("info", ("2 chunks type 3 is needed"));
/* We will write 2 chunks type 3 at the end of this group */
additional_chunk3_page= 1;
record_rest= 1;
}
DBUG_PRINT("info", ("first_page: %u (%u) full_pages: %u (%lu) "
"additional: %u (%u) rest %u = %u",
first_page, first_page - header_length,
full_pages,
(ulong) full_pages *
log_descriptor.page_capacity_chunk_2,
additional_chunk3_page,
additional_chunk3_page *
(log_descriptor.page_capacity_chunk_2 - 1),
record_rest, parts->record_length));
/* record_rest + 3 is chunk type 3 overhead + record_rest */
rc= translog_advance_pointer((int)(full_pages + additional_chunk3_page),
(record_rest ? record_rest + 3 : 0),
&cursor.buffs);
log_descriptor.bc.buffer->last_lsn= *lsn;
DBUG_PRINT("info", ("last_lsn set to " LSN_FMT " buffer: %p",
LSN_IN_PARTS(log_descriptor.bc.buffer->last_lsn),
log_descriptor.bc.buffer));
translog_unlock();
/*
Check if we switched buffer and need process it (current buffer is
unlocked already => we will not delay other threads
*/
if (buffer_to_flush != NULL)
{
if (!rc)
rc= translog_buffer_flush(buffer_to_flush);
translog_buffer_unlock(buffer_to_flush);
}
if (rc)
{
//translog_advance_pointer decreased writers so it is OK
DBUG_ASSERT(cursor.buffs.unlck_ptr == cursor.buffs.wrt_ptr);
DBUG_RETURN(1);
}
translog_write_variable_record_1group_header(parts, type, short_trid,
header_length, chunk0_header);
/* fill the pages */
translog_write_parts_on_page(&horizon, &cursor, first_page, parts);
DBUG_PRINT("info", ("absolute horizon: " LSN_FMT " local: " LSN_FMT,
LSN_IN_PARTS(log_descriptor.horizon),
LSN_IN_PARTS(horizon)));
for (i= 0; i < full_pages; i++)
{
if (translog_write_variable_record_chunk2_page(parts, &horizon, &cursor))
goto error;
DBUG_PRINT("info", ("absolute horizon: " LSN_FMT " local: " LSN_FMT,
LSN_IN_PARTS(log_descriptor.horizon),
LSN_IN_PARTS(horizon)));
}
if (additional_chunk3_page)
{
if (translog_write_variable_record_chunk3_page(parts,
log_descriptor.
page_capacity_chunk_2 - 2,
&horizon, &cursor))
goto error;
DBUG_PRINT("info", ("absolute horizon: " LSN_FMT " local: " LSN_FMT,
LSN_IN_PARTS(log_descriptor.horizon),
LSN_IN_PARTS(horizon)));
DBUG_ASSERT(cursor.current_page_fill == TRANSLOG_PAGE_SIZE);
}
if (translog_write_variable_record_chunk3_page(parts,
record_rest,
&horizon, &cursor))
goto error;
DBUG_PRINT("info", ("absolute horizon: " LSN_FMT " local: " LSN_FMT,
(uint) LSN_FILE_NO(log_descriptor.horizon),
(uint) LSN_OFFSET(log_descriptor.horizon),
(uint) LSN_FILE_NO(horizon),
(uint) LSN_OFFSET(horizon)));
translog_buffer_lock(cursor.buffer);
translog_buffer_decrease_writers(cursor.buffer);
used_buffs_register_unlock(&cursor.buffs, cursor.buffer);
translog_buffer_unlock(cursor.buffer);
DBUG_ASSERT(cursor.buffs.unlck_ptr == cursor.buffs.wrt_ptr);
DBUG_RETURN(0);
error:
used_buffs_urgent_unlock(&cursor.buffs);
DBUG_RETURN(1);
} | O0 | c | translog_write_variable_record_1group:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movw %cx, %ax
movq 0x20(%rbp), %rcx
movq 0x18(%rbp), %rcx
movw 0x10(%rbp), %cx
movq %fs:0x28, %rcx
movq %rcx, -0x8(%rbp)
movq %rdi, -0x20(%rbp)
movl %esi, -0x24(%rbp)
movq %rdx, -0x30(%rbp)
movw %ax, -0x32(%rbp)
movq %r8, -0x40(%rbp)
movq %r9, -0x48(%rbp)
movl $0x0, -0x94(%rbp)
movl $0x0, -0xa8(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x3634b
jmp 0x3634b
movq -0x20(%rbp), %rdi
movq 0xc4a682(%rip), %rsi # 0xc809d8
movq %rsi, -0x50(%rbp)
callq 0x376c0
movq -0x20(%rbp), %rax
movq (%rax), %rax
sarq $0x20, %rax
movl %eax, %edi
movq -0x20(%rbp), %rax
movq (%rax), %rax
sarq $0x20, %rax
movl %eax, %esi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movl $0x1, %ecx
callq 0x376f0
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x363e0
movl -0x24(%rbp), %eax
movl %eax, %ecx
leaq 0x4487f2(%rip), %rax # 0x47eb90
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
je 0x36409
movl -0x24(%rbp), %eax
movl %eax, %ecx
leaq 0x4487d8(%rip), %rax # 0x47eb90
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movl -0x24(%rbp), %edi
movq 0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq 0x20(%rbp), %r8
callq *%rax
movsbl %al, %eax
cmpl $0x0, %eax
je 0x36409
callq 0x2c4b0
cmpq $0x0, -0x48(%rbp)
je 0x363fe
movq -0x48(%rbp), %rdi
callq 0x32670
movq -0x48(%rbp), %rdi
callq 0x2c480
jmp 0x36400
movb $0x1, -0x13(%rbp)
jmp 0x36694
leaq -0x90(%rbp), %rdi
leaq 0x449979(%rip), %rsi # 0x47fd90
addq $0x800c50, %rsi # imm = 0x800C50
movl $0x40, %edx
callq 0x2a0b0
movb $0x1, -0x59(%rbp)
callq 0x38150
movl %eax, -0xa4(%rbp)
movq -0x40(%rbp), %rax
movl (%rax), %eax
movl -0xa4(%rbp), %ecx
movzwl 0x10(%rbp), %edx
subl %edx, %ecx
subl %ecx, %eax
movl %eax, -0x9c(%rbp)
movl -0x9c(%rbp), %eax
movzwl 0x449958(%rip), %ecx # 0x47fdb6
xorl %edx, %edx
divl %ecx
movl %eax, -0xa0(%rbp)
movl -0x9c(%rbp), %eax
movzwl 0x449941(%rip), %ecx # 0x47fdb6
xorl %edx, %edx
divl %ecx
movl %edx, -0x9c(%rbp)
movl -0x9c(%rbp), %eax
addl $0x1, %eax
movzwl 0x449927(%rip), %ecx # 0x47fdb6
cmpl %ecx, %eax
jne 0x364ab
jmp 0x36495
jmp 0x36497
movl $0x1, -0xa8(%rbp)
movl $0x1, -0x9c(%rbp)
jmp 0x364ad
jmp 0x364af
movl -0xa0(%rbp), %eax
addl -0xa8(%rbp), %eax
movl %eax, -0xac(%rbp)
cmpl $0x0, -0x9c(%rbp)
je 0x364db
movl -0x9c(%rbp), %eax
addl $0x3, %eax
movl %eax, -0xb0(%rbp)
jmp 0x364e5
xorl %eax, %eax
movl %eax, -0xb0(%rbp)
jmp 0x364e5
movl -0xac(%rbp), %edi
movl -0xb0(%rbp), %eax
leaq -0x90(%rbp), %rdx
movzwl %ax, %esi
callq 0x37b70
movsbl %al, %eax
movl %eax, -0x94(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq 0xc4a4f1(%rip), %rax # 0xc80a08
movq %rcx, 0x100000(%rax)
jmp 0x36520
callq 0x2c4b0
cmpq $0x0, -0x48(%rbp)
je 0x36550
cmpl $0x0, -0x94(%rbp)
jne 0x36547
movq -0x48(%rbp), %rdi
callq 0x32670
movsbl %al, %eax
movl %eax, -0x94(%rbp)
movq -0x48(%rbp), %rdi
callq 0x2c480
cmpl $0x0, -0x94(%rbp)
je 0x36568
jmp 0x3655b
jmp 0x3655d
jmp 0x3655f
movb $0x1, -0x13(%rbp)
jmp 0x36694
movq -0x40(%rbp), %rdi
movl -0x24(%rbp), %esi
movw -0x32(%rbp), %cx
movw 0x10(%rbp), %ax
leaq -0x12(%rbp), %r8
movzwl %cx, %edx
movzwl %ax, %ecx
callq 0x375f0
movl -0xa4(%rbp), %edx
movq -0x40(%rbp), %rcx
leaq -0x50(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x37890
jmp 0x365a2
movl $0x0, -0x98(%rbp)
movl -0x98(%rbp), %eax
cmpl -0xa0(%rbp), %eax
jae 0x365ee
movq -0x40(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x37ef0
cmpb $0x0, %al
je 0x365d7
jmp 0x36684
jmp 0x365d9
jmp 0x365db
jmp 0x365dd
movl -0x98(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x98(%rbp)
jmp 0x365ac
cmpl $0x0, -0xa8(%rbp)
je 0x36628
movq -0x40(%rbp), %rdi
movzwl 0x4497b4(%rip), %eax # 0x47fdb6
subl $0x2, %eax
leaq -0x50(%rbp), %rdx
leaq -0x90(%rbp), %rcx
movzwl %ax, %esi
callq 0x37f60
cmpb $0x0, %al
je 0x3661e
jmp 0x36684
jmp 0x36620
jmp 0x36622
jmp 0x36624
jmp 0x36626
jmp 0x36628
movq -0x40(%rbp), %rdi
movl -0x9c(%rbp), %eax
leaq -0x50(%rbp), %rdx
leaq -0x90(%rbp), %rcx
movzwl %ax, %esi
callq 0x37f60
cmpb $0x0, %al
je 0x3664b
jmp 0x36684
jmp 0x3664d
jmp 0x3664f
movq -0x68(%rbp), %rdi
callq 0x2c440
movq -0x68(%rbp), %rdi
callq 0x38040
leaq -0x90(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x38090
movq -0x68(%rbp), %rdi
callq 0x2c480
jmp 0x3667c
jmp 0x3667e
movb $0x0, -0x13(%rbp)
jmp 0x36694
leaq -0x90(%rbp), %rdi
callq 0x380c0
movb $0x1, -0x13(%rbp)
movb -0x13(%rbp), %al
movb %al, -0xb1(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x366be
movb -0xb1(%rbp), %al
addq $0xc0, %rsp
popq %rbp
retq
callq 0x2a250
nopw %cs:(%rax,%rax)
| translog_write_variable_record_1group:
push rbp
mov rbp, rsp
sub rsp, 0C0h
mov ax, cx
mov rcx, [rbp+arg_10]
mov rcx, [rbp+arg_8]
mov cx, [rbp+arg_0]
mov rcx, fs:28h
mov [rbp+var_8], rcx
mov [rbp+var_20], rdi
mov [rbp+var_24], esi
mov [rbp+var_30], rdx
mov [rbp+var_32], ax
mov [rbp+var_40], r8
mov [rbp+var_48], r9
mov [rbp+var_94], 0
mov [rbp+var_A8], 0
cmp [rbp+var_48], 0
jz short loc_3634B
jmp short $+2
loc_3634B:
mov rdi, [rbp+var_20]
mov rsi, cs:qword_C809D8
mov [rbp+var_50], rsi
call set_lsn
mov rax, [rbp+var_20]
mov rax, [rax]
sar rax, 20h
mov edi, eax
mov rax, [rbp+var_20]
mov rax, [rax]
sar rax, 20h
mov esi, eax
mov rax, [rbp+var_20]
mov rdx, [rax]
mov ecx, 1
call translog_set_lsn_for_files
movsx eax, al
cmp eax, 0
jnz short loc_363E0
mov eax, [rbp+var_24]
mov ecx, eax
lea rax, log_record_type_descriptor
imul rcx, 48h ; 'H'
add rax, rcx
cmp qword ptr [rax+10h], 0
jz short loc_36409
mov eax, [rbp+var_24]
mov ecx, eax
lea rax, log_record_type_descriptor
imul rcx, 48h ; 'H'
add rax, rcx
mov rax, [rax+10h]
mov edi, [rbp+var_24]
mov rsi, [rbp+arg_8]
mov rdx, [rbp+var_30]
mov rcx, [rbp+var_20]
mov r8, [rbp+arg_10]
call rax
movsx eax, al
cmp eax, 0
jz short loc_36409
loc_363E0:
call translog_unlock
cmp [rbp+var_48], 0
jz short loc_363FE
mov rdi, [rbp+var_48]
call translog_buffer_flush
mov rdi, [rbp+var_48]
call translog_buffer_unlock
loc_363FE:
jmp short $+2
loc_36400:
mov [rbp+var_13], 1
jmp loc_36694
loc_36409:
lea rdi, [rbp+var_90]
lea rsi, log_descriptor
add rsi, 800C50h
mov edx, 40h ; '@'
call _memcpy
mov [rbp+var_59], 1
call translog_get_current_page_rest
mov [rbp+var_A4], eax
mov rax, [rbp+var_40]
mov eax, [rax]
mov ecx, [rbp+var_A4]
movzx edx, [rbp+arg_0]
sub ecx, edx
sub eax, ecx
mov [rbp+var_9C], eax
mov eax, [rbp+var_9C]
movzx ecx, cs:word_47FDB6
xor edx, edx
div ecx
mov [rbp+var_A0], eax
mov eax, [rbp+var_9C]
movzx ecx, cs:word_47FDB6
xor edx, edx
div ecx
mov [rbp+var_9C], edx
mov eax, [rbp+var_9C]
add eax, 1
movzx ecx, cs:word_47FDB6
cmp eax, ecx
jnz short loc_364AB
jmp short $+2
loc_36495:
jmp short $+2
loc_36497:
mov [rbp+var_A8], 1
mov [rbp+var_9C], 1
loc_364AB:
jmp short $+2
loc_364AD:
jmp short $+2
loc_364AF:
mov eax, [rbp+var_A0]
add eax, [rbp+var_A8]
mov [rbp+var_AC], eax
cmp [rbp+var_9C], 0
jz short loc_364DB
mov eax, [rbp+var_9C]
add eax, 3
mov [rbp+var_B0], eax
jmp short loc_364E5
loc_364DB:
xor eax, eax
mov [rbp+var_B0], eax
jmp short $+2
loc_364E5:
mov edi, [rbp+var_AC]
mov eax, [rbp+var_B0]
lea rdx, [rbp+var_90]
movzx esi, ax
call translog_advance_pointer
movsx eax, al
mov [rbp+var_94], eax
mov rax, [rbp+var_20]
mov rcx, [rax]
mov rax, cs:qword_C80A08
mov qword ptr ds:loc_100000[rax], rcx
jmp short $+2
loc_36520:
call translog_unlock
cmp [rbp+var_48], 0
jz short loc_36550
cmp [rbp+var_94], 0
jnz short loc_36547
mov rdi, [rbp+var_48]
call translog_buffer_flush
movsx eax, al
mov [rbp+var_94], eax
loc_36547:
mov rdi, [rbp+var_48]
call translog_buffer_unlock
loc_36550:
cmp [rbp+var_94], 0
jz short loc_36568
jmp short $+2
loc_3655B:
jmp short $+2
loc_3655D:
jmp short $+2
loc_3655F:
mov [rbp+var_13], 1
jmp loc_36694
loc_36568:
mov rdi, [rbp+var_40]
mov esi, [rbp+var_24]
mov cx, [rbp+var_32]
mov ax, [rbp+arg_0]
lea r8, [rbp+var_12]
movzx edx, cx
movzx ecx, ax
call translog_write_variable_record_1group_header
mov edx, [rbp+var_A4]
mov rcx, [rbp+var_40]
lea rdi, [rbp+var_50]
lea rsi, [rbp+var_90]
call translog_write_parts_on_page
jmp short $+2
loc_365A2:
mov [rbp+var_98], 0
loc_365AC:
mov eax, [rbp+var_98]
cmp eax, [rbp+var_A0]
jnb short loc_365EE
mov rdi, [rbp+var_40]
lea rsi, [rbp+var_50]
lea rdx, [rbp+var_90]
call translog_write_variable_record_chunk2_page
cmp al, 0
jz short loc_365D7
jmp loc_36684
loc_365D7:
jmp short $+2
loc_365D9:
jmp short $+2
loc_365DB:
jmp short $+2
loc_365DD:
mov eax, [rbp+var_98]
add eax, 1
mov [rbp+var_98], eax
jmp short loc_365AC
loc_365EE:
cmp [rbp+var_A8], 0
jz short loc_36628
mov rdi, [rbp+var_40]
movzx eax, cs:word_47FDB6
sub eax, 2
lea rdx, [rbp+var_50]
lea rcx, [rbp+var_90]
movzx esi, ax
call translog_write_variable_record_chunk3_page
cmp al, 0
jz short loc_3661E
jmp short loc_36684
loc_3661E:
jmp short $+2
loc_36620:
jmp short $+2
loc_36622:
jmp short $+2
loc_36624:
jmp short $+2
loc_36626:
jmp short $+2
loc_36628:
mov rdi, [rbp+var_40]
mov eax, [rbp+var_9C]
lea rdx, [rbp+var_50]
lea rcx, [rbp+var_90]
movzx esi, ax
call translog_write_variable_record_chunk3_page
cmp al, 0
jz short loc_3664B
jmp short loc_36684
loc_3664B:
jmp short $+2
loc_3664D:
jmp short $+2
loc_3664F:
mov rdi, [rbp+var_68]
call translog_buffer_lock
mov rdi, [rbp+var_68]
call translog_buffer_decrease_writers
lea rdi, [rbp+var_90]
mov rsi, [rbp+var_68]
call used_buffs_register_unlock
mov rdi, [rbp+var_68]
call translog_buffer_unlock
jmp short $+2
loc_3667C:
jmp short $+2
loc_3667E:
mov [rbp+var_13], 0
jmp short loc_36694
loc_36684:
lea rdi, [rbp+var_90]
call used_buffs_urgent_unlock
mov [rbp+var_13], 1
loc_36694:
mov al, [rbp+var_13]
mov [rbp+var_B1], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_366BE
mov al, [rbp+var_B1]
add rsp, 0C0h
pop rbp
retn
loc_366BE:
call ___stack_chk_fail
| char translog_write_variable_record_1group(
_QWORD *a1,
unsigned int a2,
long long a3,
unsigned __int16 a4,
_DWORD *a5,
long long a6,
unsigned __int16 a7,
long long a8,
long long a9)
{
unsigned __int16 v10; // [rsp+10h] [rbp-B0h]
int v11; // [rsp+18h] [rbp-A8h]
unsigned int current_page_rest; // [rsp+1Ch] [rbp-A4h]
unsigned int v13; // [rsp+20h] [rbp-A0h]
unsigned int v14; // [rsp+24h] [rbp-9Ch]
unsigned int v15; // [rsp+24h] [rbp-9Ch]
unsigned int i; // [rsp+28h] [rbp-98h]
int v17; // [rsp+2Ch] [rbp-94h]
_BYTE v18[40]; // [rsp+30h] [rbp-90h] BYREF
long long v19; // [rsp+58h] [rbp-68h]
char v20; // [rsp+67h] [rbp-59h]
long long v21; // [rsp+70h] [rbp-50h] BYREF
long long v22; // [rsp+78h] [rbp-48h]
_DWORD *v23; // [rsp+80h] [rbp-40h]
unsigned __int16 v24; // [rsp+8Eh] [rbp-32h]
long long v25; // [rsp+90h] [rbp-30h]
unsigned int v26; // [rsp+9Ch] [rbp-24h]
_QWORD *v27; // [rsp+A0h] [rbp-20h]
_BYTE v29[10]; // [rsp+AEh] [rbp-12h] BYREF
unsigned long long v30; // [rsp+B8h] [rbp-8h]
v30 = __readfsqword(0x28u);
v27 = a1;
v26 = a2;
v25 = a3;
v24 = a4;
v23 = a5;
v22 = a6;
v11 = 0;
v21 = qword_C809D8;
set_lsn(a1, qword_C809D8);
if ( (unsigned __int8)translog_set_lsn_for_files((unsigned int)HIDWORD(*v27), (unsigned int)HIDWORD(*v27), *v27, 1LL)
|| *(_QWORD *)&log_record_type_descriptor[18 * v26 + 4]
&& (*(unsigned __int8 ( **)(_QWORD, long long, long long, _QWORD *, long long))&log_record_type_descriptor[18 * v26 + 4])(
v26,
a8,
v25,
v27,
a9) )
{
translog_unlock();
if ( v22 )
{
translog_buffer_flush(v22);
translog_buffer_unlock(v22);
}
return 1;
}
else
{
memcpy(v18, &log_descriptor[1048970], 64LL);
v20 = 1;
current_page_rest = translog_get_current_page_rest();
v14 = *v23 - (current_page_rest - a7);
v13 = v14 / (unsigned __int16)word_47FDB6;
v15 = v14 % (unsigned __int16)word_47FDB6;
if ( v15 + 1 == (unsigned __int16)word_47FDB6 )
{
v11 = 1;
v15 = 1;
}
if ( v15 )
v10 = v15 + 3;
else
v10 = 0;
v17 = (char)translog_advance_pointer(v11 + v13, v10, v18);
*(_QWORD *)((char *)&loc_100000 + qword_C80A08) = *v27;
translog_unlock();
if ( v22 )
{
if ( !v17 )
v17 = translog_buffer_flush(v22);
translog_buffer_unlock(v22);
}
if ( v17 )
{
return 1;
}
else
{
translog_write_variable_record_1group_header(v23, v26, v24, a7, v29);
translog_write_parts_on_page(&v21, v18, current_page_rest, v23);
for ( i = 0; i < v13; ++i )
{
if ( (unsigned __int8)translog_write_variable_record_chunk2_page(v23, &v21, v18) )
goto LABEL_26;
}
if ( (!v11
|| !(unsigned __int8)translog_write_variable_record_chunk3_page(
v23,
(unsigned __int16)(word_47FDB6 - 2),
&v21,
v18))
&& !(unsigned __int8)translog_write_variable_record_chunk3_page(v23, (unsigned __int16)v15, &v21, v18) )
{
translog_buffer_lock(v19);
translog_buffer_decrease_writers(v19);
used_buffs_register_unlock(v18, v19);
translog_buffer_unlock(v19);
return 0;
}
LABEL_26:
used_buffs_urgent_unlock(v18);
return 1;
}
}
}
| translog_write_variable_record_1group:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xc0
MOV AX,CX
MOV RCX,qword ptr [RBP + 0x20]
MOV RCX,qword ptr [RBP + 0x18]
MOV CX,word ptr [RBP + 0x10]
MOV RCX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RCX
MOV qword ptr [RBP + -0x20],RDI
MOV dword ptr [RBP + -0x24],ESI
MOV qword ptr [RBP + -0x30],RDX
MOV word ptr [RBP + -0x32],AX
MOV qword ptr [RBP + -0x40],R8
MOV qword ptr [RBP + -0x48],R9
MOV dword ptr [RBP + -0x94],0x0
MOV dword ptr [RBP + -0xa8],0x0
CMP qword ptr [RBP + -0x48],0x0
JZ 0x0013634b
JMP 0x0013634b
LAB_0013634b:
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [0x00d809d8]
MOV qword ptr [RBP + -0x50],RSI
CALL 0x001376c0
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
SAR RAX,0x20
MOV EDI,EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
SAR RAX,0x20
MOV ESI,EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RAX]
MOV ECX,0x1
CALL 0x001376f0
MOVSX EAX,AL
CMP EAX,0x0
JNZ 0x001363e0
MOV EAX,dword ptr [RBP + -0x24]
MOV ECX,EAX
LEA RAX,[0x57eb90]
IMUL RCX,RCX,0x48
ADD RAX,RCX
CMP qword ptr [RAX + 0x10],0x0
JZ 0x00136409
MOV EAX,dword ptr [RBP + -0x24]
MOV ECX,EAX
LEA RAX,[0x57eb90]
IMUL RCX,RCX,0x48
ADD RAX,RCX
MOV RAX,qword ptr [RAX + 0x10]
MOV EDI,dword ptr [RBP + -0x24]
MOV RSI,qword ptr [RBP + 0x18]
MOV RDX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x20]
MOV R8,qword ptr [RBP + 0x20]
CALL RAX
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x00136409
LAB_001363e0:
CALL 0x0012c4b0
CMP qword ptr [RBP + -0x48],0x0
JZ 0x001363fe
MOV RDI,qword ptr [RBP + -0x48]
CALL 0x00132670
MOV RDI,qword ptr [RBP + -0x48]
CALL 0x0012c480
LAB_001363fe:
JMP 0x00136400
LAB_00136400:
MOV byte ptr [RBP + -0x13],0x1
JMP 0x00136694
LAB_00136409:
LEA RDI,[RBP + -0x90]
LEA RSI,[0x57fd90]
ADD RSI,0x800c50
MOV EDX,0x40
CALL 0x0012a0b0
MOV byte ptr [RBP + -0x59],0x1
CALL 0x00138150
MOV dword ptr [RBP + -0xa4],EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RAX]
MOV ECX,dword ptr [RBP + -0xa4]
MOVZX EDX,word ptr [RBP + 0x10]
SUB ECX,EDX
SUB EAX,ECX
MOV dword ptr [RBP + -0x9c],EAX
MOV EAX,dword ptr [RBP + -0x9c]
MOVZX ECX,word ptr [0x0057fdb6]
XOR EDX,EDX
DIV ECX
MOV dword ptr [RBP + -0xa0],EAX
MOV EAX,dword ptr [RBP + -0x9c]
MOVZX ECX,word ptr [0x0057fdb6]
XOR EDX,EDX
DIV ECX
MOV dword ptr [RBP + -0x9c],EDX
MOV EAX,dword ptr [RBP + -0x9c]
ADD EAX,0x1
MOVZX ECX,word ptr [0x0057fdb6]
CMP EAX,ECX
JNZ 0x001364ab
JMP 0x00136495
LAB_00136495:
JMP 0x00136497
LAB_00136497:
MOV dword ptr [RBP + -0xa8],0x1
MOV dword ptr [RBP + -0x9c],0x1
LAB_001364ab:
JMP 0x001364ad
LAB_001364ad:
JMP 0x001364af
LAB_001364af:
MOV EAX,dword ptr [RBP + -0xa0]
ADD EAX,dword ptr [RBP + -0xa8]
MOV dword ptr [RBP + -0xac],EAX
CMP dword ptr [RBP + -0x9c],0x0
JZ 0x001364db
MOV EAX,dword ptr [RBP + -0x9c]
ADD EAX,0x3
MOV dword ptr [RBP + -0xb0],EAX
JMP 0x001364e5
LAB_001364db:
XOR EAX,EAX
MOV dword ptr [RBP + -0xb0],EAX
JMP 0x001364e5
LAB_001364e5:
MOV EDI,dword ptr [RBP + -0xac]
MOV EAX,dword ptr [RBP + -0xb0]
LEA RDX,[RBP + -0x90]
MOVZX ESI,AX
CALL 0x00137b70
MOVSX EAX,AL
MOV dword ptr [RBP + -0x94],EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [0x00d80a08]
MOV qword ptr [RAX + 0x100000],RCX
JMP 0x00136520
LAB_00136520:
CALL 0x0012c4b0
CMP qword ptr [RBP + -0x48],0x0
JZ 0x00136550
CMP dword ptr [RBP + -0x94],0x0
JNZ 0x00136547
MOV RDI,qword ptr [RBP + -0x48]
CALL 0x00132670
MOVSX EAX,AL
MOV dword ptr [RBP + -0x94],EAX
LAB_00136547:
MOV RDI,qword ptr [RBP + -0x48]
CALL 0x0012c480
LAB_00136550:
CMP dword ptr [RBP + -0x94],0x0
JZ 0x00136568
JMP 0x0013655b
LAB_0013655b:
JMP 0x0013655d
LAB_0013655d:
JMP 0x0013655f
LAB_0013655f:
MOV byte ptr [RBP + -0x13],0x1
JMP 0x00136694
LAB_00136568:
MOV RDI,qword ptr [RBP + -0x40]
MOV ESI,dword ptr [RBP + -0x24]
MOV CX,word ptr [RBP + -0x32]
MOV AX,word ptr [RBP + 0x10]
LEA R8,[RBP + -0x12]
MOVZX EDX,CX
MOVZX ECX,AX
CALL 0x001375f0
MOV EDX,dword ptr [RBP + -0xa4]
MOV RCX,qword ptr [RBP + -0x40]
LEA RDI,[RBP + -0x50]
LEA RSI,[RBP + -0x90]
CALL 0x00137890
JMP 0x001365a2
LAB_001365a2:
MOV dword ptr [RBP + -0x98],0x0
LAB_001365ac:
MOV EAX,dword ptr [RBP + -0x98]
CMP EAX,dword ptr [RBP + -0xa0]
JNC 0x001365ee
MOV RDI,qword ptr [RBP + -0x40]
LEA RSI,[RBP + -0x50]
LEA RDX,[RBP + -0x90]
CALL 0x00137ef0
CMP AL,0x0
JZ 0x001365d7
JMP 0x00136684
LAB_001365d7:
JMP 0x001365d9
LAB_001365d9:
JMP 0x001365db
LAB_001365db:
JMP 0x001365dd
LAB_001365dd:
MOV EAX,dword ptr [RBP + -0x98]
ADD EAX,0x1
MOV dword ptr [RBP + -0x98],EAX
JMP 0x001365ac
LAB_001365ee:
CMP dword ptr [RBP + -0xa8],0x0
JZ 0x00136628
MOV RDI,qword ptr [RBP + -0x40]
MOVZX EAX,word ptr [0x0057fdb6]
SUB EAX,0x2
LEA RDX,[RBP + -0x50]
LEA RCX,[RBP + -0x90]
MOVZX ESI,AX
CALL 0x00137f60
CMP AL,0x0
JZ 0x0013661e
JMP 0x00136684
LAB_0013661e:
JMP 0x00136620
LAB_00136620:
JMP 0x00136622
LAB_00136622:
JMP 0x00136624
LAB_00136624:
JMP 0x00136626
LAB_00136626:
JMP 0x00136628
LAB_00136628:
MOV RDI,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RBP + -0x9c]
LEA RDX,[RBP + -0x50]
LEA RCX,[RBP + -0x90]
MOVZX ESI,AX
CALL 0x00137f60
CMP AL,0x0
JZ 0x0013664b
JMP 0x00136684
LAB_0013664b:
JMP 0x0013664d
LAB_0013664d:
JMP 0x0013664f
LAB_0013664f:
MOV RDI,qword ptr [RBP + -0x68]
CALL 0x0012c440
MOV RDI,qword ptr [RBP + -0x68]
CALL 0x00138040
LEA RDI,[RBP + -0x90]
MOV RSI,qword ptr [RBP + -0x68]
CALL 0x00138090
MOV RDI,qword ptr [RBP + -0x68]
CALL 0x0012c480
JMP 0x0013667c
LAB_0013667c:
JMP 0x0013667e
LAB_0013667e:
MOV byte ptr [RBP + -0x13],0x0
JMP 0x00136694
LAB_00136684:
LEA RDI,[RBP + -0x90]
CALL 0x001380c0
MOV byte ptr [RBP + -0x13],0x1
LAB_00136694:
MOV AL,byte ptr [RBP + -0x13]
MOV byte ptr [RBP + -0xb1],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001366be
MOV AL,byte ptr [RBP + -0xb1]
ADD RSP,0xc0
POP RBP
RET
LAB_001366be:
CALL 0x0012a250
|
int8
translog_write_variable_record_1group
(long *param_1,uint param_2,int8 param_3,int2 param_4,int *param_5,
long param_6,ushort param_7,int8 param_8,int8 param_9)
{
char cVar1;
int iVar2;
uint uVar3;
long in_FS_OFFSET;
bool bVar4;
uint local_b8;
uint local_b0;
uint local_a4;
uint local_a0;
int1 local_98 [40];
int8 local_70;
int1 local_61;
int8 local_58;
long local_50;
int *local_48;
int2 local_3a;
int8 local_38;
uint local_2c;
long *local_28;
int1 local_1b;
int1 local_1a [10];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_58 = DAT_00d809d8;
local_50 = param_6;
local_48 = param_5;
local_3a = param_4;
local_38 = param_3;
local_2c = param_2;
local_28 = param_1;
set_lsn(param_1);
cVar1 = translog_set_lsn_for_files
(*local_28 >> 0x20 & 0xffffffff,*local_28 >> 0x20 & 0xffffffff,*local_28,1);
if ((cVar1 == '\0') &&
((*(long *)(log_record_type_descriptor + (ulong)local_2c * 0x48 + 0x10) == 0 ||
(cVar1 = (**(code **)(log_record_type_descriptor + (ulong)local_2c * 0x48 + 0x10))
(local_2c,param_8,local_38,local_28,param_9), cVar1 == '\0')))) {
memcpy(local_98,&DAT_00d809e0,0x40);
local_61 = 1;
iVar2 = translog_get_current_page_rest();
local_a4 = *local_48 - (iVar2 - (uint)param_7);
uVar3 = local_a4 / DAT_0057fdb6;
local_a4 = local_a4 % (uint)DAT_0057fdb6;
bVar4 = local_a4 + 1 == (uint)DAT_0057fdb6;
if (bVar4) {
local_a4 = 1;
}
local_b0 = (uint)bVar4;
if (local_a4 == 0) {
local_b8 = 0;
}
else {
local_b8 = local_a4 + 3;
}
cVar1 = translog_advance_pointer(uVar3 + local_b0,local_b8 & 0xffff,local_98);
*(long *)(DAT_00d80a08 + 0x100000) = *local_28;
translog_unlock();
if (local_50 != 0) {
if (cVar1 == '\0') {
cVar1 = translog_buffer_flush(local_50);
}
translog_buffer_unlock(local_50);
}
if (cVar1 == '\0') {
translog_write_variable_record_1group_header(local_48,local_2c,local_3a,param_7,local_1a);
translog_write_parts_on_page(&local_58,local_98,iVar2,local_48);
for (local_a0 = 0; local_a0 < uVar3; local_a0 = local_a0 + 1) {
cVar1 = translog_write_variable_record_chunk2_page(local_48,&local_58,local_98);
if (cVar1 != '\0') goto LAB_00136684;
}
if (((local_b0 == 0) ||
(cVar1 = translog_write_variable_record_chunk3_page
(local_48,DAT_0057fdb6 - 2,&local_58,local_98), cVar1 == '\0')) &&
(cVar1 = translog_write_variable_record_chunk3_page(local_48,local_a4,&local_58,local_98),
cVar1 == '\0')) {
translog_buffer_lock(local_70);
translog_buffer_decrease_writers(local_70);
used_buffs_register_unlock(local_98,local_70);
translog_buffer_unlock(local_70);
local_1b = 0;
}
else {
LAB_00136684:
used_buffs_urgent_unlock(local_98);
local_1b = 1;
}
}
else {
local_1b = 1;
}
}
else {
translog_unlock();
if (local_50 != 0) {
translog_buffer_flush(local_50);
translog_buffer_unlock(local_50);
}
local_1b = 1;
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),local_1b);
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
27,868 | ImPlot3D::ComputeBoxCorners(ImPlot3DPoint*, ImPlot3DPoint const&, ImPlot3DPoint const&) | zkingston[P]unknot/build_O1/_deps/implot3d-src/implot3d.cpp | void ComputeBoxCorners(ImPlot3DPoint* corners, const ImPlot3DPoint& range_min, const ImPlot3DPoint& range_max) {
corners[0] = ImPlot3DPoint(range_min.x, range_min.y, range_min.z); // 0
corners[1] = ImPlot3DPoint(range_max.x, range_min.y, range_min.z); // 1
corners[2] = ImPlot3DPoint(range_max.x, range_max.y, range_min.z); // 2
corners[3] = ImPlot3DPoint(range_min.x, range_max.y, range_min.z); // 3
corners[4] = ImPlot3DPoint(range_min.x, range_min.y, range_max.z); // 4
corners[5] = ImPlot3DPoint(range_max.x, range_min.y, range_max.z); // 5
corners[6] = ImPlot3DPoint(range_max.x, range_max.y, range_max.z); // 6
corners[7] = ImPlot3DPoint(range_min.x, range_max.y, range_max.z); // 7
} | O1 | cpp | ImPlot3D::ComputeBoxCorners(ImPlot3DPoint*, ImPlot3DPoint const&, ImPlot3DPoint const&):
movss 0x8(%rsi), %xmm0
movsd (%rsi), %xmm1
movsd %xmm1, (%rdi)
movss %xmm0, 0x8(%rdi)
movss (%rdx), %xmm0
movsd 0x4(%rsi), %xmm1
movss %xmm0, 0xc(%rdi)
movsd %xmm1, 0x10(%rdi)
movss 0x8(%rsi), %xmm0
movsd (%rdx), %xmm1
movsd %xmm1, 0x18(%rdi)
movss %xmm0, 0x20(%rdi)
movss 0x4(%rdx), %xmm0
movss (%rsi), %xmm1
movss 0x8(%rsi), %xmm2
movss %xmm1, 0x24(%rdi)
movss %xmm0, 0x28(%rdi)
movss %xmm2, 0x2c(%rdi)
movss 0x8(%rdx), %xmm0
movsd (%rsi), %xmm1
movsd %xmm1, 0x30(%rdi)
movss %xmm0, 0x38(%rdi)
movss 0x4(%rsi), %xmm0
movss (%rdx), %xmm1
movss 0x8(%rdx), %xmm2
movss %xmm1, 0x3c(%rdi)
movss %xmm0, 0x40(%rdi)
movss %xmm2, 0x44(%rdi)
movss 0x8(%rdx), %xmm0
movsd (%rdx), %xmm1
movsd %xmm1, 0x48(%rdi)
movss %xmm0, 0x50(%rdi)
movss (%rsi), %xmm0
movsd 0x4(%rdx), %xmm1
movss %xmm0, 0x54(%rdi)
movsd %xmm1, 0x58(%rdi)
retq
| _ZN8ImPlot3D17ComputeBoxCornersEP13ImPlot3DPointRKS0_S3_:
movss xmm0, dword ptr [rsi+8]
movsd xmm1, qword ptr [rsi]
movsd qword ptr [rdi], xmm1
movss dword ptr [rdi+8], xmm0
movss xmm0, dword ptr [rdx]
movsd xmm1, qword ptr [rsi+4]
movss dword ptr [rdi+0Ch], xmm0
movsd qword ptr [rdi+10h], xmm1
movss xmm0, dword ptr [rsi+8]
movsd xmm1, qword ptr [rdx]
movsd qword ptr [rdi+18h], xmm1
movss dword ptr [rdi+20h], xmm0
movss xmm0, dword ptr [rdx+4]
movss xmm1, dword ptr [rsi]
movss xmm2, dword ptr [rsi+8]
movss dword ptr [rdi+24h], xmm1
movss dword ptr [rdi+28h], xmm0
movss dword ptr [rdi+2Ch], xmm2
movss xmm0, dword ptr [rdx+8]
movsd xmm1, qword ptr [rsi]
movsd qword ptr [rdi+30h], xmm1
movss dword ptr [rdi+38h], xmm0
movss xmm0, dword ptr [rsi+4]
movss xmm1, dword ptr [rdx]
movss xmm2, dword ptr [rdx+8]
movss dword ptr [rdi+3Ch], xmm1
movss dword ptr [rdi+40h], xmm0
movss dword ptr [rdi+44h], xmm2
movss xmm0, dword ptr [rdx+8]
movsd xmm1, qword ptr [rdx]
movsd qword ptr [rdi+48h], xmm1
movss dword ptr [rdi+50h], xmm0
movss xmm0, dword ptr [rsi]
movsd xmm1, qword ptr [rdx+4]
movss dword ptr [rdi+54h], xmm0
movsd qword ptr [rdi+58h], xmm1
retn
| void ImPlot3D::ComputeBoxCorners(
ImPlot3D *this,
ImPlot3DPoint *a2,
const ImPlot3DPoint *a3,
const ImPlot3DPoint *a4)
{
int v4; // xmm0_4
long long v5; // xmm1_8
int v6; // xmm0_4
int v7; // xmm0_4
int v8; // xmm2_4
int v9; // xmm0_4
int v10; // xmm0_4
int v11; // xmm2_4
int v12; // xmm0_4
long long v13; // xmm1_8
v4 = *((_DWORD *)a2 + 2);
*(_QWORD *)this = *(_QWORD *)a2;
*((_DWORD *)this + 2) = v4;
v5 = *(_QWORD *)((char *)a2 + 4);
*((_DWORD *)this + 3) = *(_DWORD *)a3;
*((_QWORD *)this + 2) = v5;
v6 = *((_DWORD *)a2 + 2);
*((_QWORD *)this + 3) = *(_QWORD *)a3;
*((_DWORD *)this + 8) = v6;
v7 = *((_DWORD *)a3 + 1);
v8 = *((_DWORD *)a2 + 2);
*((_DWORD *)this + 9) = *(_DWORD *)a2;
*((_DWORD *)this + 10) = v7;
*((_DWORD *)this + 11) = v8;
v9 = *((_DWORD *)a3 + 2);
*((_QWORD *)this + 6) = *(_QWORD *)a2;
*((_DWORD *)this + 14) = v9;
v10 = *((_DWORD *)a2 + 1);
v11 = *((_DWORD *)a3 + 2);
*((_DWORD *)this + 15) = *(_DWORD *)a3;
*((_DWORD *)this + 16) = v10;
*((_DWORD *)this + 17) = v11;
v12 = *((_DWORD *)a3 + 2);
*((_QWORD *)this + 9) = *(_QWORD *)a3;
*((_DWORD *)this + 20) = v12;
v13 = *(_QWORD *)((char *)a3 + 4);
*((_DWORD *)this + 21) = *(_DWORD *)a2;
*((_QWORD *)this + 11) = v13;
}
| ComputeBoxCorners:
MOVSS XMM0,dword ptr [RSI + 0x8]
MOVSD XMM1,qword ptr [RSI]
MOVSD qword ptr [RDI],XMM1
MOVSS dword ptr [RDI + 0x8],XMM0
MOVSS XMM0,dword ptr [RDX]
MOVSD XMM1,qword ptr [RSI + 0x4]
MOVSS dword ptr [RDI + 0xc],XMM0
MOVSD qword ptr [RDI + 0x10],XMM1
MOVSS XMM0,dword ptr [RSI + 0x8]
MOVSD XMM1,qword ptr [RDX]
MOVSD qword ptr [RDI + 0x18],XMM1
MOVSS dword ptr [RDI + 0x20],XMM0
MOVSS XMM0,dword ptr [RDX + 0x4]
MOVSS XMM1,dword ptr [RSI]
MOVSS XMM2,dword ptr [RSI + 0x8]
MOVSS dword ptr [RDI + 0x24],XMM1
MOVSS dword ptr [RDI + 0x28],XMM0
MOVSS dword ptr [RDI + 0x2c],XMM2
MOVSS XMM0,dword ptr [RDX + 0x8]
MOVSD XMM1,qword ptr [RSI]
MOVSD qword ptr [RDI + 0x30],XMM1
MOVSS dword ptr [RDI + 0x38],XMM0
MOVSS XMM0,dword ptr [RSI + 0x4]
MOVSS XMM1,dword ptr [RDX]
MOVSS XMM2,dword ptr [RDX + 0x8]
MOVSS dword ptr [RDI + 0x3c],XMM1
MOVSS dword ptr [RDI + 0x40],XMM0
MOVSS dword ptr [RDI + 0x44],XMM2
MOVSS XMM0,dword ptr [RDX + 0x8]
MOVSD XMM1,qword ptr [RDX]
MOVSD qword ptr [RDI + 0x48],XMM1
MOVSS dword ptr [RDI + 0x50],XMM0
MOVSS XMM0,dword ptr [RSI]
MOVSD XMM1,qword ptr [RDX + 0x4]
MOVSS dword ptr [RDI + 0x54],XMM0
MOVSD qword ptr [RDI + 0x58],XMM1
RET
|
/* ImPlot3D::ComputeBoxCorners(ImPlot3DPoint*, ImPlot3DPoint const&, ImPlot3DPoint const&) */
void ImPlot3D::ComputeBoxCorners
(ImPlot3DPoint *param_1,ImPlot3DPoint *param_2,ImPlot3DPoint *param_3)
{
int4 uVar1;
int4 uVar2;
int8 uVar3;
uVar1 = *(int4 *)(param_2 + 8);
*(int8 *)param_1 = *(int8 *)param_2;
*(int4 *)(param_1 + 8) = uVar1;
uVar3 = *(int8 *)(param_2 + 4);
*(int4 *)(param_1 + 0xc) = *(int4 *)param_3;
*(int8 *)(param_1 + 0x10) = uVar3;
uVar1 = *(int4 *)(param_2 + 8);
*(int8 *)(param_1 + 0x18) = *(int8 *)param_3;
*(int4 *)(param_1 + 0x20) = uVar1;
uVar1 = *(int4 *)(param_3 + 4);
uVar2 = *(int4 *)(param_2 + 8);
*(int4 *)(param_1 + 0x24) = *(int4 *)param_2;
*(int4 *)(param_1 + 0x28) = uVar1;
*(int4 *)(param_1 + 0x2c) = uVar2;
uVar1 = *(int4 *)(param_3 + 8);
*(int8 *)(param_1 + 0x30) = *(int8 *)param_2;
*(int4 *)(param_1 + 0x38) = uVar1;
uVar1 = *(int4 *)(param_2 + 4);
uVar2 = *(int4 *)(param_3 + 8);
*(int4 *)(param_1 + 0x3c) = *(int4 *)param_3;
*(int4 *)(param_1 + 0x40) = uVar1;
*(int4 *)(param_1 + 0x44) = uVar2;
uVar1 = *(int4 *)(param_3 + 8);
*(int8 *)(param_1 + 0x48) = *(int8 *)param_3;
*(int4 *)(param_1 + 0x50) = uVar1;
uVar3 = *(int8 *)(param_3 + 4);
*(int4 *)(param_1 + 0x54) = *(int4 *)param_2;
*(int8 *)(param_1 + 0x58) = uVar3;
return;
}
| |
27,869 | my_wc_mb_eucjpms | eloqsql/strings/ctype-eucjpms.c | static int
my_wc_mb_eucjpms(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
int jp;
if ((int) wc < 0x80) /* ASCII [00-7F] */
{
if (s >= e)
return MY_CS_TOOSMALL;
*s= (uchar) wc;
return 1;
}
if (wc > 0xFFFF)
return MY_CS_ILUNI;
if ((jp= unicode_to_jisx0208_eucjpms[wc])) /* JIS-X-0208 MS */
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
MY_PUT_MB2(s, jp);
return 2;
}
if ((jp= unicode_to_jisx0212_eucjpms[wc])) /* JIS-X-0212 MS */
{
if (s + 3 > e)
return MY_CS_TOOSMALL3;
s[0]= 0x8F;
MY_PUT_MB2(s + 1, jp);
return 3;
}
if (wc >= 0xFF61 && wc <= 0xFF9F) /* Half width Katakana */
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
s[0]= 0x8E;
s[1]= (uchar) (wc - 0xFEC0);
return 2;
}
return MY_CS_ILUNI;
} | O3 | c | my_wc_mb_eucjpms:
cmpl $0x7f, %esi
jg 0xcf1bd
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0xcf1f2
movb %sil, (%rdx)
movl $0x1, %eax
retq
xorl %eax, %eax
cmpq $0xffff, %rsi # imm = 0xFFFF
ja 0xcf1f2
leaq 0xf1591(%rip), %rdi # 0x1c0760
movzwl (%rdi,%rsi,2), %edi
testw %di, %di
je 0xcf1f3
leaq 0x2(%rdx), %rsi
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %rsi
ja 0xcf1f2
rolw $0x8, %di
movw %di, (%rdx)
movl $0x2, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
leaq 0x111561(%rip), %rdi # 0x1e0760
movzwl (%rdi,%rsi,2), %ebx
testw %bx, %bx
je 0xcf226
leaq 0x3(%rdx), %rsi
movl $0xffffff99, %eax # imm = 0xFFFFFF99
cmpq %rcx, %rsi
ja 0xcf251
movb $-0x71, (%rdx)
movb %bh, 0x1(%rdx)
movb %bl, 0x2(%rdx)
movl $0x3, %eax
jmp 0xcf251
leaq -0xff61(%rsi), %rdi
cmpq $0x3e, %rdi
ja 0xcf251
leaq 0x2(%rdx), %rdi
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %rdi
ja 0xcf251
movb $-0x72, (%rdx)
addb $0x40, %sil
movb %sil, 0x1(%rdx)
movl $0x2, %eax
popq %rbx
popq %rbp
retq
| my_wc_mb_eucjpms:
cmp esi, 7Fh
jg short loc_CF1BD
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short locret_CF1F2
mov [rdx], sil
mov eax, 1
retn
loc_CF1BD:
xor eax, eax
cmp rsi, 0FFFFh
ja short locret_CF1F2
lea rdi, unicode_to_jisx0208_eucjpms
movzx edi, word ptr [rdi+rsi*2]
test di, di
jz short loc_CF1F3
lea rsi, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp rsi, rcx
ja short locret_CF1F2
rol di, 8
mov [rdx], di
mov eax, 2
locret_CF1F2:
retn
loc_CF1F3:
push rbp
mov rbp, rsp
push rbx
lea rdi, unicode_to_jisx0212_eucjpms
movzx ebx, word ptr [rdi+rsi*2]
test bx, bx
jz short loc_CF226
lea rsi, [rdx+3]
mov eax, 0FFFFFF99h
cmp rsi, rcx
ja short loc_CF251
mov byte ptr [rdx], 8Fh
mov [rdx+1], bh
mov [rdx+2], bl
mov eax, 3
jmp short loc_CF251
loc_CF226:
lea rdi, [rsi-0FF61h]
cmp rdi, 3Eh ; '>'
ja short loc_CF251
lea rdi, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp rdi, rcx
ja short loc_CF251
mov byte ptr [rdx], 8Eh
add sil, 40h ; '@'
mov [rdx+1], sil
mov eax, 2
loc_CF251:
pop rbx
pop rbp
retn
| long long my_wc_mb_eucjpms(long long a1, unsigned long long a2, unsigned long long a3, unsigned long long a4)
{
long long result; // rax
__int16 v5; // di
__int16 v6; // bx
if ( (int)a2 > 127 )
{
result = 0LL;
if ( a2 <= 0xFFFF )
{
v5 = unicode_to_jisx0208_eucjpms[a2];
if ( v5 )
{
result = 4294967194LL;
if ( a3 + 2 <= a4 )
{
*(_WORD *)a3 = __ROL2__(v5, 8);
return 2LL;
}
}
else
{
v6 = unicode_to_jisx0212_eucjpms[a2];
if ( v6 )
{
result = 4294967193LL;
if ( a3 + 3 <= a4 )
{
*(_BYTE *)a3 = -113;
*(_BYTE *)(a3 + 1) = HIBYTE(v6);
*(_BYTE *)(a3 + 2) = v6;
return 3LL;
}
}
else if ( a2 - 65377 <= 0x3E )
{
result = 4294967194LL;
if ( a3 + 2 <= a4 )
{
*(_BYTE *)a3 = -114;
*(_BYTE *)(a3 + 1) = a2 + 64;
return 2LL;
}
}
}
}
}
else
{
result = 4294967195LL;
if ( a3 < a4 )
{
*(_BYTE *)a3 = a2;
return 1LL;
}
}
return result;
}
| my_wc_mb_eucjpms:
CMP ESI,0x7f
JG 0x001cf1bd
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x001cf1f2
MOV byte ptr [RDX],SIL
MOV EAX,0x1
RET
LAB_001cf1bd:
XOR EAX,EAX
CMP RSI,0xffff
JA 0x001cf1f2
LEA RDI,[0x2c0760]
MOVZX EDI,word ptr [RDI + RSI*0x2]
TEST DI,DI
JZ 0x001cf1f3
LEA RSI,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP RSI,RCX
JA 0x001cf1f2
ROL DI,0x8
MOV word ptr [RDX],DI
MOV EAX,0x2
LAB_001cf1f2:
RET
LAB_001cf1f3:
PUSH RBP
MOV RBP,RSP
PUSH RBX
LEA RDI,[0x2e0760]
MOVZX EBX,word ptr [RDI + RSI*0x2]
TEST BX,BX
JZ 0x001cf226
LEA RSI,[RDX + 0x3]
MOV EAX,0xffffff99
CMP RSI,RCX
JA 0x001cf251
MOV byte ptr [RDX],0x8f
MOV byte ptr [RDX + 0x1],BH
MOV byte ptr [RDX + 0x2],BL
MOV EAX,0x3
JMP 0x001cf251
LAB_001cf226:
LEA RDI,[RSI + -0xff61]
CMP RDI,0x3e
JA 0x001cf251
LEA RDI,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP RDI,RCX
JA 0x001cf251
MOV byte ptr [RDX],0x8e
ADD SIL,0x40
MOV byte ptr [RDX + 0x1],SIL
MOV EAX,0x2
LAB_001cf251:
POP RBX
POP RBP
RET
|
int8 my_wc_mb_eucjpms(int8 param_1,ulong param_2,ushort *param_3,ushort *param_4)
{
ushort uVar1;
short sVar2;
int8 uVar3;
if ((int)param_2 < 0x80) {
uVar3 = 0xffffff9b;
if (param_3 < param_4) {
*(char *)param_3 = (char)param_2;
return 1;
}
}
else {
uVar3 = 0;
if (param_2 < 0x10000) {
uVar1 = *(ushort *)(unicode_to_jisx0208_eucjpms + param_2 * 2);
if (uVar1 == 0) {
sVar2 = *(short *)(unicode_to_jisx0212_eucjpms + param_2 * 2);
if (sVar2 == 0) {
if ((param_2 - 0xff61 < 0x3f) && (uVar3 = 0xffffff9a, param_3 + 1 <= param_4)) {
*(char *)param_3 = -0x72;
*(char *)((long)param_3 + 1) = (char)param_2 + '@';
uVar3 = 2;
}
}
else {
uVar3 = 0xffffff99;
if ((ushort *)((long)param_3 + 3) <= param_4) {
*(char *)param_3 = -0x71;
*(char *)((long)param_3 + 1) = (char)((ushort)sVar2 >> 8);
*(char *)(param_3 + 1) = (char)sVar2;
uVar3 = 3;
}
}
return uVar3;
}
uVar3 = 0xffffff9a;
if (param_3 + 1 <= param_4) {
*param_3 = uVar1 << 8 | uVar1 >> 8;
uVar3 = 2;
}
}
}
return uVar3;
}
| |
27,870 | my_aes_crypt | eloqsql/mysys_ssl/my_crypt.cc | int my_aes_crypt(enum my_aes_mode mode, int flags,
const uchar *src, uint slen, uchar *dst, uint *dlen,
const uchar *key, uint klen, const uchar *iv, uint ivlen)
{
void *ctx= alloca(MY_AES_CTX_SIZE);
int res1, res2;
uint d1= 0, d2;
if ((res1= my_aes_crypt_init(ctx, mode, flags, key, klen, iv, ivlen)))
return res1;
res1= my_aes_crypt_update(ctx, src, slen, dst, &d1);
res2= my_aes_crypt_finish(ctx, dst + d1, &d2);
if (res1 || res2)
ERR_remove_state(0); /* in case of failure clear error queue */
else
*dlen= d1 + d2;
return res1 ? res1 : res2;
} | O3 | cpp | my_aes_crypt:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2c8, %rsp # imm = 0x2C8
movq %r9, %rbx
movq %r8, %r14
movl %ecx, %r12d
movq %rdx, %r13
movl %esi, %edx
movl %edi, %esi
movq 0x10(%rbp), %rcx
movl 0x18(%rbp), %r8d
movq 0x20(%rbp), %r9
movl 0x28(%rbp), %eax
movq %fs:0x28, %rdi
movq %rdi, -0x30(%rbp)
movl $0x0, -0x2d4(%rbp)
movl %eax, (%rsp)
leaq -0x2d0(%rbp), %rdi
callq 0xd8054
movl %eax, %r15d
testl %eax, %eax
jne 0xd82bc
movq %rbx, -0x2e0(%rbp)
leaq -0x2d0(%rbp), %rbx
movq (%rbx), %rax
leaq -0x2d4(%rbp), %r15
movq %rbx, %rdi
movq %r13, %rsi
movl %r12d, %edx
movq %r14, %rcx
movq %r15, %r8
callq *0x18(%rax)
movl %eax, %r12d
movl (%r15), %esi
addq %r14, %rsi
movq (%rbx), %rax
leaq -0x2d8(%rbp), %rdx
movq %rbx, %rdi
callq *0x20(%rax)
movl %eax, %r15d
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movl %r15d, %eax
orl %r12d, %eax
je 0xd82a0
callq 0x297c0
jmp 0xd82b5
movl -0x2d8(%rbp), %eax
addl -0x2d4(%rbp), %eax
movq -0x2e0(%rbp), %rcx
movl %eax, (%rcx)
testl %r12d, %r12d
cmovnel %r12d, %r15d
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0xd82e0
movl %r15d, %eax
addq $0x2c8, %rsp # imm = 0x2C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x29270
| my_aes_crypt:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 2C8h
mov rbx, r9
mov r14, r8
mov r12d, ecx
mov r13, rdx
mov edx, esi
mov esi, edi
mov rcx, [rbp+arg_0]
mov r8d, [rbp+arg_8]
mov r9, [rbp+arg_10]
mov eax, [rbp+arg_18]
mov rdi, fs:28h
mov [rbp+var_30], rdi
mov [rbp+var_2D4], 0
mov [rsp+2F0h+var_2F0], eax
lea rdi, [rbp+var_2D0]
call my_aes_crypt_init
mov r15d, eax
test eax, eax
jnz short loc_D82BC
mov [rbp+var_2E0], rbx
lea rbx, [rbp+var_2D0]
mov rax, [rbx]
lea r15, [rbp+var_2D4]
mov rdi, rbx
mov rsi, r13
mov edx, r12d
mov rcx, r14
mov r8, r15
call qword ptr [rax+18h]
mov r12d, eax
mov esi, [r15]
add rsi, r14
mov rax, [rbx]
lea rdx, [rbp+var_2D8]
mov rdi, rbx
call qword ptr [rax+20h]
mov r15d, eax
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax]
mov eax, r15d
or eax, r12d
jz short loc_D82A0
call _ERR_clear_error
jmp short loc_D82B5
loc_D82A0:
mov eax, [rbp+var_2D8]
add eax, [rbp+var_2D4]
mov rcx, [rbp+var_2E0]
mov [rcx], eax
loc_D82B5:
test r12d, r12d
cmovnz r15d, r12d
loc_D82BC:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_D82E0
mov eax, r15d
add rsp, 2C8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_D82E0:
call ___stack_chk_fail
| long long my_aes_crypt(
int a1,
char a2,
long long a3,
unsigned int a4,
long long a5,
_DWORD *a6,
long long a7,
unsigned int a8,
long long a9)
{
unsigned int v13; // r15d
unsigned int v14; // r12d
int v16; // [rsp+18h] [rbp-2D8h] BYREF
unsigned int v17; // [rsp+1Ch] [rbp-2D4h] BYREF
_QWORD v18[90]; // [rsp+20h] [rbp-2D0h] BYREF
v18[84] = __readfsqword(0x28u);
v17 = 0;
v13 = my_aes_crypt_init(v18, a1, a2, a7, a8, a9);
if ( !v13 )
{
v14 = (*(long long ( **)(_QWORD *, long long, _QWORD, long long, unsigned int *))(v18[0] + 24LL))(
v18,
a3,
a4,
a5,
&v17);
v13 = (*(long long ( **)(_QWORD *, long long, int *))(v18[0] + 32LL))(v18, a5 + v17, &v16);
(*(void ( **)(_QWORD *))v18[0])(v18);
if ( v14 | v13 )
ERR_clear_error(v18);
else
*a6 = v17 + v16;
if ( v14 )
return v14;
}
return v13;
}
| my_aes_crypt:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x2c8
MOV RBX,R9
MOV R14,R8
MOV R12D,ECX
MOV R13,RDX
MOV EDX,ESI
MOV ESI,EDI
MOV RCX,qword ptr [RBP + 0x10]
MOV R8D,dword ptr [RBP + 0x18]
MOV R9,qword ptr [RBP + 0x20]
MOV EAX,dword ptr [RBP + 0x28]
MOV RDI,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RDI
MOV dword ptr [RBP + -0x2d4],0x0
MOV dword ptr [RSP],EAX
LEA RDI,[RBP + -0x2d0]
CALL 0x001d8054
MOV R15D,EAX
TEST EAX,EAX
JNZ 0x001d82bc
MOV qword ptr [RBP + -0x2e0],RBX
LEA RBX,[RBP + -0x2d0]
MOV RAX,qword ptr [RBX]
LEA R15,[RBP + -0x2d4]
MOV RDI,RBX
MOV RSI,R13
MOV EDX,R12D
MOV RCX,R14
MOV R8,R15
CALL qword ptr [RAX + 0x18]
MOV R12D,EAX
MOV ESI,dword ptr [R15]
ADD RSI,R14
MOV RAX,qword ptr [RBX]
LEA RDX,[RBP + -0x2d8]
MOV RDI,RBX
CALL qword ptr [RAX + 0x20]
MOV R15D,EAX
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX]
MOV EAX,R15D
OR EAX,R12D
JZ 0x001d82a0
CALL 0x001297c0
JMP 0x001d82b5
LAB_001d82a0:
MOV EAX,dword ptr [RBP + -0x2d8]
ADD EAX,dword ptr [RBP + -0x2d4]
MOV RCX,qword ptr [RBP + -0x2e0]
MOV dword ptr [RCX],EAX
LAB_001d82b5:
TEST R12D,R12D
CMOVNZ R15D,R12D
LAB_001d82bc:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001d82e0
MOV EAX,R15D
ADD RSP,0x2c8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001d82e0:
CALL 0x00129270
|
int my_aes_crypt(int4 param_1,int4 param_2,int8 param_3,int4 param_4,
long param_5,int *param_6,int8 param_7,int4 param_8,int8 param_9,
int4 param_10)
{
int iVar1;
int iVar2;
long in_FS_OFFSET;
int local_2e0;
uint local_2dc;
int8 *local_2d8 [84];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
local_2dc = 0;
iVar1 = my_aes_crypt_init(local_2d8,param_1,param_2,param_7,param_8,param_9,param_10);
if (iVar1 == 0) {
iVar2 = (*(code *)local_2d8[0][3])(local_2d8,param_3,param_4,param_5,&local_2dc);
iVar1 = (*(code *)local_2d8[0][4])(local_2d8,(ulong)local_2dc + param_5,&local_2e0);
(*(code *)*local_2d8[0])(local_2d8);
if (iVar1 == 0 && iVar2 == 0) {
*param_6 = local_2e0 + local_2dc;
}
else {
ERR_clear_error();
}
if (iVar2 != 0) {
iVar1 = iVar2;
}
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return iVar1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
27,871 | my_uca_add_contraction | eloqsql/strings/ctype-uca.c | static MY_CONTRACTION *
my_uca_add_contraction(MY_CONTRACTIONS *list, my_wc_t *wc, size_t len,
my_bool with_context)
{
MY_CONTRACTION *next= &list->item[list->nitems];
size_t i;
/*
Contraction is always at least 2 characters.
Contraction is never longer than MY_UCA_MAX_CONTRACTION,
which is guaranteed by using my_coll_rule_expand() with proper limit.
*/
DBUG_ASSERT(len > 1 && len <= MY_UCA_MAX_CONTRACTION);
for (i= 0; i < len; i++)
{
/*
We don't support contractions with U+0000.
my_coll_rule_expand() guarantees there're no U+0000 in a contraction.
*/
DBUG_ASSERT(wc[i] != 0);
next->ch[i]= wc[i];
}
if (i < MY_UCA_MAX_CONTRACTION)
next->ch[i]= 0; /* Add end-of-line marker */
next->with_context= with_context;
list->nitems++;
return next;
} | O0 | c | my_uca_add_contraction:
pushq %rbp
movq %rsp, %rbp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
imulq $0x58, (%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x87cbe
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x87cfa
jmp 0x87cd2
jmp 0x87cd4
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x87cc6
cmpq $0x6, -0x30(%rbp)
jae 0x87d11
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movb -0x19(%rbp), %cl
movq -0x28(%rbp), %rax
movb %cl, 0x52(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
popq %rbp
retq
nop
| my_uca_add_contraction:
push rbp
mov rbp, rsp
mov al, cl
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_19], al
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov rcx, [rbp+var_8]
imul rcx, [rcx], 58h ; 'X'
add rax, rcx
mov [rbp+var_28], rax
jmp short $+2
loc_87CBE:
mov [rbp+var_30], 0
loc_87CC6:
mov rax, [rbp+var_30]
cmp rax, [rbp+var_18]
jnb short loc_87CFA
jmp short $+2
loc_87CD2:
jmp short $+2
loc_87CD4:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_30]
mov rdx, [rax+rcx*8]
mov rax, [rbp+var_28]
mov rcx, [rbp+var_30]
mov [rax+rcx*8], rdx
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_30], rax
jmp short loc_87CC6
loc_87CFA:
cmp [rbp+var_30], 6
jnb short loc_87D11
mov rax, [rbp+var_28]
mov rcx, [rbp+var_30]
mov qword ptr [rax+rcx*8], 0
loc_87D11:
mov cl, [rbp+var_19]
mov rax, [rbp+var_28]
mov [rax+52h], cl
mov rax, [rbp+var_8]
mov rcx, [rax]
add rcx, 1
mov [rax], rcx
mov rax, [rbp+var_28]
pop rbp
retn
| long long my_uca_add_contraction(_QWORD *a1, long long a2, unsigned long long a3, char a4)
{
unsigned long long i; // [rsp+0h] [rbp-30h]
long long v6; // [rsp+8h] [rbp-28h]
v6 = 88LL * *a1 + a1[1];
for ( i = 0LL; i < a3; ++i )
*(_QWORD *)(v6 + 8 * i) = *(_QWORD *)(a2 + 8 * i);
if ( i < 6 )
*(_QWORD *)(v6 + 8 * i) = 0LL;
*(_BYTE *)(v6 + 82) = a4;
++*a1;
return v6;
}
| my_uca_add_contraction:
PUSH RBP
MOV RBP,RSP
MOV AL,CL
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV byte ptr [RBP + -0x19],AL
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x8]
IMUL RCX,qword ptr [RCX],0x58
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00187cbe
LAB_00187cbe:
MOV qword ptr [RBP + -0x30],0x0
LAB_00187cc6:
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x18]
JNC 0x00187cfa
JMP 0x00187cd2
LAB_00187cd2:
JMP 0x00187cd4
LAB_00187cd4:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RAX + RCX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + RCX*0x8],RDX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
JMP 0x00187cc6
LAB_00187cfa:
CMP qword ptr [RBP + -0x30],0x6
JNC 0x00187d11
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + RCX*0x8],0x0
LAB_00187d11:
MOV CL,byte ptr [RBP + -0x19]
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x52],CL
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX]
ADD RCX,0x1
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x28]
POP RBP
RET
|
long my_uca_add_contraction(long *param_1,long param_2,ulong param_3,int1 param_4)
{
long lVar1;
ulong local_38;
lVar1 = param_1[1] + *param_1 * 0x58;
for (local_38 = 0; local_38 < param_3; local_38 = local_38 + 1) {
*(int8 *)(lVar1 + local_38 * 8) = *(int8 *)(param_2 + local_38 * 8);
}
if (local_38 < 6) {
*(int8 *)(lVar1 + local_38 * 8) = 0;
}
*(int1 *)(lVar1 + 0x52) = param_4;
*param_1 = *param_1 + 1;
return lVar1;
}
| |
27,872 | check_mb_gb18030_valid | eloqsql/libmariadb/libmariadb/ma_charset.c | static unsigned int check_mb_gb18030_valid(const char * start, const char * end)
{
if (end - start <= 1 || !is_gb18030_odd(start[0])) {
return 0;
}
if (is_gb18030_even_2(start[1])) {
return 2;
} else if (end - start > 3 && is_gb18030_even_4(start[1]) && is_gb18030_odd(start[2]) && is_gb18030_even_4(start[3])) {
return 4;
}
return 0;
} | O0 | c | check_mb_gb18030_valid:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
cmpq $0x1, %rax
jle 0x43cfb
movq -0x10(%rbp), %rax
movzbl (%rax), %ecx
movl $0x81, %eax
cmpl %ecx, %eax
jg 0x43cfb
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xfe, %eax
jle 0x43d07
movl $0x0, -0x4(%rbp)
jmp 0x43dcd
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %ecx
movl $0x40, %eax
cmpl %ecx, %eax
jg 0x43d25
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x7e, %eax
jle 0x43d45
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %ecx
movl $0x80, %eax
cmpl %ecx, %eax
jg 0x43d4e
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xfe, %eax
jg 0x43d4e
movl $0x2, -0x4(%rbp)
jmp 0x43dcd
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
cmpq $0x3, %rax
jle 0x43dc4
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %ecx
movl $0x30, %eax
cmpl %ecx, %eax
jg 0x43dc4
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x39, %eax
jg 0x43dc4
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %ecx
movl $0x81, %eax
cmpl %ecx, %eax
jg 0x43dc4
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
cmpl $0xfe, %eax
jg 0x43dc4
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %ecx
movl $0x30, %eax
cmpl %ecx, %eax
jg 0x43dc4
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
cmpl $0x39, %eax
jg 0x43dc4
movl $0x4, -0x4(%rbp)
jmp 0x43dcd
jmp 0x43dc6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| check_mb_gb18030_valid:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
sub rax, rcx
cmp rax, 1
jle short loc_43CFB
mov rax, [rbp+var_10]
movzx ecx, byte ptr [rax]
mov eax, 81h
cmp eax, ecx
jg short loc_43CFB
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax]
cmp eax, 0FEh
jle short loc_43D07
loc_43CFB:
mov [rbp+var_4], 0
jmp loc_43DCD
loc_43D07:
mov rax, [rbp+var_10]
movzx ecx, byte ptr [rax+1]
mov eax, 40h ; '@'
cmp eax, ecx
jg short loc_43D25
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+1]
cmp eax, 7Eh ; '~'
jle short loc_43D45
loc_43D25:
mov rax, [rbp+var_10]
movzx ecx, byte ptr [rax+1]
mov eax, 80h
cmp eax, ecx
jg short loc_43D4E
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+1]
cmp eax, 0FEh
jg short loc_43D4E
loc_43D45:
mov [rbp+var_4], 2
jmp short loc_43DCD
loc_43D4E:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
sub rax, rcx
cmp rax, 3
jle short loc_43DC4
mov rax, [rbp+var_10]
movzx ecx, byte ptr [rax+1]
mov eax, 30h ; '0'
cmp eax, ecx
jg short loc_43DC4
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+1]
cmp eax, 39h ; '9'
jg short loc_43DC4
mov rax, [rbp+var_10]
movzx ecx, byte ptr [rax+2]
mov eax, 81h
cmp eax, ecx
jg short loc_43DC4
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+2]
cmp eax, 0FEh
jg short loc_43DC4
mov rax, [rbp+var_10]
movzx ecx, byte ptr [rax+3]
mov eax, 30h ; '0'
cmp eax, ecx
jg short loc_43DC4
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+3]
cmp eax, 39h ; '9'
jg short loc_43DC4
mov [rbp+var_4], 4
jmp short loc_43DCD
loc_43DC4:
jmp short $+2
loc_43DC6:
mov [rbp+var_4], 0
loc_43DCD:
mov eax, [rbp+var_4]
pop rbp
retn
| long long check_mb_gb18030_valid(unsigned __int8 *a1, long long a2)
{
if ( a2 - (long long)a1 <= 1 || *a1 < 0x81u || *a1 == 255 )
{
return 0;
}
else if ( (a1[1] < 0x40u || a1[1] > 0x7Eu) && (a1[1] < 0x80u || a1[1] == 255) )
{
if ( a2 - (long long)a1 <= 3
|| a1[1] < 0x30u
|| a1[1] > 0x39u
|| a1[2] < 0x81u
|| a1[2] == 255
|| a1[3] < 0x30u
|| a1[3] > 0x39u )
{
return 0;
}
else
{
return 4;
}
}
else
{
return 2;
}
}
| check_mb_gb18030_valid:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
SUB RAX,RCX
CMP RAX,0x1
JLE 0x00143cfb
MOV RAX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RAX]
MOV EAX,0x81
CMP EAX,ECX
JG 0x00143cfb
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0xfe
JLE 0x00143d07
LAB_00143cfb:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00143dcd
LAB_00143d07:
MOV RAX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RAX + 0x1]
MOV EAX,0x40
CMP EAX,ECX
JG 0x00143d25
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x7e
JLE 0x00143d45
LAB_00143d25:
MOV RAX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RAX + 0x1]
MOV EAX,0x80
CMP EAX,ECX
JG 0x00143d4e
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0xfe
JG 0x00143d4e
LAB_00143d45:
MOV dword ptr [RBP + -0x4],0x2
JMP 0x00143dcd
LAB_00143d4e:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
SUB RAX,RCX
CMP RAX,0x3
JLE 0x00143dc4
MOV RAX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RAX + 0x1]
MOV EAX,0x30
CMP EAX,ECX
JG 0x00143dc4
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x39
JG 0x00143dc4
MOV RAX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RAX + 0x2]
MOV EAX,0x81
CMP EAX,ECX
JG 0x00143dc4
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x2]
CMP EAX,0xfe
JG 0x00143dc4
MOV RAX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RAX + 0x3]
MOV EAX,0x30
CMP EAX,ECX
JG 0x00143dc4
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x3]
CMP EAX,0x39
JG 0x00143dc4
MOV dword ptr [RBP + -0x4],0x4
JMP 0x00143dcd
LAB_00143dc4:
JMP 0x00143dc6
LAB_00143dc6:
MOV dword ptr [RBP + -0x4],0x0
LAB_00143dcd:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 check_mb_gb18030_valid(byte *param_1,long param_2)
{
int4 local_c;
if (((param_2 - (long)param_1 < 2) || (*param_1 < 0x81)) || (*param_1 == 0xff)) {
local_c = 0;
}
else if (((param_1[1] < 0x40) || (0x7e < param_1[1])) &&
((param_1[1] < 0x80 || (param_1[1] == 0xff)))) {
if (((param_2 - (long)param_1 < 4) || (param_1[1] < 0x30)) ||
((0x39 < param_1[1] ||
((((param_1[2] < 0x81 || (0xfe < param_1[2])) || (param_1[3] < 0x30)) || (0x39 < param_1[3])
))))) {
local_c = 0;
}
else {
local_c = 4;
}
}
else {
local_c = 2;
}
return local_c;
}
| |
27,873 | ftxui::(anonymous namespace)::Set[abi:cxx11](std::vector<ftxui::(anonymous namespace)::DECMode, std::allocator<ftxui::(anonymous namespace)::DECMode>> const&) | Andrewchistyakov[P]flashcards_lyc/build_O2/_deps/ftxui-src/src/ftxui/component/screen_interactive.cpp | std::string Set(const std::vector<DECMode>& parameters) {
return CSI + "?" + Serialize(parameters) + "h";
} | O2 | cpp | ftxui::(anonymous namespace)::Set[abi:cxx11](std::vector<ftxui::(anonymous namespace)::DECMode, std::allocator<ftxui::(anonymous namespace)::DECMode>> const&):
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2ac48(%rip), %rsi # 0x532f8
leaq 0xc88a(%rip), %rdx # 0x34f41
leaq 0x28(%rsp), %rdi
callq 0x1802a
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x287b9
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x17fa4
leaq 0x9bb3(%rip), %rdx # 0x3229c
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x17f85
leaq 0x48(%rsp), %rdi
callq 0xc8c8
leaq 0x8(%rsp), %rdi
callq 0xc8c8
leaq 0x28(%rsp), %rdi
callq 0xc8c8
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xc8c8
jmp 0x28731
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xc8c8
jmp 0x28740
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xc8c8
movq %rbx, %rdi
callq 0xc7f0
| _ZN5ftxui12_GLOBAL__N_13SetB5cxx11ERKSt6vectorINS0_7DECModeESaIS2_EE:
push r14
push rbx
sub rsp, 68h
mov r14, rsi
mov rbx, rdi
lea rsi, _ZN5ftxui12_GLOBAL__N_13CSIB5cxx11E; ftxui::`anonymous namespace'::CSI
lea rdx, asc_34F41; "?"
lea rdi, [rsp+78h+var_50]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EERKS8_PKS5_; std::operator+<char>(std::string const&,char const*)
lea rdi, [rsp+78h+var_70]
mov rsi, r14
call _ZN5ftxui12_GLOBAL__N_19SerializeB5cxx11ERKSt6vectorINS0_7DECModeESaIS2_EE; ftxui::`anonymous namespace'::Serialize(std::vector<ftxui::`anonymous namespace'::DECMode> const&)
lea rdi, [rsp+78h+var_30]
lea rsi, [rsp+78h+var_50]
lea rdx, [rsp+78h+var_70]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
lea rdx, aWorkspaceLlm4b+53h; "h"
lea rsi, [rsp+78h+var_30]
mov rdi, rbx
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
lea rdi, [rsp+78h+var_30]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+78h+var_70]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+78h+var_50]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rax, rbx
add rsp, 68h
pop rbx
pop r14
retn
mov rbx, rax
lea rdi, [rsp+arg_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_28731
mov rbx, rax
loc_28731:
lea rdi, [rsp+arg_0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_28740
mov rbx, rax
loc_28740:
lea rdi, [rsp+arg_20]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
call __Unwind_Resume
| long long ftxui::`anonymous namespace'::Set[abi:cxx11](long long a1, int a2)
{
int v2; // edx
int v3; // ecx
int v4; // r8d
int v5; // r9d
_QWORD v7[4]; // [rsp+8h] [rbp-70h] BYREF
_QWORD v8[4]; // [rsp+28h] [rbp-50h] BYREF
_BYTE v9[48]; // [rsp+48h] [rbp-30h] BYREF
std::operator+<char>((long long)v8, (long long)&ftxui::`anonymous namespace'::CSI[abi:cxx11], (long long)"?");
ftxui::`anonymous namespace'::Serialize[abi:cxx11]((unsigned int)v7, a2, v2, v3, v4, v5);
std::operator+<char>((long long)v9, v8, v7);
std::operator+<char>(a1, (long long)v9, (long long)"h");
std::string::~string(v9);
std::string::~string(v7);
std::string::~string(v8);
return a1;
}
| Set[abi:cxx11]:
PUSH R14
PUSH RBX
SUB RSP,0x68
MOV R14,RSI
MOV RBX,RDI
LEA RSI,[0x1532f8]
LEA RDX,[0x134f41]
LEA RDI,[RSP + 0x28]
CALL 0x0011802a
LAB_001286c1:
LEA RDI,[RSP + 0x8]
MOV RSI,R14
CALL 0x001287b9
LAB_001286ce:
LEA RDI,[RSP + 0x48]
LEA RSI,[RSP + 0x28]
LEA RDX,[RSP + 0x8]
CALL 0x00117fa4
LAB_001286e2:
LEA RDX,[0x13229c]
LEA RSI,[RSP + 0x48]
MOV RDI,RBX
CALL 0x00117f85
LAB_001286f6:
LEA RDI,[RSP + 0x48]
CALL 0x0010c8c8
LEA RDI,[RSP + 0x8]
CALL 0x0010c8c8
LEA RDI,[RSP + 0x28]
CALL 0x0010c8c8
MOV RAX,RBX
ADD RSP,0x68
POP RBX
POP R14
RET
|
/* ftxui::(anonymous namespace)::Set[abi:cxx11](std::vector<ftxui::(anonymous namespace)::DECMode,
std::allocator<ftxui::(anonymous namespace)::DECMode> > const&) */
_anonymous_namespace_ * __thiscall
ftxui::(anonymous_namespace)::Set_abi_cxx11_(_anonymous_namespace_ *this,vector *param_1)
{
_anonymous_namespace_ local_70 [32];
string local_50 [32];
string local_30 [32];
std::operator+(local_50,CSI_abi_cxx11_);
/* try { // try from 001286c1 to 001286cd has its CatchHandler @ 0012873d */
Serialize_abi_cxx11_(local_70,param_1);
/* try { // try from 001286ce to 001286e1 has its CatchHandler @ 0012872e */
std::operator+(local_30,local_50);
/* try { // try from 001286e2 to 001286f5 has its CatchHandler @ 0012871f */
std::operator+((string *)this,(char *)local_30);
std::__cxx11::string::~string(local_30);
std::__cxx11::string::~string((string *)local_70);
std::__cxx11::string::~string(local_50);
return this;
}
| |
27,874 | mysql_close | eloqsql/libmariadb/libmariadb/mariadb_lib.c | void STDCALL
mysql_close(MYSQL *mysql)
{
if (mysql) /* Some simple safety */
{
if (mysql->extension && mysql->extension->conn_hdlr)
{
MA_CONNECTION_HANDLER *p= mysql->extension->conn_hdlr;
if (p->plugin->close)
p->plugin->close(mysql);
free(p);
/* Fix for CONC-294: Since we already called plugin->close function
we need to prevent that mysql_close_slow_part (which sends COM_QUIT
to the server) will be handled by plugin again. */
mysql->extension->conn_hdlr= NULL;
}
if (mysql->methods)
mysql->methods->db_close(mysql);
/* reset the connection in all active statements */
ma_invalidate_stmts(mysql, "mysql_close()");
mysql_close_memory(mysql);
mysql_close_options(mysql);
ma_clear_session_state(mysql);
if (mysql->net.extension)
{
if (compression_plugin(&mysql->net))
compression_plugin(&mysql->net)->free_ctx(compression_ctx(&mysql->net));
free(mysql->net.extension);
}
mysql->host_info=mysql->user=mysql->passwd=mysql->db=0;
/* Clear pointers for better safety */
memset((char*) &mysql->options, 0, sizeof(mysql->options));
if (mysql->extension)
free(mysql->extension);
/* Clear pointers for better safety */
mysql->net.extension = NULL;
mysql->extension = NULL;
mysql->net.pvio= 0;
if (mysql->free_me)
free(mysql);
}
return;
} | O0 | c | mysql_close:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1e036
movq -0x8(%rbp), %rax
cmpq $0x0, 0x4f0(%rax)
je 0x1dee2
movq -0x8(%rbp), %rax
movq 0x4f0(%rax), %rax
cmpq $0x0, (%rax)
je 0x1dee2
movq -0x8(%rbp), %rax
movq 0x4f0(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x60(%rax)
je 0x1dec7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x60(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x10(%rbp), %rdi
callq 0x13520
movq -0x8(%rbp), %rax
movq 0x4f0(%rax), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x4d0(%rax)
je 0x1df05
movq -0x8(%rbp), %rax
movq 0x4d0(%rax), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x8(%rbp), %rdi
leaq 0x2ddc2(%rip), %rsi # 0x4bcd2
callq 0x1e040
movq -0x8(%rbp), %rdi
callq 0x1d850
movq -0x8(%rbp), %rdi
callq 0x1d950
movq -0x8(%rbp), %rdi
callq 0x1e660
movq -0x8(%rbp), %rax
cmpq $0x0, 0x2a0(%rax)
je 0x1df84
movq -0x8(%rbp), %rax
movq 0x2a0(%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x1df74
movq -0x8(%rbp), %rax
movq 0x2a0(%rax), %rax
movq 0x10(%rax), %rax
movq 0x60(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x2a0(%rcx), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq 0x2a0(%rax), %rdi
callq 0x13520
movq -0x8(%rbp), %rax
movq $0x0, 0x2e8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x2c0(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x2b8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x2d8(%rax)
movq -0x8(%rbp), %rdi
addq $0x390, %rdi # imm = 0x390
xorl %esi, %esi
movl $0xf8, %edx
callq 0x13250
movq -0x8(%rbp), %rax
cmpq $0x0, 0x4f0(%rax)
je 0x1dff5
movq -0x8(%rbp), %rax
movq 0x4f0(%rax), %rdi
callq 0x13520
movq -0x8(%rbp), %rax
movq $0x0, 0x2a0(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x4f0(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
cmpb $0x0, 0x48c(%rax)
je 0x1e034
movq -0x8(%rbp), %rdi
callq 0x13520
jmp 0x1e036
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| mysql_close:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
cmp [rbp+var_8], 0
jz loc_1E036
mov rax, [rbp+var_8]
cmp qword ptr [rax+4F0h], 0
jz short loc_1DEE2
mov rax, [rbp+var_8]
mov rax, [rax+4F0h]
cmp qword ptr [rax], 0
jz short loc_1DEE2
mov rax, [rbp+var_8]
mov rax, [rax+4F0h]
mov rax, [rax]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rax, [rax]
cmp qword ptr [rax+60h], 0
jz short loc_1DEC7
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+60h]
mov rdi, [rbp+var_8]
call rax
loc_1DEC7:
mov rdi, [rbp+var_10]
call _free
mov rax, [rbp+var_8]
mov rax, [rax+4F0h]
mov qword ptr [rax], 0
loc_1DEE2:
mov rax, [rbp+var_8]
cmp qword ptr [rax+4D0h], 0
jz short loc_1DF05
mov rax, [rbp+var_8]
mov rax, [rax+4D0h]
mov rax, [rax+8]
mov rdi, [rbp+var_8]
call rax
loc_1DF05:
mov rdi, [rbp+var_8]
lea rsi, aMysqlClose; "mysql_close()"
call ma_invalidate_stmts
mov rdi, [rbp+var_8]
call mysql_close_memory
mov rdi, [rbp+var_8]
call mysql_close_options
mov rdi, [rbp+var_8]
call ma_clear_session_state
mov rax, [rbp+var_8]
cmp qword ptr [rax+2A0h], 0
jz short loc_1DF84
mov rax, [rbp+var_8]
mov rax, [rax+2A0h]
cmp qword ptr [rax+10h], 0
jz short loc_1DF74
mov rax, [rbp+var_8]
mov rax, [rax+2A0h]
mov rax, [rax+10h]
mov rax, [rax+60h]
mov rcx, [rbp+var_8]
mov rcx, [rcx+2A0h]
mov rdi, [rcx+8]
call rax
loc_1DF74:
mov rax, [rbp+var_8]
mov rdi, [rax+2A0h]
call _free
loc_1DF84:
mov rax, [rbp+var_8]
mov qword ptr [rax+2E8h], 0
mov rax, [rbp+var_8]
mov qword ptr [rax+2C0h], 0
mov rax, [rbp+var_8]
mov qword ptr [rax+2B8h], 0
mov rax, [rbp+var_8]
mov qword ptr [rax+2D8h], 0
mov rdi, [rbp+var_8]
add rdi, 390h
xor esi, esi
mov edx, 0F8h
call _memset
mov rax, [rbp+var_8]
cmp qword ptr [rax+4F0h], 0
jz short loc_1DFF5
mov rax, [rbp+var_8]
mov rdi, [rax+4F0h]
call _free
loc_1DFF5:
mov rax, [rbp+var_8]
mov qword ptr [rax+2A0h], 0
mov rax, [rbp+var_8]
mov qword ptr [rax+4F0h], 0
mov rax, [rbp+var_8]
mov qword ptr [rax], 0
mov rax, [rbp+var_8]
cmp byte ptr [rax+48Ch], 0
jz short loc_1E034
mov rdi, [rbp+var_8]
call _free
loc_1E034:
jmp short $+2
loc_1E036:
add rsp, 10h
pop rbp
retn
| long long mysql_close(long long a1)
{
long long result; // rax
long long v2; // [rsp+0h] [rbp-10h]
if ( a1 )
{
if ( *(_QWORD *)(a1 + 1264) && **(_QWORD **)(a1 + 1264) )
{
v2 = **(_QWORD **)(a1 + 1264);
if ( *(_QWORD *)(*(_QWORD *)v2 + 96LL) )
(*(void ( **)(long long))(*(_QWORD *)v2 + 96LL))(a1);
free(v2);
**(_QWORD **)(a1 + 1264) = 0LL;
}
if ( *(_QWORD *)(a1 + 1232) )
(*(void ( **)(long long))(*(_QWORD *)(a1 + 1232) + 8LL))(a1);
ma_invalidate_stmts(a1, "mysql_close()");
mysql_close_memory((_QWORD *)a1);
mysql_close_options(a1);
ma_clear_session_state(a1);
if ( *(_QWORD *)(a1 + 672) )
{
if ( *(_QWORD *)(*(_QWORD *)(a1 + 672) + 16LL) )
(*(void ( **)(_QWORD))(*(_QWORD *)(*(_QWORD *)(a1 + 672) + 16LL) + 96LL))(*(_QWORD *)(*(_QWORD *)(a1 + 672) + 8LL));
free(*(_QWORD *)(a1 + 672));
}
*(_QWORD *)(a1 + 744) = 0LL;
*(_QWORD *)(a1 + 704) = 0LL;
*(_QWORD *)(a1 + 696) = 0LL;
*(_QWORD *)(a1 + 728) = 0LL;
memset(a1 + 912, 0LL, 248LL);
if ( *(_QWORD *)(a1 + 1264) )
free(*(_QWORD *)(a1 + 1264));
*(_QWORD *)(a1 + 672) = 0LL;
*(_QWORD *)(a1 + 1264) = 0LL;
*(_QWORD *)a1 = 0LL;
result = a1;
if ( *(_BYTE *)(a1 + 1164) )
return free(a1);
}
return result;
}
| mysql_close:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
CMP qword ptr [RBP + -0x8],0x0
JZ 0x0011e036
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x4f0],0x0
JZ 0x0011dee2
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x4f0]
CMP qword ptr [RAX],0x0
JZ 0x0011dee2
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x4f0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
CMP qword ptr [RAX + 0x60],0x0
JZ 0x0011dec7
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x60]
MOV RDI,qword ptr [RBP + -0x8]
CALL RAX
LAB_0011dec7:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00113520
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x4f0]
MOV qword ptr [RAX],0x0
LAB_0011dee2:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x4d0],0x0
JZ 0x0011df05
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x4d0]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RBP + -0x8]
CALL RAX
LAB_0011df05:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x14bcd2]
CALL 0x0011e040
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0011d850
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0011d950
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0011e660
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x2a0],0x0
JZ 0x0011df84
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x2a0]
CMP qword ptr [RAX + 0x10],0x0
JZ 0x0011df74
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x2a0]
MOV RAX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RAX + 0x60]
MOV RCX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RCX + 0x2a0]
MOV RDI,qword ptr [RCX + 0x8]
CALL RAX
LAB_0011df74:
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x2a0]
CALL 0x00113520
LAB_0011df84:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x2e8],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x2c0],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x2b8],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x2d8],0x0
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x390
XOR ESI,ESI
MOV EDX,0xf8
CALL 0x00113250
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x4f0],0x0
JZ 0x0011dff5
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x4f0]
CALL 0x00113520
LAB_0011dff5:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x2a0],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x4f0],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
CMP byte ptr [RAX + 0x48c],0x0
JZ 0x0011e034
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00113520
LAB_0011e034:
JMP 0x0011e036
LAB_0011e036:
ADD RSP,0x10
POP RBP
RET
|
void mysql_close(int8 *param_1)
{
long *__ptr;
if (param_1 != (int8 *)0x0) {
if ((param_1[0x9e] != 0) && (*(long *)param_1[0x9e] != 0)) {
__ptr = *(long **)param_1[0x9e];
if (*(long *)(*__ptr + 0x60) != 0) {
(**(code **)(*__ptr + 0x60))(param_1);
}
free(__ptr);
*(int8 *)param_1[0x9e] = 0;
}
if (param_1[0x9a] != 0) {
(**(code **)(param_1[0x9a] + 8))(param_1);
}
ma_invalidate_stmts(param_1);
mysql_close_memory(param_1);
mysql_close_options(param_1);
ma_clear_session_state(param_1);
if (param_1[0x54] != 0) {
if (*(long *)(param_1[0x54] + 0x10) != 0) {
(**(code **)(*(long *)(param_1[0x54] + 0x10) + 0x60))(*(int8 *)(param_1[0x54] + 8));
}
free((void *)param_1[0x54]);
}
param_1[0x5d] = 0;
param_1[0x58] = 0;
param_1[0x57] = 0;
param_1[0x5b] = 0;
memset(param_1 + 0x72,0,0xf8);
if (param_1[0x9e] != 0) {
free((void *)param_1[0x9e]);
}
param_1[0x54] = 0;
param_1[0x9e] = 0;
*param_1 = 0;
if (*(char *)((long)param_1 + 0x48c) != '\0') {
free(param_1);
}
}
return;
}
| |
27,875 | mysql_close | eloqsql/libmariadb/libmariadb/mariadb_lib.c | void STDCALL
mysql_close(MYSQL *mysql)
{
if (mysql) /* Some simple safety */
{
if (mysql->extension && mysql->extension->conn_hdlr)
{
MA_CONNECTION_HANDLER *p= mysql->extension->conn_hdlr;
if (p->plugin->close)
p->plugin->close(mysql);
free(p);
/* Fix for CONC-294: Since we already called plugin->close function
we need to prevent that mysql_close_slow_part (which sends COM_QUIT
to the server) will be handled by plugin again. */
mysql->extension->conn_hdlr= NULL;
}
if (mysql->methods)
mysql->methods->db_close(mysql);
/* reset the connection in all active statements */
ma_invalidate_stmts(mysql, "mysql_close()");
mysql_close_memory(mysql);
mysql_close_options(mysql);
ma_clear_session_state(mysql);
if (mysql->net.extension)
{
if (compression_plugin(&mysql->net))
compression_plugin(&mysql->net)->free_ctx(compression_ctx(&mysql->net));
free(mysql->net.extension);
}
mysql->host_info=mysql->user=mysql->passwd=mysql->db=0;
/* Clear pointers for better safety */
memset((char*) &mysql->options, 0, sizeof(mysql->options));
if (mysql->extension)
free(mysql->extension);
/* Clear pointers for better safety */
mysql->net.extension = NULL;
mysql->extension = NULL;
mysql->net.pvio= 0;
if (mysql->free_me)
free(mysql);
}
return;
} | O3 | c | mysql_close:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1a27d
movq %rdi, %rbx
movq 0x4f0(%rdi), %rax
testq %rax, %rax
je 0x1a1b6
movq (%rax), %r14
testq %r14, %r14
je 0x1a1b6
movq (%r14), %rax
movq 0x60(%rax), %rax
testq %rax, %rax
je 0x1a1a0
movq %rbx, %rdi
callq *%rax
movq %r14, %rdi
callq 0x13570
movq 0x4f0(%rbx), %rax
movq $0x0, (%rax)
movq 0x4d0(%rbx), %rax
testq %rax, %rax
je 0x1a1c8
movq %rbx, %rdi
callq *0x8(%rax)
leaq 0x1aa1b(%rip), %rsi # 0x34bea
movq %rbx, %rdi
callq 0x1a282
movq %rbx, %rdi
callq 0x19d20
movq %rbx, %rdi
callq 0x19dac
movq %rbx, %rdi
callq 0x1a693
movq 0x2a0(%rbx), %rdi
testq %rdi, %rdi
je 0x1a217
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x1a212
movq 0x8(%rdi), %rdi
callq *0x60(%rax)
movq 0x2a0(%rbx), %rdi
callq 0x13570
xorl %eax, %eax
movq %rax, 0x2e8(%rbx)
movq %rax, 0x2d8(%rbx)
leaq 0x390(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x2b8(%rbx)
movl $0xf8, %edx
xorl %esi, %esi
callq 0x13260
movq 0x4f0(%rbx), %rdi
testq %rdi, %rdi
je 0x1a255
callq 0x13570
xorl %eax, %eax
movq %rax, 0x2a0(%rbx)
movq %rax, 0x4f0(%rbx)
movq %rax, (%rbx)
cmpb $0x0, 0x48c(%rbx)
je 0x1a27d
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x13570
popq %rbx
popq %r14
popq %rbp
retq
| mysql_close:
push rbp
mov rbp, rsp
push r14
push rbx
test rdi, rdi
jz loc_1A27D
mov rbx, rdi
mov rax, [rdi+4F0h]
test rax, rax
jz short loc_1A1B6
mov r14, [rax]
test r14, r14
jz short loc_1A1B6
mov rax, [r14]
mov rax, [rax+60h]
test rax, rax
jz short loc_1A1A0
mov rdi, rbx
call rax
loc_1A1A0:
mov rdi, r14
call _free
mov rax, [rbx+4F0h]
mov qword ptr [rax], 0
loc_1A1B6:
mov rax, [rbx+4D0h]
test rax, rax
jz short loc_1A1C8
mov rdi, rbx
call qword ptr [rax+8]
loc_1A1C8:
lea rsi, aMysqlClose; "mysql_close()"
mov rdi, rbx
call ma_invalidate_stmts
mov rdi, rbx
call mysql_close_memory
mov rdi, rbx
call mysql_close_options
mov rdi, rbx
call ma_clear_session_state
mov rdi, [rbx+2A0h]
test rdi, rdi
jz short loc_1A217
mov rax, [rdi+10h]
test rax, rax
jz short loc_1A212
mov rdi, [rdi+8]
call qword ptr [rax+60h]
mov rdi, [rbx+2A0h]
loc_1A212:
call _free
loc_1A217:
xor eax, eax
mov [rbx+2E8h], rax
mov [rbx+2D8h], rax
lea rdi, [rbx+390h]
xorps xmm0, xmm0
movups xmmword ptr [rbx+2B8h], xmm0
mov edx, 0F8h
xor esi, esi
call _memset
mov rdi, [rbx+4F0h]
test rdi, rdi
jz short loc_1A255
call _free
loc_1A255:
xor eax, eax
mov [rbx+2A0h], rax
mov [rbx+4F0h], rax
mov [rbx], rax
cmp byte ptr [rbx+48Ch], 0
jz short loc_1A27D
mov rdi, rbx
pop rbx
pop r14
pop rbp
jmp _free
loc_1A27D:
pop rbx
pop r14
pop rbp
retn
| void mysql_close(long long a1)
{
long long *v2; // rax
long long v3; // r14
void ( *v4)(long long); // rax
long long v5; // rax
long long v6; // rdi
long long v7; // rax
long long v8; // rdi
if ( a1 )
{
v2 = *(long long **)(a1 + 1264);
if ( v2 )
{
v3 = *v2;
if ( *v2 )
{
v4 = *(void ( **)(long long))(*(_QWORD *)v3 + 96LL);
if ( v4 )
v4(a1);
free(v3);
**(_QWORD **)(a1 + 1264) = 0LL;
}
}
v5 = *(_QWORD *)(a1 + 1232);
if ( v5 )
(*(void ( **)(long long))(v5 + 8))(a1);
ma_invalidate_stmts(a1, "mysql_close()");
mysql_close_memory((_QWORD *)a1);
mysql_close_options((_QWORD *)a1);
ma_clear_session_state(a1);
v6 = *(_QWORD *)(a1 + 672);
if ( v6 )
{
v7 = *(_QWORD *)(v6 + 16);
if ( v7 )
{
(*(void ( **)(_QWORD))(v7 + 96))(*(_QWORD *)(v6 + 8));
v6 = *(_QWORD *)(a1 + 672);
}
free(v6);
}
*(_QWORD *)(a1 + 744) = 0LL;
*(_QWORD *)(a1 + 728) = 0LL;
*(_OWORD *)(a1 + 696) = 0LL;
memset(a1 + 912, 0LL, 248LL);
v8 = *(_QWORD *)(a1 + 1264);
if ( v8 )
free(v8);
*(_QWORD *)(a1 + 672) = 0LL;
*(_QWORD *)(a1 + 1264) = 0LL;
*(_QWORD *)a1 = 0LL;
if ( *(_BYTE *)(a1 + 1164) )
free(a1);
}
}
| mysql_close:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
TEST RDI,RDI
JZ 0x0011a27d
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x4f0]
TEST RAX,RAX
JZ 0x0011a1b6
MOV R14,qword ptr [RAX]
TEST R14,R14
JZ 0x0011a1b6
MOV RAX,qword ptr [R14]
MOV RAX,qword ptr [RAX + 0x60]
TEST RAX,RAX
JZ 0x0011a1a0
MOV RDI,RBX
CALL RAX
LAB_0011a1a0:
MOV RDI,R14
CALL 0x00113570
MOV RAX,qword ptr [RBX + 0x4f0]
MOV qword ptr [RAX],0x0
LAB_0011a1b6:
MOV RAX,qword ptr [RBX + 0x4d0]
TEST RAX,RAX
JZ 0x0011a1c8
MOV RDI,RBX
CALL qword ptr [RAX + 0x8]
LAB_0011a1c8:
LEA RSI,[0x134bea]
MOV RDI,RBX
CALL 0x0011a282
MOV RDI,RBX
CALL 0x00119d20
MOV RDI,RBX
CALL 0x00119dac
MOV RDI,RBX
CALL 0x0011a693
MOV RDI,qword ptr [RBX + 0x2a0]
TEST RDI,RDI
JZ 0x0011a217
MOV RAX,qword ptr [RDI + 0x10]
TEST RAX,RAX
JZ 0x0011a212
MOV RDI,qword ptr [RDI + 0x8]
CALL qword ptr [RAX + 0x60]
MOV RDI,qword ptr [RBX + 0x2a0]
LAB_0011a212:
CALL 0x00113570
LAB_0011a217:
XOR EAX,EAX
MOV qword ptr [RBX + 0x2e8],RAX
MOV qword ptr [RBX + 0x2d8],RAX
LEA RDI,[RBX + 0x390]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x2b8],XMM0
MOV EDX,0xf8
XOR ESI,ESI
CALL 0x00113260
MOV RDI,qword ptr [RBX + 0x4f0]
TEST RDI,RDI
JZ 0x0011a255
CALL 0x00113570
LAB_0011a255:
XOR EAX,EAX
MOV qword ptr [RBX + 0x2a0],RAX
MOV qword ptr [RBX + 0x4f0],RAX
MOV qword ptr [RBX],RAX
CMP byte ptr [RBX + 0x48c],0x0
JZ 0x0011a27d
MOV RDI,RBX
POP RBX
POP R14
POP RBP
JMP 0x00113570
LAB_0011a27d:
POP RBX
POP R14
POP RBP
RET
|
void mysql_close(int8 *param_1)
{
long *__ptr;
void *__ptr_00;
if (param_1 != (int8 *)0x0) {
if (((int8 *)param_1[0x9e] != (int8 *)0x0) &&
(__ptr = *(long **)param_1[0x9e], __ptr != (long *)0x0)) {
if (*(code **)(*__ptr + 0x60) != (code *)0x0) {
(**(code **)(*__ptr + 0x60))(param_1);
}
free(__ptr);
*(int8 *)param_1[0x9e] = 0;
}
if (param_1[0x9a] != 0) {
(**(code **)(param_1[0x9a] + 8))(param_1);
}
ma_invalidate_stmts(param_1);
mysql_close_memory(param_1);
mysql_close_options(param_1);
ma_clear_session_state(param_1);
__ptr_00 = (void *)param_1[0x54];
if (__ptr_00 != (void *)0x0) {
if (*(long *)((long)__ptr_00 + 0x10) != 0) {
(**(code **)(*(long *)((long)__ptr_00 + 0x10) + 0x60))(*(int8 *)((long)__ptr_00 + 8));
__ptr_00 = (void *)param_1[0x54];
}
free(__ptr_00);
}
param_1[0x5d] = 0;
param_1[0x5b] = 0;
param_1[0x57] = 0;
param_1[0x58] = 0;
memset(param_1 + 0x72,0,0xf8);
if ((void *)param_1[0x9e] != (void *)0x0) {
free((void *)param_1[0x9e]);
}
param_1[0x54] = 0;
param_1[0x9e] = 0;
*param_1 = 0;
if (*(char *)((long)param_1 + 0x48c) != '\0') {
free(param_1);
return;
}
}
return;
}
| |
27,876 | my_thread_init | eloqsql/mysys/my_thr_init.c | my_bool my_thread_init(void)
{
struct st_my_thread_var *tmp;
my_bool error=0;
if (!my_thread_global_init_done)
return 1; /* cannot proceed with uninitialized library */
#ifdef EXTRA_DEBUG_THREADS
fprintf(stderr,"my_thread_init(): pthread_self: %p\n", pthread_self());
#endif
if (my_thread_var)
{
#ifdef EXTRA_DEBUG_THREADS
fprintf(stderr,"my_thread_init() called more than once in thread 0x%lx\n",
(long) pthread_self());
#endif
goto end;
}
#ifdef _MSC_VER
install_sigabrt_handler();
#endif
if (!(tmp= (struct st_my_thread_var *) calloc(1, sizeof(*tmp))))
{
error= 1;
goto end;
}
set_mysys_var(tmp);
tmp->pthread_self= pthread_self();
my_thread_init_thr_mutex(tmp);
tmp->stack_ends_here= (char*)&tmp +
STACK_DIRECTION * (long)my_thread_stack_size;
mysql_mutex_lock(&THR_LOCK_threads);
tmp->id= tmp->dbug_id= ++thread_id;
++THR_thread_count;
mysql_mutex_unlock(&THR_LOCK_threads);
tmp->init= 1;
#ifndef DBUG_OFF
/* Generate unique name for thread */
(void) my_thread_name();
#endif
end:
return error;
} | O0 | c | my_thread_init:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb $0x0, -0x11(%rbp)
cmpb $0x0, 0x35daf5(%rip) # 0x384548
jne 0x26a5e
movb $0x1, -0x1(%rbp)
jmp 0x26b47
callq 0x26900
cmpq $0x0, %rax
je 0x26a6e
jmp 0x26b41
movl $0x1, %edi
movl $0xf0, %esi
callq 0x241e0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x26a90
movb $0x1, -0x11(%rbp)
jmp 0x26b41
movq -0x10(%rbp), %rdi
callq 0x26db0
callq 0x24240
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xc8(%rax)
movq -0x10(%rbp), %rdi
callq 0x26950
leaq 0x1a5614(%rip), %rax # 0x1cc0d0
movq (%rax), %rax
shlq $0x0, %rax
leaq -0x10(%rbp), %rcx
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xb8(%rax)
leaq 0x35d9a4(%rip), %rdi # 0x384480
leaq 0x51a2e(%rip), %rsi # 0x78511
movl $0x12e, %edx # imm = 0x12E
callq 0x26c60
movq 0x35da5c(%rip), %rcx # 0x384550
addq $0x1, %rcx
movq %rcx, 0x35da51(%rip) # 0x384550
movq -0x10(%rbp), %rax
movq %rcx, 0xd8(%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0xd0(%rax)
leaq 0x35d764(%rip), %rax # 0x384280
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x35d758(%rip), %rax # 0x384280
movl %ecx, (%rax)
leaq 0x35d94f(%rip), %rdi # 0x384480
callq 0x26d50
movq -0x10(%rbp), %rax
movb $0x1, 0xe8(%rax)
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
| my_thread_init:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_11], 0
cmp cs:my_thread_global_init_done, 0
jnz short loc_26A5E
mov [rbp+var_1], 1
jmp loc_26B47
loc_26A5E:
call _my_thread_var
cmp rax, 0
jz short loc_26A6E
jmp loc_26B41
loc_26A6E:
mov edi, 1
mov esi, 0F0h
call _calloc
mov [rbp+var_10], rax
cmp rax, 0
jnz short loc_26A90
mov [rbp+var_11], 1
jmp loc_26B41
loc_26A90:
mov rdi, [rbp+var_10]
call set_mysys_var
call _pthread_self
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax+0C8h], rcx
mov rdi, [rbp+var_10]
call my_thread_init_thr_mutex
lea rax, my_thread_stack_size
mov rax, [rax]
shl rax, 0
lea rcx, [rbp+var_10]
add rcx, rax
mov rax, [rbp+var_10]
mov [rax+0B8h], rcx
lea rdi, THR_LOCK_threads
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 12Eh
call inline_mysql_mutex_lock
mov rcx, cs:thread_id
add rcx, 1
mov cs:thread_id, rcx
mov rax, [rbp+var_10]
mov [rax+0D8h], rcx
mov rax, [rbp+var_10]
mov [rax+0D0h], rcx
lea rax, THR_thread_count
mov ecx, [rax]
add ecx, 1
lea rax, THR_thread_count
mov [rax], ecx
lea rdi, THR_LOCK_threads
call inline_mysql_mutex_unlock
mov rax, [rbp+var_10]
mov byte ptr [rax+0E8h], 1
loc_26B41:
mov al, [rbp+var_11]
mov [rbp+var_1], al
loc_26B47:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
| char my_thread_init()
{
long long v0; // rcx
char v2; // [rsp+Fh] [rbp-11h]
long long v3; // [rsp+10h] [rbp-10h] BYREF
v2 = 0;
if ( !my_thread_global_init_done )
return 1;
if ( !my_thread_var() )
{
v3 = calloc(1LL, 240LL);
if ( v3 )
{
set_mysys_var(v3);
*(_QWORD *)(v3 + 200) = pthread_self();
my_thread_init_thr_mutex(v3);
*(_QWORD *)(v3 + 184) = (char *)&v3 + (_QWORD)my_thread_stack_size;
inline_mysql_mutex_lock(&THR_LOCK_threads, "/workspace/llm4binary/github2025/eloqsql/mysys/my_thr_init.c", 302LL);
v0 = thread_id + 1;
thread_id = v0;
*(_QWORD *)(v3 + 216) = v0;
*(_QWORD *)(v3 + 208) = v0;
++THR_thread_count;
inline_mysql_mutex_unlock(&THR_LOCK_threads);
*(_BYTE *)(v3 + 232) = 1;
}
else
{
return 1;
}
}
return v2;
}
| my_thread_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV byte ptr [RBP + -0x11],0x0
CMP byte ptr [0x00484548],0x0
JNZ 0x00126a5e
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00126b47
LAB_00126a5e:
CALL 0x00126900
CMP RAX,0x0
JZ 0x00126a6e
JMP 0x00126b41
LAB_00126a6e:
MOV EDI,0x1
MOV ESI,0xf0
CALL 0x001241e0
MOV qword ptr [RBP + -0x10],RAX
CMP RAX,0x0
JNZ 0x00126a90
MOV byte ptr [RBP + -0x11],0x1
JMP 0x00126b41
LAB_00126a90:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00126db0
CALL 0x00124240
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xc8],RCX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00126950
LEA RAX,[0x2cc0d0]
MOV RAX,qword ptr [RAX]
SHL RAX,0x0
LEA RCX,[RBP + -0x10]
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xb8],RCX
LEA RDI,[0x484480]
LEA RSI,[0x178511]
MOV EDX,0x12e
CALL 0x00126c60
MOV RCX,qword ptr [0x00484550]
ADD RCX,0x1
MOV qword ptr [0x00484550],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xd8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xd0],RCX
LEA RAX,[0x484280]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x484280]
MOV dword ptr [RAX],ECX
LEA RDI,[0x484480]
CALL 0x00126d50
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0xe8],0x1
LAB_00126b41:
MOV AL,byte ptr [RBP + -0x11]
MOV byte ptr [RBP + -0x1],AL
LAB_00126b47:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int1 my_thread_init(void)
{
long lVar1;
pthread_t pVar2;
int1 local_19;
void *local_18;
int1 local_9;
local_19 = 0;
if (my_thread_global_init_done == '\0') {
local_9 = 1;
}
else {
lVar1 = _my_thread_var();
if (lVar1 == 0) {
local_18 = calloc(1,0xf0);
if (local_18 == (void *)0x0) {
local_19 = 1;
}
else {
set_mysys_var(local_18);
pVar2 = pthread_self();
*(pthread_t *)((long)local_18 + 200) = pVar2;
my_thread_init_thr_mutex(local_18);
*(long *)((long)local_18 + 0xb8) = (long)&local_18 + my_thread_stack_size;
inline_mysql_mutex_lock
(THR_LOCK_threads,"/workspace/llm4binary/github2025/eloqsql/mysys/my_thr_init.c",
0x12e);
lVar1 = thread_id + 1;
thread_id = lVar1;
*(long *)((long)local_18 + 0xd8) = lVar1;
*(long *)((long)local_18 + 0xd0) = lVar1;
THR_thread_count = THR_thread_count + 1;
inline_mysql_mutex_unlock(THR_LOCK_threads);
*(int1 *)((long)local_18 + 0xe8) = 1;
}
}
local_9 = local_19;
}
return local_9;
}
| |
27,877 | crypto_sign_ed25519_ref10_ge_tobytes | eloqsql/plugin/auth_ed25519/ref10/ge_tobytes.c | void ge_tobytes(unsigned char *s,const ge_p2 *h)
{
fe recip;
fe x;
fe y;
fe_invert(recip,h->Z);
fe_mul(x,h->X,recip);
fe_mul(y,h->Y,recip);
fe_tobytes(s,y);
s[31] ^= fe_isnegative(x) << 7;
} | O3 | c | crypto_sign_ed25519_ref10_ge_tobytes:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x50, %rsi
leaq -0xb0(%rbp), %r15
movq %r15, %rdi
callq 0x21a0
leaq -0x80(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2140
addq $0x28, %r14
leaq -0x50(%rbp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2140
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2030
movq %r12, %rdi
callq 0x2070
shlb $0x7, %al
xorb %al, 0x1f(%rbx)
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| crypto_sign_ed25519_ref10_ge_tobytes:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 88h
mov r14, rsi
mov rbx, rdi
add rsi, 50h ; 'P'
lea r15, [rbp+var_B0]
mov rdi, r15
call _crypto_sign_ed25519_ref10_fe_invert
lea r12, [rbp+var_80]
mov rdi, r12
mov rsi, r14
mov rdx, r15
call _crypto_sign_ed25519_ref10_fe_mul
add r14, 28h ; '('
lea r13, [rbp+var_50]
mov rdi, r13
mov rsi, r14
mov rdx, r15
call _crypto_sign_ed25519_ref10_fe_mul
mov rdi, rbx
mov rsi, r13
call _crypto_sign_ed25519_ref10_fe_tobytes
mov rdi, r12
call _crypto_sign_ed25519_ref10_fe_isnegative
shl al, 7
xor [rbx+1Fh], al
add rsp, 88h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| char crypto_sign_ed25519_ref10_ge_tobytes(long long a1, long long a2)
{
char result; // al
_BYTE v3[48]; // [rsp+0h] [rbp-B0h] BYREF
_BYTE v4[48]; // [rsp+30h] [rbp-80h] BYREF
_BYTE v5[80]; // [rsp+60h] [rbp-50h] BYREF
crypto_sign_ed25519_ref10_fe_invert((long long)v3, a2 + 80);
crypto_sign_ed25519_ref10_fe_mul(v4, a2, v3);
crypto_sign_ed25519_ref10_fe_mul(v5, a2 + 40, v3);
crypto_sign_ed25519_ref10_fe_tobytes(a1, v5);
result = (unsigned __int8)crypto_sign_ed25519_ref10_fe_isnegative((long long)v4) << 7;
*(_BYTE *)(a1 + 31) ^= result;
return result;
}
| crypto_sign_ed25519_ref10_ge_tobytes:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV R14,RSI
MOV RBX,RDI
ADD RSI,0x50
LEA R15,[RBP + -0xb0]
MOV RDI,R15
CALL 0x001021a0
LEA R12,[RBP + -0x80]
MOV RDI,R12
MOV RSI,R14
MOV RDX,R15
CALL 0x00102140
ADD R14,0x28
LEA R13,[RBP + -0x50]
MOV RDI,R13
MOV RSI,R14
MOV RDX,R15
CALL 0x00102140
MOV RDI,RBX
MOV RSI,R13
CALL 0x00102030
MOV RDI,R12
CALL 0x00102070
SHL AL,0x7
XOR byte ptr [RBX + 0x1f],AL
ADD RSP,0x88
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void crypto_sign_ed25519_ref10_ge_tobytes(long param_1,long param_2)
{
char cVar1;
int1 local_b8 [48];
int1 local_88 [48];
int1 local_58 [40];
crypto_sign_ed25519_ref10_fe_invert(local_b8,param_2 + 0x50);
crypto_sign_ed25519_ref10_fe_mul(local_88,param_2,local_b8);
crypto_sign_ed25519_ref10_fe_mul(local_58,param_2 + 0x28,local_b8);
crypto_sign_ed25519_ref10_fe_tobytes(param_1,local_58);
cVar1 = crypto_sign_ed25519_ref10_fe_isnegative(local_88);
*(byte *)(param_1 + 0x1f) = *(byte *)(param_1 + 0x1f) ^ cVar1 << 7;
return;
}
| |
27,878 | ftxui::Screen::ResetPosition[abi:cxx11](bool) const | Andrewchistyakov[P]flashcards_lyc/build_O2/_deps/ftxui-src/src/ftxui/screen/screen.cpp | std::string Screen::ResetPosition(bool clear) const {
std::stringstream ss;
if (clear) {
ss << "\r"; // MOVE_LEFT;
ss << "\x1b[2K"; // CLEAR_SCREEN;
for (int y = 1; y < dimy_; ++y) {
ss << "\x1B[1A"; // MOVE_UP;
ss << "\x1B[2K"; // CLEAR_LINE;
}
} else {
ss << "\r"; // MOVE_LEFT;
for (int y = 1; y < dimy_; ++y) {
ss << "\x1B[1A"; // MOVE_UP;
}
}
return ss.str();
} | O2 | cpp | ftxui::Screen::ResetPosition[abi:cxx11](bool) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0xc310
leaq 0x10(%rsp), %r15
testl %ebp, %ebp
je 0x30561
leaq 0x4b7f(%rip), %rsi # 0x35098
movq %r15, %rdi
callq 0xc440
leaq 0x5611(%rip), %rsi # 0x35b39
movq %r15, %rdi
callq 0xc440
pushq $0x1
popq %rbp
leaq 0x5604(%rip), %r12 # 0x35b3e
leaq 0x55f8(%rip), %r13 # 0x35b39
cmpl 0x14(%r14), %ebp
jge 0x3058f
movq %r15, %rdi
movq %r12, %rsi
callq 0xc440
movq %r15, %rdi
movq %r13, %rsi
callq 0xc440
incl %ebp
jmp 0x30541
leaq 0x4b30(%rip), %rsi # 0x35098
movq %r15, %rdi
callq 0xc440
pushq $0x1
popq %rbp
leaq 0x55c4(%rip), %r12 # 0x35b3e
cmpl 0x14(%r14), %ebp
jge 0x3058f
movq %r15, %rdi
movq %r12, %rsi
callq 0xc440
incl %ebp
jmp 0x3057a
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0xc730
movq %rsp, %rdi
callq 0xc360
movq %rbx, %rax
addq $0x188, %rsp # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x305bd
jmp 0x305bd
movq %rax, %rbx
movq %rsp, %rdi
callq 0xc360
movq %rbx, %rdi
callq 0xc7f0
| _ZNK5ftxui6Screen13ResetPositionB5cxx11Eb:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 188h
mov ebp, edx
mov r14, rsi
mov rbx, rdi
mov rdi, rsp
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(void)
lea r15, [rsp+1B8h+var_1A8]
test ebp, ebp
jz short loc_30561
lea rsi, unk_35098
mov rdi, r15
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
lea rsi, a2k; "\x1B[2K"
mov rdi, r15
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
push 1
pop rbp
lea r12, a1a; "\x1B[1A"
lea r13, a2k; "\x1B[2K"
loc_30541:
cmp ebp, [r14+14h]
jge short loc_3058F
mov rdi, r15
mov rsi, r12
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, r15
mov rsi, r13
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
inc ebp
jmp short loc_30541
loc_30561:
lea rsi, unk_35098
mov rdi, r15
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
push 1
pop rbp
lea r12, a1a; "\x1B[1A"
loc_3057A:
cmp ebp, [r14+14h]
jge short loc_3058F
mov rdi, r15
mov rsi, r12
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
inc ebp
jmp short loc_3057A
loc_3058F:
lea rsi, [rsp+1B8h+var_1A0]
mov rdi, rbx
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
mov rdi, rsp
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
mov rax, rbx
add rsp, 188h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_305BD
jmp short $+2
loc_305BD:
mov rbx, rax
mov rdi, rsp
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
mov rdi, rbx
call __Unwind_Resume
| long long ftxui::Screen::ResetPosition[abi:cxx11](long long a1, long long a2, int a3)
{
int i; // ebp
int j; // ebp
_BYTE v7[16]; // [rsp+0h] [rbp-1B8h] BYREF
_BYTE v8[8]; // [rsp+10h] [rbp-1A8h] BYREF
_BYTE v9[416]; // [rsp+18h] [rbp-1A0h] BYREF
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(v7);
if ( a3 )
{
std::operator<<<std::char_traits<char>>(v8, &unk_35098);
std::operator<<<std::char_traits<char>>(v8, "\x1B[2K");
for ( i = 1; i < *(_DWORD *)(a2 + 20); ++i )
{
std::operator<<<std::char_traits<char>>(v8, "\x1B[1A");
std::operator<<<std::char_traits<char>>(v8, "\x1B[2K");
}
}
else
{
std::operator<<<std::char_traits<char>>(v8, &unk_35098);
for ( j = 1; j < *(_DWORD *)(a2 + 20); ++j )
std::operator<<<std::char_traits<char>>(v8, "\x1B[1A");
}
std::stringbuf::str(a1, v9);
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream(v7);
return a1;
}
| ResetPosition[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x188
MOV EBP,EDX
MOV R14,RSI
MOV RBX,RDI
MOV RDI,RSP
CALL 0x0010c310
LEA R15,[RSP + 0x10]
TEST EBP,EBP
JZ 0x00130561
LAB_00130512:
LEA RSI,[0x135098]
MOV RDI,R15
CALL 0x0010c440
LEA RSI,[0x135b39]
MOV RDI,R15
CALL 0x0010c440
PUSH 0x1
POP RBP
LEA R12,[0x135b3e]
LEA R13,[0x135b39]
LAB_00130541:
CMP EBP,dword ptr [R14 + 0x14]
JGE 0x0013058f
LAB_00130547:
MOV RDI,R15
MOV RSI,R12
CALL 0x0010c440
MOV RDI,R15
MOV RSI,R13
CALL 0x0010c440
INC EBP
JMP 0x00130541
LAB_00130561:
LEA RSI,[0x135098]
MOV RDI,R15
CALL 0x0010c440
PUSH 0x1
POP RBP
LEA R12,[0x135b3e]
LAB_0013057a:
CMP EBP,dword ptr [R14 + 0x14]
JGE 0x0013058f
LAB_00130580:
MOV RDI,R15
MOV RSI,R12
CALL 0x0010c440
INC EBP
JMP 0x0013057a
LAB_0013058f:
LEA RSI,[RSP + 0x18]
LAB_00130594:
MOV RDI,RBX
CALL 0x0010c730
LAB_0013059c:
MOV RDI,RSP
CALL 0x0010c360
MOV RAX,RBX
ADD RSP,0x188
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* ftxui::Screen::ResetPosition[abi:cxx11](bool) const */
int8 ftxui::Screen::ResetPosition_abi_cxx11_(bool param_1)
{
int in_EDX;
int iVar1;
long in_RSI;
int7 in_register_00000039;
stringstream asStack_1b8 [16];
ostream local_1a8 [376];
std::__cxx11::stringstream::stringstream(asStack_1b8);
if (in_EDX == 0) {
/* try { // try from 00130561 to 0013056f has its CatchHandler @ 001305b9 */
std::operator<<(local_1a8,"\r");
for (iVar1 = 1; iVar1 < *(int *)(in_RSI + 0x14); iVar1 = iVar1 + 1) {
/* try { // try from 00130580 to 0013058a has its CatchHandler @ 001305bb */
std::operator<<(local_1a8,"\x1b[1A");
}
}
else {
/* try { // try from 00130512 to 0013052f has its CatchHandler @ 001305b9 */
std::operator<<(local_1a8,"\r");
std::operator<<(local_1a8,"\x1b[2K");
for (iVar1 = 1; iVar1 < *(int *)(in_RSI + 0x14); iVar1 = iVar1 + 1) {
/* try { // try from 00130547 to 0013055c has its CatchHandler @ 001305bd */
std::operator<<(local_1a8,"\x1b[1A");
std::operator<<(local_1a8,"\x1b[2K");
}
}
/* try { // try from 00130594 to 0013059b has its CatchHandler @ 001305b9 */
std::__cxx11::stringbuf::str();
std::__cxx11::stringstream::~stringstream(asStack_1b8);
return CONCAT71(in_register_00000039,param_1);
}
| |
27,879 | PFS_buffer_scalable_container<PFS_user, 128, 128, PFS_user_array, PFS_user_allocator>::apply_all(void (*)(PFS_user*)) | eloqsql/storage/perfschema/pfs_buffer_container.h | void apply_all(function_type fct)
{
uint i;
array_type *page;
value_type *pfs;
value_type *pfs_last;
for (i=0 ; i < PFS_PAGE_COUNT; i++)
{
page= m_pages[i];
if (page != NULL)
{
pfs= page->get_first();
pfs_last= page->get_last();
while (pfs < pfs_last)
{
fct(pfs);
pfs++;
}
}
}
} | O0 | c | PFS_buffer_scalable_container<PFS_user, 128, 128, PFS_user_array, PFS_user_allocator>::apply_all(void (*)(PFS_user*)):
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x400, -0x14(%rbp) # imm = 0x400
jae 0x5345f
movq -0x38(%rbp), %rax
movl -0x14(%rbp), %ecx
movq 0xa8(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x53452
movq -0x20(%rbp), %rdi
callq 0x3e570
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3e590
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x53450
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rdi
callq *%rax
movq -0x28(%rbp), %rax
addq $0x1c0, %rax # imm = 0x1C0
movq %rax, -0x28(%rbp)
jmp 0x5342c
jmp 0x53452
jmp 0x53454
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x533ef
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| _ZN29PFS_buffer_scalable_containerI11PFS_programLi1024ELi1024E24PFS_buffer_default_arrayIS0_E28PFS_buffer_default_allocatorIS0_EE9apply_allEPFvPS0_E:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov [rbp+var_38], rax
mov [rbp+var_14], 0
loc_533EF:
cmp [rbp+var_14], 400h
jnb short loc_5345F
mov rax, [rbp+var_38]
mov ecx, [rbp+var_14]
mov rax, [rax+rcx*8+0A8h]
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
jz short loc_53452
mov rdi, [rbp+var_20]
call _ZN24PFS_buffer_default_arrayI11PFS_programE9get_firstEv; PFS_buffer_default_array<PFS_program>::get_first(void)
mov [rbp+var_28], rax
mov rdi, [rbp+var_20]
call _ZN24PFS_buffer_default_arrayI11PFS_programE8get_lastEv; PFS_buffer_default_array<PFS_program>::get_last(void)
mov [rbp+var_30], rax
loc_5342C:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jnb short loc_53450
mov rax, [rbp+var_10]
mov rdi, [rbp+var_28]
call rax
mov rax, [rbp+var_28]
add rax, 1C0h
mov [rbp+var_28], rax
jmp short loc_5342C
loc_53450:
jmp short $+2
loc_53452:
jmp short $+2
loc_53454:
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_14], eax
jmp short loc_533EF
loc_5345F:
add rsp, 40h
pop rbp
retn
| long long PFS_buffer_scalable_container<PFS_program,1024,1024,PFS_buffer_default_array<PFS_program>,PFS_buffer_default_allocator<PFS_program>>::apply_all(
long long a1,
void ( *a2)(unsigned long long))
{
long long result; // rax
unsigned long long last; // [rsp+10h] [rbp-30h]
unsigned long long first; // [rsp+18h] [rbp-28h]
long long v5; // [rsp+20h] [rbp-20h]
unsigned int i; // [rsp+2Ch] [rbp-14h]
result = a1;
for ( i = 0; i < 0x400; ++i )
{
v5 = *(_QWORD *)(a1 + 8LL * i + 168);
if ( v5 )
{
first = PFS_buffer_default_array<PFS_program>::get_first(v5);
last = PFS_buffer_default_array<PFS_program>::get_last(v5);
while ( first < last )
{
a2(first);
first += 448LL;
}
}
result = i + 1;
}
return result;
}
| apply_all:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x38],RAX
MOV dword ptr [RBP + -0x14],0x0
LAB_001533ef:
CMP dword ptr [RBP + -0x14],0x400
JNC 0x0015345f
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RAX + RCX*0x8 + 0xa8]
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x20],0x0
JZ 0x00153452
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x0013e570
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x0013e590
MOV qword ptr [RBP + -0x30],RAX
LAB_0015342c:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x00153450
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RBP + -0x28]
CALL RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1c0
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0015342c
LAB_00153450:
JMP 0x00153452
LAB_00153452:
JMP 0x00153454
LAB_00153454:
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x001533ef
LAB_0015345f:
ADD RSP,0x40
POP RBP
RET
|
/* PFS_buffer_scalable_container<PFS_program, 1024, 1024, PFS_buffer_default_array<PFS_program>,
PFS_buffer_default_allocator<PFS_program> >::apply_all(void (*)(PFS_program*)) */
void __thiscall
PFS_buffer_scalable_container<PFS_program,1024,1024,PFS_buffer_default_array<PFS_program>,PFS_buffer_default_allocator<PFS_program>>
::apply_all(PFS_buffer_scalable_container<PFS_program,1024,1024,PFS_buffer_default_array<PFS_program>,PFS_buffer_default_allocator<PFS_program>>
*this,_func_void_PFS_program_ptr *param_1)
{
PFS_buffer_default_array<PFS_program> *this_00;
PFS_program *pPVar1;
PFS_program *local_30;
uint local_1c;
for (local_1c = 0; local_1c < 0x400; local_1c = local_1c + 1) {
this_00 = *(PFS_buffer_default_array<PFS_program> **)(this + (ulong)local_1c * 8 + 0xa8);
if (this_00 != (PFS_buffer_default_array<PFS_program> *)0x0) {
local_30 = (PFS_program *)PFS_buffer_default_array<PFS_program>::get_first(this_00);
pPVar1 = (PFS_program *)PFS_buffer_default_array<PFS_program>::get_last(this_00);
for (; local_30 < pPVar1; local_30 = local_30 + 0x1c0) {
(*param_1)(local_30);
}
}
}
return;
}
| |
27,880 | ha_federated::store_result(st_mysql*) | eloqsql/storage/federated/ha_federated.cc | MYSQL_RES *ha_federated::store_result(MYSQL *mysql_arg)
{
MYSQL_RES *result= mysql_store_result(mysql_arg);
DBUG_ENTER("ha_federated::store_result");
if (result)
{
(void) insert_dynamic(&results, (uchar*) &result);
}
position_called= FALSE;
DBUG_RETURN(result);
} | O3 | cpp | ha_federated::store_result(st_mysql*):
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x82c0
movq %rax, -0x18(%rbp)
testq %rax, %rax
je 0xb8eb
leaq 0x550(%rbx), %rdi
leaq -0x18(%rbp), %r14
movq %r14, %rsi
callq 0x8450
movq (%r14), %rax
jmp 0xb8ed
xorl %eax, %eax
movb $0x0, 0x578(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
| _ZN12ha_federated12store_resultEP8st_mysql:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 10h
mov rbx, rdi
mov rdi, rsi
call _mysql_store_result
mov [rbp+var_18], rax
test rax, rax
jz short loc_B8EB
lea rdi, [rbx+550h]
lea r14, [rbp+var_18]
mov rsi, r14
call _insert_dynamic
mov rax, [r14]
jmp short loc_B8ED
loc_B8EB:
xor eax, eax
loc_B8ED:
mov byte ptr [rbx+578h], 0
add rsp, 10h
pop rbx
pop r14
pop rbp
retn
| long long ha_federated::store_result(long long a1, long long a2)
{
long long result; // rax
long long v3[3]; // [rsp+8h] [rbp-18h] BYREF
v3[0] = mysql_store_result(a2);
if ( v3[0] )
{
insert_dynamic(a1 + 1360, v3);
result = v3[0];
}
else
{
result = 0LL;
}
*(_BYTE *)(a1 + 1400) = 0;
return result;
}
| store_result:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
MOV RDI,RSI
CALL 0x001082c0
MOV qword ptr [RBP + -0x18],RAX
TEST RAX,RAX
JZ 0x0010b8eb
LEA RDI,[RBX + 0x550]
LEA R14,[RBP + -0x18]
MOV RSI,R14
CALL 0x00108450
MOV RAX,qword ptr [R14]
JMP 0x0010b8ed
LAB_0010b8eb:
XOR EAX,EAX
LAB_0010b8ed:
MOV byte ptr [RBX + 0x578],0x0
ADD RSP,0x10
POP RBX
POP R14
POP RBP
RET
|
/* ha_federated::store_result(st_mysql*) */
long __thiscall ha_federated::store_result(ha_federated *this,st_mysql *param_1)
{
long local_20;
local_20 = mysql_store_result(param_1);
if (local_20 == 0) {
local_20 = 0;
}
else {
insert_dynamic(this + 0x550,&local_20);
}
this[0x578] = (ha_federated)0x0;
return local_20;
}
| |
27,881 | reset_pagecache_counters | eloqsql/storage/maria/ma_pagecache.c | int reset_pagecache_counters(const char *name __attribute__((unused)),
PAGECACHE *pagecache)
{
DBUG_ENTER("reset_pagecache_counters");
if (!pagecache->inited)
{
DBUG_PRINT("info", ("Key cache %s not initialized.", name));
DBUG_RETURN(0);
}
DBUG_PRINT("info", ("Resetting counters for key cache %s.", name));
pagecache->global_blocks_changed= 0; /* Key_blocks_not_flushed */
pagecache->global_cache_r_requests= 0; /* Key_read_requests */
pagecache->global_cache_read= 0; /* Key_reads */
pagecache->global_cache_w_requests= 0; /* Key_write_requests */
pagecache->global_cache_write= 0; /* Key_writes */
DBUG_RETURN(0);
} | O0 | c | reset_pagecache_counters:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, 0x1a8(%rax)
jne 0x3f658
jmp 0x3f64b
jmp 0x3f64d
jmp 0x3f64f
movl $0x0, -0x4(%rbp)
jmp 0x3f6ae
jmp 0x3f65a
jmp 0x3f65c
movq -0x18(%rbp), %rax
movq $0x0, 0x168(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x180(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x188(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x170(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x178(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| reset_pagecache_counters:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_18]
cmp byte ptr [rax+1A8h], 0
jnz short loc_3F658
jmp short $+2
loc_3F64B:
jmp short $+2
loc_3F64D:
jmp short $+2
loc_3F64F:
mov [rbp+var_4], 0
jmp short loc_3F6AE
loc_3F658:
jmp short $+2
loc_3F65A:
jmp short $+2
loc_3F65C:
mov rax, [rbp+var_18]
mov qword ptr [rax+168h], 0
mov rax, [rbp+var_18]
mov qword ptr [rax+180h], 0
mov rax, [rbp+var_18]
mov qword ptr [rax+188h], 0
mov rax, [rbp+var_18]
mov qword ptr [rax+170h], 0
mov rax, [rbp+var_18]
mov qword ptr [rax+178h], 0
mov [rbp+var_4], 0
loc_3F6AE:
mov eax, [rbp+var_4]
pop rbp
retn
| long long reset_pagecache_counters(long long a1, long long a2)
{
if ( *(_BYTE *)(a2 + 424) )
{
*(_QWORD *)(a2 + 360) = 0LL;
*(_QWORD *)(a2 + 384) = 0LL;
*(_QWORD *)(a2 + 392) = 0LL;
*(_QWORD *)(a2 + 368) = 0LL;
*(_QWORD *)(a2 + 376) = 0LL;
}
return 0LL;
}
| reset_pagecache_counters:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x18]
CMP byte ptr [RAX + 0x1a8],0x0
JNZ 0x0013f658
JMP 0x0013f64b
LAB_0013f64b:
JMP 0x0013f64d
LAB_0013f64d:
JMP 0x0013f64f
LAB_0013f64f:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0013f6ae
LAB_0013f658:
JMP 0x0013f65a
LAB_0013f65a:
JMP 0x0013f65c
LAB_0013f65c:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x168],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x180],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x188],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x170],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x178],0x0
MOV dword ptr [RBP + -0x4],0x0
LAB_0013f6ae:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 reset_pagecache_counters(int8 param_1,long param_2)
{
if (*(char *)(param_2 + 0x1a8) != '\0') {
*(int8 *)(param_2 + 0x168) = 0;
*(int8 *)(param_2 + 0x180) = 0;
*(int8 *)(param_2 + 0x188) = 0;
*(int8 *)(param_2 + 0x170) = 0;
*(int8 *)(param_2 + 0x178) = 0;
}
return 0;
}
| |
27,882 | reset_pagecache_counters | eloqsql/storage/maria/ma_pagecache.c | int reset_pagecache_counters(const char *name __attribute__((unused)),
PAGECACHE *pagecache)
{
DBUG_ENTER("reset_pagecache_counters");
if (!pagecache->inited)
{
DBUG_PRINT("info", ("Key cache %s not initialized.", name));
DBUG_RETURN(0);
}
DBUG_PRINT("info", ("Resetting counters for key cache %s.", name));
pagecache->global_blocks_changed= 0; /* Key_blocks_not_flushed */
pagecache->global_cache_r_requests= 0; /* Key_read_requests */
pagecache->global_cache_read= 0; /* Key_reads */
pagecache->global_cache_w_requests= 0; /* Key_write_requests */
pagecache->global_cache_write= 0; /* Key_writes */
DBUG_RETURN(0);
} | O3 | c | reset_pagecache_counters:
pushq %rbp
movq %rsp, %rbp
cmpb $0x0, 0x1a8(%rsi)
je 0x3d371
xorps %xmm0, %xmm0
movups %xmm0, 0x178(%rsi)
movups %xmm0, 0x168(%rsi)
movq $0x0, 0x188(%rsi)
xorl %eax, %eax
popq %rbp
retq
| reset_pagecache_counters:
push rbp
mov rbp, rsp
cmp byte ptr [rsi+1A8h], 0
jz short loc_3D371
xorps xmm0, xmm0
movups xmmword ptr [rsi+178h], xmm0
movups xmmword ptr [rsi+168h], xmm0
mov qword ptr [rsi+188h], 0
loc_3D371:
xor eax, eax
pop rbp
retn
| long long reset_pagecache_counters(long long a1, long long a2)
{
if ( *(_BYTE *)(a2 + 424) )
{
*(_OWORD *)(a2 + 376) = 0LL;
*(_OWORD *)(a2 + 360) = 0LL;
*(_QWORD *)(a2 + 392) = 0LL;
}
return 0LL;
}
| reset_pagecache_counters:
PUSH RBP
MOV RBP,RSP
CMP byte ptr [RSI + 0x1a8],0x0
JZ 0x0013d371
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSI + 0x178],XMM0
MOVUPS xmmword ptr [RSI + 0x168],XMM0
MOV qword ptr [RSI + 0x188],0x0
LAB_0013d371:
XOR EAX,EAX
POP RBP
RET
|
int8 reset_pagecache_counters(int8 param_1,long param_2)
{
if (*(char *)(param_2 + 0x1a8) != '\0') {
*(int8 *)(param_2 + 0x178) = 0;
*(int8 *)(param_2 + 0x180) = 0;
*(int8 *)(param_2 + 0x168) = 0;
*(int8 *)(param_2 + 0x170) = 0;
*(int8 *)(param_2 + 0x188) = 0;
}
return 0;
}
| |
27,883 | func_gb2312_uni_onechar | eloqsql/strings/ctype-gb2312.c | static int func_gb2312_uni_onechar(int code){
if ((code>=0x2121)&&(code<=0x2658))
return(tab_gb2312_uni0[code-0x2121]);
if ((code>=0x2721)&&(code<=0x296F))
return(tab_gb2312_uni1[code-0x2721]);
if ((code>=0x3021)&&(code<=0x777E))
return(tab_gb2312_uni2[code-0x3021]);
return(0);
} | O0 | c | func_gb2312_uni_onechar:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x2121, -0x8(%rbp) # imm = 0x2121
jl 0x3c6f4
cmpl $0x2658, -0x8(%rbp) # imm = 0x2658
jg 0x3c6f4
movl -0x8(%rbp), %eax
subl $0x2121, %eax # imm = 0x2121
movslq %eax, %rcx
leaq 0xc5515(%rip), %rax # 0x101c00
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x3c755
cmpl $0x2721, -0x8(%rbp) # imm = 0x2721
jl 0x3c721
cmpl $0x296f, -0x8(%rbp) # imm = 0x296F
jg 0x3c721
movl -0x8(%rbp), %eax
subl $0x2721, %eax # imm = 0x2721
movslq %eax, %rcx
leaq 0xc5f58(%rip), %rax # 0x102670
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x3c755
cmpl $0x3021, -0x8(%rbp) # imm = 0x3021
jl 0x3c74e
cmpl $0x777e, -0x8(%rbp) # imm = 0x777E
jg 0x3c74e
movl -0x8(%rbp), %eax
subl $0x3021, %eax # imm = 0x3021
movslq %eax, %rcx
leaq 0xc63cb(%rip), %rax # 0x102b10
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x3c755
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
| func_gb2312_uni_onechar:
push rbp
mov rbp, rsp
mov [rbp+var_8], edi
cmp [rbp+var_8], 2121h
jl short loc_3C6F4
cmp [rbp+var_8], 2658h
jg short loc_3C6F4
mov eax, [rbp+var_8]
sub eax, 2121h
movsxd rcx, eax
lea rax, tab_gb2312_uni0
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_3C755
loc_3C6F4:
cmp [rbp+var_8], 2721h
jl short loc_3C721
cmp [rbp+var_8], 296Fh
jg short loc_3C721
mov eax, [rbp+var_8]
sub eax, 2721h
movsxd rcx, eax
lea rax, tab_gb2312_uni1
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_3C755
loc_3C721:
cmp [rbp+var_8], 3021h
jl short loc_3C74E
cmp [rbp+var_8], 777Eh
jg short loc_3C74E
mov eax, [rbp+var_8]
sub eax, 3021h
movsxd rcx, eax
lea rax, tab_gb2312_uni2
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_3C755
loc_3C74E:
mov [rbp+var_4], 0
loc_3C755:
mov eax, [rbp+var_4]
pop rbp
retn
| long long func_gb2312_uni_onechar(int a1)
{
if ( a1 < 8481 || a1 > 9816 )
{
if ( a1 < 10017 || a1 > 10607 )
{
if ( a1 < 12321 || a1 > 30590 )
return 0;
else
return tab_gb2312_uni2[a1 - 12321];
}
else
{
return tab_gb2312_uni1[a1 - 10017];
}
}
else
{
return tab_gb2312_uni0[a1 - 8481];
}
}
| func_gb2312_uni_onechar:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x8],EDI
CMP dword ptr [RBP + -0x8],0x2121
JL 0x0013c6f4
CMP dword ptr [RBP + -0x8],0x2658
JG 0x0013c6f4
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2121
MOVSXD RCX,EAX
LEA RAX,[0x201c00]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013c755
LAB_0013c6f4:
CMP dword ptr [RBP + -0x8],0x2721
JL 0x0013c721
CMP dword ptr [RBP + -0x8],0x296f
JG 0x0013c721
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2721
MOVSXD RCX,EAX
LEA RAX,[0x202670]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013c755
LAB_0013c721:
CMP dword ptr [RBP + -0x8],0x3021
JL 0x0013c74e
CMP dword ptr [RBP + -0x8],0x777e
JG 0x0013c74e
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x3021
MOVSXD RCX,EAX
LEA RAX,[0x202b10]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013c755
LAB_0013c74e:
MOV dword ptr [RBP + -0x4],0x0
LAB_0013c755:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int2 func_gb2312_uni_onechar(int param_1)
{
int2 uVar1;
if ((param_1 < 0x2121) || (0x2658 < param_1)) {
if ((param_1 < 0x2721) || (0x296f < param_1)) {
if ((param_1 < 0x3021) || (0x777e < param_1)) {
uVar1 = 0;
}
else {
uVar1 = *(int2 *)(tab_gb2312_uni2 + (long)(param_1 + -0x3021) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_gb2312_uni1 + (long)(param_1 + -0x2721) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_gb2312_uni0 + (long)(param_1 + -0x2121) * 2);
}
return uVar1;
}
| |
27,884 | minja::Value::pop(minja::Value const&) | monkey531[P]llama/common/./minja.hpp | Value pop(const Value& index) {
if (is_array()) {
if (array_->empty())
throw std::runtime_error("pop from empty list");
if (index.is_null()) {
auto ret = array_->back();
array_->pop_back();
return ret;
} else if (!index.is_number_integer()) {
throw std::runtime_error("pop index must be an integer: " + index.dump());
} else {
auto i = index.get<int>();
if (i < 0 || i >= static_cast<int>(array_->size()))
throw std::runtime_error("pop index out of range: " + index.dump());
auto it = array_->begin() + (i < 0 ? array_->size() + i : i);
auto ret = *it;
array_->erase(it);
return ret;
}
} else if (is_object()) {
if (!index.is_hashable())
throw std::runtime_error("Unashable type: " + index.dump());
auto it = object_->find(index.primitive_);
if (it == object_->end())
throw std::runtime_error("Key not found: " + index.dump());
auto ret = it->second;
object_->erase(it);
return ret;
} else {
throw std::runtime_error("Value is not an array or object: " + dump());
}
} | O3 | cpp | minja::Value::pop(minja::Value const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %rbp
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x54151
movq 0x8(%rax), %rsi
cmpq %rsi, (%rax)
je 0x5425f
cmpq $0x0, 0x20(%rbx)
movb 0x40(%rbx), %al
jne 0x541b6
cmpq $0x0, 0x10(%rbx)
jne 0x541b6
testb %al, %al
jne 0x541b6
cmpq $0x0, 0x30(%rbx)
jne 0x541b6
addq $-0x50, %rsi
movq %rbp, %rdi
callq 0x4ed98
movq 0x10(%r15), %rdi
movq 0x8(%rdi), %rsi
addq $-0x50, %rsi
movq %rsi, 0x8(%rdi)
callq 0x4412e
jmp 0x5424d
movq 0x20(%r15), %r14
testq %r14, %r14
je 0x542f1
cmpq $0x0, 0x10(%rbx)
jne 0x54351
cmpq $0x0, 0x20(%rbx)
jne 0x54351
cmpq $0x0, 0x30(%rbx)
jne 0x54351
movq (%r14), %r13
movq 0x8(%r14), %r12
cmpq %r12, %r13
je 0x54226
movq %rbp, 0x40(%rsp)
leaq 0x40(%rbx), %rbp
movq %r13, %rdi
movq %rbp, %rsi
callq 0x4e6da
testb %al, %al
jne 0x54216
addq $0x60, %r13
movq 0x8(%r14), %r12
cmpq %r12, %r13
jne 0x54198
jmp 0x54219
addb $-0x5, %al
cmpb $0x2, %al
jae 0x5440e
movq %rbx, %rdi
callq 0x51e3a
testl %eax, %eax
js 0x54291
movq 0x10(%r15), %rcx
movq (%rcx), %r12
movq 0x8(%rcx), %rcx
subq %r12, %rcx
shrq $0x4, %rcx
imull $0xcccccccd, %ecx, %ecx # imm = 0xCCCCCCCD
cmpl %ecx, %eax
jge 0x54291
movl %eax, %eax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
addq %rax, %r12
movq %rbp, %rdi
movq %r12, %rsi
callq 0x4ed98
movq 0x10(%r15), %rdi
movq %r12, %rsi
callq 0x557de
jmp 0x5424d
movq %r13, %r12
movq 0x20(%r15), %rax
movq 0x8(%rax), %r13
movq 0x40(%rsp), %rbp
cmpq %r13, %r12
je 0x543b1
leaq 0x10(%r12), %rsi
movq %rbp, %rdi
callq 0x4ed98
movq 0x20(%r15), %rdi
leaq 0x60(%r12), %rdx
movq %r12, %rsi
callq 0x5585a
movq %rbp, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x18360
movq %rax, %r14
leaq 0x67071(%rip), %rsi # 0xbb2e4
movq %rax, %rdi
callq 0x18270
movq 0x9bd6e(%rip), %rsi # 0xefff0
movq 0x9bcf7(%rip), %rdx # 0xeff80
movq %r14, %rdi
callq 0x18b30
movl $0x10, %edi
callq 0x18360
movq %rax, %r14
movq %rsp, %rdi
movq %rbx, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x3dcdc
leaq 0x67060(%rip), %rsi # 0xbb317
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x30c3b
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x18a80
xorl %ebp, %ebp
movq 0x9bd13(%rip), %rsi # 0xefff0
movq 0x9bc9c(%rip), %rdx # 0xeff80
movq %r14, %rdi
callq 0x18b30
jmp 0x54469
movl $0x10, %edi
callq 0x18360
movq %rax, %r14
movq %rsp, %rdi
movq %r15, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x3dcdc
leaq 0x66cc5(%rip), %rsi # 0xbafdc
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x30c3b
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x18a80
xorl %ebp, %ebp
movq 0x9bcb3(%rip), %rsi # 0xefff0
movq 0x9bc3c(%rip), %rdx # 0xeff80
movq %r14, %rdi
callq 0x18b30
jmp 0x54469
movl $0x10, %edi
callq 0x18360
movq %rax, %r14
movq %rsp, %rdi
movq %rbx, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x3dcdc
leaq 0x66b19(%rip), %rsi # 0xbae90
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x30c3b
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x18a80
xorl %ebp, %ebp
movq 0x9bc53(%rip), %rsi # 0xefff0
movq 0x9bbdc(%rip), %rdx # 0xeff80
movq %r14, %rdi
callq 0x18b30
jmp 0x54469
movl $0x10, %edi
callq 0x18360
movq %rax, %r14
movq %rsp, %rdi
movq %rbx, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x3dcdc
leaq 0x66f59(%rip), %rsi # 0xbb330
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x30c3b
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x18a80
xorl %ebp, %ebp
movq 0x9bbf3(%rip), %rsi # 0xefff0
movq 0x9bb7c(%rip), %rdx # 0xeff80
movq %r14, %rdi
callq 0x18b30
jmp 0x54469
movl $0x10, %edi
callq 0x18360
movq %rax, %r14
movq %rsp, %rdi
movq %rbx, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x3dcdc
leaq 0x66ec4(%rip), %rsi # 0xbb2f8
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x30c3b
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x18a80
xorl %ebp, %ebp
movq 0x9bb96(%rip), %rsi # 0xefff0
movq 0x9bb1f(%rip), %rdx # 0xeff80
movq %r14, %rdi
callq 0x18b30
jmp 0x54479
jmp 0x544b9
jmp 0x54479
jmp 0x544b9
jmp 0x54479
jmp 0x544b9
jmp 0x54479
jmp 0x544b9
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x54497
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x186a0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x544b2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x186a0
testb %bpl, %bpl
jne 0x544e8
jmp 0x544fd
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x544e8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x186a0
jmp 0x544e8
jmp 0x544e5
jmp 0x544e5
jmp 0x544e5
jmp 0x544e5
jmp 0x544f2
jmp 0x544e5
movq %rax, %rbx
movq %r14, %rdi
callq 0x18500
jmp 0x544fd
movq %rax, %rbx
movq %rbp, %rdi
callq 0x3d8e4
movq %rbx, %rdi
callq 0x18b90
nop
| _ZN5minja5Value3popERKS0_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov rbx, rdx
mov r15, rsi
mov rbp, rdi
mov rax, [rsi+10h]
test rax, rax
jz short loc_54151
mov rsi, [rax+8]
cmp [rax], rsi
jz loc_5425F
cmp qword ptr [rbx+20h], 0
mov al, [rbx+40h]
jnz loc_541B6
cmp qword ptr [rbx+10h], 0
jnz loc_541B6
test al, al
jnz loc_541B6
cmp qword ptr [rbx+30h], 0
jnz loc_541B6
add rsi, 0FFFFFFFFFFFFFFB0h; minja::Value *
mov rdi, rbp; this
call _ZN5minja5ValueC2ERKS0_; minja::Value::Value(minja::Value const&)
mov rdi, [r15+10h]
mov rsi, [rdi+8]
add rsi, 0FFFFFFFFFFFFFFB0h
mov [rdi+8], rsi
call _ZN9__gnu_cxx13new_allocatorIN5minja5ValueEE7destroyIS2_EEvPT_; __gnu_cxx::new_allocator<minja::Value>::destroy<minja::Value>(minja::Value *)
jmp loc_5424D
loc_54151:
mov r14, [r15+20h]
test r14, r14
jz loc_542F1
cmp qword ptr [rbx+10h], 0
jnz loc_54351
cmp qword ptr [rbx+20h], 0
jnz loc_54351
cmp qword ptr [rbx+30h], 0
jnz loc_54351
mov r13, [r14]
mov r12, [r14+8]
cmp r13, r12
jz loc_54226
mov [rsp+78h+var_38], rbp
lea rbp, [rbx+40h]
loc_54198:
mov rdi, r13
mov rsi, rbp
call _ZN8nlohmann16json_abi_v3_11_3eqERKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEESF_; nlohmann::json_abi_v3_11_3::operator==(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
test al, al
jnz short loc_54216
add r13, 60h ; '`'
mov r12, [r14+8]
cmp r13, r12
jnz short loc_54198
jmp short loc_54219
loc_541B6:
add al, 0FBh
cmp al, 2
jnb loc_5440E
mov rdi, rbx
call _ZNK5minja5Value3getIiEET_v; minja::Value::get<int>(void)
test eax, eax
js loc_54291
mov rcx, [r15+10h]
mov r12, [rcx]
mov rcx, [rcx+8]
sub rcx, r12
shr rcx, 4
imul ecx, 0CCCCCCCDh
cmp eax, ecx
jge loc_54291
mov eax, eax
lea rax, [rax+rax*4]
shl rax, 4
add r12, rax
mov rdi, rbp; this
mov rsi, r12; minja::Value *
call _ZN5minja5ValueC2ERKS0_; minja::Value::Value(minja::Value const&)
mov rdi, [r15+10h]
mov rsi, r12
call _ZNSt6vectorIN5minja5ValueESaIS1_EE8_M_eraseEN9__gnu_cxx17__normal_iteratorIPS1_S3_EE; std::vector<minja::Value>::_M_erase(__gnu_cxx::__normal_iterator<minja::Value*,std::vector<minja::Value>>)
jmp short loc_5424D
loc_54216:
mov r12, r13
loc_54219:
mov rax, [r15+20h]
mov r13, [rax+8]
mov rbp, [rsp+78h+var_38]
loc_54226:
cmp r12, r13
jz loc_543B1
lea rsi, [r12+10h]; minja::Value *
mov rdi, rbp; this
call _ZN5minja5ValueC2ERKS0_; minja::Value::Value(minja::Value const&)
mov rdi, [r15+20h]
lea rdx, [r12+60h]
mov rsi, r12
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE5eraseEN9__gnu_cxx17__normal_iteratorIPSK_S3_ISK_SL_EEESR_; 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>>>::erase(__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>,__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>)
loc_5424D:
mov rax, rbp
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_5425F:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aPopFromEmptyLi; "pop from empty list"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
loc_54291:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
mov rdi, rsp
mov rsi, rbx
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aPopIndexOutOfR; "pop index out of range: "
lea rdi, [rsp+78h+var_58]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+78h+var_58]
mov rdi, r14
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp loc_54469
loc_542F1:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
mov rdi, rsp
mov rsi, r15
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aValueIsNotAnAr_0; "Value is not an array or object: "
lea rdi, [rsp+78h+var_58]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+78h+var_58]
mov rdi, r14
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp loc_54469
loc_54351:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
mov rdi, rsp
mov rsi, rbx
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aUnashableType; "Unashable type: "
lea rdi, [rsp+78h+var_58]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+78h+var_58]
mov rdi, r14
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp loc_54469
loc_543B1:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
mov rdi, rsp
mov rsi, rbx
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aKeyNotFound_0; "Key not found: "
lea rdi, [rsp+78h+var_58]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+78h+var_58]
mov rdi, r14
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp short loc_54469
loc_5440E:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
mov rdi, rsp
mov rsi, rbx
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aPopIndexMustBe; "pop index must be an integer: "
lea rdi, [rsp+78h+var_58]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+78h+var_58]
mov rdi, r14
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
loc_54469:
jmp short loc_54479
jmp short loc_544B9
jmp short loc_54479
jmp short loc_544B9
jmp short loc_54479
jmp short loc_544B9
jmp short loc_54479
jmp short loc_544B9
loc_54479:
mov rbx, rax
lea rax, [rsp+78h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_54497
mov rsi, [rsp+78h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_54497:
lea rax, [rsp+78h+var_68]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_544B2
mov rsi, [rsp+78h+var_68]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_544B2:
test bpl, bpl
jnz short loc_544E8
jmp short loc_544FD
loc_544B9:
mov rbx, rax
lea rax, [rsp+78h+var_68]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_544E8
mov rsi, [rsp+78h+var_68]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_544E8
jmp short loc_544E5
jmp short loc_544E5
jmp short loc_544E5
jmp short loc_544E5
jmp short loc_544F2
jmp short $+2
loc_544E5:
mov rbx, rax
loc_544E8:
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_544FD
loc_544F2:
mov rbx, rax
mov rdi, rbp; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_544FD:
mov rdi, rbx
call __Unwind_Resume
| minja::Value * minja::Value::pop(minja::Value *this, const minja::Value *a2, long long a3, __m128d a4)
{
minja::Value *v6; // rbp
_QWORD *v7; // rax
long long v8; // rsi
char v9; // al
long long v10; // rdi
long long v11; // rsi
unsigned __int8 **v12; // r14
unsigned __int8 *v13; // r13
unsigned __int8 *v14; // r12
int v15; // eax
_QWORD *v16; // rcx
const minja::Value *v17; // r12
std::runtime_error *exception; // r14
void *v20; // r14
void *v21; // r14
void *v22; // r14
void *v23; // r14
void *v24; // r14
_BYTE v25[16]; // [rsp+0h] [rbp-78h] BYREF
_BYTE v26[16]; // [rsp+20h] [rbp-58h] BYREF
minja::Value *v27; // [rsp+40h] [rbp-38h]
v6 = this;
v7 = (_QWORD *)*((_QWORD *)a2 + 2);
if ( v7 )
{
v8 = v7[1];
if ( *v7 == v8 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "pop from empty list");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v9 = *(_BYTE *)(a3 + 64);
if ( *(_QWORD *)(a3 + 32) || *(_QWORD *)(a3 + 16) || v9 || *(_QWORD *)(a3 + 48) )
{
if ( (unsigned __int8)(v9 - 5) >= 2u )
{
v24 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v25, a3, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v26, (long long)"pop index must be an integer: ", (long long)v25);
std::runtime_error::runtime_error(v24, v26);
__cxa_throw(
v24,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v15 = minja::Value::get<int>((_QWORD *)a3);
if ( v15 < 0 || (v16 = (_QWORD *)*((_QWORD *)a2 + 2), v15 >= (int)(-858993459 * ((v16[1] - *v16) >> 4))) )
{
v20 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v25, a3, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v26, (long long)"pop index out of range: ", (long long)v25);
std::runtime_error::runtime_error(v20, v26);
__cxa_throw(
v20,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v17 = (const minja::Value *)(80LL * (unsigned int)v15 + *v16);
minja::Value::Value(this, v17);
std::vector<minja::Value>::_M_erase(*((_QWORD *)a2 + 2), v17);
}
else
{
minja::Value::Value(this, (const minja::Value *)(v8 - 80));
v10 = *((_QWORD *)a2 + 2);
v11 = *(_QWORD *)(v10 + 8) - 80LL;
*(_QWORD *)(v10 + 8) = v11;
__gnu_cxx::new_allocator<minja::Value>::destroy<minja::Value>(v10, v11);
}
}
else
{
v12 = (unsigned __int8 **)*((_QWORD *)a2 + 4);
if ( !v12 )
{
v21 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v25, (long long)a2, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v26, (long long)"Value is not an array or object: ", (long long)v25);
std::runtime_error::runtime_error(v21, v26);
__cxa_throw(
v21,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( *(_QWORD *)(a3 + 16) || *(_QWORD *)(a3 + 32) || *(_QWORD *)(a3 + 48) )
{
v22 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v25, a3, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v26, (long long)"Unashable type: ", (long long)v25);
std::runtime_error::runtime_error(v22, v26);
__cxa_throw(
v22,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v13 = *v12;
v14 = v12[1];
if ( *v12 != v14 )
{
v27 = this;
while ( !(unsigned __int8)nlohmann::json_abi_v3_11_3::operator==(v13, (unsigned __int8 *)(a3 + 64), a4) )
{
v13 += 96;
v14 = v12[1];
if ( v13 == v14 )
goto LABEL_22;
}
v14 = v13;
LABEL_22:
v13 = *(unsigned __int8 **)(*((_QWORD *)a2 + 4) + 8LL);
v6 = v27;
}
if ( v14 == v13 )
{
v23 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v25, a3, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v26, (long long)"Key not found: ", (long long)v25);
std::runtime_error::runtime_error(v23, v26);
__cxa_throw(
v23,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::Value::Value(v6, (const minja::Value *)(v14 + 16));
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>>>::erase(
*((_QWORD *)a2 + 4),
v14,
v14 + 96);
}
return v6;
}
| pop:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV RBX,RDX
MOV R15,RSI
MOV RBP,RDI
MOV RAX,qword ptr [RSI + 0x10]
TEST RAX,RAX
JZ 0x00154151
MOV RSI,qword ptr [RAX + 0x8]
CMP qword ptr [RAX],RSI
JZ 0x0015425f
CMP qword ptr [RBX + 0x20],0x0
MOV AL,byte ptr [RBX + 0x40]
JNZ 0x001541b6
CMP qword ptr [RBX + 0x10],0x0
JNZ 0x001541b6
TEST AL,AL
JNZ 0x001541b6
CMP qword ptr [RBX + 0x30],0x0
JNZ 0x001541b6
ADD RSI,-0x50
MOV RDI,RBP
CALL 0x0014ed98
MOV RDI,qword ptr [R15 + 0x10]
MOV RSI,qword ptr [RDI + 0x8]
ADD RSI,-0x50
MOV qword ptr [RDI + 0x8],RSI
CALL 0x0014412e
JMP 0x0015424d
LAB_00154151:
MOV R14,qword ptr [R15 + 0x20]
TEST R14,R14
JZ 0x001542f1
CMP qword ptr [RBX + 0x10],0x0
JNZ 0x00154351
CMP qword ptr [RBX + 0x20],0x0
JNZ 0x00154351
CMP qword ptr [RBX + 0x30],0x0
JNZ 0x00154351
MOV R13,qword ptr [R14]
MOV R12,qword ptr [R14 + 0x8]
CMP R13,R12
JZ 0x00154226
MOV qword ptr [RSP + 0x40],RBP
LEA RBP,[RBX + 0x40]
LAB_00154198:
MOV RDI,R13
MOV RSI,RBP
CALL 0x0014e6da
TEST AL,AL
JNZ 0x00154216
ADD R13,0x60
MOV R12,qword ptr [R14 + 0x8]
CMP R13,R12
JNZ 0x00154198
JMP 0x00154219
LAB_001541b6:
ADD AL,0xfb
CMP AL,0x2
JNC 0x0015440e
MOV RDI,RBX
CALL 0x00151e3a
TEST EAX,EAX
JS 0x00154291
MOV RCX,qword ptr [R15 + 0x10]
MOV R12,qword ptr [RCX]
MOV RCX,qword ptr [RCX + 0x8]
SUB RCX,R12
SHR RCX,0x4
IMUL ECX,ECX,-0x33333333
CMP EAX,ECX
JGE 0x00154291
MOV EAX,EAX
LEA RAX,[RAX + RAX*0x4]
SHL RAX,0x4
ADD R12,RAX
MOV RDI,RBP
MOV RSI,R12
CALL 0x0014ed98
MOV RDI,qword ptr [R15 + 0x10]
LAB_0015420c:
MOV RSI,R12
CALL 0x001557de
LAB_00154214:
JMP 0x0015424d
LAB_00154216:
MOV R12,R13
LAB_00154219:
MOV RAX,qword ptr [R15 + 0x20]
MOV R13,qword ptr [RAX + 0x8]
MOV RBP,qword ptr [RSP + 0x40]
LAB_00154226:
CMP R12,R13
JZ 0x001543b1
LEA RSI,[R12 + 0x10]
MOV RDI,RBP
CALL 0x0014ed98
MOV RDI,qword ptr [R15 + 0x20]
LEA RDX,[R12 + 0x60]
LAB_00154245:
MOV RSI,R12
CALL 0x0015585a
LAB_0015424d:
MOV RAX,RBP
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0015425f:
MOV EDI,0x10
CALL 0x00118360
MOV R14,RAX
LAB_0015426c:
LEA RSI,[0x1bb2e4]
MOV RDI,RAX
CALL 0x00118270
LAB_0015427b:
MOV RSI,qword ptr [0x001efff0]
MOV RDX,qword ptr [0x001eff80]
MOV RDI,R14
CALL 0x00118b30
LAB_00154291:
MOV EDI,0x10
CALL 0x00118360
MOV R14,RAX
LAB_0015429e:
MOV RDI,RSP
MOV RSI,RBX
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x0013dcdc
LAB_001542b0:
LEA RSI,[0x1bb317]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x00130c3b
MOV BPL,0x1
LAB_001542c7:
LEA RSI,[RSP + 0x20]
MOV RDI,R14
CALL 0x00118a80
XOR EBP,EBP
MOV RSI,qword ptr [0x001efff0]
MOV RDX,qword ptr [0x001eff80]
MOV RDI,R14
CALL 0x00118b30
LAB_001542f1:
MOV EDI,0x10
CALL 0x00118360
MOV R14,RAX
LAB_001542fe:
MOV RDI,RSP
MOV RSI,R15
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x0013dcdc
LAB_00154310:
LEA RSI,[0x1bafdc]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x00130c3b
MOV BPL,0x1
LAB_00154327:
LEA RSI,[RSP + 0x20]
MOV RDI,R14
CALL 0x00118a80
XOR EBP,EBP
MOV RSI,qword ptr [0x001efff0]
MOV RDX,qword ptr [0x001eff80]
MOV RDI,R14
CALL 0x00118b30
LAB_00154351:
MOV EDI,0x10
CALL 0x00118360
MOV R14,RAX
LAB_0015435e:
MOV RDI,RSP
MOV RSI,RBX
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x0013dcdc
LAB_00154370:
LEA RSI,[0x1bae90]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x00130c3b
MOV BPL,0x1
LAB_00154387:
LEA RSI,[RSP + 0x20]
MOV RDI,R14
CALL 0x00118a80
XOR EBP,EBP
MOV RSI,qword ptr [0x001efff0]
MOV RDX,qword ptr [0x001eff80]
MOV RDI,R14
CALL 0x00118b30
LAB_001543b1:
MOV EDI,0x10
CALL 0x00118360
MOV R14,RAX
LAB_001543be:
MOV RDI,RSP
MOV RSI,RBX
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x0013dcdc
LAB_001543d0:
LEA RSI,[0x1bb330]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x00130c3b
MOV BPL,0x1
LAB_001543e7:
LEA RSI,[RSP + 0x20]
MOV RDI,R14
CALL 0x00118a80
XOR EBP,EBP
MOV RSI,qword ptr [0x001efff0]
MOV RDX,qword ptr [0x001eff80]
MOV RDI,R14
CALL 0x00118b30
LAB_0015440e:
MOV EDI,0x10
CALL 0x00118360
MOV R14,RAX
LAB_0015441b:
MOV RDI,RSP
MOV RSI,RBX
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x0013dcdc
LAB_0015442d:
LEA RSI,[0x1bb2f8]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x00130c3b
MOV BPL,0x1
LAB_00154444:
LEA RSI,[RSP + 0x20]
MOV RDI,R14
CALL 0x00118a80
XOR EBP,EBP
MOV RSI,qword ptr [0x001efff0]
MOV RDX,qword ptr [0x001eff80]
MOV RDI,R14
CALL 0x00118b30
|
/* minja::Value::pop(minja::Value const&) */
Value * minja::Value::pop(Value *param_1)
{
long *plVar1;
new_allocator<minja::Value> *this;
long lVar2;
char cVar3;
uint uVar4;
runtime_error *prVar5;
int iVar6;
Value *in_RDX;
bool bVar7;
long in_RSI;
int iVar8;
Value *pVVar9;
basic_json *pbVar10;
basic_json *pbVar11;
int1 auStack_78 [32];
string local_58 [32];
Value *local_38;
plVar1 = *(long **)(in_RSI + 0x10);
bVar7 = SUB81(in_RDX,0);
iVar8 = (int)auStack_78;
if (plVar1 == (long *)0x0) {
plVar1 = *(long **)(in_RSI + 0x20);
if (plVar1 == (long *)0x0) {
prVar5 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001542fe to 0015430f has its CatchHandler @ 001544df */
dump_abi_cxx11_(iVar8,SUB81(in_RSI,0));
/* try { // try from 00154310 to 00154323 has its CatchHandler @ 00154477 */
std::operator+((char *)local_58,(string *)"Value is not an array or object: ");
/* try { // try from 00154327 to 0015434b has its CatchHandler @ 00154475 */
std::runtime_error::runtime_error(prVar5,local_58);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar5,PTR_typeinfo_001efff0,PTR__runtime_error_001eff80);
}
if (((*(long *)(in_RDX + 0x10) != 0) || (*(long *)(in_RDX + 0x20) != 0)) ||
(*(long *)(in_RDX + 0x30) != 0)) {
prVar5 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0015435e to 0015436f has its CatchHandler @ 001544dd */
dump_abi_cxx11_(iVar8,bVar7);
/* try { // try from 00154370 to 00154383 has its CatchHandler @ 00154473 */
std::operator+((char *)local_58,(string *)"Unashable type: ");
/* try { // try from 00154387 to 001543ab has its CatchHandler @ 00154471 */
std::runtime_error::runtime_error(prVar5,local_58);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar5,PTR_typeinfo_001efff0,PTR__runtime_error_001eff80);
}
pbVar11 = (basic_json *)*plVar1;
pbVar10 = (basic_json *)plVar1[1];
if (pbVar11 != pbVar10) {
local_38 = param_1;
do {
pbVar10 = pbVar11;
cVar3 = nlohmann::json_abi_v3_11_3::operator==(pbVar10,(basic_json *)(in_RDX + 0x40));
if (cVar3 != '\0') break;
pbVar11 = pbVar10 + 0x60;
pbVar10 = (basic_json *)plVar1[1];
} while (pbVar11 != pbVar10);
pbVar11 = *(basic_json **)(*(long *)(in_RSI + 0x20) + 8);
param_1 = local_38;
}
if (pbVar10 == pbVar11) {
prVar5 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001543be to 001543cf has its CatchHandler @ 001544db */
dump_abi_cxx11_(iVar8,bVar7);
/* try { // try from 001543d0 to 001543e3 has its CatchHandler @ 0015446f */
std::operator+((char *)local_58,(string *)"Key not found: ");
/* try { // try from 001543e7 to 0015440b has its CatchHandler @ 0015446d */
std::runtime_error::runtime_error(prVar5,local_58);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar5,PTR_typeinfo_001efff0,PTR__runtime_error_001eff80);
}
Value(param_1,(Value *)(pbVar10 + 0x10));
/* try { // try from 00154245 to 0015424c has its CatchHandler @ 001544f2 */
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>>>
::erase(*(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>>>
**)(in_RSI + 0x20),pbVar10,pbVar10 + 0x60);
}
else {
if (*plVar1 == plVar1[1]) {
prVar5 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0015426c to 0015427a has its CatchHandler @ 001544e5 */
std::runtime_error::runtime_error(prVar5,"pop from empty list");
/* WARNING: Subroutine does not return */
__cxa_throw(prVar5,PTR_typeinfo_001efff0,PTR__runtime_error_001eff80);
}
if (((*(long *)(in_RDX + 0x20) == 0) && (*(long *)(in_RDX + 0x10) == 0)) &&
((in_RDX[0x40] == (Value)0x0 && (*(long *)(in_RDX + 0x30) == 0)))) {
Value(param_1,(Value *)(plVar1[1] + -0x50));
this = *(new_allocator<minja::Value> **)(in_RSI + 0x10);
lVar2 = *(long *)(this + 8);
*(Value **)(this + 8) = (Value *)(lVar2 + -0x50);
__gnu_cxx::new_allocator<minja::Value>::destroy<minja::Value>(this,(Value *)(lVar2 + -0x50));
}
else {
if (1 < (byte)((char)in_RDX[0x40] - 5U)) {
prVar5 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0015441b to 0015442c has its CatchHandler @ 001544d9 */
dump_abi_cxx11_(iVar8,bVar7);
/* try { // try from 0015442d to 00154440 has its CatchHandler @ 0015446b */
std::operator+((char *)local_58,(string *)"pop index must be an integer: ");
/* try { // try from 00154444 to 00154468 has its CatchHandler @ 00154469 */
std::runtime_error::runtime_error(prVar5,local_58);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar5,PTR_typeinfo_001efff0,PTR__runtime_error_001eff80);
}
uVar4 = get<int>(in_RDX);
if (((int)uVar4 < 0) ||
(lVar2 = **(long **)(in_RSI + 0x10),
iVar6 = (int)((ulong)((*(long **)(in_RSI + 0x10))[1] - lVar2) >> 4),
SBORROW4(uVar4,iVar6 * -0x33333333) == (int)(uVar4 + iVar6 * 0x33333333) < 0)) {
prVar5 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0015429e to 001542af has its CatchHandler @ 001544e3 */
dump_abi_cxx11_(iVar8,bVar7);
/* try { // try from 001542b0 to 001542c3 has its CatchHandler @ 001544b9 */
std::operator+((char *)local_58,(string *)"pop index out of range: ");
/* try { // try from 001542c7 to 001542eb has its CatchHandler @ 00154479 */
std::runtime_error::runtime_error(prVar5,local_58);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar5,PTR_typeinfo_001efff0,PTR__runtime_error_001eff80);
}
pVVar9 = (Value *)(lVar2 + (ulong)uVar4 * 0x50);
Value(param_1,pVVar9);
/* try { // try from 0015420c to 00154213 has its CatchHandler @ 001544e1 */
std::vector<minja::Value,std::allocator<minja::Value>>::_M_erase
(*(vector<minja::Value,std::allocator<minja::Value>> **)(in_RSI + 0x10),pVVar9);
}
}
return param_1;
}
| |
27,885 | std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::handle_value<nlohmann::json_abi_v3_11_3::detail::value_t>(nlohmann::json_abi_v3_11_3::detail::value_t&&, bool) | 11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp | std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (!keep_stack.back())
{
return {false, nullptr};
}
// create value
auto value = BasicJsonType(std::forward<Value>(v));
#if JSON_DIAGNOSTIC_POSITIONS
handle_diagnostic_positions_for_json_value(value);
#endif
// check callback
const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
// do not handle this value if we just learnt it shall be discarded
if (!keep)
{
return {false, nullptr};
}
if (ref_stack.empty())
{
root = std::move(value);
return {true, & root};
}
// skip this value if we already decided to skip the parent
// (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
if (!ref_stack.back())
{
return {false, nullptr};
}
// we now only expect arrays and objects
JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
// array
if (ref_stack.back()->is_array())
{
ref_stack.back()->m_data.m_value.array->emplace_back(std::move(value));
return {true, & (ref_stack.back()->m_data.m_value.array->back())};
}
// object
JSON_ASSERT(ref_stack.back()->is_object());
// check if we should store an element for the current key
JSON_ASSERT(!key_keep_stack.empty());
const bool store_element = key_keep_stack.back();
key_keep_stack.pop_back();
if (!store_element)
{
return {false, nullptr};
}
JSON_ASSERT(object_element);
*object_element = std::move(value);
return {true, object_element};
} | O0 | cpp | std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::handle_value<nlohmann::json_abi_v3_11_3::detail::value_t>(nlohmann::json_abi_v3_11_3::detail::value_t&&, bool):
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movb %dl, %al
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x108(%rbp)
addq $0x20, %rdi
callq 0x60380
xorb $-0x1, %al
testb $0x1, %al
jne 0x854d6
jmp 0x854d8
jmp 0x854f7
leaq 0xa5f2(%rip), %rdi # 0x8fad1
leaq 0x7a1d(%rip), %rsi # 0x8cf03
movl $0x2500, %edx # imm = 0x2500
leaq 0xb5c1(%rip), %rcx # 0x90ab3
callq 0x5d1f0
movq -0x108(%rbp), %rdi
addq $0x20, %rdi
callq 0x61710
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5b800
xorb $-0x1, %al
testb $0x1, %al
jne 0x85520
jmp 0x85542
movb $0x0, -0x39(%rbp)
movq $0x0, -0x48(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x39(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x61b90
jmp 0x85997
movq -0x20(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x5fcb0
movb $0x1, %al
testb $0x1, -0x21(%rbp)
movb %al, -0x109(%rbp)
jne 0x855a8
movq -0x108(%rbp), %rdi
movq %rdi, %rax
subq $-0x80, %rax
movq %rax, -0x118(%rbp)
addq $0x8, %rdi
callq 0x5f6f0
movq -0x118(%rbp), %rdi
movl %eax, %esi
movl $0x5, %edx
leaq -0x58(%rbp), %rcx
callq 0x5d470
movb %al, -0x10a(%rbp)
jmp 0x8559a
movb -0x10a(%rbp), %al
movb %al, -0x109(%rbp)
jmp 0x855a8
movb -0x109(%rbp), %al
andb $0x1, %al
movb %al, -0x59(%rbp)
testb $0x1, -0x59(%rbp)
jne 0x855fe
movb $0x0, -0x6d(%rbp)
movq $0x0, -0x78(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x6d(%rbp), %rsi
leaq -0x78(%rbp), %rdx
callq 0x61b90
jmp 0x855d8
movl $0x1, -0x7c(%rbp)
jmp 0x8598e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x5fdc0
jmp 0x859a7
movq -0x108(%rbp), %rdi
addq $0x8, %rdi
callq 0x60af0
testb $0x1, %al
jne 0x85614
jmp 0x8568a
leaq -0x90(%rbp), %rdi
movq %rdi, -0x120(%rbp)
leaq -0x58(%rbp), %rsi
callq 0x5ce40
movq -0x120(%rbp), %rsi
movq -0x108(%rbp), %rax
movq (%rax), %rdi
callq 0x5c770
movq -0x120(%rbp), %rdi
callq 0x5fdc0
movq -0x108(%rbp), %rax
movb $0x1, -0x91(%rbp)
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x91(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0x5e090
jmp 0x8567e
movl $0x1, -0x7c(%rbp)
jmp 0x8598e
movq -0x108(%rbp), %rdi
addq $0x8, %rdi
callq 0x60240
cmpq $0x0, (%rax)
jne 0x856d7
movb $0x0, -0xa1(%rbp)
movq $0x0, -0xb0(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0xa1(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
callq 0x61b90
jmp 0x856cb
movl $0x1, -0x7c(%rbp)
jmp 0x8598e
movq -0x108(%rbp), %rdi
addq $0x8, %rdi
callq 0x60240
movq (%rax), %rdi
callq 0x5dd70
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x121(%rbp)
jne 0x8571c
movq -0x108(%rbp), %rdi
addq $0x8, %rdi
callq 0x60240
movq (%rax), %rdi
callq 0x5d880
movb %al, -0x121(%rbp)
movb -0x121(%rbp), %al
testb $0x1, %al
jne 0x85728
jmp 0x8572a
jmp 0x85749
leaq 0xa57d(%rip), %rdi # 0x8fcae
leaq 0x77cb(%rip), %rsi # 0x8cf03
movl $0x2527, %edx # imm = 0x2527
leaq 0xb36f(%rip), %rcx # 0x90ab3
callq 0x5d1f0
movq -0x108(%rbp), %rdi
addq $0x8, %rdi
callq 0x60240
movq (%rax), %rdi
callq 0x5dd70
testb $0x1, %al
jne 0x85767
jmp 0x857d8
movq -0x108(%rbp), %rdi
addq $0x8, %rdi
callq 0x60240
movq (%rax), %rax
movq 0x8(%rax), %rdi
leaq -0x58(%rbp), %rsi
callq 0x5e050
jmp 0x85789
movq -0x108(%rbp), %rdi
movb $0x1, -0xb1(%rbp)
addq $0x8, %rdi
callq 0x60240
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x5bd30
movq %rax, -0xc0(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0xb1(%rbp), %rsi
leaq -0xc0(%rbp), %rdx
callq 0x5e090
jmp 0x857cc
movl $0x1, -0x7c(%rbp)
jmp 0x8598e
movq -0x108(%rbp), %rdi
addq $0x8, %rdi
callq 0x60240
movq (%rax), %rdi
callq 0x5d880
testb $0x1, %al
jne 0x857f6
jmp 0x857f8
jmp 0x85817
leaq 0xa4cf(%rip), %rdi # 0x8fcce
leaq 0x76fd(%rip), %rsi # 0x8cf03
movl $0x2531, %edx # imm = 0x2531
leaq 0xb2a1(%rip), %rcx # 0x90ab3
callq 0x5d1f0
movq -0x108(%rbp), %rdi
addq $0x48, %rdi
callq 0x60380
xorb $-0x1, %al
testb $0x1, %al
jne 0x8582f
jmp 0x85831
jmp 0x85850
leaq 0xa4b4(%rip), %rdi # 0x8fcec
leaq 0x76c4(%rip), %rsi # 0x8cf03
movl $0x2533, %edx # imm = 0x2533
leaq 0xb268(%rip), %rcx # 0x90ab3
callq 0x5d1f0
movq -0x108(%rbp), %rdi
addq $0x48, %rdi
callq 0x61710
movq %rdx, -0x138(%rbp)
movq %rax, -0x130(%rbp)
jmp 0x85870
movq -0x138(%rbp), %rax
movq -0x130(%rbp), %rcx
movq %rcx, -0xd8(%rbp)
movq %rax, -0xd0(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x5b800
movq -0x108(%rbp), %rdi
movb %al, -0xc1(%rbp)
addq $0x48, %rdi
callq 0x60710
jmp 0x858b0
testb $0x1, -0xc1(%rbp)
jne 0x858f0
movb $0x0, -0xd9(%rbp)
movq $0x0, -0xe8(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0xd9(%rbp), %rsi
leaq -0xe8(%rbp), %rdx
callq 0x61b90
jmp 0x858e4
movl $0x1, -0x7c(%rbp)
jmp 0x8598e
movq -0x108(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0x85900
jmp 0x8591f
leaq 0xa3fd(%rip), %rdi # 0x8fd04
leaq 0x75f5(%rip), %rsi # 0x8cf03
movl $0x253c, %edx # imm = 0x253C
leaq 0xb199(%rip), %rcx # 0x90ab3
callq 0x5d1f0
leaq -0xf8(%rbp), %rdi
movq %rdi, -0x148(%rbp)
leaq -0x58(%rbp), %rsi
callq 0x5ce40
movq -0x108(%rbp), %rax
movq -0x148(%rbp), %rsi
movq %rax, %rcx
addq $0x70, %rcx
movq %rcx, -0x140(%rbp)
movq 0x70(%rax), %rdi
callq 0x5c770
movq -0x148(%rbp), %rdi
callq 0x5fdc0
movq -0x140(%rbp), %rdx
movb $0x1, -0xf9(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0xf9(%rbp), %rsi
callq 0x5c700
jmp 0x85987
movl $0x1, -0x7c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x5fdc0
movb -0x10(%rbp), %al
movq -0x8(%rbp), %rdx
addq $0x150, %rsp # imm = 0x150
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x611b0
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE12handle_valueIRbEESt4pairIbPSF_EOT_b:
push rbp
mov rbp, rsp
sub rsp, 150h
mov al, dl
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
and al, 1
mov [rbp+var_21], al
mov rdi, [rbp+var_18]
mov [rbp+var_108], rdi
add rdi, 20h ; ' '
call __ZNKSt6vectorIbSaIbEE5emptyEv; std::vector<bool>::empty(void)
xor al, 0FFh
test al, 1
jnz short loc_854D6
jmp short loc_854D8
loc_854D6:
jmp short loc_854F7
loc_854D8:
lea rdi, aKeepStackEmpty; "!keep_stack.empty()"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 2500h
lea rcx, aStdPairBoolBas_1; "std::pair<bool, BasicJsonType *> nlohma"...
call ___assert_fail
loc_854F7:
mov rdi, [rbp+var_108]
add rdi, 20h ; ' '
call __ZNSt6vectorIbSaIbEE4backEv; std::vector<bool>::back(void)
mov [rbp+var_38], rax
mov [rbp+var_30], rdx
lea rdi, [rbp+var_38]
call __ZNKSt14_Bit_referencecvbEv; std::_Bit_reference::operator bool(void)
xor al, 0FFh
test al, 1
jnz short loc_85520
jmp short loc_85542
loc_85520:
mov [rbp+var_39], 0
mov [rbp+var_48], 0
lea rdi, [rbp+var_10]
lea rsi, [rbp+var_39]
lea rdx, [rbp+var_48]
call __ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
jmp loc_85997
loc_85542:
mov rsi, [rbp+var_20]
lea rdi, [rbp+var_58]
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRbbTnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_
mov al, 1
test [rbp+var_21], 1
mov [rbp+var_109], al
jnz short loc_855A8
mov rdi, [rbp+var_108]
mov rax, rdi
sub rax, 0FFFFFFFFFFFFFF80h
mov [rbp+var_118], rax
add rdi, 8
call __ZNKSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4sizeEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::size(void)
mov rdi, [rbp+var_118]
mov esi, eax
mov edx, 5
lea rcx, [rbp+var_58]
call __ZNKSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEEclEiS3_SH_; std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)>::operator()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)
mov [rbp+var_10A], al
jmp short $+2
loc_8559A:
mov al, [rbp+var_10A]
mov [rbp+var_109], al
jmp short $+2
loc_855A8:
mov al, [rbp+var_109]
and al, 1
mov [rbp+var_59], al
test [rbp+var_59], 1
jnz short loc_855FE
mov [rbp+var_6D], 0
mov [rbp+var_78], 0
lea rdi, [rbp+var_10]
lea rsi, [rbp+var_6D]
lea rdx, [rbp+var_78]
call __ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
jmp short $+2
loc_855D8:
mov [rbp+var_7C], 1
jmp loc_8598E
mov rcx, rax
mov eax, edx
mov [rbp+var_68], rcx
mov [rbp+var_6C], eax
lea rdi, [rbp+var_58]
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
jmp loc_859A7
loc_855FE:
mov rdi, [rbp+var_108]
add rdi, 8
call __ZNKSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE5emptyEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::empty(void)
test al, 1
jnz short loc_85614
jmp short loc_8568A
loc_85614:
lea rdi, [rbp+var_90]
mov [rbp+var_120], rdi
lea rsi, [rbp+var_58]
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EOSD_; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&&)
mov rsi, [rbp+var_120]
mov rax, [rbp+var_108]
mov rdi, [rax]
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, [rbp+var_120]
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
mov rax, [rbp+var_108]
mov [rbp+var_91], 1
mov rax, [rax]
mov [rbp+var_A0], rax
lea rdi, [rbp+var_10]
lea rsi, [rbp+var_91]
lea rdx, [rbp+var_A0]
call __ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbSF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
jmp short $+2
loc_8567E:
mov [rbp+var_7C], 1
jmp loc_8598E
loc_8568A:
mov rdi, [rbp+var_108]
add rdi, 8
call __ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::back(void)
cmp qword ptr [rax], 0
jnz short loc_856D7
mov [rbp+var_A1], 0
mov [rbp+var_B0], 0
lea rdi, [rbp+var_10]
lea rsi, [rbp+var_A1]
lea rdx, [rbp+var_B0]
call __ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
jmp short $+2
loc_856CB:
mov [rbp+var_7C], 1
jmp loc_8598E
loc_856D7:
mov rdi, [rbp+var_108]
add rdi, 8
call __ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::back(void)
mov rdi, [rax]
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8is_arrayEv; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::is_array(void)
mov cl, al
mov al, 1
test cl, 1
mov [rbp+var_121], al
jnz short loc_8571C
mov rdi, [rbp+var_108]
add rdi, 8
call __ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::back(void)
mov rdi, [rax]
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9is_objectEv; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::is_object(void)
mov [rbp+var_121], al
loc_8571C:
mov al, [rbp+var_121]
test al, 1
jnz short loc_85728
jmp short loc_8572A
loc_85728:
jmp short loc_85749
loc_8572A:
lea rdi, aRefStackBackIs; "ref_stack.back()->is_array() || ref_sta"...
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 2527h
lea rcx, aStdPairBoolBas_1; "std::pair<bool, BasicJsonType *> nlohma"...
call ___assert_fail
loc_85749:
mov rdi, [rbp+var_108]
add rdi, 8
call __ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::back(void)
mov rdi, [rax]
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8is_arrayEv; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::is_array(void)
test al, 1
jnz short loc_85767
jmp short loc_857D8
loc_85767:
mov rdi, [rbp+var_108]
add rdi, 8
call __ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::back(void)
mov rax, [rax]
mov rdi, [rax+8]
lea rsi, [rbp+var_58]
call __ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
jmp short $+2
loc_85789:
mov rdi, [rbp+var_108]
mov [rbp+var_B1], 1
add rdi, 8
call __ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::back(void)
mov rax, [rax]
mov rdi, [rax+8]
call __ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::back(void)
mov [rbp+var_C0], rax
lea rdi, [rbp+var_10]
lea rsi, [rbp+var_B1]
lea rdx, [rbp+var_C0]
call __ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbSF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
jmp short $+2
loc_857CC:
mov [rbp+var_7C], 1
jmp loc_8598E
loc_857D8:
mov rdi, [rbp+var_108]
add rdi, 8
call __ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::back(void)
mov rdi, [rax]
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9is_objectEv; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::is_object(void)
test al, 1
jnz short loc_857F6
jmp short loc_857F8
loc_857F6:
jmp short loc_85817
loc_857F8:
lea rdi, aRefStackBackIs+20h; "ref_stack.back()->is_object()"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 2531h
lea rcx, aStdPairBoolBas_1; "std::pair<bool, BasicJsonType *> nlohma"...
call ___assert_fail
loc_85817:
mov rdi, [rbp+var_108]
add rdi, 48h ; 'H'
call __ZNKSt6vectorIbSaIbEE5emptyEv; std::vector<bool>::empty(void)
xor al, 0FFh
test al, 1
jnz short loc_8582F
jmp short loc_85831
loc_8582F:
jmp short loc_85850
loc_85831:
lea rdi, aKeyKeepStackEm; "!key_keep_stack.empty()"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 2533h
lea rcx, aStdPairBoolBas_1; "std::pair<bool, BasicJsonType *> nlohma"...
call ___assert_fail
loc_85850:
mov rdi, [rbp+var_108]
add rdi, 48h ; 'H'
call __ZNSt6vectorIbSaIbEE4backEv; std::vector<bool>::back(void)
mov [rbp+var_138], rdx
mov [rbp+var_130], rax
jmp short $+2
loc_85870:
mov rax, [rbp+var_138]
mov rcx, [rbp+var_130]
mov [rbp+var_D8], rcx
mov [rbp+var_D0], rax
lea rdi, [rbp+var_D8]
call __ZNKSt14_Bit_referencecvbEv; std::_Bit_reference::operator bool(void)
mov rdi, [rbp+var_108]
mov [rbp+var_C1], al
add rdi, 48h ; 'H'
call __ZNSt6vectorIbSaIbEE8pop_backEv; std::vector<bool>::pop_back(void)
jmp short $+2
loc_858B0:
test [rbp+var_C1], 1
jnz short loc_858F0
mov [rbp+var_D9], 0
mov [rbp+var_E8], 0
lea rdi, [rbp+var_10]
lea rsi, [rbp+var_D9]
lea rdx, [rbp+var_E8]
call __ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
jmp short $+2
loc_858E4:
mov [rbp+var_7C], 1
jmp loc_8598E
loc_858F0:
mov rax, [rbp+var_108]
cmp qword ptr [rax+70h], 0
jz short loc_85900
jmp short loc_8591F
loc_85900:
lea rdi, aObjectElement; "object_element"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 253Ch
lea rcx, aStdPairBoolBas_1; "std::pair<bool, BasicJsonType *> nlohma"...
call ___assert_fail
loc_8591F:
lea rdi, [rbp+var_F8]
mov [rbp+var_148], rdi
lea rsi, [rbp+var_58]
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EOSD_; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&&)
mov rax, [rbp+var_108]
mov rsi, [rbp+var_148]
mov rcx, rax
add rcx, 70h ; 'p'
mov [rbp+var_140], rcx
mov rdi, [rax+70h]
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, [rbp+var_148]
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
mov rdx, [rbp+var_140]
mov [rbp+var_F9], 1
lea rdi, [rbp+var_10]
lea rsi, [rbp+var_F9]
call __ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbRSF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISK_SL_EEEbE4typeELb1EEEOSK_OSL_
jmp short $+2
loc_85987:
mov [rbp+var_7C], 1
loc_8598E:
lea rdi, [rbp+var_58]
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
loc_85997:
mov al, [rbp+var_10]
mov rdx, [rbp+var_8]
add rsp, 150h
pop rbp
retn
loc_859A7:
mov rdi, [rbp+var_68]
call __Unwind_Resume
| char nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::handle_value<bool &>(
_QWORD *a1,
long long a2,
char a3)
{
long long v3; // rdx
char v4; // al
unsigned int v5; // eax
_QWORD *v6; // rax
_QWORD *v7; // rax
_QWORD *v8; // rax
char is_array; // al
long long v10; // rax
long long v11; // rax
_QWORD *v12; // rax
char v13; // al
long long v14; // rdx
char is_object; // [rsp+2Fh] [rbp-121h]
char v17; // [rsp+47h] [rbp-109h]
char v18; // [rsp+57h] [rbp-F9h] BYREF
_BYTE v19[16]; // [rsp+58h] [rbp-F8h] BYREF
long long v20; // [rsp+68h] [rbp-E8h] BYREF
char v21; // [rsp+77h] [rbp-D9h] BYREF
_QWORD v22[2]; // [rsp+78h] [rbp-D8h] BYREF
char v23; // [rsp+8Fh] [rbp-C1h]
long long v24; // [rsp+90h] [rbp-C0h] BYREF
char v25; // [rsp+9Fh] [rbp-B1h] BYREF
long long v26; // [rsp+A0h] [rbp-B0h] BYREF
char v27; // [rsp+AFh] [rbp-A1h] BYREF
long long v28; // [rsp+B0h] [rbp-A0h] BYREF
char v29; // [rsp+BFh] [rbp-91h] BYREF
_BYTE v30[20]; // [rsp+C0h] [rbp-90h] BYREF
int v31; // [rsp+D4h] [rbp-7Ch]
long long v32; // [rsp+D8h] [rbp-78h] BYREF
_BYTE v33[21]; // [rsp+E3h] [rbp-6Dh] BYREF
_BYTE v34[16]; // [rsp+F8h] [rbp-58h] BYREF
long long v35; // [rsp+108h] [rbp-48h] BYREF
char v36; // [rsp+117h] [rbp-39h] BYREF
_QWORD v37[2]; // [rsp+118h] [rbp-38h] BYREF
char v38; // [rsp+12Fh] [rbp-21h]
long long v39; // [rsp+130h] [rbp-20h]
_QWORD *v40; // [rsp+138h] [rbp-18h]
_BYTE v41[8]; // [rsp+140h] [rbp-10h] BYREF
v40 = a1;
v39 = a2;
v38 = a3 & 1;
if ( (std::vector<bool>::empty(a1 + 4) & 1) != 0 )
__assert_fail(
"!keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp",
9472LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nlohmann::"
"detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::handle_value"
"(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohmann::detail::iterator_inpu"
"t_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>, Value = bool &]");
v37[0] = std::vector<bool>::back(a1 + 4);
v37[1] = v3;
v4 = std::_Bit_reference::operator bool(v37);
if ( (v4 & 1) != 0 )
{
_ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRbbTnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_(
v34,
v39);
v17 = 1;
if ( (v38 & 1) == 0 )
{
v5 = std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::size(a1 + 1);
v17 = std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &)>::operator()(
a1 + 16,
v5,
5LL,
v34);
}
v33[20] = v17 & 1;
if ( (v17 & 1) != 0 )
{
if ( (std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::empty(a1 + 1) & 1) != 0 )
{
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
v30,
v34);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*a1,
v30);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json(v30);
v29 = 1;
v28 = *a1;
_ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbSF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_(
v41,
&v29,
&v28);
v31 = 1;
}
else if ( *(_QWORD *)std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::back(a1 + 1) )
{
v6 = (_QWORD *)std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::back(a1 + 1);
is_object = 1;
if ( (nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::is_array(*v6) & 1) == 0 )
{
v7 = (_QWORD *)std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::back(a1 + 1);
is_object = nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::is_object(*v7);
}
if ( (is_object & 1) == 0 )
__assert_fail(
"ref_stack.back()->is_array() || ref_stack.back()->is_object()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp",
9511LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nloh"
"mann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::"
"handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohmann::det"
"ail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>, Value = bool &]");
v8 = (_QWORD *)std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::back(a1 + 1);
is_array = nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::is_array(*v8);
if ( (is_array & 1) != 0 )
{
v10 = std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::back(a1 + 1);
std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
*(_QWORD *)(*(_QWORD *)v10 + 8LL),
v34);
v25 = 1;
v11 = std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::back(a1 + 1);
v24 = std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::back(*(_QWORD *)(*(_QWORD *)v11 + 8LL));
_ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbSF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_(
v41,
&v25,
&v24);
v31 = 1;
}
else
{
v12 = (_QWORD *)std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::back(a1 + 1);
if ( (nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::is_object(*v12) & 1) == 0 )
__assert_fail(
"ref_stack.back()->is_object()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp",
9521LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nl"
"ohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>"
">>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohman"
"n::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>, Value = bool &]");
v13 = std::vector<bool>::empty(a1 + 9);
if ( (v13 & 1) != 0 )
__assert_fail(
"!key_keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp",
9523LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nl"
"ohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>"
">>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohman"
"n::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>, Value = bool &]");
v22[0] = std::vector<bool>::back(a1 + 9);
v22[1] = v14;
v23 = std::_Bit_reference::operator bool(v22);
std::vector<bool>::pop_back(a1 + 9);
if ( (v23 & 1) != 0 )
{
if ( !a1[14] )
__assert_fail(
"object_element",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp",
9532LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, "
"nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<ch"
"ar>>>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = n"
"lohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<cha"
"r>>>, Value = bool &]");
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
v19,
v34);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
a1[14],
v19);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json(v19);
v18 = 1;
_ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbRSF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISK_SL_EEEbE4typeELb1EEEOSK_OSL_(
v41,
&v18,
a1 + 14);
v31 = 1;
}
else
{
v21 = 0;
v20 = 0LL;
_ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_(
v41,
&v21,
&v20);
v31 = 1;
}
}
}
else
{
v27 = 0;
v26 = 0LL;
_ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_(
v41,
&v27,
&v26);
v31 = 1;
}
}
else
{
v33[0] = 0;
v32 = 0LL;
_ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_(
v41,
v33,
&v32);
v31 = 1;
}
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json(v34);
}
else
{
v36 = 0;
v35 = 0LL;
_ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_(
v41,
&v36,
&v35);
}
return v41[0];
}
| handle_value<bool&>:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x150
MOV AL,DL
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
AND AL,0x1
MOV byte ptr [RBP + -0x21],AL
MOV RDI,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x108],RDI
ADD RDI,0x20
CALL 0x00160380
XOR AL,0xff
TEST AL,0x1
JNZ 0x001854d6
JMP 0x001854d8
LAB_001854d6:
JMP 0x001854f7
LAB_001854d8:
LEA RDI,[0x18fad1]
LEA RSI,[0x18cf03]
MOV EDX,0x2500
LEA RCX,[0x190ab3]
CALL 0x0015d1f0
LAB_001854f7:
MOV RDI,qword ptr [RBP + -0x108]
ADD RDI,0x20
CALL 0x00161710
MOV qword ptr [RBP + -0x38],RAX
MOV qword ptr [RBP + -0x30],RDX
LEA RDI,[RBP + -0x38]
CALL 0x0015b800
XOR AL,0xff
TEST AL,0x1
JNZ 0x00185520
JMP 0x00185542
LAB_00185520:
MOV byte ptr [RBP + -0x39],0x0
MOV qword ptr [RBP + -0x48],0x0
LEA RDI,[RBP + -0x10]
LEA RSI,[RBP + -0x39]
LEA RDX,[RBP + -0x48]
CALL 0x00161b90
JMP 0x00185997
LAB_00185542:
MOV RSI,qword ptr [RBP + -0x20]
LEA RDI,[RBP + -0x58]
CALL 0x0015fcb0
MOV AL,0x1
TEST byte ptr [RBP + -0x21],0x1
MOV byte ptr [RBP + -0x109],AL
JNZ 0x001855a8
MOV RDI,qword ptr [RBP + -0x108]
MOV RAX,RDI
SUB RAX,-0x80
MOV qword ptr [RBP + -0x118],RAX
ADD RDI,0x8
CALL 0x0015f6f0
MOV RDI,qword ptr [RBP + -0x118]
MOV ESI,EAX
LAB_00185584:
MOV EDX,0x5
LEA RCX,[RBP + -0x58]
CALL 0x0015d470
MOV byte ptr [RBP + -0x10a],AL
JMP 0x0018559a
LAB_0018559a:
MOV AL,byte ptr [RBP + -0x10a]
MOV byte ptr [RBP + -0x109],AL
JMP 0x001855a8
LAB_001855a8:
MOV AL,byte ptr [RBP + -0x109]
AND AL,0x1
MOV byte ptr [RBP + -0x59],AL
TEST byte ptr [RBP + -0x59],0x1
JNZ 0x001855fe
MOV byte ptr [RBP + -0x6d],0x0
MOV qword ptr [RBP + -0x78],0x0
LEA RDI,[RBP + -0x10]
LEA RSI,[RBP + -0x6d]
LEA RDX,[RBP + -0x78]
CALL 0x00161b90
JMP 0x001855d8
LAB_001855d8:
MOV dword ptr [RBP + -0x7c],0x1
JMP 0x0018598e
LAB_001855fe:
MOV RDI,qword ptr [RBP + -0x108]
ADD RDI,0x8
CALL 0x00160af0
TEST AL,0x1
JNZ 0x00185614
JMP 0x0018568a
LAB_00185614:
LEA RDI,[RBP + -0x90]
MOV qword ptr [RBP + -0x120],RDI
LEA RSI,[RBP + -0x58]
CALL 0x0015ce40
MOV RSI,qword ptr [RBP + -0x120]
MOV RAX,qword ptr [RBP + -0x108]
MOV RDI,qword ptr [RAX]
CALL 0x0015c770
MOV RDI,qword ptr [RBP + -0x120]
CALL 0x0015fdc0
MOV RAX,qword ptr [RBP + -0x108]
MOV byte ptr [RBP + -0x91],0x1
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0xa0],RAX
LEA RDI,[RBP + -0x10]
LEA RSI,[RBP + -0x91]
LEA RDX,[RBP + -0xa0]
CALL 0x0015e090
JMP 0x0018567e
LAB_0018567e:
MOV dword ptr [RBP + -0x7c],0x1
JMP 0x0018598e
LAB_0018568a:
MOV RDI,qword ptr [RBP + -0x108]
ADD RDI,0x8
CALL 0x00160240
CMP qword ptr [RAX],0x0
JNZ 0x001856d7
MOV byte ptr [RBP + -0xa1],0x0
MOV qword ptr [RBP + -0xb0],0x0
LEA RDI,[RBP + -0x10]
LEA RSI,[RBP + -0xa1]
LEA RDX,[RBP + -0xb0]
CALL 0x00161b90
JMP 0x001856cb
LAB_001856cb:
MOV dword ptr [RBP + -0x7c],0x1
JMP 0x0018598e
LAB_001856d7:
MOV RDI,qword ptr [RBP + -0x108]
ADD RDI,0x8
CALL 0x00160240
MOV RDI,qword ptr [RAX]
CALL 0x0015dd70
MOV CL,AL
MOV AL,0x1
TEST CL,0x1
MOV byte ptr [RBP + -0x121],AL
JNZ 0x0018571c
MOV RDI,qword ptr [RBP + -0x108]
ADD RDI,0x8
CALL 0x00160240
MOV RDI,qword ptr [RAX]
CALL 0x0015d880
MOV byte ptr [RBP + -0x121],AL
LAB_0018571c:
MOV AL,byte ptr [RBP + -0x121]
TEST AL,0x1
JNZ 0x00185728
JMP 0x0018572a
LAB_00185728:
JMP 0x00185749
LAB_0018572a:
LEA RDI,[0x18fcae]
LEA RSI,[0x18cf03]
MOV EDX,0x2527
LEA RCX,[0x190ab3]
CALL 0x0015d1f0
LAB_00185749:
MOV RDI,qword ptr [RBP + -0x108]
ADD RDI,0x8
CALL 0x00160240
MOV RDI,qword ptr [RAX]
CALL 0x0015dd70
TEST AL,0x1
JNZ 0x00185767
JMP 0x001857d8
LAB_00185767:
MOV RDI,qword ptr [RBP + -0x108]
ADD RDI,0x8
CALL 0x00160240
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + 0x8]
LEA RSI,[RBP + -0x58]
CALL 0x0015e050
JMP 0x00185789
LAB_00185789:
MOV RDI,qword ptr [RBP + -0x108]
MOV byte ptr [RBP + -0xb1],0x1
ADD RDI,0x8
CALL 0x00160240
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x0015bd30
MOV qword ptr [RBP + -0xc0],RAX
LEA RDI,[RBP + -0x10]
LEA RSI,[RBP + -0xb1]
LEA RDX,[RBP + -0xc0]
CALL 0x0015e090
JMP 0x001857cc
LAB_001857cc:
MOV dword ptr [RBP + -0x7c],0x1
JMP 0x0018598e
LAB_001857d8:
MOV RDI,qword ptr [RBP + -0x108]
ADD RDI,0x8
CALL 0x00160240
MOV RDI,qword ptr [RAX]
CALL 0x0015d880
TEST AL,0x1
JNZ 0x001857f6
JMP 0x001857f8
LAB_001857f6:
JMP 0x00185817
LAB_001857f8:
LEA RDI,[0x18fcce]
LEA RSI,[0x18cf03]
MOV EDX,0x2531
LEA RCX,[0x190ab3]
CALL 0x0015d1f0
LAB_00185817:
MOV RDI,qword ptr [RBP + -0x108]
ADD RDI,0x48
CALL 0x00160380
XOR AL,0xff
TEST AL,0x1
JNZ 0x0018582f
JMP 0x00185831
LAB_0018582f:
JMP 0x00185850
LAB_00185831:
LEA RDI,[0x18fcec]
LEA RSI,[0x18cf03]
MOV EDX,0x2533
LEA RCX,[0x190ab3]
CALL 0x0015d1f0
LAB_00185850:
MOV RDI,qword ptr [RBP + -0x108]
ADD RDI,0x48
CALL 0x00161710
MOV qword ptr [RBP + -0x138],RDX
MOV qword ptr [RBP + -0x130],RAX
JMP 0x00185870
LAB_00185870:
MOV RAX,qword ptr [RBP + -0x138]
MOV RCX,qword ptr [RBP + -0x130]
MOV qword ptr [RBP + -0xd8],RCX
MOV qword ptr [RBP + -0xd0],RAX
LEA RDI,[RBP + -0xd8]
CALL 0x0015b800
MOV RDI,qword ptr [RBP + -0x108]
MOV byte ptr [RBP + -0xc1],AL
ADD RDI,0x48
CALL 0x00160710
JMP 0x001858b0
LAB_001858b0:
TEST byte ptr [RBP + -0xc1],0x1
JNZ 0x001858f0
MOV byte ptr [RBP + -0xd9],0x0
MOV qword ptr [RBP + -0xe8],0x0
LEA RDI,[RBP + -0x10]
LEA RSI,[RBP + -0xd9]
LEA RDX,[RBP + -0xe8]
CALL 0x00161b90
JMP 0x001858e4
LAB_001858e4:
MOV dword ptr [RBP + -0x7c],0x1
JMP 0x0018598e
LAB_001858f0:
MOV RAX,qword ptr [RBP + -0x108]
CMP qword ptr [RAX + 0x70],0x0
JZ 0x00185900
JMP 0x0018591f
LAB_00185900:
LEA RDI,[0x18fd04]
LEA RSI,[0x18cf03]
MOV EDX,0x253c
LEA RCX,[0x190ab3]
CALL 0x0015d1f0
LAB_0018591f:
LEA RDI,[RBP + -0xf8]
MOV qword ptr [RBP + -0x148],RDI
LEA RSI,[RBP + -0x58]
CALL 0x0015ce40
MOV RAX,qword ptr [RBP + -0x108]
MOV RSI,qword ptr [RBP + -0x148]
MOV RCX,RAX
ADD RCX,0x70
MOV qword ptr [RBP + -0x140],RCX
MOV RDI,qword ptr [RAX + 0x70]
CALL 0x0015c770
MOV RDI,qword ptr [RBP + -0x148]
CALL 0x0015fdc0
MOV RDX,qword ptr [RBP + -0x140]
MOV byte ptr [RBP + -0xf9],0x1
LEA RDI,[RBP + -0x10]
LEA RSI,[RBP + -0xf9]
CALL 0x0015c700
LAB_00185985:
JMP 0x00185987
LAB_00185987:
MOV dword ptr [RBP + -0x7c],0x1
LAB_0018598e:
LEA RDI,[RBP + -0x58]
CALL 0x0015fdc0
LAB_00185997:
MOV AL,byte ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
ADD RSP,0x150
POP RBP
RET
|
/* std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>*>
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > > >::handle_value<bool&>(bool&, bool) */
int1 [16] __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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>>>
::handle_value<bool&>
(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*this,bool *param_1,bool param_2)
{
byte bVar1;
bool bVar2;
int4 uVar3;
ulong uVar4;
long *plVar5;
int8 *puVar6;
int8 uVar7;
int1 auVar8 [16];
byte local_129;
byte local_111;
int1 local_101;
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_100 [16];
int8 local_f0;
int1 local_e1;
int1 local_e0 [16];
byte local_c9;
int8 local_c8;
int1 local_b9;
int8 local_b8;
int1 local_a9;
int8 local_a8;
int1 local_99;
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_98 [20];
int4 local_84;
int8 local_80;
int1 local_75 [20];
byte local_61;
basic_json local_60 [16];
int8 local_50;
int1 local_41;
_Bit_reference local_40 [23];
byte local_29;
bool *local_28;
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*local_20;
int1 local_18 [8];
int8 local_10;
local_29 = param_2;
local_28 = param_1;
local_20 = this;
bVar1 = std::vector<bool,std::allocator<bool>>::empty
((vector<bool,std::allocator<bool>> *)(this + 0x20));
if (((bVar1 ^ 0xff) & 1) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("!keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp"
,0x2500,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>, Value = bool &]"
);
}
local_40._0_16_ =
std::vector<bool,std::allocator<bool>>::back
((vector<bool,std::allocator<bool>> *)(this + 0x20));
bVar2 = std::_Bit_reference::operator_cast_to_bool(local_40);
if (((bVar2 ^ 0xffU) & 1) == 0) {
_ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRbbTnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_
(local_60,local_28);
local_111 = 1;
if ((local_29 & 1) == 0) {
uVar3 = std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::size((vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
/* try { // try from 00185584 to 00185984 has its CatchHandler @ 001855e4 */
local_111 = std::
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
::operator()((function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
*)(this + 0x80),uVar3,5,local_60);
}
local_61 = local_111 & 1;
if (local_61 == 0) {
local_75[0] = 0;
local_80 = 0;
_ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
(local_18,local_75,&local_80);
}
else {
uVar4 = std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::empty((vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
if ((uVar4 & 1) == 0) {
plVar5 = (long *)std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
if (*plVar5 == 0) {
local_a9 = 0;
local_b8 = 0;
_ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
(local_18,&local_a9,&local_b8);
}
else {
puVar6 = (int8 *)
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
bVar1 = basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::is_array((basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)*puVar6);
local_129 = 1;
if ((bVar1 & 1) == 0) {
puVar6 = (int8 *)
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
local_129 = basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::is_object((basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)*puVar6);
}
if ((local_129 & 1) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("ref_stack.back()->is_array() || ref_stack.back()->is_object()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp"
,0x2527,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>, Value = bool &]"
);
}
puVar6 = (int8 *)
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
uVar4 = basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::is_array((basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)*puVar6);
if ((uVar4 & 1) == 0) {
puVar6 = (int8 *)
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
uVar4 = basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::is_object((basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)*puVar6);
if ((uVar4 & 1) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("ref_stack.back()->is_object()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp"
,0x2531,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>, Value = bool &]"
);
}
bVar1 = std::vector<bool,std::allocator<bool>>::empty
((vector<bool,std::allocator<bool>> *)(this + 0x48));
if (((bVar1 ^ 0xff) & 1) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("!key_keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp"
,0x2533,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>, Value = bool &]"
);
}
local_e0 = std::vector<bool,std::allocator<bool>>::back
((vector<bool,std::allocator<bool>> *)(this + 0x48));
local_c9 = std::_Bit_reference::operator_cast_to_bool((_Bit_reference *)local_e0);
std::vector<bool,std::allocator<bool>>::pop_back
((vector<bool,std::allocator<bool>> *)(this + 0x48));
if ((local_c9 & 1) == 0) {
local_e1 = 0;
local_f0 = 0;
_ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
(local_18,&local_e1,&local_f0);
}
else {
if (*(long *)(this + 0x70) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("object_element",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp"
,0x253c,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>, Value = bool &]"
);
}
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(local_100,local_60);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
**)(this + 0x70),local_100);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::~basic_json(local_100);
local_101 = 1;
_ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbRSF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISK_SL_EEEbE4typeELb1EEEOSK_OSL_
(local_18,&local_101,this + 0x70);
}
}
else {
plVar5 = (long *)std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(*(vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(*plVar5 + 8),local_60);
local_b9 = 1;
plVar5 = (long *)std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
local_c8 = std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::back(*(vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(*plVar5 + 8));
_ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbSF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
(local_18,&local_b9,&local_c8);
}
}
}
else {
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(local_98,local_60);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
**)this,local_98);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::~basic_json(local_98);
local_99 = 1;
local_a8 = *(int8 *)this;
_ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbSF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
(local_18,&local_99,&local_a8);
}
}
local_84 = 1;
uVar7 = basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::~basic_json((basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)local_60);
}
else {
local_41 = 0;
local_50 = 0;
uVar7 = _ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
(local_18,&local_41,&local_50);
}
auVar8._1_7_ = (int7)((ulong)uVar7 >> 8);
auVar8[0] = local_18[0];
auVar8._8_8_ = local_10;
return auVar8;
}
| |
27,886 | std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::handle_value<nlohmann::json_abi_v3_11_3::detail::value_t>(nlohmann::json_abi_v3_11_3::detail::value_t&&, bool) | 11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp | std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (!keep_stack.back())
{
return {false, nullptr};
}
// create value
auto value = BasicJsonType(std::forward<Value>(v));
#if JSON_DIAGNOSTIC_POSITIONS
handle_diagnostic_positions_for_json_value(value);
#endif
// check callback
const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
// do not handle this value if we just learnt it shall be discarded
if (!keep)
{
return {false, nullptr};
}
if (ref_stack.empty())
{
root = std::move(value);
return {true, & root};
}
// skip this value if we already decided to skip the parent
// (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
if (!ref_stack.back())
{
return {false, nullptr};
}
// we now only expect arrays and objects
JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
// array
if (ref_stack.back()->is_array())
{
ref_stack.back()->m_data.m_value.array->emplace_back(std::move(value));
return {true, & (ref_stack.back()->m_data.m_value.array->back())};
}
// object
JSON_ASSERT(ref_stack.back()->is_object());
// check if we should store an element for the current key
JSON_ASSERT(!key_keep_stack.empty());
const bool store_element = key_keep_stack.back();
key_keep_stack.pop_back();
if (!store_element)
{
return {false, nullptr};
}
JSON_ASSERT(object_element);
*object_element = std::move(value);
return {true, object_element};
} | O1 | cpp | std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::handle_value<nlohmann::json_abi_v3_11_3::detail::value_t>(nlohmann::json_abi_v3_11_3::detail::value_t&&, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movl 0x38(%rdi), %ecx
cmpq %rax, 0x20(%rdi)
sete %dl
testl %ecx, %ecx
sete %dil
andb %dl, %dil
cmpb $0x1, %dil
je 0x1f5f6
movl %ecx, %ecx
movabsq $-0x8000000000000000, %r15 # imm = 0x8000000000000000
leaq -0x1(%rcx), %rdx
addq $0x3e, %rcx
testq %rdx, %rdx
cmovnsq %rdx, %rcx
sarq $0x6, %rcx
leaq (%rax,%rcx,8), %rax
leaq 0x3f(%r15), %rcx
andq %rdx, %rcx
xorl %edi, %edi
cmpq %r15, %rcx
setbe %dil
movq -0x8(%rax,%rdi,8), %rax
btq %rdx, %rax
jae 0x1f489
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movaps %xmm0, (%r14)
movq (%rsi), %rsi
movq %r14, %rdi
callq 0x12000
movq %r14, %rdi
movl $0x1, %esi
callq 0x11430
testb %bpl, %bpl
jne 0x1f436
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
shrq $0x3, %rax
movl %eax, 0xc(%rsp)
movb $0x5, 0xb(%rsp)
cmpq $0x0, 0x90(%rbx)
je 0x1f615
leaq 0x80(%rbx), %rdi
leaq 0xc(%rsp), %rsi
leaq 0xb(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq *0x98(%rbx)
testb %al, %al
je 0x1f5ca
movq 0x10(%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x1f493
movq -0x8(%rax), %rax
testq %rax, %rax
je 0x1f5ca
movzbl (%rax), %ecx
cmpl $0x1, %ecx
je 0x1f4ed
cmpl $0x2, %ecx
jne 0x1f61a
movq 0x8(%rax), %rdi
leaq 0x10(%rsp), %rsi
callq 0x118c0
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r14
addq $-0x10, %r14
jmp 0x1f5c6
xorl %ebx, %ebx
xorl %r14d, %r14d
jmp 0x1f5e6
leaq 0x10(%rsp), %r14
movaps (%r14), %xmm0
leaq 0x30(%rsp), %r15
movaps %xmm0, (%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x11430
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x11430
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x11490
movq %r15, %rdi
xorl %esi, %esi
callq 0x11430
movq %r15, %rdi
callq 0x11e50
movq (%rbx), %r14
jmp 0x1f5c6
movq 0x58(%rbx), %rax
movl 0x60(%rbx), %ecx
cmpq %rax, 0x48(%rbx)
sete %dl
testl %ecx, %ecx
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
je 0x1f639
movl %ecx, %esi
leaq -0x1(%rsi), %rcx
movq %rsi, %rdx
addq $0x3e, %rdx
testq %rcx, %rcx
cmovnsq %rcx, %rdx
sarq $0x6, %rdx
leaq (%rax,%rdx,8), %rdi
leaq 0x3f(%r15), %rdx
andq %rcx, %rdx
xorl %r8d, %r8d
cmpq %r15, %rdx
setbe %r8b
movl $0x1, %edx
shlq %cl, %rdx
andq -0x8(%rdi,%r8,8), %rdx
subl $0x1, %esi
movl %esi, 0x60(%rbx)
jae 0x1f55f
movl $0x3f, 0x60(%rbx)
addq $-0x8, %rax
movq %rax, 0x58(%rbx)
testq %rdx, %rdx
je 0x1f5ca
cmpq $0x0, 0x70(%rbx)
je 0x1f658
leaq 0x10(%rsp), %r14
movaps (%r14), %xmm0
leaq 0x20(%rsp), %r15
movaps %xmm0, (%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x11430
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x11430
movq 0x70(%rbx), %rdi
movq %r15, %rsi
callq 0x11490
movq %r15, %rdi
xorl %esi, %esi
callq 0x11430
movq %r15, %rdi
callq 0x11e50
movq 0x70(%rbx), %r14
movb $0x1, %bl
jmp 0x1f5cf
xorl %ebx, %ebx
xorl %r14d, %r14d
leaq 0x10(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x11430
movq %r15, %rdi
callq 0x11e50
movl %ebx, %eax
movq %r14, %rdx
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5497(%rip), %rdi # 0x24a94
leaq 0x3273(%rip), %rsi # 0x22877
leaq 0x6360(%rip), %rcx # 0x2596b
movl $0x2500, %edx # imm = 0x2500
callq 0x11620
callq 0x11310
leaq 0x5650(%rip), %rdi # 0x24c71
leaq 0x324f(%rip), %rsi # 0x22877
leaq 0x633c(%rip), %rcx # 0x2596b
movl $0x2527, %edx # imm = 0x2527
callq 0x11620
leaq 0x566f(%rip), %rdi # 0x24caf
leaq 0x3230(%rip), %rsi # 0x22877
leaq 0x631d(%rip), %rcx # 0x2596b
movl $0x2533, %edx # imm = 0x2533
callq 0x11620
leaq 0x5668(%rip), %rdi # 0x24cc7
leaq 0x3211(%rip), %rsi # 0x22877
leaq 0x62fe(%rip), %rcx # 0x2596b
movl $0x253c, %edx # imm = 0x253C
callq 0x11620
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x11430
movq %r14, %rdi
callq 0x11e50
movq %rbx, %rdi
callq 0x12010
nop
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE12handle_valueIRmEESt4pairIbPSF_EOT_b:
push rbp
push r15
push r14
push rbx
sub rsp, 48h
mov ebp, edx
mov rbx, rdi
mov rax, [rdi+30h]
mov ecx, [rdi+38h]
cmp [rdi+20h], rax
setz dl
test ecx, ecx
setz dil
and dil, dl
cmp dil, 1
jz loc_1F5F6
mov ecx, ecx
mov r15, 8000000000000000h
lea rdx, [rcx-1]
add rcx, 3Eh ; '>'
test rdx, rdx
cmovns rcx, rdx
sar rcx, 6
lea rax, [rax+rcx*8]
lea rcx, [r15+3Fh]
and rcx, rdx
xor edi, edi
cmp rcx, r15
setbe dil
mov rax, [rax+rdi*8-8]
bt rax, rdx
jnb loc_1F489
xorps xmm0, xmm0
lea r14, [rsp+68h+var_58]
movaps xmmword ptr [r14], xmm0
mov rsi, [rsi]
mov rdi, r14
call __ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE6EE9constructINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEEEEvRT_NSJ_17number_unsigned_tE; nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)6>::construct<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::number_unsigned_t)
mov rdi, r14
mov esi, 1
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
test bpl, bpl
jnz short loc_1F436
mov rax, [rbx+10h]
sub rax, [rbx+8]
shr rax, 3
mov [rsp+68h+var_5C], eax
mov [rsp+68h+var_5D], 5
cmp qword ptr [rbx+90h], 0
jz loc_1F615
lea rdi, [rbx+80h]
lea rsi, [rsp+68h+var_5C]
lea rdx, [rsp+68h+var_5D]
lea rcx, [rsp+68h+var_58]
call qword ptr [rbx+98h]
test al, al
jz loc_1F5CA
loc_1F436:
mov rax, [rbx+10h]
cmp [rbx+8], rax
jz short loc_1F493
mov rax, [rax-8]
test rax, rax
jz loc_1F5CA
movzx ecx, byte ptr [rax]
cmp ecx, 1
jz loc_1F4ED
cmp ecx, 2
jnz loc_1F61A
mov rdi, [rax+8]
lea rsi, [rsp+68h+var_58]
call __ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
mov rax, [rbx+10h]
mov rax, [rax-8]
mov rax, [rax+8]
mov r14, [rax+8]
add r14, 0FFFFFFFFFFFFFFF0h
jmp loc_1F5C6
loc_1F489:
xor ebx, ebx
xor r14d, r14d
jmp loc_1F5E6
loc_1F493:
lea r14, [rsp+68h+var_58]
movaps xmm0, xmmword ptr [r14]
lea r15, [rsp+68h+var_38]
movaps xmmword ptr [r15], xmm0
mov rdi, r14
xor esi, esi
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov byte ptr [r14], 0
mov qword ptr [r14+8], 0
mov rdi, r15
mov esi, 1
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, [rbx]
mov rsi, r15
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r15
xor esi, esi
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov r14, [rbx]
jmp loc_1F5C6
loc_1F4ED:
mov rax, [rbx+58h]
mov ecx, [rbx+60h]
cmp [rbx+48h], rax
setz dl
test ecx, ecx
setz sil
and sil, dl
cmp sil, 1
jz loc_1F639
mov esi, ecx
lea rcx, [rsi-1]
mov rdx, rsi
add rdx, 3Eh ; '>'
test rcx, rcx
cmovns rdx, rcx
sar rdx, 6
lea rdi, [rax+rdx*8]
lea rdx, [r15+3Fh]
and rdx, rcx
xor r8d, r8d
cmp rdx, r15
setbe r8b
mov edx, 1
shl rdx, cl
and rdx, [rdi+r8*8-8]
sub esi, 1
mov [rbx+60h], esi
jnb short loc_1F55F
mov dword ptr [rbx+60h], 3Fh ; '?'
add rax, 0FFFFFFFFFFFFFFF8h
mov [rbx+58h], rax
loc_1F55F:
test rdx, rdx
jz short loc_1F5CA
cmp qword ptr [rbx+70h], 0
jz loc_1F658
lea r14, [rsp+68h+var_58]
movaps xmm0, xmmword ptr [r14]
lea r15, [rsp+68h+var_48]
movaps xmmword ptr [r15], xmm0
mov rdi, r14
xor esi, esi
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov byte ptr [r14], 0
mov qword ptr [r14+8], 0
mov rdi, r15
mov esi, 1
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, [rbx+70h]
mov rsi, r15
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r15
xor esi, esi
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov r14, [rbx+70h]
loc_1F5C6:
mov bl, 1
jmp short loc_1F5CF
loc_1F5CA:
xor ebx, ebx
xor r14d, r14d
loc_1F5CF:
lea r15, [rsp+68h+var_58]
mov rdi, r15
xor esi, esi
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_1F5E6:
mov eax, ebx
mov rdx, r14
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_1F5F6:
lea rdi, aKeepStackEmpty; "!keep_stack.empty()"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStdPairBoolBas_5; "std::pair<bool, BasicJsonType *> nlohma"...
mov edx, 2500h
call ___assert_fail
loc_1F615:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
loc_1F61A:
lea rdi, aRefStackBackIs; "ref_stack.back()->is_array() || ref_sta"...
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStdPairBoolBas_5; "std::pair<bool, BasicJsonType *> nlohma"...
mov edx, 2527h
call ___assert_fail
loc_1F639:
lea rdi, aKeyKeepStackEm; "!key_keep_stack.empty()"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStdPairBoolBas_5; "std::pair<bool, BasicJsonType *> nlohma"...
mov edx, 2533h
call ___assert_fail
loc_1F658:
lea rdi, aObjectElement; "object_element"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStdPairBoolBas_5; "std::pair<bool, BasicJsonType *> nlohma"...
mov edx, 253Ch
call ___assert_fail
mov rbx, rax
lea r14, [rsp+68h+var_58]
mov rdi, r14
xor esi, esi
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, rbx
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::handle_value<unsigned long &>(
long long a1,
_QWORD *a2,
char a3)
{
unsigned int v4; // ebx
long long v5; // rax
unsigned int v6; // ecx
signed long long v7; // rdx
long long v8; // rcx
long long v9; // rax
long long v10; // rax
unsigned __int8 *v11; // rax
int v12; // ecx
long long v13; // rax
unsigned int v14; // ecx
long long v15; // rsi
long long v16; // rcx
long long v17; // rdx
long long v18; // rdx
char v20; // [rsp+Bh] [rbp-5Dh] BYREF
int v21; // [rsp+Ch] [rbp-5Ch] BYREF
__int128 v22; // [rsp+10h] [rbp-58h] BYREF
__int128 v23; // [rsp+20h] [rbp-48h] BYREF
_OWORD v24[3]; // [rsp+30h] [rbp-38h] BYREF
v4 = a1;
v5 = *(_QWORD *)(a1 + 48);
v6 = *(_DWORD *)(a1 + 56);
if ( *(_QWORD *)(a1 + 32) == v5 && v6 == 0 )
__assert_fail(
"!keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp",
9472LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nlohmann::"
"detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::handle_value"
"(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohmann::detail::iterator_inpu"
"t_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>, Value = unsigned long &]");
v7 = v6 - 1LL;
v8 = v6 + 62LL;
if ( v7 >= 0 )
v8 = v7;
v9 = *(_QWORD *)(v5 + 8 * (v8 >> 6) + 8LL * ((v7 & 0x800000000000003FLL) <= 0x8000000000000000LL) - 8);
if ( _bittest64(&v9, v7) )
{
v22 = 0LL;
nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)6>::construct<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
&v22,
*a2);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
&v22,
1LL);
if ( a3 )
goto LABEL_8;
v21 = (*(_QWORD *)(a1 + 16) - *(_QWORD *)(a1 + 8)) >> 3;
v20 = 5;
if ( !*(_QWORD *)(a1 + 144) )
std::__throw_bad_function_call();
if ( (*(unsigned __int8 ( **)(long long, int *, char *, __int128 *))(a1 + 152))(a1 + 128, &v21, &v20, &v22) )
{
LABEL_8:
v10 = *(_QWORD *)(a1 + 16);
if ( *(_QWORD *)(a1 + 8) == v10 )
{
v24[0] = v22;
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
&v22,
0LL);
LOBYTE(v22) = 0;
*((_QWORD *)&v22 + 1) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
v24,
1LL);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*(_QWORD *)a1,
v24);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
v24,
0LL);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v24);
LABEL_23:
LOBYTE(v4) = 1;
LABEL_25:
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
&v22,
0LL);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(&v22);
return v4;
}
v11 = *(unsigned __int8 **)(v10 - 8);
if ( v11 )
{
v12 = *v11;
if ( v12 != 1 )
{
if ( v12 != 2 )
__assert_fail(
"ref_stack.back()->is_array() || ref_stack.back()->is_object()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp",
9511LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nl"
"ohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>"
">>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohman"
"n::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>, Va"
"lue = unsigned long &]");
std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
*((_QWORD *)v11 + 1),
&v22);
goto LABEL_23;
}
v13 = *(_QWORD *)(a1 + 88);
v14 = *(_DWORD *)(a1 + 96);
if ( *(_QWORD *)(a1 + 72) == v13 && v14 == 0 )
__assert_fail(
"!key_keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp",
9523LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nloh"
"mann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::"
"handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohmann::det"
"ail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>, Value = unsigned long &]");
v15 = v14;
v16 = v14 - 1LL;
v17 = v15 + 62;
if ( v16 >= 0 )
v17 = v16;
v18 = *(_QWORD *)(v13 + 8 * (v17 >> 6) + 8LL * ((v16 & 0x800000000000003FLL) <= 0x8000000000000000LL) - 8) & (1LL << v16);
*(_DWORD *)(a1 + 96) = v15 - 1;
if ( !(_DWORD)v15 )
{
*(_DWORD *)(a1 + 96) = 63;
*(_QWORD *)(a1 + 88) = v13 - 8;
}
if ( v18 )
{
if ( !*(_QWORD *)(a1 + 112) )
__assert_fail(
"object_element",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp",
9532LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nl"
"ohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>"
">>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohman"
"n::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>, Va"
"lue = unsigned long &]");
v23 = v22;
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
&v22,
0LL);
LOBYTE(v22) = 0;
*((_QWORD *)&v22 + 1) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
&v23,
1LL);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*(_QWORD *)(a1 + 112),
&v23);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
&v23,
0LL);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(&v23);
goto LABEL_23;
}
}
}
v4 = 0;
goto LABEL_25;
}
return 0;
}
| handle_value<unsigned_long&>:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV EBP,EDX
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x30]
MOV ECX,dword ptr [RDI + 0x38]
CMP qword ptr [RDI + 0x20],RAX
SETZ DL
TEST ECX,ECX
SETZ DIL
AND DIL,DL
CMP DIL,0x1
JZ 0x0011f5f6
MOV ECX,ECX
MOV R15,-0x8000000000000000
LEA RDX,[RCX + -0x1]
ADD RCX,0x3e
TEST RDX,RDX
CMOVNS RCX,RDX
SAR RCX,0x6
LEA RAX,[RAX + RCX*0x8]
LEA RCX,[R15 + 0x3f]
AND RCX,RDX
XOR EDI,EDI
CMP RCX,R15
SETBE DIL
MOV RAX,qword ptr [RAX + RDI*0x8 + -0x8]
BT RAX,RDX
JNC 0x0011f489
XORPS XMM0,XMM0
LEA R14,[RSP + 0x10]
MOVAPS xmmword ptr [R14],XMM0
MOV RSI,qword ptr [RSI]
MOV RDI,R14
CALL 0x00112000
MOV RDI,R14
MOV ESI,0x1
CALL 0x00111430
TEST BPL,BPL
JNZ 0x0011f436
MOV RAX,qword ptr [RBX + 0x10]
SUB RAX,qword ptr [RBX + 0x8]
SHR RAX,0x3
MOV dword ptr [RSP + 0xc],EAX
MOV byte ptr [RSP + 0xb],0x5
CMP qword ptr [RBX + 0x90],0x0
JZ 0x0011f615
LEA RDI,[RBX + 0x80]
LAB_0011f419:
LEA RSI,[RSP + 0xc]
LEA RDX,[RSP + 0xb]
LEA RCX,[RSP + 0x10]
CALL qword ptr [RBX + 0x98]
TEST AL,AL
JZ 0x0011f5ca
LAB_0011f436:
MOV RAX,qword ptr [RBX + 0x10]
CMP qword ptr [RBX + 0x8],RAX
JZ 0x0011f493
MOV RAX,qword ptr [RAX + -0x8]
TEST RAX,RAX
JZ 0x0011f5ca
MOVZX ECX,byte ptr [RAX]
CMP ECX,0x1
JZ 0x0011f4ed
CMP ECX,0x2
JNZ 0x0011f61a
MOV RDI,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x10]
CALL 0x001118c0
MOV RAX,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RAX + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV R14,qword ptr [RAX + 0x8]
ADD R14,-0x10
JMP 0x0011f5c6
LAB_0011f489:
XOR EBX,EBX
XOR R14D,R14D
JMP 0x0011f5e6
LAB_0011f493:
LEA R14,[RSP + 0x10]
MOVAPS XMM0,xmmword ptr [R14]
LEA R15,[RSP + 0x30]
MOVAPS xmmword ptr [R15],XMM0
MOV RDI,R14
XOR ESI,ESI
CALL 0x00111430
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x00111430
MOV RDI,qword ptr [RBX]
MOV RSI,R15
CALL 0x00111490
MOV RDI,R15
XOR ESI,ESI
CALL 0x00111430
MOV RDI,R15
CALL 0x00111e50
MOV R14,qword ptr [RBX]
JMP 0x0011f5c6
LAB_0011f4ed:
MOV RAX,qword ptr [RBX + 0x58]
MOV ECX,dword ptr [RBX + 0x60]
CMP qword ptr [RBX + 0x48],RAX
SETZ DL
TEST ECX,ECX
SETZ SIL
AND SIL,DL
CMP SIL,0x1
JZ 0x0011f639
MOV ESI,ECX
LEA RCX,[RSI + -0x1]
MOV RDX,RSI
ADD RDX,0x3e
TEST RCX,RCX
CMOVNS RDX,RCX
SAR RDX,0x6
LEA RDI,[RAX + RDX*0x8]
LEA RDX,[R15 + 0x3f]
AND RDX,RCX
XOR R8D,R8D
CMP RDX,R15
SETBE R8B
MOV EDX,0x1
SHL RDX,CL
AND RDX,qword ptr [RDI + R8*0x8 + -0x8]
SUB ESI,0x1
MOV dword ptr [RBX + 0x60],ESI
JNC 0x0011f55f
MOV dword ptr [RBX + 0x60],0x3f
ADD RAX,-0x8
MOV qword ptr [RBX + 0x58],RAX
LAB_0011f55f:
TEST RDX,RDX
JZ 0x0011f5ca
CMP qword ptr [RBX + 0x70],0x0
JZ 0x0011f658
LEA R14,[RSP + 0x10]
MOVAPS XMM0,xmmword ptr [R14]
LEA R15,[RSP + 0x20]
MOVAPS xmmword ptr [R15],XMM0
MOV RDI,R14
XOR ESI,ESI
CALL 0x00111430
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x00111430
MOV RDI,qword ptr [RBX + 0x70]
MOV RSI,R15
CALL 0x00111490
MOV RDI,R15
XOR ESI,ESI
CALL 0x00111430
MOV RDI,R15
CALL 0x00111e50
MOV R14,qword ptr [RBX + 0x70]
LAB_0011f5c6:
MOV BL,0x1
JMP 0x0011f5cf
LAB_0011f5ca:
XOR EBX,EBX
XOR R14D,R14D
LAB_0011f5cf:
LEA R15,[RSP + 0x10]
MOV RDI,R15
XOR ESI,ESI
CALL 0x00111430
MOV RDI,R15
CALL 0x00111e50
LAB_0011f5e6:
MOV EAX,EBX
MOV RDX,R14
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0011f5f6:
LEA RDI,[0x124a94]
LEA RSI,[0x122877]
LEA RCX,[0x12596b]
MOV EDX,0x2500
CALL 0x00111620
LAB_0011f615:
CALL 0x00111310
LAB_0011f61a:
LEA RDI,[0x124c71]
LEA RSI,[0x122877]
LEA RCX,[0x12596b]
MOV EDX,0x2527
CALL 0x00111620
LAB_0011f639:
LEA RDI,[0x124caf]
LEA RSI,[0x122877]
LEA RCX,[0x12596b]
MOV EDX,0x2533
CALL 0x00111620
LAB_0011f658:
LEA RDI,[0x124cc7]
LEA RSI,[0x122877]
LEA RCX,[0x12596b]
MOV EDX,0x253c
CALL 0x00111620
|
/* std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>*>
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > > >::handle_value<unsigned long&>(unsigned long&, bool) */
int1 [16] __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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>>>
::handle_value<unsigned_long&>
(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*this,ulong *param_1,bool param_2)
{
uint uVar1;
char *pcVar2;
char cVar3;
ulong uVar4;
ulong uVar5;
bool bVar6;
long lVar7;
int1 auVar8 [16];
int1 local_5d;
int4 local_5c;
ulong local_58;
int8 uStack_50;
ulong local_48;
int8 uStack_40;
ulong local_38;
int8 uStack_30;
uVar1 = *(uint *)(this + 0x38);
if (uVar1 == 0 && *(long *)(this + 0x20) == *(long *)(this + 0x30)) {
/* WARNING: Subroutine does not return */
__assert_fail("!keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp"
,0x2500,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>, Value = unsigned long &]"
);
}
uVar5 = (ulong)uVar1 - 1;
uVar4 = (ulong)uVar1 + 0x3e;
if (-1 < (long)uVar5) {
uVar4 = uVar5;
}
if ((*(ulong *)(*(long *)(this + 0x30) + ((long)uVar4 >> 6) * 8 + -8 +
(ulong)((uVar5 & 0x800000000000003f) < 0x8000000000000001) * 8) >> (uVar5 & 0x3f) &
1) == 0) {
uVar5 = 0;
lVar7 = 0;
goto LAB_0011f5e6;
}
local_58 = 0;
uStack_50 = 0;
external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)6>::
construct<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(&local_58,*param_1);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_58,0));
if (param_2) {
LAB_0011f436:
if (*(long *)(this + 8) == *(long *)(this + 0x10)) {
local_38 = local_58;
uStack_30 = uStack_50;
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_58,0));
local_58 = local_58 & 0xffffffffffffff00;
uStack_50 = 0;
bVar6 = SUB81((data *)&local_38,0);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar6);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
**)this,(data *)&local_38);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar6);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_38);
lVar7 = *(long *)this;
}
else {
pcVar2 = *(char **)(*(long *)(this + 0x10) + -8);
if (pcVar2 == (char *)0x0) goto LAB_0011f5ca;
if (*pcVar2 == '\x01') {
lVar7 = *(long *)(this + 0x58);
uVar1 = *(uint *)(this + 0x60);
if (uVar1 == 0 && *(long *)(this + 0x48) == lVar7) {
/* WARNING: Subroutine does not return */
__assert_fail("!key_keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp"
,0x2533,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>, Value = unsigned long &]"
);
}
uVar5 = (ulong)uVar1 - 1;
uVar4 = (ulong)uVar1 + 0x3e;
if (-1 < (long)uVar5) {
uVar4 = uVar5;
}
uVar4 = *(ulong *)(lVar7 + ((long)uVar4 >> 6) * 8 + -8 +
(ulong)((uVar5 & 0x800000000000003f) < 0x8000000000000001) * 8);
*(uint *)(this + 0x60) = uVar1 - 1;
if (uVar1 == 0) {
*(int4 *)(this + 0x60) = 0x3f;
*(long *)(this + 0x58) = lVar7 + -8;
}
if ((1L << ((byte)uVar5 & 0x3f) & uVar4) == 0) goto LAB_0011f5ca;
if (*(long *)(this + 0x70) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("object_element",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp"
,0x253c,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>, Value = unsigned long &]"
);
}
local_48 = local_58;
uStack_40 = uStack_50;
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_58,0));
local_58 = local_58 & 0xffffffffffffff00;
uStack_50 = 0;
bVar6 = SUB81((data *)&local_48,0);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar6);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
**)(this + 0x70),(data *)&local_48);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar6);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_48);
lVar7 = *(long *)(this + 0x70);
}
else {
if (*pcVar2 != '\x02') {
LAB_0011f61a:
/* WARNING: Subroutine does not return */
__assert_fail("ref_stack.back()->is_array() || ref_stack.back()->is_object()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp"
,0x2527,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>, Value = unsigned long &]"
);
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(*(vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(pcVar2 + 8),(basic_json *)&local_58);
lVar7 = *(long *)(*(long *)(*(long *)(*(long *)(this + 0x10) + -8) + 8) + 8) + -0x10;
}
}
uVar5 = CONCAT71((int7)((ulong)this >> 8),1);
}
else {
local_5c = (int4)((ulong)(*(long *)(this + 0x10) - *(long *)(this + 8)) >> 3);
local_5d = 5;
if (*(long *)(this + 0x90) == 0) {
std::__throw_bad_function_call();
goto LAB_0011f61a;
}
/* try { // try from 0011f419 to 0011f619 has its CatchHandler @ 0011f677 */
cVar3 = (**(code **)(this + 0x98))(this + 0x80,&local_5c,&local_5d,&local_58);
if (cVar3 != '\0') goto LAB_0011f436;
LAB_0011f5ca:
uVar5 = 0;
lVar7 = 0;
}
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81((data *)&local_58,0));
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_58);
LAB_0011f5e6:
auVar8._0_8_ = uVar5 & 0xffffffff;
auVar8._8_8_ = lVar7;
return auVar8;
}
| |
27,887 | std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::handle_value<nlohmann::json_abi_v3_11_3::detail::value_t>(nlohmann::json_abi_v3_11_3::detail::value_t&&, bool) | 11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp | std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (!keep_stack.back())
{
return {false, nullptr};
}
// create value
auto value = BasicJsonType(std::forward<Value>(v));
#if JSON_DIAGNOSTIC_POSITIONS
handle_diagnostic_positions_for_json_value(value);
#endif
// check callback
const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
// do not handle this value if we just learnt it shall be discarded
if (!keep)
{
return {false, nullptr};
}
if (ref_stack.empty())
{
root = std::move(value);
return {true, & root};
}
// skip this value if we already decided to skip the parent
// (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
if (!ref_stack.back())
{
return {false, nullptr};
}
// we now only expect arrays and objects
JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
// array
if (ref_stack.back()->is_array())
{
ref_stack.back()->m_data.m_value.array->emplace_back(std::move(value));
return {true, & (ref_stack.back()->m_data.m_value.array->back())};
}
// object
JSON_ASSERT(ref_stack.back()->is_object());
// check if we should store an element for the current key
JSON_ASSERT(!key_keep_stack.empty());
const bool store_element = key_keep_stack.back();
key_keep_stack.pop_back();
if (!store_element)
{
return {false, nullptr};
}
JSON_ASSERT(object_element);
*object_element = std::move(value);
return {true, object_element};
} | O2 | cpp | std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::handle_value<nlohmann::json_abi_v3_11_3::detail::value_t>(nlohmann::json_abi_v3_11_3::detail::value_t&&, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rax
cmpq 0x30(%rdi), %rax
jne 0x28df0
cmpl $0x0, 0x38(%rbx)
je 0x28f48
leaq 0x20(%rbx), %rdi
callq 0x1dde0
testq %rdx, (%rax)
je 0x28e8b
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x1c910
testb %bpl, %bpl
jne 0x28e3c
leaq 0x80(%rbx), %rdi
movq 0x10(%rbx), %rsi
subq 0x8(%rbx), %rsi
shrq $0x3, %rsi
pushq $0x5
popq %rdx
leaq 0x8(%rsp), %rcx
callq 0x1cbe0
testb %al, %al
je 0x28f29
movq 0x10(%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x28e95
movq -0x8(%rax), %rax
testq %rax, %rax
je 0x28f29
movzbl (%rax), %ecx
cmpl $0x1, %ecx
je 0x28ebf
cmpl $0x2, %ecx
jne 0x28f67
movq 0x8(%rax), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1cfb0
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r14
addq $-0x10, %r14
jmp 0x28f25
xorl %ebx, %ebx
xorl %r14d, %r14d
jmp 0x28f38
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x1ca10
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x1c7e0
movq %r14, %rdi
callq 0x1d7b0
movq (%rbx), %r14
jmp 0x28f25
movq 0x48(%rbx), %rax
cmpq 0x58(%rbx), %rax
jne 0x28ed3
cmpl $0x0, 0x60(%rbx)
je 0x28f86
leaq 0x48(%rbx), %rdi
callq 0x1dde0
movq %rdx, %r14
leaq 0x58(%rbx), %rdi
movq (%rax), %r15
callq 0x1d1f0
testq %r14, %r15
je 0x28f29
cmpq $0x0, 0x70(%rbx)
je 0x28fa5
leaq 0x18(%rsp), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x1ca10
movq 0x70(%rbx), %rdi
movq %r14, %rsi
callq 0x1c7e0
movq %r14, %rdi
callq 0x1d7b0
movq 0x70(%rbx), %r14
movb $0x1, %bl
jmp 0x28f2e
xorl %ebx, %ebx
xorl %r14d, %r14d
leaq 0x8(%rsp), %rdi
callq 0x1d7b0
movl %ebx, %eax
movq %r14, %rdx
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4ec0(%rip), %rdi # 0x2de0f
leaq 0x2911(%rip), %rsi # 0x2b867
leaq 0x5d89(%rip), %rcx # 0x2ece6
movl $0x2500, %edx # imm = 0x2500
callq 0x1cb30
leaq 0x507e(%rip), %rdi # 0x2dfec
leaq 0x28f2(%rip), %rsi # 0x2b867
leaq 0x5d6a(%rip), %rcx # 0x2ece6
movl $0x2527, %edx # imm = 0x2527
callq 0x1cb30
leaq 0x509d(%rip), %rdi # 0x2e02a
leaq 0x28d3(%rip), %rsi # 0x2b867
leaq 0x5d4b(%rip), %rcx # 0x2ece6
movl $0x2533, %edx # imm = 0x2533
callq 0x1cb30
leaq 0x5096(%rip), %rdi # 0x2e042
leaq 0x28b4(%rip), %rsi # 0x2b867
leaq 0x5d2c(%rip), %rcx # 0x2ece6
movl $0x253c, %edx # imm = 0x253C
callq 0x1cb30
jmp 0x28fc6
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1d7b0
movq %rbx, %rdi
callq 0x1dcb0
nop
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE12handle_valueIRmEESt4pairIbPSF_EOT_b:
push rbp
push r15
push r14
push rbx
sub rsp, 38h
mov ebp, edx
mov r14, rsi
mov rbx, rdi
mov rax, [rdi+20h]
cmp rax, [rdi+30h]
jnz short loc_28DF0
cmp dword ptr [rbx+38h], 0
jz loc_28F48
loc_28DF0:
lea rdi, [rbx+20h]
call __ZNSt6vectorIbSaIbEE4backEv; std::vector<bool>::back(void)
test [rax], rdx
jz loc_28E8B
lea rdi, [rsp+58h+var_50]
mov rsi, r14
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRmmTnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_
test bpl, bpl
jnz short loc_28E3C
lea rdi, [rbx+80h]
mov rsi, [rbx+10h]
sub rsi, [rbx+8]
shr rsi, 3
push 5
pop rdx
lea rcx, [rsp+58h+var_50]
call __ZNKSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEEclEiS3_SH_; std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)>::operator()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)
test al, al
jz loc_28F29
loc_28E3C:
mov rax, [rbx+10h]
cmp [rbx+8], rax
jz short loc_28E95
mov rax, [rax-8]
test rax, rax
jz loc_28F29
movzx ecx, byte ptr [rax]
cmp ecx, 1
jz short loc_28EBF
cmp ecx, 2
jnz loc_28F67
mov rdi, [rax+8]
lea rsi, [rsp+58h+var_50]
call __ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
mov rax, [rbx+10h]
mov rax, [rax-8]
mov rax, [rax+8]
mov r14, [rax+8]
add r14, 0FFFFFFFFFFFFFFF0h
jmp loc_28F25
loc_28E8B:
xor ebx, ebx
xor r14d, r14d
jmp loc_28F38
loc_28E95:
lea r14, [rsp+58h+var_30]
lea rsi, [rsp+58h+var_50]
mov rdi, r14
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EOSD_; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&&)
mov rdi, [rbx]
mov rsi, r14
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r14
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
mov r14, [rbx]
jmp short loc_28F25
loc_28EBF:
mov rax, [rbx+48h]
cmp rax, [rbx+58h]
jnz short loc_28ED3
cmp dword ptr [rbx+60h], 0
jz loc_28F86
loc_28ED3:
lea rdi, [rbx+48h]
call __ZNSt6vectorIbSaIbEE4backEv; std::vector<bool>::back(void)
mov r14, rdx
lea rdi, [rbx+58h]; this
mov r15, [rax]
call __ZNSt18_Bit_iterator_base12_M_bump_downEv; std::_Bit_iterator_base::_M_bump_down(void)
test r15, r14
jz short loc_28F29
cmp qword ptr [rbx+70h], 0
jz loc_28FA5
lea r14, [rsp+58h+var_40]
lea rsi, [rsp+58h+var_50]
mov rdi, r14
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EOSD_; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&&)
mov rdi, [rbx+70h]
mov rsi, r14
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r14
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
mov r14, [rbx+70h]
loc_28F25:
mov bl, 1
jmp short loc_28F2E
loc_28F29:
xor ebx, ebx
xor r14d, r14d
loc_28F2E:
lea rdi, [rsp+58h+var_50]
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
loc_28F38:
mov eax, ebx
mov rdx, r14
add rsp, 38h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_28F48:
lea rdi, aKeepStackEmpty; "!keep_stack.empty()"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStdPairBoolBas_5; "std::pair<bool, BasicJsonType *> nlohma"...
mov edx, 2500h
call ___assert_fail
loc_28F67:
lea rdi, aRefStackBackIs; "ref_stack.back()->is_array() || ref_sta"...
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStdPairBoolBas_5; "std::pair<bool, BasicJsonType *> nlohma"...
mov edx, 2527h
call ___assert_fail
loc_28F86:
lea rdi, aKeyKeepStackEm; "!key_keep_stack.empty()"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStdPairBoolBas_5; "std::pair<bool, BasicJsonType *> nlohma"...
mov edx, 2533h
call ___assert_fail
loc_28FA5:
lea rdi, aObjectElement; "object_element"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStdPairBoolBas_5; "std::pair<bool, BasicJsonType *> nlohma"...
mov edx, 253Ch
call ___assert_fail
jmp short $+2
loc_28FC6:
mov rbx, rax
lea rdi, [rsp+58h+var_50]
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
mov rdi, rbx
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::handle_value<unsigned long &>(
long long a1,
long long a2,
char a3)
{
unsigned int v4; // ebx
_QWORD *v5; // rax
long long v6; // rdx
long long v7; // rax
unsigned __int8 *v8; // rax
int v9; // ecx
long long *v10; // rax
long long v11; // rdx
long long v12; // r14
long long v13; // r15
_BYTE v15[16]; // [rsp+8h] [rbp-50h] BYREF
_BYTE v16[16]; // [rsp+18h] [rbp-40h] BYREF
_BYTE v17[48]; // [rsp+28h] [rbp-30h] BYREF
v4 = a1;
if ( *(_QWORD *)(a1 + 32) == *(_QWORD *)(a1 + 48) && !*(_DWORD *)(a1 + 56) )
__assert_fail(
"!keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp",
9472LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nlohmann::"
"detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::handle_value"
"(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohmann::detail::iterator_inpu"
"t_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>, Value = unsigned long &]");
v5 = (_QWORD *)std::vector<bool>::back(a1 + 32);
if ( (v6 & *v5) != 0 )
{
_ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRmmTnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_(
v15,
a2);
if ( a3
|| (unsigned __int8)std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &)>::operator()(
a1 + 128,
(*(_QWORD *)(a1 + 16) - *(_QWORD *)(a1 + 8)) >> 3,
5LL,
v15) )
{
v7 = *(_QWORD *)(a1 + 16);
if ( *(_QWORD *)(a1 + 8) == v7 )
{
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
v17,
v15);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*(_QWORD *)a1,
v17);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json(v17);
LABEL_18:
LOBYTE(v4) = 1;
LABEL_20:
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json(v15);
return v4;
}
v8 = *(unsigned __int8 **)(v7 - 8);
if ( v8 )
{
v9 = *v8;
if ( v9 != 1 )
{
if ( v9 != 2 )
__assert_fail(
"ref_stack.back()->is_array() || ref_stack.back()->is_object()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp",
9511LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nl"
"ohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>"
">>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohman"
"n::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>, Va"
"lue = unsigned long &]");
std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
*((_QWORD *)v8 + 1),
v15);
goto LABEL_18;
}
if ( *(_QWORD *)(a1 + 72) == *(_QWORD *)(a1 + 88) && !*(_DWORD *)(a1 + 96) )
__assert_fail(
"!key_keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp",
9523LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nloh"
"mann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::"
"handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohmann::det"
"ail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>, Value = unsigned long &]");
v10 = (long long *)std::vector<bool>::back(a1 + 72);
v12 = v11;
v13 = *v10;
std::_Bit_iterator_base::_M_bump_down((std::_Bit_iterator_base *)(a1 + 88));
if ( (v12 & v13) != 0 )
{
if ( !*(_QWORD *)(a1 + 112) )
__assert_fail(
"object_element",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp",
9532LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nl"
"ohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>"
">>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohman"
"n::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>, Va"
"lue = unsigned long &]");
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
v16,
v15);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*(_QWORD *)(a1 + 112),
v16);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json(v16);
goto LABEL_18;
}
}
}
v4 = 0;
goto LABEL_20;
}
return 0;
}
| handle_value<unsigned_long&>:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x38
MOV EBP,EDX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x20]
CMP RAX,qword ptr [RDI + 0x30]
JNZ 0x00128df0
CMP dword ptr [RBX + 0x38],0x0
JZ 0x00128f48
LAB_00128df0:
LEA RDI,[RBX + 0x20]
CALL 0x0011dde0
TEST qword ptr [RAX],RDX
JZ 0x00128e8b
LEA RDI,[RSP + 0x8]
MOV RSI,R14
CALL 0x0011c910
TEST BPL,BPL
JNZ 0x00128e3c
LEA RDI,[RBX + 0x80]
MOV RSI,qword ptr [RBX + 0x10]
SUB RSI,qword ptr [RBX + 0x8]
SHR RSI,0x3
LAB_00128e27:
PUSH 0x5
POP RDX
LEA RCX,[RSP + 0x8]
CALL 0x0011cbe0
TEST AL,AL
JZ 0x00128f29
LAB_00128e3c:
MOV RAX,qword ptr [RBX + 0x10]
CMP qword ptr [RBX + 0x8],RAX
JZ 0x00128e95
MOV RAX,qword ptr [RAX + -0x8]
TEST RAX,RAX
JZ 0x00128f29
MOVZX ECX,byte ptr [RAX]
CMP ECX,0x1
JZ 0x00128ebf
CMP ECX,0x2
JNZ 0x00128f67
MOV RDI,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x8]
CALL 0x0011cfb0
MOV RAX,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RAX + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV R14,qword ptr [RAX + 0x8]
ADD R14,-0x10
JMP 0x00128f25
LAB_00128e8b:
XOR EBX,EBX
XOR R14D,R14D
JMP 0x00128f38
LAB_00128e95:
LEA R14,[RSP + 0x28]
LEA RSI,[RSP + 0x8]
MOV RDI,R14
CALL 0x0011ca10
MOV RDI,qword ptr [RBX]
MOV RSI,R14
CALL 0x0011c7e0
MOV RDI,R14
CALL 0x0011d7b0
MOV R14,qword ptr [RBX]
JMP 0x00128f25
LAB_00128ebf:
MOV RAX,qword ptr [RBX + 0x48]
CMP RAX,qword ptr [RBX + 0x58]
JNZ 0x00128ed3
CMP dword ptr [RBX + 0x60],0x0
JZ 0x00128f86
LAB_00128ed3:
LEA RDI,[RBX + 0x48]
CALL 0x0011dde0
LAB_00128edc:
MOV R14,RDX
LEA RDI,[RBX + 0x58]
MOV R15,qword ptr [RAX]
CALL 0x0011d1f0
TEST R15,R14
JZ 0x00128f29
CMP qword ptr [RBX + 0x70],0x0
JZ 0x00128fa5
LEA R14,[RSP + 0x18]
LEA RSI,[RSP + 0x8]
MOV RDI,R14
CALL 0x0011ca10
MOV RDI,qword ptr [RBX + 0x70]
MOV RSI,R14
CALL 0x0011c7e0
MOV RDI,R14
CALL 0x0011d7b0
MOV R14,qword ptr [RBX + 0x70]
LAB_00128f25:
MOV BL,0x1
JMP 0x00128f2e
LAB_00128f29:
XOR EBX,EBX
XOR R14D,R14D
LAB_00128f2e:
LEA RDI,[RSP + 0x8]
CALL 0x0011d7b0
LAB_00128f38:
MOV EAX,EBX
MOV RDX,R14
ADD RSP,0x38
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00128f48:
LEA RDI,[0x12de0f]
LEA RSI,[0x12b867]
LEA RCX,[0x12ece6]
MOV EDX,0x2500
CALL 0x0011cb30
LAB_00128f67:
LEA RDI,[0x12dfec]
LEA RSI,[0x12b867]
LEA RCX,[0x12ece6]
MOV EDX,0x2527
CALL 0x0011cb30
LAB_00128f86:
LEA RDI,[0x12e02a]
LEA RSI,[0x12b867]
LEA RCX,[0x12ece6]
MOV EDX,0x2533
CALL 0x0011cb30
LAB_00128fa5:
LEA RDI,[0x12e042]
LEA RSI,[0x12b867]
LEA RCX,[0x12ece6]
MOV EDX,0x253c
CALL 0x0011cb30
|
/* std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>*>
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > > >::handle_value<unsigned long&>(unsigned long&, bool) */
int1 [16] __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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>>>
::handle_value<unsigned_long&>
(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*this,ulong *param_1,bool param_2)
{
char *pcVar1;
char cVar2;
ulong uVar3;
long lVar4;
int1 auVar5 [16];
basic_json local_50 [16];
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_40 [16];
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_30 [16];
if ((*(long *)(this + 0x20) == *(long *)(this + 0x30)) && (*(int *)(this + 0x38) == 0)) {
/* WARNING: Subroutine does not return */
__assert_fail("!keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp"
,0x2500,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>, Value = unsigned long &]"
);
}
auVar5 = std::vector<bool,std::allocator<bool>>::back
((vector<bool,std::allocator<bool>> *)(this + 0x20));
if ((*auVar5._0_8_ & auVar5._8_8_) == 0) {
uVar3 = 0;
lVar4 = 0;
goto LAB_00128f38;
}
_ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRmmTnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_
(local_50,param_1);
if (param_2) {
LAB_00128e3c:
if (*(long *)(this + 8) == *(long *)(this + 0x10)) {
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(local_30,local_50);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
**)this,local_30);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::~basic_json(local_30);
lVar4 = *(long *)this;
}
else {
pcVar1 = *(char **)(*(long *)(this + 0x10) + -8);
if (pcVar1 == (char *)0x0) goto LAB_00128f29;
if (*pcVar1 == '\x01') {
if ((*(long *)(this + 0x48) == *(long *)(this + 0x58)) && (*(int *)(this + 0x60) == 0)) {
/* WARNING: Subroutine does not return */
__assert_fail("!key_keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp"
,0x2533,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>, Value = unsigned long &]"
);
}
/* try { // try from 00128ed3 to 00128edb has its CatchHandler @ 00128fc4 */
auVar5 = std::vector<bool,std::allocator<bool>>::back
((vector<bool,std::allocator<bool>> *)(this + 0x48));
uVar3 = *auVar5._0_8_;
std::_Bit_iterator_base::_M_bump_down((_Bit_iterator_base *)(this + 0x58));
if ((uVar3 & auVar5._8_8_) == 0) goto LAB_00128f29;
if (*(long *)(this + 0x70) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("object_element",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp"
,0x253c,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>, Value = unsigned long &]"
);
}
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(local_40,local_50);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
**)(this + 0x70),local_40);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::~basic_json(local_40);
lVar4 = *(long *)(this + 0x70);
}
else {
if (*pcVar1 != '\x02') {
/* WARNING: Subroutine does not return */
__assert_fail("ref_stack.back()->is_array() || ref_stack.back()->is_object()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp"
,0x2527,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>, Value = unsigned long &]"
);
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(*(vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(pcVar1 + 8),local_50);
lVar4 = *(long *)(*(long *)(*(long *)(*(long *)(this + 0x10) + -8) + 8) + 8) + -0x10;
}
}
uVar3 = CONCAT71((int7)((ulong)this >> 8),1);
}
else {
/* try { // try from 00128e27 to 00128e71 has its CatchHandler @ 00128fc6 */
cVar2 = std::
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
::operator()(this + 0x80,(ulong)(*(long *)(this + 0x10) - *(long *)(this + 8)) >> 3,5,
local_50);
if (cVar2 != '\0') goto LAB_00128e3c;
LAB_00128f29:
uVar3 = 0;
lVar4 = 0;
}
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::~basic_json((basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)local_50);
LAB_00128f38:
auVar5._0_8_ = uVar3 & 0xffffffff;
auVar5._8_8_ = lVar4;
return auVar5;
}
| |
27,888 | std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::handle_value<nlohmann::json_abi_v3_11_3::detail::value_t>(nlohmann::json_abi_v3_11_3::detail::value_t&&, bool) | 11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp | std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (!keep_stack.back())
{
return {false, nullptr};
}
// create value
auto value = BasicJsonType(std::forward<Value>(v));
#if JSON_DIAGNOSTIC_POSITIONS
handle_diagnostic_positions_for_json_value(value);
#endif
// check callback
const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
// do not handle this value if we just learnt it shall be discarded
if (!keep)
{
return {false, nullptr};
}
if (ref_stack.empty())
{
root = std::move(value);
return {true, & root};
}
// skip this value if we already decided to skip the parent
// (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
if (!ref_stack.back())
{
return {false, nullptr};
}
// we now only expect arrays and objects
JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
// array
if (ref_stack.back()->is_array())
{
ref_stack.back()->m_data.m_value.array->emplace_back(std::move(value));
return {true, & (ref_stack.back()->m_data.m_value.array->back())};
}
// object
JSON_ASSERT(ref_stack.back()->is_object());
// check if we should store an element for the current key
JSON_ASSERT(!key_keep_stack.empty());
const bool store_element = key_keep_stack.back();
key_keep_stack.pop_back();
if (!store_element)
{
return {false, nullptr};
}
JSON_ASSERT(object_element);
*object_element = std::move(value);
return {true, object_element};
} | O3 | cpp | std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::handle_value<nlohmann::json_abi_v3_11_3::detail::value_t>(nlohmann::json_abi_v3_11_3::detail::value_t&&, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movl 0x38(%rdi), %ecx
cmpq %rax, 0x20(%rdi)
sete %dl
testl %ecx, %ecx
sete %dil
andb %dl, %dil
cmpb $0x1, %dil
je 0x1ef26
movl %ecx, %ecx
movabsq $-0x8000000000000000, %r14 # imm = 0x8000000000000000
leaq -0x1(%rcx), %rdx
addq $0x3e, %rcx
testq %rdx, %rdx
cmovnsq %rdx, %rcx
sarq $0x6, %rcx
leaq (%rax,%rcx,8), %rax
leaq 0x3f(%r14), %rcx
andq %rdx, %rcx
xorl %edi, %edi
cmpq %r14, %rcx
setbe %dil
movq -0x8(%rax,%rdi,8), %rax
btq %rdx, %rax
jae 0x1edb9
leaq 0x10(%rsp), %rdi
callq 0x11d10
testb %bpl, %bpl
jne 0x1ed66
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
shrq $0x3, %rax
movl %eax, 0xc(%rsp)
movb $0x5, 0xb(%rsp)
cmpq $0x0, 0x90(%rbx)
je 0x1ef45
leaq 0x80(%rbx), %rdi
leaq 0xc(%rsp), %rsi
leaq 0xb(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq *0x98(%rbx)
testb %al, %al
je 0x1eefa
movq 0x10(%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x1edc3
movq -0x8(%rax), %rax
testq %rax, %rax
je 0x1eefa
movzbl (%rax), %ecx
cmpl $0x1, %ecx
je 0x1ee1d
cmpl $0x2, %ecx
jne 0x1ef4a
movq 0x8(%rax), %rdi
leaq 0x10(%rsp), %rsi
callq 0x118b0
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r14
addq $-0x10, %r14
jmp 0x1eef6
xorl %ebx, %ebx
xorl %r14d, %r14d
jmp 0x1ef16
leaq 0x10(%rsp), %r14
movups (%r14), %xmm0
leaq 0x30(%rsp), %r15
movaps %xmm0, (%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x11430
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x11430
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x11490
movq %r15, %rdi
xorl %esi, %esi
callq 0x11430
movq %r15, %rdi
callq 0x11e20
movq (%rbx), %r14
jmp 0x1eef6
movq 0x58(%rbx), %rax
movl 0x60(%rbx), %ecx
cmpq %rax, 0x48(%rbx)
sete %dl
testl %ecx, %ecx
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
je 0x1ef69
movl %ecx, %esi
leaq -0x1(%rsi), %rcx
movq %rsi, %rdx
addq $0x3e, %rdx
testq %rcx, %rcx
cmovnsq %rcx, %rdx
sarq $0x6, %rdx
leaq (%rax,%rdx,8), %rdi
leaq 0x3f(%r14), %rdx
andq %rcx, %rdx
xorl %r8d, %r8d
cmpq %r14, %rdx
setbe %r8b
movl $0x1, %edx
shlq %cl, %rdx
andq -0x8(%rdi,%r8,8), %rdx
subl $0x1, %esi
movl %esi, 0x60(%rbx)
jae 0x1ee8f
movl $0x3f, 0x60(%rbx)
addq $-0x8, %rax
movq %rax, 0x58(%rbx)
testq %rdx, %rdx
je 0x1eefa
cmpq $0x0, 0x70(%rbx)
je 0x1ef88
leaq 0x10(%rsp), %r14
movups (%r14), %xmm0
leaq 0x20(%rsp), %r15
movaps %xmm0, (%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x11430
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x11430
movq 0x70(%rbx), %rdi
movq %r15, %rsi
callq 0x11490
movq %r15, %rdi
xorl %esi, %esi
callq 0x11430
movq %r15, %rdi
callq 0x11e20
movq 0x70(%rbx), %r14
movb $0x1, %bl
jmp 0x1eeff
xorl %ebx, %ebx
xorl %r14d, %r14d
leaq 0x10(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x11430
movq %r15, %rdi
callq 0x11e20
movl %ebx, %eax
movq %r14, %rdx
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4b67(%rip), %rdi # 0x23a94
leaq 0x2943(%rip), %rsi # 0x21877
leaq 0x5867(%rip), %rcx # 0x247a2
movl $0x2500, %edx # imm = 0x2500
callq 0x11610
callq 0x11310
leaq 0x4d20(%rip), %rdi # 0x23c71
leaq 0x291f(%rip), %rsi # 0x21877
leaq 0x5843(%rip), %rcx # 0x247a2
movl $0x2527, %edx # imm = 0x2527
callq 0x11610
leaq 0x4d3f(%rip), %rdi # 0x23caf
leaq 0x2900(%rip), %rsi # 0x21877
leaq 0x5824(%rip), %rcx # 0x247a2
movl $0x2533, %edx # imm = 0x2533
callq 0x11610
leaq 0x4d38(%rip), %rdi # 0x23cc7
leaq 0x28e1(%rip), %rsi # 0x21877
leaq 0x5805(%rip), %rcx # 0x247a2
movl $0x253c, %edx # imm = 0x253C
callq 0x11610
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x11430
movq %r14, %rdi
callq 0x11e20
movq %rbx, %rdi
callq 0x11fe0
nop
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE12handle_valueIRSB_EESt4pairIbPSF_EOT_b:
push rbp
push r15
push r14
push rbx
sub rsp, 48h
mov ebp, edx
mov rbx, rdi
mov rax, [rdi+30h]
mov ecx, [rdi+38h]
cmp [rdi+20h], rax
setz dl
test ecx, ecx
setz dil
and dil, dl
cmp dil, 1
jz loc_1EF26
mov ecx, ecx
mov r14, 8000000000000000h
lea rdx, [rcx-1]
add rcx, 3Eh ; '>'
test rdx, rdx
cmovns rcx, rdx
sar rcx, 6
lea rax, [rax+rcx*8]
lea rcx, [r14+3Fh]
and rcx, rdx
xor edi, edi
cmp rcx, r14
setbe dil
mov rax, [rax+rdi*8-8]
bt rax, rdx
jnb loc_1EDB9
lea rdi, [rsp+68h+var_58]
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_
test bpl, bpl
jnz short loc_1ED66
mov rax, [rbx+10h]
sub rax, [rbx+8]
shr rax, 3
mov [rsp+68h+var_5C], eax
mov [rsp+68h+var_5D], 5
cmp qword ptr [rbx+90h], 0
jz loc_1EF45
lea rdi, [rbx+80h]
lea rsi, [rsp+68h+var_5C]
lea rdx, [rsp+68h+var_5D]
lea rcx, [rsp+68h+var_58]
call qword ptr [rbx+98h]
test al, al
jz loc_1EEFA
loc_1ED66:
mov rax, [rbx+10h]
cmp [rbx+8], rax
jz short loc_1EDC3
mov rax, [rax-8]
test rax, rax
jz loc_1EEFA
movzx ecx, byte ptr [rax]
cmp ecx, 1
jz loc_1EE1D
cmp ecx, 2
jnz loc_1EF4A
mov rdi, [rax+8]
lea rsi, [rsp+68h+var_58]
call __ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
mov rax, [rbx+10h]
mov rax, [rax-8]
mov rax, [rax+8]
mov r14, [rax+8]
add r14, 0FFFFFFFFFFFFFFF0h
jmp loc_1EEF6
loc_1EDB9:
xor ebx, ebx
xor r14d, r14d
jmp loc_1EF16
loc_1EDC3:
lea r14, [rsp+68h+var_58]
movups xmm0, xmmword ptr [r14]
lea r15, [rsp+68h+var_38]
movaps xmmword ptr [r15], xmm0
mov rdi, r14
xor esi, esi
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov byte ptr [r14], 0
mov qword ptr [r14+8], 0
mov rdi, r15
mov esi, 1
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, [rbx]
mov rsi, r15
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r15
xor esi, esi
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov r14, [rbx]
jmp loc_1EEF6
loc_1EE1D:
mov rax, [rbx+58h]
mov ecx, [rbx+60h]
cmp [rbx+48h], rax
setz dl
test ecx, ecx
setz sil
and sil, dl
cmp sil, 1
jz loc_1EF69
mov esi, ecx
lea rcx, [rsi-1]
mov rdx, rsi
add rdx, 3Eh ; '>'
test rcx, rcx
cmovns rdx, rcx
sar rdx, 6
lea rdi, [rax+rdx*8]
lea rdx, [r14+3Fh]
and rdx, rcx
xor r8d, r8d
cmp rdx, r14
setbe r8b
mov edx, 1
shl rdx, cl
and rdx, [rdi+r8*8-8]
sub esi, 1
mov [rbx+60h], esi
jnb short loc_1EE8F
mov dword ptr [rbx+60h], 3Fh ; '?'
add rax, 0FFFFFFFFFFFFFFF8h
mov [rbx+58h], rax
loc_1EE8F:
test rdx, rdx
jz short loc_1EEFA
cmp qword ptr [rbx+70h], 0
jz loc_1EF88
lea r14, [rsp+68h+var_58]
movups xmm0, xmmword ptr [r14]
lea r15, [rsp+68h+var_48]
movaps xmmword ptr [r15], xmm0
mov rdi, r14
xor esi, esi
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov byte ptr [r14], 0
mov qword ptr [r14+8], 0
mov rdi, r15
mov esi, 1
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, [rbx+70h]
mov rsi, r15
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r15
xor esi, esi
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov r14, [rbx+70h]
loc_1EEF6:
mov bl, 1
jmp short loc_1EEFF
loc_1EEFA:
xor ebx, ebx
xor r14d, r14d
loc_1EEFF:
lea r15, [rsp+68h+var_58]
mov rdi, r15
xor esi, esi
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_1EF16:
mov eax, ebx
mov rdx, r14
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_1EF26:
lea rdi, aKeepStackEmpty; "!keep_stack.empty()"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStdPairBoolBas_4; "std::pair<bool, BasicJsonType *> nlohma"...
mov edx, 2500h
call ___assert_fail
loc_1EF45:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
loc_1EF4A:
lea rdi, aRefStackBackIs; "ref_stack.back()->is_array() || ref_sta"...
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStdPairBoolBas_4; "std::pair<bool, BasicJsonType *> nlohma"...
mov edx, 2527h
call ___assert_fail
loc_1EF69:
lea rdi, aKeyKeepStackEm; "!key_keep_stack.empty()"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStdPairBoolBas_4; "std::pair<bool, BasicJsonType *> nlohma"...
mov edx, 2533h
call ___assert_fail
loc_1EF88:
lea rdi, aObjectElement; "object_element"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStdPairBoolBas_4; "std::pair<bool, BasicJsonType *> nlohma"...
mov edx, 253Ch
call ___assert_fail
mov rbx, rax
lea r14, [rsp+68h+var_58]
mov rdi, r14
xor esi, esi
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, rbx
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::handle_value<std::string&>(
long long a1,
long long a2,
char a3)
{
unsigned int v4; // ebx
long long v5; // rax
unsigned int v6; // ecx
signed long long v7; // rdx
long long v8; // rcx
long long v9; // rax
long long v10; // rax
unsigned __int8 *v11; // rax
int v12; // ecx
long long v13; // rax
unsigned int v14; // ecx
long long v15; // rsi
long long v16; // rcx
long long v17; // rdx
long long v18; // rdx
char v20; // [rsp+Bh] [rbp-5Dh] BYREF
int v21; // [rsp+Ch] [rbp-5Ch] BYREF
__int128 v22; // [rsp+10h] [rbp-58h] BYREF
__int128 v23; // [rsp+20h] [rbp-48h] BYREF
_OWORD v24[3]; // [rsp+30h] [rbp-38h] BYREF
v4 = a1;
v5 = *(_QWORD *)(a1 + 48);
v6 = *(_DWORD *)(a1 + 56);
if ( *(_QWORD *)(a1 + 32) == v5 && v6 == 0 )
__assert_fail(
"!keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp",
9472LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nlohmann::"
"detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::handle_value"
"(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohmann::detail::iterator_inpu"
"t_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>, Value = std::basic_string<char> &]");
v7 = v6 - 1LL;
v8 = v6 + 62LL;
if ( v7 >= 0 )
v8 = v7;
v9 = *(_QWORD *)(v5 + 8 * (v8 >> 6) + 8LL * ((v7 & 0x800000000000003FLL) <= 0x8000000000000000LL) - 8);
if ( _bittest64(&v9, v7) )
{
_ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_(&v22);
if ( a3 )
goto LABEL_8;
v21 = (*(_QWORD *)(a1 + 16) - *(_QWORD *)(a1 + 8)) >> 3;
v20 = 5;
if ( !*(_QWORD *)(a1 + 144) )
std::__throw_bad_function_call();
if ( (*(unsigned __int8 ( **)(long long, int *, char *, __int128 *))(a1 + 152))(a1 + 128, &v21, &v20, &v22) )
{
LABEL_8:
v10 = *(_QWORD *)(a1 + 16);
if ( *(_QWORD *)(a1 + 8) == v10 )
{
v24[0] = v22;
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
&v22,
0LL);
LOBYTE(v22) = 0;
*((_QWORD *)&v22 + 1) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
v24,
1LL);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*(_QWORD *)a1,
v24);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
v24,
0LL);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v24);
LABEL_23:
LOBYTE(v4) = 1;
LABEL_25:
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
&v22,
0LL);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(&v22);
return v4;
}
v11 = *(unsigned __int8 **)(v10 - 8);
if ( v11 )
{
v12 = *v11;
if ( v12 != 1 )
{
if ( v12 != 2 )
__assert_fail(
"ref_stack.back()->is_array() || ref_stack.back()->is_object()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp",
9511LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nl"
"ohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>"
">>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohman"
"n::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>, Va"
"lue = std::basic_string<char> &]");
std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
*((_QWORD *)v11 + 1),
&v22);
goto LABEL_23;
}
v13 = *(_QWORD *)(a1 + 88);
v14 = *(_DWORD *)(a1 + 96);
if ( *(_QWORD *)(a1 + 72) == v13 && v14 == 0 )
__assert_fail(
"!key_keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp",
9523LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nloh"
"mann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::"
"handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohmann::det"
"ail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>, Value = st"
"d::basic_string<char> &]");
v15 = v14;
v16 = v14 - 1LL;
v17 = v15 + 62;
if ( v16 >= 0 )
v17 = v16;
v18 = *(_QWORD *)(v13 + 8 * (v17 >> 6) + 8LL * ((v16 & 0x800000000000003FLL) <= 0x8000000000000000LL) - 8) & (1LL << v16);
*(_DWORD *)(a1 + 96) = v15 - 1;
if ( !(_DWORD)v15 )
{
*(_DWORD *)(a1 + 96) = 63;
*(_QWORD *)(a1 + 88) = v13 - 8;
}
if ( v18 )
{
if ( !*(_QWORD *)(a1 + 112) )
__assert_fail(
"object_element",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp",
9532LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nl"
"ohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>"
">>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohman"
"n::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>, Va"
"lue = std::basic_string<char> &]");
v23 = v22;
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
&v22,
0LL);
LOBYTE(v22) = 0;
*((_QWORD *)&v22 + 1) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
&v23,
1LL);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*(_QWORD *)(a1 + 112),
&v23);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
&v23,
0LL);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(&v23);
goto LABEL_23;
}
}
}
v4 = 0;
goto LABEL_25;
}
return 0;
}
| handle_value<std::__cxx11::string&>:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV EBP,EDX
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x30]
MOV ECX,dword ptr [RDI + 0x38]
CMP qword ptr [RDI + 0x20],RAX
SETZ DL
TEST ECX,ECX
SETZ DIL
AND DIL,DL
CMP DIL,0x1
JZ 0x0011ef26
MOV ECX,ECX
MOV R14,-0x8000000000000000
LEA RDX,[RCX + -0x1]
ADD RCX,0x3e
TEST RDX,RDX
CMOVNS RCX,RDX
SAR RCX,0x6
LEA RAX,[RAX + RCX*0x8]
LEA RCX,[R14 + 0x3f]
AND RCX,RDX
XOR EDI,EDI
CMP RCX,R14
SETBE DIL
MOV RAX,qword ptr [RAX + RDI*0x8 + -0x8]
BT RAX,RDX
JNC 0x0011edb9
LEA RDI,[RSP + 0x10]
CALL 0x00111d10
TEST BPL,BPL
JNZ 0x0011ed66
MOV RAX,qword ptr [RBX + 0x10]
SUB RAX,qword ptr [RBX + 0x8]
SHR RAX,0x3
MOV dword ptr [RSP + 0xc],EAX
MOV byte ptr [RSP + 0xb],0x5
CMP qword ptr [RBX + 0x90],0x0
JZ 0x0011ef45
LEA RDI,[RBX + 0x80]
LAB_0011ed49:
LEA RSI,[RSP + 0xc]
LEA RDX,[RSP + 0xb]
LEA RCX,[RSP + 0x10]
CALL qword ptr [RBX + 0x98]
TEST AL,AL
JZ 0x0011eefa
LAB_0011ed66:
MOV RAX,qword ptr [RBX + 0x10]
CMP qword ptr [RBX + 0x8],RAX
JZ 0x0011edc3
MOV RAX,qword ptr [RAX + -0x8]
TEST RAX,RAX
JZ 0x0011eefa
MOVZX ECX,byte ptr [RAX]
CMP ECX,0x1
JZ 0x0011ee1d
CMP ECX,0x2
JNZ 0x0011ef4a
MOV RDI,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x10]
CALL 0x001118b0
MOV RAX,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RAX + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV R14,qword ptr [RAX + 0x8]
ADD R14,-0x10
JMP 0x0011eef6
LAB_0011edb9:
XOR EBX,EBX
XOR R14D,R14D
JMP 0x0011ef16
LAB_0011edc3:
LEA R14,[RSP + 0x10]
MOVUPS XMM0,xmmword ptr [R14]
LEA R15,[RSP + 0x30]
MOVAPS xmmword ptr [R15],XMM0
MOV RDI,R14
XOR ESI,ESI
CALL 0x00111430
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x00111430
MOV RDI,qword ptr [RBX]
MOV RSI,R15
CALL 0x00111490
MOV RDI,R15
XOR ESI,ESI
CALL 0x00111430
MOV RDI,R15
CALL 0x00111e20
MOV R14,qword ptr [RBX]
JMP 0x0011eef6
LAB_0011ee1d:
MOV RAX,qword ptr [RBX + 0x58]
MOV ECX,dword ptr [RBX + 0x60]
CMP qword ptr [RBX + 0x48],RAX
SETZ DL
TEST ECX,ECX
SETZ SIL
AND SIL,DL
CMP SIL,0x1
JZ 0x0011ef69
MOV ESI,ECX
LEA RCX,[RSI + -0x1]
MOV RDX,RSI
ADD RDX,0x3e
TEST RCX,RCX
CMOVNS RDX,RCX
SAR RDX,0x6
LEA RDI,[RAX + RDX*0x8]
LEA RDX,[R14 + 0x3f]
AND RDX,RCX
XOR R8D,R8D
CMP RDX,R14
SETBE R8B
MOV EDX,0x1
SHL RDX,CL
AND RDX,qword ptr [RDI + R8*0x8 + -0x8]
SUB ESI,0x1
MOV dword ptr [RBX + 0x60],ESI
JNC 0x0011ee8f
MOV dword ptr [RBX + 0x60],0x3f
ADD RAX,-0x8
MOV qword ptr [RBX + 0x58],RAX
LAB_0011ee8f:
TEST RDX,RDX
JZ 0x0011eefa
CMP qword ptr [RBX + 0x70],0x0
JZ 0x0011ef88
LEA R14,[RSP + 0x10]
MOVUPS XMM0,xmmword ptr [R14]
LEA R15,[RSP + 0x20]
MOVAPS xmmword ptr [R15],XMM0
MOV RDI,R14
XOR ESI,ESI
CALL 0x00111430
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x00111430
MOV RDI,qword ptr [RBX + 0x70]
MOV RSI,R15
CALL 0x00111490
MOV RDI,R15
XOR ESI,ESI
CALL 0x00111430
MOV RDI,R15
CALL 0x00111e20
MOV R14,qword ptr [RBX + 0x70]
LAB_0011eef6:
MOV BL,0x1
JMP 0x0011eeff
LAB_0011eefa:
XOR EBX,EBX
XOR R14D,R14D
LAB_0011eeff:
LEA R15,[RSP + 0x10]
MOV RDI,R15
XOR ESI,ESI
CALL 0x00111430
MOV RDI,R15
CALL 0x00111e20
LAB_0011ef16:
MOV EAX,EBX
MOV RDX,R14
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0011ef26:
LEA RDI,[0x123a94]
LEA RSI,[0x121877]
LEA RCX,[0x1247a2]
MOV EDX,0x2500
CALL 0x00111610
LAB_0011ef45:
CALL 0x00111310
LAB_0011ef4a:
LEA RDI,[0x123c71]
LEA RSI,[0x121877]
LEA RCX,[0x1247a2]
MOV EDX,0x2527
CALL 0x00111610
LAB_0011ef69:
LEA RDI,[0x123caf]
LEA RSI,[0x121877]
LEA RCX,[0x1247a2]
MOV EDX,0x2533
CALL 0x00111610
LAB_0011ef88:
LEA RDI,[0x123cc7]
LEA RSI,[0x121877]
LEA RCX,[0x1247a2]
MOV EDX,0x253c
CALL 0x00111610
|
/* std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>*>
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > > >::handle_value<std::__cxx11::string&>(std::__cxx11::string&,
bool) */
int1 [16] __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,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>>>
::handle_value<std::__cxx11::string&>
(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*this,string *param_1,bool param_2)
{
uint uVar1;
char *pcVar2;
char cVar3;
ulong uVar4;
ulong uVar5;
bool bVar6;
long lVar7;
int1 auVar8 [16];
int1 local_5d;
int4 local_5c;
basic_json local_58 [8];
int8 uStack_50;
data local_48 [8];
int8 uStack_40;
data local_38 [8];
int8 uStack_30;
uVar1 = *(uint *)(this + 0x38);
if (uVar1 == 0 && *(long *)(this + 0x20) == *(long *)(this + 0x30)) {
/* WARNING: Subroutine does not return */
__assert_fail("!keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp"
,0x2500,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>, Value = std::basic_string<char> &]"
);
}
uVar5 = (ulong)uVar1 - 1;
uVar4 = (ulong)uVar1 + 0x3e;
if (-1 < (long)uVar5) {
uVar4 = uVar5;
}
if ((*(ulong *)(*(long *)(this + 0x30) + ((long)uVar4 >> 6) * 8 + -8 +
(ulong)((uVar5 & 0x800000000000003f) < 0x8000000000000001) * 8) >> (uVar5 & 0x3f) &
1) == 0) {
uVar5 = 0;
lVar7 = 0;
goto LAB_0011ef16;
}
_ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_
(local_58);
if (param_2) {
LAB_0011ed66:
if (*(long *)(this + 8) == *(long *)(this + 0x10)) {
uStack_30 = uStack_50;
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_58,0));
local_58[0] = (basic_json)0x0;
uStack_50 = 0;
bVar6 = SUB81(local_38,0);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar6);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
**)this,local_38);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar6);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_38);
lVar7 = *(long *)this;
}
else {
pcVar2 = *(char **)(*(long *)(this + 0x10) + -8);
if (pcVar2 == (char *)0x0) goto LAB_0011eefa;
if (*pcVar2 == '\x01') {
lVar7 = *(long *)(this + 0x58);
uVar1 = *(uint *)(this + 0x60);
if (uVar1 == 0 && *(long *)(this + 0x48) == lVar7) {
/* WARNING: Subroutine does not return */
__assert_fail("!key_keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp"
,0x2533,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>, Value = std::basic_string<char> &]"
);
}
uVar5 = (ulong)uVar1 - 1;
uVar4 = (ulong)uVar1 + 0x3e;
if (-1 < (long)uVar5) {
uVar4 = uVar5;
}
uVar4 = *(ulong *)(lVar7 + ((long)uVar4 >> 6) * 8 + -8 +
(ulong)((uVar5 & 0x800000000000003f) < 0x8000000000000001) * 8);
*(uint *)(this + 0x60) = uVar1 - 1;
if (uVar1 == 0) {
*(int4 *)(this + 0x60) = 0x3f;
*(long *)(this + 0x58) = lVar7 + -8;
}
if ((1L << ((byte)uVar5 & 0x3f) & uVar4) == 0) goto LAB_0011eefa;
if (*(long *)(this + 0x70) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("object_element",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp"
,0x253c,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>, Value = std::basic_string<char> &]"
);
}
uStack_40 = uStack_50;
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_58,0));
local_58[0] = (basic_json)0x0;
uStack_50 = 0;
bVar6 = SUB81(local_48,0);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar6);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
**)(this + 0x70),local_48);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar6);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_48);
lVar7 = *(long *)(this + 0x70);
}
else {
if (*pcVar2 != '\x02') {
LAB_0011ef4a:
/* WARNING: Subroutine does not return */
__assert_fail("ref_stack.back()->is_array() || ref_stack.back()->is_object()",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp"
,0x2527,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<>, nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<>, InputAdapterType = nlohmann::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<const char *, std::basic_string<char>>>, Value = std::basic_string<char> &]"
);
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(*(vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(pcVar2 + 8),local_58);
lVar7 = *(long *)(*(long *)(*(long *)(*(long *)(this + 0x10) + -8) + 8) + 8) + -0x10;
}
}
uVar5 = CONCAT71((int7)((ulong)this >> 8),1);
}
else {
local_5c = (int4)((ulong)(*(long *)(this + 0x10) - *(long *)(this + 8)) >> 3);
local_5d = 5;
if (*(long *)(this + 0x90) == 0) {
std::__throw_bad_function_call();
goto LAB_0011ef4a;
}
/* try { // try from 0011ed49 to 0011ef49 has its CatchHandler @ 0011efa7 */
cVar3 = (**(code **)(this + 0x98))(this + 0x80,&local_5c,&local_5d,local_58);
if (cVar3 != '\0') goto LAB_0011ed66;
LAB_0011eefa:
uVar5 = 0;
lVar7 = 0;
}
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81((data *)local_58,0));
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)local_58);
LAB_0011ef16:
auVar8._0_8_ = uVar5 & 0xffffffff;
auVar8._8_8_ = lVar7;
return auVar8;
}
| |
27,889 | minja::Value::callable(std::function<minja::Value (std::shared_ptr<minja::Context> const&, minja::ArgumentsValue&)> const&) | monkey531[P]llama/common/minja.hpp | static Value callable(const CallableType & callable) {
return Value(std::make_shared<CallableType>(callable));
} | O3 | cpp | minja::Value::callable(std::function<minja::Value (std::shared_ptr<minja::Context> const&, minja::ArgumentsValue&)> const&):
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rcx
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rsi
callq 0x9b1f4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9b120
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x9aa70
callq 0x725dc
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x9aa8d
callq 0x725dc
movq %rbx, %rdi
callq 0x1c030
nop
| _ZN5minja5Value8callableERKSt8functionIFS0_RKSt10shared_ptrINS_7ContextEERNS_14ArgumentsValueEEE:
push r14
push rbx
sub rsp, 18h
mov rcx, rsi
mov rbx, rdi
lea rdi, [rsp+28h+var_18]
mov qword ptr [rdi-8], 0
lea r14, [rsp+28h+var_20]
lea rdx, [rsp+28h+var_21]
mov rsi, r14
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EEC2ISt8functionIFN5minja5ValueERKSt10shared_ptrINS5_7ContextEERNS5_14ArgumentsValueEEESaISF_EJRKSF_EEERPT_St20_Sp_alloc_shared_tagIT0_EDpOT1_; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::__shared_count<std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>,std::allocator<std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>>,std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)> const&>(std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)> *&,std::_Sp_alloc_shared_tag<std::allocator<std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>>>,std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)> const&)
mov rdi, rbx
mov rsi, r14
call _ZN5minja5ValueC2ERKSt10shared_ptrISt8functionIFS0_RKS1_INS_7ContextEERNS_14ArgumentsValueEEEE; minja::Value::Value(std::shared_ptr<std::function<minja::Value ()(std::shared_ptr const&<minja::Context>,minja::ArgumentsValue &)>> const&)
mov rdi, [rsp+28h+var_18]
test rdi, rdi
jz short loc_9AA70
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9AA70:
mov rax, rbx
add rsp, 18h
pop rbx
pop r14
retn
mov rbx, rax
mov rdi, [rsp+arg_8]
test rdi, rdi
jz short loc_9AA8D
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9AA8D:
mov rdi, rbx
call __Unwind_Resume
| long long minja::Value::callable(long long a1, long long a2)
{
char v3; // [rsp+7h] [rbp-21h] BYREF
long long v4; // [rsp+8h] [rbp-20h] BYREF
volatile signed __int32 *v5; // [rsp+10h] [rbp-18h] BYREF
v4 = 0LL;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::__shared_count<std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>,std::allocator<std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>>,std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)> const&>(
&v5,
&v4,
&v3,
a2);
minja::Value::Value(a1, &v4);
if ( v5 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v5);
return a1;
}
| callable:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RCX,RSI
MOV RBX,RDI
LEA RDI,[RSP + 0x10]
MOV qword ptr [RDI + -0x8],0x0
LEA R14,[RSP + 0x8]
LEA RDX,[RSP + 0x7]
MOV RSI,R14
CALL 0x0019b1f4
LAB_0019aa56:
MOV RDI,RBX
MOV RSI,R14
CALL 0x0019b120
LAB_0019aa61:
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x0019aa70
CALL 0x001725dc
LAB_0019aa70:
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R14
RET
|
/* minja::Value::callable(std::function<minja::Value (std::shared_ptr<minja::Context> const&,
minja::ArgumentsValue&)> const&) */
Value * __thiscall minja::Value::callable(Value *this,function *param_1)
{
int1 local_21;
int8 local_20;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_18;
local_20 = 0;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::
__shared_count<std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&)>,std::allocator<std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&)>>,std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&)>const&>
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&local_18,(shared_ptr *)&local_20,
&local_21,param_1);
/* try { // try from 0019aa56 to 0019aa60 has its CatchHandler @ 0019aa7b */
Value(this,(shared_ptr *)&local_20);
if (local_18 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_18);
}
return this;
}
| |
27,890 | unsigned char const& gguf_kv::get_val<unsigned char>(unsigned long) const | Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp | const T & get_val(const size_t i = 0) const {
GGML_ASSERT(type_to_gguf_type<T>::value == type);
if constexpr (std::is_same<T, std::string>::value) {
GGML_ASSERT(data_string.size() >= i+1);
return data_string[i];
}
const size_t type_size = gguf_type_size(type);
GGML_ASSERT(data.size() % type_size == 0);
GGML_ASSERT(data.size() >= (i+1)*type_size);
return reinterpret_cast<const T *>(data.data())[i];
} | O0 | cpp | unsigned char const& gguf_kv::get_val<unsigned char>(unsigned long) const:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl $0x8, %eax
cmpl 0x24(%rcx), %eax
je 0x91bc3
leaq 0x30a20(%rip), %rdi # 0xc25c9
movl $0xb7, %esi
leaq 0x1fa54(%rip), %rdx # 0xb1609
leaq 0x31ccf(%rip), %rcx # 0xc388b
movb $0x0, %al
callq 0x48a00
movq -0x20(%rbp), %rdi
addq $0x40, %rdi
callq 0x49490
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jae 0x91bfe
leaq 0x309e5(%rip), %rdi # 0xc25c9
movl $0xb9, %esi
leaq 0x1fa19(%rip), %rdx # 0xb1609
leaq 0x31cd7(%rip), %rcx # 0xc38ce
movb $0x0, %al
callq 0x48a00
movq -0x20(%rbp), %rdi
addq $0x40, %rdi
movq -0x10(%rbp), %rsi
callq 0x46a40
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| _ZNK7gguf_kv7get_valINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEERKT_m:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rcx, [rbp+var_8]
mov [rbp+var_20], rcx
mov eax, 8
cmp eax, [rcx+24h]
jz short loc_91BC3
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
mov esi, 0B7h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aTypeToGgufType; "type_to_gguf_type<T>::value == type"
mov al, 0
call _ggml_abort
loc_91BC3:
mov rdi, [rbp+var_20]
add rdi, 40h ; '@'
call __ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE4sizeEv; std::vector<std::string>::size(void)
mov rcx, [rbp+var_10]
add rcx, 1
cmp rax, rcx
jnb short loc_91BFE
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
mov esi, 0B9h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aDataStringSize; "data_string.size() >= i+1"
mov al, 0
call _ggml_abort
loc_91BFE:
mov rdi, [rbp+var_20]
add rdi, 40h ; '@'
mov rsi, [rbp+var_10]
call __ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEixEm; std::vector<std::string>::operator[](ulong)
add rsp, 20h
pop rbp
retn
| long long gguf_kv::get_val<std::string>(long long a1, long long a2)
{
if ( *(_DWORD *)(a1 + 36) != 8 )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp",
183,
(long long)"GGML_ASSERT(%s) failed",
"type_to_gguf_type<T>::value == type");
if ( std::vector<std::string>::size(a1 + 64) < (unsigned long long)(a2 + 1) )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp",
185,
(long long)"GGML_ASSERT(%s) failed",
"data_string.size() >= i+1");
return std::vector<std::string>::operator[](a1 + 64, a2);
}
| get_val<std::__cxx11::string>:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RCX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RCX
MOV EAX,0x8
CMP EAX,dword ptr [RCX + 0x24]
JZ 0x00191bc3
LEA RDI,[0x1c25c9]
MOV ESI,0xb7
LEA RDX,[0x1b1609]
LEA RCX,[0x1c388b]
MOV AL,0x0
CALL 0x00148a00
LAB_00191bc3:
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x40
CALL 0x00149490
MOV RCX,qword ptr [RBP + -0x10]
ADD RCX,0x1
CMP RAX,RCX
JNC 0x00191bfe
LEA RDI,[0x1c25c9]
MOV ESI,0xb9
LEA RDX,[0x1b1609]
LEA RCX,[0x1c38ce]
MOV AL,0x0
CALL 0x00148a00
LAB_00191bfe:
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x40
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x00146a40
ADD RSP,0x20
POP RBP
RET
|
/* std::__cxx11::string const& gguf_kv::get_val<std::__cxx11::string >(unsigned long) const */
string * __thiscall gguf_kv::get_val<std::__cxx11::string>(gguf_kv *this,ulong param_1)
{
ulong uVar1;
string *psVar2;
if (*(int *)(this + 0x24) != 8) {
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp"
,0xb7,"GGML_ASSERT(%s) failed","type_to_gguf_type<T>::value == type");
}
uVar1 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::size
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)
(this + 0x40));
if (uVar1 < param_1 + 1) {
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp"
,0xb9,"GGML_ASSERT(%s) failed","data_string.size() >= i+1");
}
psVar2 = (string *)
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::operator[]
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)
(this + 0x40),param_1);
return psVar2;
}
| |
27,891 | unsigned char const& gguf_kv::get_val<unsigned char>(unsigned long) const | Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp | const T & get_val(const size_t i = 0) const {
GGML_ASSERT(type_to_gguf_type<T>::value == type);
if constexpr (std::is_same<T, std::string>::value) {
GGML_ASSERT(data_string.size() >= i+1);
return data_string[i];
}
const size_t type_size = gguf_type_size(type);
GGML_ASSERT(data.size() % type_size == 0);
GGML_ASSERT(data.size() >= (i+1)*type_size);
return reinterpret_cast<const T *>(data.data())[i];
} | O1 | cpp | unsigned char const& gguf_kv::get_val<unsigned char>(unsigned long) const:
pushq %rax
cmpl $0x8, 0x24(%rdi)
jne 0x42802
movq 0x40(%rdi), %rax
movq 0x48(%rdi), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
leaq 0x1(%rsi), %rdx
cmpq %rdx, %rcx
jb 0x4281e
cmpq %rsi, %rcx
jbe 0x427fd
shlq $0x5, %rsi
addq %rsi, %rax
popq %rcx
retq
callq 0x19db1
leaq 0x1a7e4(%rip), %rdi # 0x5cfed
leaq 0x9db1(%rip), %rdx # 0x4c5c1
leaq 0x1b1f3(%rip), %rcx # 0x5da0a
movl $0xb7, %esi
jmp 0x42838
leaq 0x1a7c8(%rip), %rdi # 0x5cfed
leaq 0x9d95(%rip), %rdx # 0x4c5c1
leaq 0x1b21a(%rip), %rcx # 0x5da4d
movl $0xb9, %esi
xorl %eax, %eax
callq 0x18ce0
nop
| _ZNK7gguf_kv7get_valINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEERKT_m:
push rax
cmp dword ptr [rdi+24h], 8
jnz short loc_42802
mov rax, [rdi+40h]
mov rcx, [rdi+48h]
sub rcx, rax
sar rcx, 5
lea rdx, [rsi+1]
cmp rcx, rdx
jb short loc_4281E
cmp rcx, rsi
jbe short loc_427FD
shl rsi, 5
add rax, rsi
pop rcx
retn
loc_427FD:
call _ZNK7gguf_kv7get_valINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEERKT_m_cold_1; gguf_kv::get_val<std::string>(ulong) [clone]
loc_42802:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aTypeToGgufType; "type_to_gguf_type<T>::value == type"
mov esi, 0B7h
jmp short loc_42838
loc_4281E:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aDataStringSize; "data_string.size() >= i+1"
mov esi, 0B9h
loc_42838:
xor eax, eax
call _ggml_abort
| long long gguf_kv::get_val<std::string>(
long long a1,
unsigned long long a2,
long long a3,
long long a4,
int a5,
int a6)
{
long long v6; // rax
unsigned long long v7; // rcx
const char *v9; // rcx
int v10; // esi
if ( *(_DWORD *)(a1 + 36) != 8 )
{
v9 = "type_to_gguf_type<T>::value == type";
v10 = 183;
goto LABEL_8;
}
v6 = *(_QWORD *)(a1 + 64);
v7 = (*(_QWORD *)(a1 + 72) - v6) >> 5;
if ( v7 < a2 + 1 )
{
v9 = "data_string.size() >= i+1";
v10 = 185;
LABEL_8:
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp",
v10,
(unsigned int)"GGML_ASSERT(%s) failed",
(_DWORD)v9,
a5,
a6);
}
if ( v7 <= a2 )
gguf_kv::get_val<std::string>(a1);
return 32 * a2 + v6;
}
| get_val<std::__cxx11::string>:
PUSH RAX
CMP dword ptr [RDI + 0x24],0x8
JNZ 0x00142802
MOV RAX,qword ptr [RDI + 0x40]
MOV RCX,qword ptr [RDI + 0x48]
SUB RCX,RAX
SAR RCX,0x5
LEA RDX,[RSI + 0x1]
CMP RCX,RDX
JC 0x0014281e
CMP RCX,RSI
JBE 0x001427fd
SHL RSI,0x5
ADD RAX,RSI
POP RCX
RET
LAB_001427fd:
CALL 0x00119db1
LAB_00142802:
LEA RDI,[0x15cfed]
LEA RDX,[0x14c5c1]
LEA RCX,[0x15da0a]
MOV ESI,0xb7
JMP 0x00142838
LAB_0014281e:
LEA RDI,[0x15cfed]
LEA RDX,[0x14c5c1]
LEA RCX,[0x15da4d]
MOV ESI,0xb9
LAB_00142838:
XOR EAX,EAX
CALL 0x00118ce0
|
/* std::__cxx11::string const& gguf_kv::get_val<std::__cxx11::string >(unsigned long) const */
string * __thiscall gguf_kv::get_val<std::__cxx11::string>(gguf_kv *this,ulong param_1)
{
ulong uVar1;
char *pcVar2;
int8 uVar3;
if (*(int *)(this + 0x24) == 8) {
uVar1 = *(long *)(this + 0x48) - *(long *)(this + 0x40) >> 5;
if (uVar1 < param_1 + 1) {
pcVar2 = "data_string.size() >= i+1";
uVar3 = 0xb9;
goto LAB_00142838;
}
if (param_1 < uVar1) {
return (string *)(*(long *)(this + 0x40) + param_1 * 0x20);
}
get_val<std::__cxx11::string>((ulong)this);
}
pcVar2 = "type_to_gguf_type<T>::value == type";
uVar3 = 0xb7;
LAB_00142838:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp",
uVar3,"GGML_ASSERT(%s) failed",pcVar2);
}
| |
27,892 | unsigned char const& gguf_kv::get_val<unsigned char>(unsigned long) const | Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp | const T & get_val(const size_t i = 0) const {
GGML_ASSERT(type_to_gguf_type<T>::value == type);
if constexpr (std::is_same<T, std::string>::value) {
GGML_ASSERT(data_string.size() >= i+1);
return data_string[i];
}
const size_t type_size = gguf_type_size(type);
GGML_ASSERT(data.size() % type_size == 0);
GGML_ASSERT(data.size() >= (i+1)*type_size);
return reinterpret_cast<const T *>(data.data())[i];
} | O2 | cpp | unsigned char const& gguf_kv::get_val<unsigned char>(unsigned long) const:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0xc, 0x24(%rdi)
jne 0x442b6
movq %rsi, %rbx
movq %rdi, %r14
pushq $0xc
popq %rdi
callq 0x1fdf0
movq %rax, %rcx
movq 0x28(%r14), %rdi
movq 0x30(%r14), %rsi
subq %rdi, %rsi
movq %rsi, %rax
xorl %edx, %edx
divq %rcx
testq %rdx, %rdx
jne 0x442d2
leaq 0x1(%rbx), %rax
imulq %rax, %rcx
cmpq %rcx, %rsi
jb 0x442ee
leaq (%rdi,%rbx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1af90(%rip), %rdi # 0x5f24d
leaq 0xa311(%rip), %rdx # 0x4e5d5
leaq 0x1c244(%rip), %rcx # 0x6050f
movl $0xb7, %esi
jmp 0x44308
leaq 0x1af74(%rip), %rdi # 0x5f24d
leaq 0xa2f5(%rip), %rdx # 0x4e5d5
leaq 0x1b48e(%rip), %rcx # 0x5f775
movl $0xbd, %esi
jmp 0x44308
leaq 0x1af58(%rip), %rdi # 0x5f24d
leaq 0xa2d9(%rip), %rdx # 0x4e5d5
leaq 0x1c230(%rip), %rcx # 0x60533
movl $0xbe, %esi
xorl %eax, %eax
callq 0x1f9b0
nop
| _ZNK7gguf_kv7get_valIdEERKT_m:
push r14
push rbx
push rax
cmp dword ptr [rdi+24h], 0Ch
jnz short loc_442B6
mov rbx, rsi
mov r14, rdi
push 0Ch
pop rdi
call __Z14gguf_type_size9gguf_type; gguf_type_size(gguf_type)
mov rcx, rax
mov rdi, [r14+28h]
mov rsi, [r14+30h]
sub rsi, rdi
mov rax, rsi
xor edx, edx
div rcx
test rdx, rdx
jnz short loc_442D2
lea rax, [rbx+1]
imul rcx, rax
cmp rsi, rcx
jb short loc_442EE
lea rax, [rdi+rbx*8]
add rsp, 8
pop rbx
pop r14
retn
loc_442B6:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aTypeToGgufType; "type_to_gguf_type<T>::value == type"
mov esi, 0B7h
jmp short loc_44308
loc_442D2:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCtxKvKeyIdData+10h; "data.size() % type_size == 0"
mov esi, 0BDh
jmp short loc_44308
loc_442EE:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aDataSizeI1Type; "data.size() >= (i+1)*type_size"
mov esi, 0BEh
loc_44308:
xor eax, eax
call _ggml_abort
| long long gguf_kv::get_val<double>(
long long a1,
long long a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
long long a11,
long long a12,
long long a13,
long long a14)
{
char v14; // al
unsigned long long v16; // rcx
long long v17; // rdi
char *v19; // rcx
int v20; // esi
char v21; // [rsp-8h] [rbp-18h]
v21 = v14;
if ( *(_DWORD *)(a1 + 36) != 12 )
{
v19 = "type_to_gguf_type<T>::value == type";
v20 = 183;
goto LABEL_8;
}
v16 = gguf_type_size(12LL);
v17 = *(_QWORD *)(a1 + 40);
if ( (*(_QWORD *)(a1 + 48) - v17) % v16 )
{
v19 = "data.size() % type_size == 0";
v20 = 189;
goto LABEL_8;
}
if ( *(_QWORD *)(a1 + 48) - v17 < (a2 + 1) * v16 )
{
v19 = "data.size() >= (i+1)*type_size";
v20 = 190;
LABEL_8:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp",
v20,
(long long)"GGML_ASSERT(%s) failed",
(long long)v19,
a13,
a14,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
v21);
}
return v17 + 8 * a2;
}
| get_val<double>:
PUSH R14
PUSH RBX
PUSH RAX
CMP dword ptr [RDI + 0x24],0xc
JNZ 0x001442b6
MOV RBX,RSI
MOV R14,RDI
PUSH 0xc
POP RDI
CALL 0x0011fdf0
MOV RCX,RAX
MOV RDI,qword ptr [R14 + 0x28]
MOV RSI,qword ptr [R14 + 0x30]
SUB RSI,RDI
MOV RAX,RSI
XOR EDX,EDX
DIV RCX
TEST RDX,RDX
JNZ 0x001442d2
LEA RAX,[RBX + 0x1]
IMUL RCX,RAX
CMP RSI,RCX
JC 0x001442ee
LEA RAX,[RDI + RBX*0x8]
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_001442b6:
LEA RDI,[0x15f24d]
LEA RDX,[0x14e5d5]
LEA RCX,[0x16050f]
MOV ESI,0xb7
JMP 0x00144308
LAB_001442d2:
LEA RDI,[0x15f24d]
LEA RDX,[0x14e5d5]
LEA RCX,[0x15f775]
MOV ESI,0xbd
JMP 0x00144308
LAB_001442ee:
LEA RDI,[0x15f24d]
LEA RDX,[0x14e5d5]
LEA RCX,[0x160533]
MOV ESI,0xbe
LAB_00144308:
XOR EAX,EAX
CALL 0x0011f9b0
|
/* double const& gguf_kv::get_val<double>(unsigned long) const */
double * __thiscall gguf_kv::get_val<double>(gguf_kv *this,ulong param_1)
{
ulong uVar1;
char *pcVar2;
ulong uVar3;
int8 uVar4;
if (*(int *)(this + 0x24) == 0xc) {
uVar1 = gguf_type_size(0xc);
uVar3 = *(long *)(this + 0x30) - *(long *)(this + 0x28);
if (uVar3 % uVar1 == 0) {
if (uVar1 * (param_1 + 1) <= uVar3) {
return (double *)(*(long *)(this + 0x28) + param_1 * 8);
}
pcVar2 = "data.size() >= (i+1)*type_size";
uVar4 = 0xbe;
}
else {
pcVar2 = "data.size() % type_size == 0";
uVar4 = 0xbd;
}
}
else {
pcVar2 = "type_to_gguf_type<T>::value == type";
uVar4 = 0xb7;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp",
uVar4,"GGML_ASSERT(%s) failed",pcVar2);
}
| |
27,893 | unsigned char const& gguf_kv::get_val<unsigned char>(unsigned long) const | Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp | const T & get_val(const size_t i = 0) const {
GGML_ASSERT(type_to_gguf_type<T>::value == type);
if constexpr (std::is_same<T, std::string>::value) {
GGML_ASSERT(data_string.size() >= i+1);
return data_string[i];
}
const size_t type_size = gguf_type_size(type);
GGML_ASSERT(data.size() % type_size == 0);
GGML_ASSERT(data.size() >= (i+1)*type_size);
return reinterpret_cast<const T *>(data.data())[i];
} | O3 | cpp | unsigned char const& gguf_kv::get_val<unsigned char>(unsigned long) const:
pushq %rax
cmpl $0x8, 0x24(%rdi)
jne 0x420a8
movq 0x40(%rdi), %rax
movq 0x48(%rdi), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
leaq 0x1(%rsi), %rdx
cmpq %rdx, %rcx
jb 0x420c4
cmpq %rsi, %rcx
jbe 0x420a3
shlq $0x5, %rsi
addq %rsi, %rax
popq %rcx
retq
callq 0x18b28
leaq 0x1b42e(%rip), %rdi # 0x5d4dd
leaq 0xa5af(%rip), %rdx # 0x4c665
leaq 0x1be3d(%rip), %rcx # 0x5defa
movl $0xb7, %esi
jmp 0x420de
leaq 0x1b412(%rip), %rdi # 0x5d4dd
leaq 0xa593(%rip), %rdx # 0x4c665
leaq 0x1be64(%rip), %rcx # 0x5df3d
movl $0xb9, %esi
xorl %eax, %eax
callq 0x17cd0
nop
| _ZNK7gguf_kv7get_valINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEERKT_m:
push rax
cmp dword ptr [rdi+24h], 8
jnz short loc_420A8
mov rax, [rdi+40h]
mov rcx, [rdi+48h]
sub rcx, rax
sar rcx, 5
lea rdx, [rsi+1]
cmp rcx, rdx
jb short loc_420C4
cmp rcx, rsi
jbe short loc_420A3
shl rsi, 5
add rax, rsi
pop rcx
retn
loc_420A3:
call _ZNK7gguf_kv7get_valINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEERKT_m_cold_1; gguf_kv::get_val<std::string>(ulong) [clone]
loc_420A8:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aTypeToGgufType; "type_to_gguf_type<T>::value == type"
mov esi, 0B7h
jmp short loc_420DE
loc_420C4:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aDataStringSize; "data_string.size() >= i+1"
mov esi, 0B9h
loc_420DE:
xor eax, eax
call _ggml_abort
| long long gguf_kv::get_val<std::string>(
long long a1,
unsigned long long a2,
long long a3,
long long a4,
int a5,
int a6)
{
long long v6; // rax
unsigned long long v7; // rcx
const char *v9; // rcx
int v10; // esi
if ( *(_DWORD *)(a1 + 36) != 8 )
{
v9 = "type_to_gguf_type<T>::value == type";
v10 = 183;
goto LABEL_8;
}
v6 = *(_QWORD *)(a1 + 64);
v7 = (*(_QWORD *)(a1 + 72) - v6) >> 5;
if ( v7 < a2 + 1 )
{
v9 = "data_string.size() >= i+1";
v10 = 185;
LABEL_8:
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp",
v10,
(unsigned int)"GGML_ASSERT(%s) failed",
(_DWORD)v9,
a5,
a6);
}
if ( v7 <= a2 )
gguf_kv::get_val<std::string>(a1);
return 32 * a2 + v6;
}
| get_val<std::__cxx11::string>:
PUSH RAX
CMP dword ptr [RDI + 0x24],0x8
JNZ 0x001420a8
MOV RAX,qword ptr [RDI + 0x40]
MOV RCX,qword ptr [RDI + 0x48]
SUB RCX,RAX
SAR RCX,0x5
LEA RDX,[RSI + 0x1]
CMP RCX,RDX
JC 0x001420c4
CMP RCX,RSI
JBE 0x001420a3
SHL RSI,0x5
ADD RAX,RSI
POP RCX
RET
LAB_001420a3:
CALL 0x00118b28
LAB_001420a8:
LEA RDI,[0x15d4dd]
LEA RDX,[0x14c665]
LEA RCX,[0x15defa]
MOV ESI,0xb7
JMP 0x001420de
LAB_001420c4:
LEA RDI,[0x15d4dd]
LEA RDX,[0x14c665]
LEA RCX,[0x15df3d]
MOV ESI,0xb9
LAB_001420de:
XOR EAX,EAX
CALL 0x00117cd0
|
/* std::__cxx11::string const& gguf_kv::get_val<std::__cxx11::string >(unsigned long) const */
string * __thiscall gguf_kv::get_val<std::__cxx11::string>(gguf_kv *this,ulong param_1)
{
ulong uVar1;
char *pcVar2;
int8 uVar3;
if (*(int *)(this + 0x24) == 8) {
uVar1 = *(long *)(this + 0x48) - *(long *)(this + 0x40) >> 5;
if (uVar1 < param_1 + 1) {
pcVar2 = "data_string.size() >= i+1";
uVar3 = 0xb9;
goto LAB_001420de;
}
if (param_1 < uVar1) {
return (string *)(*(long *)(this + 0x40) + param_1 * 0x20);
}
get_val<std::__cxx11::string>((ulong)this);
}
pcVar2 = "type_to_gguf_type<T>::value == type";
uVar3 = 0xb7;
LAB_001420de:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp",
uVar3,"GGML_ASSERT(%s) failed",pcVar2);
}
| |
27,894 | psi_mutex_lock | eloqsql/mysys/my_thr_init.c | ATTRIBUTE_COLD int psi_mutex_lock(mysql_mutex_t *that,
const char *file, uint line)
{
PSI_mutex_locker_state state;
PSI_mutex_locker *locker= PSI_MUTEX_CALL(start_mutex_wait)
(&state, that->m_psi, PSI_MUTEX_LOCK, file, line);
# ifdef SAFE_MUTEX
int result= safe_mutex_lock(&that->m_mutex, FALSE, file, line);
# else
int result= pthread_mutex_lock(&that->m_mutex);
# endif
if (locker)
PSI_MUTEX_CALL(end_mutex_wait)(locker, result);
return result;
} | O3 | c | psi_mutex_lock:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edx, %r8d
movq %rsi, %rcx
movq %rdi, %r14
leaq 0x2ceced(%rip), %r15 # 0x2f3d68
movq (%r15), %rax
movq 0x40(%rdi), %rsi
leaq -0x48(%rbp), %rdi
xorl %edx, %edx
callq *0x190(%rax)
movq %rax, %rbx
movq %r14, %rdi
callq 0x24480
movl %eax, %r14d
testq %rbx, %rbx
je 0x250b0
movq (%r15), %rax
movq %rbx, %rdi
movl %r14d, %esi
callq *0x198(%rax)
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| psi_mutex_lock:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 38h
mov r8d, edx
mov rcx, rsi
mov r14, rdi
lea r15, PSI_server
mov rax, [r15]
mov rsi, [rdi+40h]
lea rdi, [rbp+var_48]
xor edx, edx
call qword ptr [rax+190h]
mov rbx, rax
mov rdi, r14
call _pthread_mutex_lock
mov r14d, eax
test rbx, rbx
jz short loc_250B0
mov rax, [r15]
mov rdi, rbx
mov esi, r14d
call qword ptr [rax+198h]
loc_250B0:
mov eax, r14d
add rsp, 38h
pop rbx
pop r14
pop r15
pop rbp
retn
| long long psi_mutex_lock(long long a1, long long a2, unsigned int a3)
{
long long v3; // rbx
unsigned int v4; // r14d
_BYTE v6[72]; // [rsp+8h] [rbp-48h] BYREF
v3 = (*((long long ( **)(_BYTE *, _QWORD, _QWORD, long long, _QWORD))PSI_server[0] + 50))(
v6,
*(_QWORD *)(a1 + 64),
0LL,
a2,
a3);
v4 = pthread_mutex_lock(a1);
if ( v3 )
(*((void ( **)(long long, _QWORD))PSI_server[0] + 51))(v3, v4);
return v4;
}
| psi_mutex_lock:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x38
MOV R8D,EDX
MOV RCX,RSI
MOV R14,RDI
LEA R15,[0x3f3d68]
MOV RAX,qword ptr [R15]
MOV RSI,qword ptr [RDI + 0x40]
LEA RDI,[RBP + -0x48]
XOR EDX,EDX
CALL qword ptr [RAX + 0x190]
MOV RBX,RAX
MOV RDI,R14
CALL 0x00124480
MOV R14D,EAX
TEST RBX,RBX
JZ 0x001250b0
MOV RAX,qword ptr [R15]
MOV RDI,RBX
MOV ESI,R14D
CALL qword ptr [RAX + 0x198]
LAB_001250b0:
MOV EAX,R14D
ADD RSP,0x38
POP RBX
POP R14
POP R15
POP RBP
RET
|
int psi_mutex_lock(pthread_mutex_t *param_1,int8 param_2,int4 param_3)
{
int iVar1;
long lVar2;
int1 local_50 [48];
lVar2 = (**(code **)(PSI_server + 400))
(local_50,*(int8 *)((long)param_1 + 0x40),0,param_2,param_3);
iVar1 = pthread_mutex_lock(param_1);
if (lVar2 != 0) {
(**(code **)(PSI_server + 0x198))(lVar2,iVar1);
}
return iVar1;
}
| |
27,895 | LefDefParser::defiPath::addViaMask(int) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiPath.cpp | void defiPath::addViaMask(int colorMask) {
int* mask;
if (numUsed_ == numAllocated_)
bumpSize(numAllocated_ * 2);
mask = (int*)malloc(sizeof(int));
*mask = colorMask;
keys_[numUsed_] = 'C'; //viaMask
data_[numUsed_] = mask;
(numUsed_)++;
} | O0 | cpp | LefDefParser::defiPath::addViaMask(int):
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movl 0x10(%rcx), %eax
cmpl 0x14(%rcx), %eax
jne 0x18b2e
movq 0x8(%rsp), %rdi
movl 0x14(%rdi), %esi
shll %esi
callq 0x179b0
movl $0x4, %edi
callq 0x72d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rsp)
movl 0x1c(%rsp), %edx
movq 0x10(%rsp), %rcx
movl %edx, (%rcx)
movq (%rax), %rcx
movslq 0x10(%rax), %rdx
movl $0x43, (%rcx,%rdx,4)
movq 0x10(%rsp), %rsi
movq 0x8(%rax), %rcx
movslq 0x10(%rax), %rdx
movq %rsi, (%rcx,%rdx,8)
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
| _ZN12LefDefParser8defiPath10addViaMaskEi:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_C], esi
mov rcx, [rsp+28h+var_8]
mov [rsp+28h+var_20], rcx
mov eax, [rcx+10h]
cmp eax, [rcx+14h]
jnz short loc_18B2E
mov rdi, [rsp+28h+var_20]; this
mov esi, [rdi+14h]
shl esi, 1; int
call _ZN12LefDefParser8defiPath8bumpSizeEi; LefDefParser::defiPath::bumpSize(int)
loc_18B2E:
mov edi, 4
call _malloc
mov rcx, rax
mov rax, [rsp+28h+var_20]
mov [rsp+28h+var_18], rcx
mov edx, [rsp+28h+var_C]
mov rcx, [rsp+28h+var_18]
mov [rcx], edx
mov rcx, [rax]
movsxd rdx, dword ptr [rax+10h]
mov dword ptr [rcx+rdx*4], 43h ; 'C'
mov rsi, [rsp+28h+var_18]
mov rcx, [rax+8]
movsxd rdx, dword ptr [rax+10h]
mov [rcx+rdx*8], rsi
mov ecx, [rax+10h]
add ecx, 1
mov [rax+10h], ecx
add rsp, 28h
retn
| LefDefParser::defiPath * LefDefParser::defiPath::addViaMask(LefDefParser::defiPath *this, int a2)
{
_DWORD *v2; // rcx
LefDefParser::defiPath *result; // rax
if ( *((_DWORD *)this + 4) == *((_DWORD *)this + 5) )
LefDefParser::defiPath::bumpSize(this, 2 * *((_DWORD *)this + 5));
v2 = (_DWORD *)malloc(4LL);
result = this;
*v2 = a2;
*(_DWORD *)(*(_QWORD *)this + 4LL * *((int *)this + 4)) = 67;
*(_QWORD *)(*((_QWORD *)this + 1) + 8LL * (int)(*((_DWORD *)this + 4))++) = v2;
return result;
}
| addViaMask:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV dword ptr [RSP + 0x1c],ESI
MOV RCX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x8],RCX
MOV EAX,dword ptr [RCX + 0x10]
CMP EAX,dword ptr [RCX + 0x14]
JNZ 0x00118b2e
MOV RDI,qword ptr [RSP + 0x8]
MOV ESI,dword ptr [RDI + 0x14]
SHL ESI,0x1
CALL 0x001179b0
LAB_00118b2e:
MOV EDI,0x4
CALL 0x001072d0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x10],RCX
MOV EDX,dword ptr [RSP + 0x1c]
MOV RCX,qword ptr [RSP + 0x10]
MOV dword ptr [RCX],EDX
MOV RCX,qword ptr [RAX]
MOVSXD RDX,dword ptr [RAX + 0x10]
MOV dword ptr [RCX + RDX*0x4],0x43
MOV RSI,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RAX + 0x8]
MOVSXD RDX,dword ptr [RAX + 0x10]
MOV qword ptr [RCX + RDX*0x8],RSI
MOV ECX,dword ptr [RAX + 0x10]
ADD ECX,0x1
MOV dword ptr [RAX + 0x10],ECX
ADD RSP,0x28
RET
|
/* LefDefParser::defiPath::addViaMask(int) */
void __thiscall LefDefParser::defiPath::addViaMask(defiPath *this,int param_1)
{
int *piVar1;
if (*(int *)(this + 0x10) == *(int *)(this + 0x14)) {
bumpSize(this,*(int *)(this + 0x14) << 1);
}
piVar1 = (int *)malloc(4);
*piVar1 = param_1;
*(int4 *)(*(long *)this + (long)*(int *)(this + 0x10) * 4) = 0x43;
*(int **)(*(long *)(this + 8) + (long)*(int *)(this + 0x10) * 8) = piVar1;
*(int *)(this + 0x10) = *(int *)(this + 0x10) + 1;
return;
}
| |
27,896 | flush_log_for_bitmap | eloqsql/storage/maria/ma_bitmap.c | static my_bool
flush_log_for_bitmap(PAGECACHE_IO_HOOK_ARGS *args __attribute__ ((unused)))
{
#ifdef DBUG_ASSERT_EXISTS
const MARIA_SHARE *share= (MARIA_SHARE*)args->data;
#endif
DBUG_ENTER("flush_log_for_bitmap");
DBUG_ASSERT(share->now_transactional);
/*
WAL imposes that UNDOs reach disk before bitmap is flushed. We don't know
the LSN of the last UNDO about this bitmap page, so we flush whole log.
*/
DBUG_RETURN(translog_flush(translog_get_horizon()));
} | O0 | c | flush_log_for_bitmap:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x3dd0e
jmp 0x3dd10
movb $0x0, %al
callq 0x4a710
movq %rax, %rdi
callq 0x4c350
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| flush_log_for_bitmap:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
jmp short $+2
loc_3DD0E:
jmp short $+2
loc_3DD10:
mov al, 0
call translog_get_horizon
mov rdi, rax
call translog_flush
mov [rbp+var_9], al
mov al, [rbp+var_9]
add rsp, 10h
pop rbp
retn
| long long flush_log_for_bitmap()
{
long long horizon; // rax
horizon = translog_get_horizon();
return translog_flush(horizon);
}
| flush_log_for_bitmap:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
JMP 0x0013dd0e
LAB_0013dd0e:
JMP 0x0013dd10
LAB_0013dd10:
MOV AL,0x0
CALL 0x0014a710
MOV RDI,RAX
CALL 0x0014c350
MOV byte ptr [RBP + -0x9],AL
MOV AL,byte ptr [RBP + -0x9]
ADD RSP,0x10
POP RBP
RET
|
int1 flush_log_for_bitmap(void)
{
int8 uVar1;
int1 uVar2;
uVar1 = translog_get_horizon();
uVar2 = translog_flush(uVar1);
return uVar2;
}
| |
27,897 | nglog::tools::(anonymous namespace)::DemangleInplace(char*, unsigned long) | ng-log[P]ng-log/src/symbolize.cc | ATTRIBUTE_NOINLINE
void DemangleInplace(char* out, size_t out_size) {
char demangled[256]; // Big enough for sane demangled symbols.
if (Demangle(out, demangled, sizeof(demangled))) {
// Demangling succeeded. Copy to out if the space allows.
size_t len = strlen(demangled);
if (len + 1 <= out_size) { // +1 for '\0'.
NGLOG_SAFE_ASSERT(len < sizeof(demangled));
memmove(out, demangled, len + 1);
}
}
} | O1 | cpp | nglog::tools::(anonymous namespace)::DemangleInplace(char*, unsigned long):
pushq %r14
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rsi
movl $0x100, %edx # imm = 0x100
callq 0xa698
testb %al, %al
je 0x21f23
movq %rsp, %rdi
callq 0x71f0
leaq 0x1(%rax), %rdx
cmpq %r14, %rdx
ja 0x21f23
cmpq $0x100, %rax # imm = 0x100
jae 0x21f2e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x7400
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r14
retq
callq 0x72b0
| _ZN5nglog5tools12_GLOBAL__N_115DemangleInplaceEPcm:
push r14
push rbx
sub rsp, 108h
mov r14, rsi
mov rbx, rdi
mov rsi, rsp; char *
mov edx, offset qword_100; char *
call _ZN5nglog5tools8DemangleEPKcPcm; nglog::tools::Demangle(char const*,char *,ulong)
test al, al
jz short loc_21F23
mov rdi, rsp
call _strlen
lea rdx, [rax+1]
cmp rdx, r14
ja short loc_21F23
cmp rax, 100h
jnb short loc_21F2E
mov rsi, rsp
mov rdi, rbx
call _memcpy
loc_21F23:
add rsp, 108h
pop rbx
pop r14
retn
loc_21F2E:
call _abort
| unsigned long long nglog::tools::`anonymous namespace'::DemangleInplace(
nglog::tools::_anonymous_namespace_ *this,
char *a2)
{
unsigned long long result; // rax
char v3[280]; // [rsp+0h] [rbp-118h] BYREF
result = nglog::tools::Demangle(this, v3, (char *)qword_100);
if ( (_BYTE)result )
{
result = strlen(v3);
if ( result + 1 <= (unsigned long long)a2 )
{
if ( result >= 0x100 )
abort(v3);
return memcpy(this, v3, result + 1);
}
}
return result;
}
| DemangleInplace:
PUSH R14
PUSH RBX
SUB RSP,0x108
MOV R14,RSI
MOV RBX,RDI
MOV RSI,RSP
MOV EDX,0x100
CALL 0x0010a698
TEST AL,AL
JZ 0x00121f23
MOV RDI,RSP
CALL 0x001071f0
LEA RDX,[RAX + 0x1]
CMP RDX,R14
JA 0x00121f23
CMP RAX,0x100
JNC 0x00121f2e
MOV RSI,RSP
MOV RDI,RBX
CALL 0x00107400
LAB_00121f23:
ADD RSP,0x108
POP RBX
POP R14
RET
LAB_00121f2e:
CALL 0x001072b0
|
/* nglog::tools::(anonymous namespace)::DemangleInplace(char*, unsigned long) */
void nglog::tools::(anonymous_namespace)::DemangleInplace(char *param_1,ulong param_2)
{
char cVar1;
size_t sVar2;
char acStack_118 [264];
cVar1 = Demangle(param_1,acStack_118,0x100);
if (cVar1 != '\0') {
sVar2 = strlen(acStack_118);
if (sVar2 + 1 <= param_2) {
if (0xff < sVar2) {
/* WARNING: Subroutine does not return */
abort();
}
memcpy(param_1,acStack_118,sVar2 + 1);
}
}
return;
}
| |
27,898 | nglog::tools::(anonymous namespace)::DemangleInplace(char*, unsigned long) | ng-log[P]ng-log/src/symbolize.cc | ATTRIBUTE_NOINLINE
void DemangleInplace(char* out, size_t out_size) {
char demangled[256]; // Big enough for sane demangled symbols.
if (Demangle(out, demangled, sizeof(demangled))) {
// Demangling succeeded. Copy to out if the space allows.
size_t len = strlen(demangled);
if (len + 1 <= out_size) { // +1 for '\0'.
NGLOG_SAFE_ASSERT(len < sizeof(demangled));
memmove(out, demangled, len + 1);
}
}
} | O2 | cpp | nglog::tools::(anonymous namespace)::DemangleInplace(char*, unsigned long):
pushq %r14
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rsi
movl $0x100, %edx # imm = 0x100
callq 0xb1b0
testb %al, %al
je 0x1e68d
movq %rsp, %rdi
callq 0x8230
leaq 0x1(%rax), %rdx
cmpq %r14, %rdx
ja 0x1e68d
cmpq $0x100, %rax # imm = 0x100
jae 0x1e698
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x8470
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r14
retq
callq 0x8310
| _ZN5nglog5tools12_GLOBAL__N_115DemangleInplaceEPcm:
push r14
push rbx
sub rsp, 108h
mov r14, rsi
mov rbx, rdi
mov rsi, rsp; char *
mov edx, offset qword_100; char *
call _ZN5nglog5tools8DemangleEPKcPcm; nglog::tools::Demangle(char const*,char *,ulong)
test al, al
jz short loc_1E68D
mov rdi, rsp
call _strlen
lea rdx, [rax+1]
cmp rdx, r14
ja short loc_1E68D
cmp rax, 100h
jnb short loc_1E698
mov rsi, rsp
mov rdi, rbx
call _memcpy
loc_1E68D:
add rsp, 108h
pop rbx
pop r14
retn
loc_1E698:
call _abort
| unsigned long long nglog::tools::`anonymous namespace'::DemangleInplace(
nglog::tools::_anonymous_namespace_ *this,
char *a2)
{
unsigned long long result; // rax
char v3[280]; // [rsp+0h] [rbp-118h] BYREF
result = nglog::tools::Demangle(this, v3, (char *)qword_100);
if ( (_BYTE)result )
{
result = strlen(v3);
if ( result + 1 <= (unsigned long long)a2 )
{
if ( result >= 0x100 )
abort(v3);
return memcpy(this, v3, result + 1);
}
}
return result;
}
| DemangleInplace:
PUSH R14
PUSH RBX
SUB RSP,0x108
MOV R14,RSI
MOV RBX,RDI
MOV RSI,RSP
MOV EDX,0x100
CALL 0x0010b1b0
TEST AL,AL
JZ 0x0011e68d
MOV RDI,RSP
CALL 0x00108230
LEA RDX,[RAX + 0x1]
CMP RDX,R14
JA 0x0011e68d
CMP RAX,0x100
JNC 0x0011e698
MOV RSI,RSP
MOV RDI,RBX
CALL 0x00108470
LAB_0011e68d:
ADD RSP,0x108
POP RBX
POP R14
RET
LAB_0011e698:
CALL 0x00108310
|
/* nglog::tools::(anonymous namespace)::DemangleInplace(char*, unsigned long) */
void nglog::tools::(anonymous_namespace)::DemangleInplace(char *param_1,ulong param_2)
{
char cVar1;
size_t sVar2;
char acStack_118 [264];
cVar1 = Demangle(param_1,acStack_118,0x100);
if (cVar1 != '\0') {
sVar2 = strlen(acStack_118);
if (sVar2 + 1 <= param_2) {
if (0xff < sVar2) {
/* WARNING: Subroutine does not return */
abort();
}
memcpy(param_1,acStack_118,sVar2 + 1);
}
}
return;
}
| |
27,899 | stmt_cursor_fetch | eloqsql/libmariadb/libmariadb/mariadb_stmt.c | static int stmt_cursor_fetch(MYSQL_STMT *stmt, uchar **row)
{
uchar buf[STMT_ID_LENGTH + 4];
MYSQL_DATA *result= &stmt->result;
if (stmt->state < MYSQL_STMT_USE_OR_STORE_CALLED)
{
SET_CLIENT_STMT_ERROR(stmt, CR_COMMANDS_OUT_OF_SYNC, SQLSTATE_UNKNOWN, 0);
return(1);
}
/* do we have some prefetched rows available ? */
if (stmt->result_cursor)
return(stmt_buffered_fetch(stmt, row));
if (stmt->upsert_status.server_status & SERVER_STATUS_LAST_ROW_SENT)
stmt->upsert_status.server_status&= ~SERVER_STATUS_LAST_ROW_SENT;
else
{
int4store(buf, stmt->stmt_id);
int4store(buf + STMT_ID_LENGTH, stmt->prefetch_rows);
if (stmt->mysql->methods->db_command(stmt->mysql, COM_STMT_FETCH, (char *)buf, sizeof(buf), 1, stmt))
{
UPDATE_STMT_ERROR(stmt);
return(1);
}
/* free previously allocated buffer */
ma_free_root(&result->alloc, MYF(MY_KEEP_PREALLOC));
result->data= 0;
result->rows= 0;
if (!stmt->mysql->options.extension->skip_read_response)
{
if (stmt->mysql->methods->db_stmt_read_all_rows(stmt))
return(1);
return(stmt_buffered_fetch(stmt, row));
}
}
/* no more cursor data available */
*row= NULL;
return(MYSQL_NO_DATA);
} | O3 | c | stmt_cursor_fetch:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x20(%rbp)
cmpl $0x3, 0x50(%rdi)
ja 0x21bf6
movl $0x7de, 0x108(%rbx) # imm = 0x7DE
leaq 0x30d(%rbx), %rdi
leaq 0x2c0ef(%rip), %rax # 0x4dca0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
xorl %r14d, %r14d
movb %r14b, 0x312(%rbx)
leaq 0x10c(%rbx), %rdi
leaq 0x2c0da(%rip), %rax # 0x4dcb0
movq 0x70(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x13220
movb %r14b, 0x30b(%rbx)
movl $0x1, %r14d
jmp 0x21ce8
movq %rsi, %r15
movq 0xe0(%rbx), %rax
testq %rax, %rax
je 0x21c2c
movl $0x5, 0x50(%rbx)
movq 0x8(%rax), %rax
movq %rax, (%r15)
movq 0xe0(%rbx), %rax
movq (%rax), %rax
movq %rax, 0xe0(%rbx)
xorl %r14d, %r14d
jmp 0x21ce8
movl 0xf4(%rbx), %eax
testb %al, %al
js 0x21cd0
movl 0x40(%rbx), %eax
leaq -0x28(%rbp), %rdx
movl %eax, (%rdx)
movl 0x318(%rbx), %eax
movl %eax, 0x4(%rdx)
movq 0x38(%rbx), %rdi
movq 0x4d0(%rdi), %rax
movl $0x1, %r14d
movl $0x8, %ecx
movl $0x1c, %esi
movl $0x1, %r8d
movq %rbx, %r9
callq *0x10(%rax)
testl %eax, %eax
je 0x21d05
movq 0x38(%rbx), %rsi
movl 0x90(%rsi), %eax
movl %eax, 0x108(%rbx)
leaq 0x30d(%rbx), %rdi
addq $0x297, %rsi # imm = 0x297
movl $0x5, %edx
callq 0x13220
xorl %r15d, %r15d
movb %r15b, 0x312(%rbx)
leaq 0x10c(%rbx), %rdi
movl $0x97, %esi
addq 0x38(%rbx), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x13220
movb %r15b, 0x30b(%rbx)
jmp 0x21ce8
andl $0xffffff7f, %eax # imm = 0xFFFFFF7F
movl %eax, 0xf4(%rbx)
movq $0x0, (%r15)
movl $0x64, %r14d
movq %fs:0x28, %rax
cmpq -0x20(%rbp), %rax
jne 0x21d6e
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x90(%rbx), %rdi
movl $0x1, %esi
callq 0x20e83
xorl %eax, %eax
movq %rax, 0x80(%rbx)
movq %rax, 0xc8(%rbx)
movq 0x38(%rbx), %rax
movq 0x480(%rax), %rcx
cmpb $0x0, 0x148(%rcx)
jne 0x21cdb
movq 0x4d0(%rax), %rax
movq %rbx, %rdi
callq *0x60(%rax)
testl %eax, %eax
jne 0x21ce8
movq 0xe0(%rbx), %rax
testq %rax, %rax
jne 0x21c05
movq $0x0, (%r15)
movl $0x6, 0x50(%rbx)
jmp 0x21ce2
callq 0x13500
| stmt_cursor_fetch:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 18h
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_20], rax
cmp dword ptr [rdi+50h], 3
ja short loc_21BF6
mov dword ptr [rbx+108h], 7DEh
lea rdi, [rbx+30Dh]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor r14d, r14d
mov [rbx+312h], r14b
lea rdi, [rbx+10Ch]
lea rax, client_errors
mov rsi, [rax+70h]
mov edx, 200h
call _strncpy
mov [rbx+30Bh], r14b
mov r14d, 1
jmp loc_21CE8
loc_21BF6:
mov r15, rsi
mov rax, [rbx+0E0h]
test rax, rax
jz short loc_21C2C
loc_21C05:
mov dword ptr [rbx+50h], 5
mov rax, [rax+8]
mov [r15], rax
mov rax, [rbx+0E0h]
mov rax, [rax]
mov [rbx+0E0h], rax
xor r14d, r14d
jmp loc_21CE8
loc_21C2C:
mov eax, [rbx+0F4h]
test al, al
js loc_21CD0
mov eax, [rbx+40h]
lea rdx, [rbp+var_28]
mov [rdx], eax
mov eax, [rbx+318h]
mov [rdx+4], eax
mov rdi, [rbx+38h]
mov rax, [rdi+4D0h]
mov r14d, 1
mov ecx, 8
mov esi, 1Ch
mov r8d, 1
mov r9, rbx
call qword ptr [rax+10h]
test eax, eax
jz loc_21D05
mov rsi, [rbx+38h]
mov eax, [rsi+90h]
mov [rbx+108h], eax
lea rdi, [rbx+30Dh]
add rsi, 297h
mov edx, 5
call _strncpy
xor r15d, r15d
mov [rbx+312h], r15b
lea rdi, [rbx+10Ch]
mov esi, 97h
add rsi, [rbx+38h]
mov edx, 200h
call _strncpy
mov [rbx+30Bh], r15b
jmp short loc_21CE8
loc_21CD0:
and eax, 0FFFFFF7Fh
mov [rbx+0F4h], eax
loc_21CDB:
mov qword ptr [r15], 0
loc_21CE2:
mov r14d, 64h ; 'd'
loc_21CE8:
mov rax, fs:28h
cmp rax, [rbp+var_20]
jnz short loc_21D6E
mov eax, r14d
add rsp, 18h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_21D05:
lea rdi, [rbx+90h]
mov esi, 1
call ma_free_root
xor eax, eax
mov [rbx+80h], rax
mov [rbx+0C8h], rax
mov rax, [rbx+38h]
mov rcx, [rax+480h]
cmp byte ptr [rcx+148h], 0
jnz short loc_21CDB
mov rax, [rax+4D0h]
mov rdi, rbx
call qword ptr [rax+60h]
test eax, eax
jnz short loc_21CE8
mov rax, [rbx+0E0h]
test rax, rax
jnz loc_21C05
mov qword ptr [r15], 0
mov dword ptr [rbx+50h], 6
jmp loc_21CE2
loc_21D6E:
call ___stack_chk_fail
| long long stmt_cursor_fetch(long long a1, _QWORD *a2)
{
unsigned int v2; // r14d
long long v3; // rax
int v4; // eax
long long v5; // rsi
long long v7; // rax
_DWORD v8[2]; // [rsp+8h] [rbp-28h] BYREF
unsigned long long v9; // [rsp+10h] [rbp-20h]
v9 = __readfsqword(0x28u);
if ( *(_DWORD *)(a1 + 80) > 3u )
{
v3 = *(_QWORD *)(a1 + 224);
if ( v3 )
{
LABEL_4:
*(_DWORD *)(a1 + 80) = 5;
*a2 = *(_QWORD *)(v3 + 8);
*(_QWORD *)(a1 + 224) = **(_QWORD **)(a1 + 224);
return 0;
}
v4 = *(_DWORD *)(a1 + 244);
if ( (v4 & 0x80u) != 0 )
{
*(_DWORD *)(a1 + 244) = v4 & 0xFFFFFF7F;
}
else
{
v8[0] = *(_DWORD *)(a1 + 64);
v8[1] = *(_DWORD *)(a1 + 792);
v2 = 1;
if ( (*(unsigned int ( **)(_QWORD, long long, _DWORD *, long long, long long, long long))(*(_QWORD *)(*(_QWORD *)(a1 + 56) + 1232LL)
+ 16LL))(
*(_QWORD *)(a1 + 56),
28LL,
v8,
8LL,
1LL,
a1) )
{
v5 = *(_QWORD *)(a1 + 56);
*(_DWORD *)(a1 + 264) = *(_DWORD *)(v5 + 144);
strncpy(a1 + 781, v5 + 663, 5LL);
*(_BYTE *)(a1 + 786) = 0;
strncpy(a1 + 268, *(_QWORD *)(a1 + 56) + 151LL, 512LL);
*(_BYTE *)(a1 + 779) = 0;
return v2;
}
ma_free_root(a1 + 144, 1);
*(_QWORD *)(a1 + 128) = 0LL;
*(_QWORD *)(a1 + 200) = 0LL;
v7 = *(_QWORD *)(a1 + 56);
if ( !*(_BYTE *)(*(_QWORD *)(v7 + 1152) + 328LL) )
{
if ( (*(unsigned int ( **)(long long))(*(_QWORD *)(v7 + 1232) + 96LL))(a1) )
return v2;
v3 = *(_QWORD *)(a1 + 224);
if ( v3 )
goto LABEL_4;
*a2 = 0LL;
*(_DWORD *)(a1 + 80) = 6;
return 100;
}
}
*a2 = 0LL;
return 100;
}
*(_DWORD *)(a1 + 264) = 2014;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
strncpy(a1 + 268, client_errors[14], 512LL);
*(_BYTE *)(a1 + 779) = 0;
return 1;
}
| stmt_cursor_fetch:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x20],RAX
CMP dword ptr [RDI + 0x50],0x3
JA 0x00121bf6
MOV dword ptr [RBX + 0x108],0x7de
LEA RDI,[RBX + 0x30d]
LEA RAX,[0x14dca0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
XOR R14D,R14D
MOV byte ptr [RBX + 0x312],R14B
LEA RDI,[RBX + 0x10c]
LEA RAX,[0x14dcb0]
MOV RSI,qword ptr [RAX + 0x70]
MOV EDX,0x200
CALL 0x00113220
MOV byte ptr [RBX + 0x30b],R14B
MOV R14D,0x1
JMP 0x00121ce8
LAB_00121bf6:
MOV R15,RSI
MOV RAX,qword ptr [RBX + 0xe0]
TEST RAX,RAX
JZ 0x00121c2c
LAB_00121c05:
MOV dword ptr [RBX + 0x50],0x5
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [R15],RAX
MOV RAX,qword ptr [RBX + 0xe0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBX + 0xe0],RAX
XOR R14D,R14D
JMP 0x00121ce8
LAB_00121c2c:
MOV EAX,dword ptr [RBX + 0xf4]
TEST AL,AL
JS 0x00121cd0
MOV EAX,dword ptr [RBX + 0x40]
LEA RDX,[RBP + -0x28]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBX + 0x318]
MOV dword ptr [RDX + 0x4],EAX
MOV RDI,qword ptr [RBX + 0x38]
MOV RAX,qword ptr [RDI + 0x4d0]
MOV R14D,0x1
MOV ECX,0x8
MOV ESI,0x1c
MOV R8D,0x1
MOV R9,RBX
CALL qword ptr [RAX + 0x10]
TEST EAX,EAX
JZ 0x00121d05
MOV RSI,qword ptr [RBX + 0x38]
MOV EAX,dword ptr [RSI + 0x90]
MOV dword ptr [RBX + 0x108],EAX
LEA RDI,[RBX + 0x30d]
ADD RSI,0x297
MOV EDX,0x5
CALL 0x00113220
XOR R15D,R15D
MOV byte ptr [RBX + 0x312],R15B
LEA RDI,[RBX + 0x10c]
MOV ESI,0x97
ADD RSI,qword ptr [RBX + 0x38]
MOV EDX,0x200
CALL 0x00113220
MOV byte ptr [RBX + 0x30b],R15B
JMP 0x00121ce8
LAB_00121cd0:
AND EAX,0xffffff7f
MOV dword ptr [RBX + 0xf4],EAX
LAB_00121cdb:
MOV qword ptr [R15],0x0
LAB_00121ce2:
MOV R14D,0x64
LAB_00121ce8:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x00121d6e
MOV EAX,R14D
ADD RSP,0x18
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00121d05:
LEA RDI,[RBX + 0x90]
MOV ESI,0x1
CALL 0x00120e83
XOR EAX,EAX
MOV qword ptr [RBX + 0x80],RAX
MOV qword ptr [RBX + 0xc8],RAX
MOV RAX,qword ptr [RBX + 0x38]
MOV RCX,qword ptr [RAX + 0x480]
CMP byte ptr [RCX + 0x148],0x0
JNZ 0x00121cdb
MOV RAX,qword ptr [RAX + 0x4d0]
MOV RDI,RBX
CALL qword ptr [RAX + 0x60]
TEST EAX,EAX
JNZ 0x00121ce8
MOV RAX,qword ptr [RBX + 0xe0]
TEST RAX,RAX
JNZ 0x00121c05
MOV qword ptr [R15],0x0
MOV dword ptr [RBX + 0x50],0x6
JMP 0x00121ce2
LAB_00121d6e:
CALL 0x00113500
|
int8 stmt_cursor_fetch(long param_1,int8 *param_2)
{
int iVar1;
long lVar2;
int8 uVar3;
long in_FS_OFFSET;
int4 local_30;
int4 local_2c;
long local_28;
local_28 = *(long *)(in_FS_OFFSET + 0x28);
if (*(uint *)(param_1 + 0x50) < 4) {
*(int4 *)(param_1 + 0x108) = 0x7de;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
strncpy((char *)(param_1 + 0x10c),PTR_s_Commands_out_of_sync__you_can_t_r_0014dd20,0x200);
*(int1 *)(param_1 + 0x30b) = 0;
uVar3 = 1;
goto LAB_00121ce8;
}
lVar2 = *(long *)(param_1 + 0xe0);
if (lVar2 != 0) {
LAB_00121c05:
*(int4 *)(param_1 + 0x50) = 5;
*param_2 = *(int8 *)(lVar2 + 8);
*(int8 *)(param_1 + 0xe0) = **(int8 **)(param_1 + 0xe0);
uVar3 = 0;
goto LAB_00121ce8;
}
if ((char)*(uint *)(param_1 + 0xf4) < '\0') {
*(uint *)(param_1 + 0xf4) = *(uint *)(param_1 + 0xf4) & 0xffffff7f;
LAB_00121cdb:
*param_2 = 0;
}
else {
local_30 = *(int4 *)(param_1 + 0x40);
local_2c = *(int4 *)(param_1 + 0x318);
uVar3 = 1;
iVar1 = (**(code **)(*(long *)(*(long *)(param_1 + 0x38) + 0x4d0) + 0x10))
(*(long *)(param_1 + 0x38),0x1c,&local_30,8,1,param_1);
if (iVar1 != 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;
strncpy((char *)(param_1 + 0x10c),(char *)(*(long *)(param_1 + 0x38) + 0x97),0x200);
*(int1 *)(param_1 + 0x30b) = 0;
goto LAB_00121ce8;
}
ma_free_root(param_1 + 0x90,1);
*(int8 *)(param_1 + 0x80) = 0;
*(int8 *)(param_1 + 200) = 0;
if (*(char *)(*(long *)(*(long *)(param_1 + 0x38) + 0x480) + 0x148) != '\0') goto LAB_00121cdb;
iVar1 = (**(code **)(*(long *)(*(long *)(param_1 + 0x38) + 0x4d0) + 0x60))(param_1);
if (iVar1 != 0) goto LAB_00121ce8;
lVar2 = *(long *)(param_1 + 0xe0);
if (lVar2 != 0) goto LAB_00121c05;
*param_2 = 0;
*(int4 *)(param_1 + 0x50) = 6;
}
uVar3 = 100;
LAB_00121ce8:
if (*(long *)(in_FS_OFFSET + 0x28) == local_28) {
return uVar3;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
Subsets and Splits
C++ Functions Using STL
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ STL Function Queries
Filters C++ code examples that use standard library containers and algorithms, helping identify common programming patterns and library usage in code generation tasks.
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.